Datasets:

casey-martin

/

math_notebooks

like 0

## Divide y vencerás Este es un método de diseño de algoritmos que se basa en *subdividir* el problema en sub-problemas, resolverlos *recursivamente*, y luego *combinar* las soluciones de los sub-problemas para construir la solución del problema original. Es necesario que los subproblemas tengan la misma estructura que el problema original, de modo que se pueda aplicar la recursividad. ## Ejemplo: Obtener la subsecuencia de suma máxima Dada una sucesión de enteros $$ a_{1}, a_{2}, …, a_{n}$$ encontrar e identificar el valor máximo de la suma de una porción consecutiva de la secuencia. Cuando todos los enteros son negativos entendemos que la subsecuencia de suma máxima es la vacía, siendo su suma cero. Ejemplos: 1. { -2, 11, -4, 13, -5, 2} 2. {1, -3, 4, -2, -1, 6} Si revisamos el problema de forma intuitiva, mediante el uso de esquemas por ejemplo, para 1 y 2 las subsecuencias de suma máxima están marcadas en negrita: 1. { -2, **11, -4, 13**, -5, 2} y la suma de esta es 20. 2. {1, -3, **4, -2, -1, 6**} y la suma de esta es 7. Esta solución intuitiva utiliza del orden de $n^2$ comparaciones: $\Theta(n^2)$. ## Usando divide y vencerás Supongamos ahora que la sucesión dada es {4, -3, 5, -2, -1, 2, 6, -2}. Dividiremos esta secuencia en dos partes iguales, como se muestra en la figura a continuación. Entonces la subsecuencia de suma máxima puede aparecer en una de estas tres formas: * *Caso 1*: está totalmente incluida en la primera mitad. * *Caso 2*: está totalmente incluida en la segunda mitad. * *Caso 3*: comienza en la primera mitad, pero termina en la segunda. La figura anterior muestra que podemos calcular, para cada elemento de la primera mitad, la suma de la subsecuencia contigua que termina en el elemento situado más a la derecha. Hacemos esto con un recorrido de derecha a izquierda, partiendo del elemento situado entre las dos mitades. Análogamente, podemos calcular la suma de todas las subsecuencias contiguas que comiencen con el primer elemento de la segunda mitad. Entonces se puede combinar estas dos subsecuencias para formar la subsecuencia de suma máxima que cruza la línea divisoria. En el ejemplo de la figura, la secuencia resultante va desde el primer elemento de la primera mitad hasta el penúltimo elemento de la segunda mitad. La suma total es la suma de las dos subsecuencias, 4+7 = 11. Esto nos muestra que el caso 3 se puede resolver en tiempo lineal. Tanto para el caso 1 como el caso 2, tenemos el mismo problema original, pero para una secuencia de tamaño $n/2$, es decir el mismo $\Theta(n^2)$ (recordemos que se obvían los coeficientes). Sin embargo, podemos aplicar la misma estrategia de división por la mitad en los casos 1 y 2. Podemos continuar dividiendo hasta que sea imposible dividir más. Esto equivale, más concretamente, a resolver los casos 1 y 2 recursivamente. Se puede demostrar que esto reduce el tiempo de ejecución por de bajo de cuadrático, pues los ahorros se acumulan a lo largo de la ejecución del algoritmo. Mostramos a continuación un esquema del algoritmo: 1. Calcular recursivamente la subsecuencia de suma máxima que está totalmente contenida en la primera mitad. 2. Calcular recursivamente la subsecuencia de suma máxima que está totalmente contenida en la segunda mitad. 3. Calcular, usando dos bucles consecutivos, la subsecuencia de suma máxima que comienza en la primera mitad pero termina en la segunda. 4. Elegir la mayor de las tres sumas. El método resultante aparece a continuación. Un algoritmo recursivo nos exige definir un caso base. Naturalmente, cuando el dato es un solo elemento, no usamos recursión. A la llamada recursiva se le pasa el vector de entrada junto con los límites izquierdo y derecho, los cuales delimitan la porción de vector sobre la que se está operando. Una rutina guía de una línea inicializa los parámetros límite a 0 y N - 1. ```python def max3(a,b,c): aux=[] aux.append(a) aux.append(b) aux.append(c) max = -1000 for e in aux: if e > max: max = e return max def maxSumaRec( a, izq, der): # Sub-problema cualquiera # a: [][ ][ ] | [][][]. (n=6) # izq der # # Sub-problema inicial # a: [ ][ ][ ] | [][][ ] # izq=0. centro=2. der=5 maxSumIzqBorde = 0; maxSumDerBorde = 0 sumIzqBorde = 0; sumDerBorde = 0 centro = int((izq+der)/2) # CASO BASE: if izq == der: if a[izq] > 0: return a[izq] else: return 0 # Se busca de forma recursiva la suma máxima en la sección izquierda maxSumIzq = maxSumaRec(a, izq, centro) # Se busca de forma recursiva la suma máxima en la sección derecha maxSumDer = maxSumaRec(a, centro+1, der) for i in range(centro, izq-1,-1): # al ppio: 3, 2, 1, 0 , para el ej. sumIzqBorde += a[i] if sumIzqBorde > maxSumIzqBorde: maxSumIzqBorde = sumIzqBorde for j in range(centro+1, der+1): # al ppio: 4, 5, 6, 7 sumDerBorde += a[j] if sumDerBorde > maxSumDerBorde: maxSumDerBorde = sumDerBorde return max3(maxSumIzq,maxSumDer, maxSumIzqBorde+maxSumDerBorde) a = [4,-3,5,-2,-1,2,6,-2] print(maxSumaRec(a,0,len(a)-1)) b = [-2, 11, -4, 13, -5, 2] print(maxSumaRec(b,0,len(b)-1)) c = [1, -3, 4, -2, -1, 6] print(maxSumaRec(c,0,len(c)-1)) ``` 11 20 7 ### Ejercicio de divide y vencerás Si tenemos dos números complejos $$ \begin{align} u&=a+bi\\ v&=c+di \end{align} $$ podemos calcular su producto $$ uv=(ac-bd)+(ad+bc)i $$ haciendo 4 multiplicación de números reales. Encuentre una forma de realizar este cálculo haciendo solo 3 multiplicaciones de números reales. ## Referencias 1. Weiss, M. A., & Marroquín, O. (2000). Estructuras de datos en JavaTM. Addison-Wesley. 2. Apuntes de Patricio Poblete (U. de Chile) disponible en: https://github.com/ivansipiran/AED-Apuntes#Algoritmos-y-Estructuras-de-Datos (visitado en mayo 2021)

c580d718bf76158a572568de2acf9a892e6899af

ipynb

Jupyter Notebook

Dividir_para_reinar.ipynb

femunoz/AED

7d156a385ff4e4948f53003eb161ff2df0088bb2

2022-01-16T16:15:34.000Z

2022-01-16T16:15:34.000Z

Dividir_para_reinar.ipynb

femunoz/AED

7d156a385ff4e4948f53003eb161ff2df0088bb2

Dividir_para_reinar.ipynb

femunoz/AED

7d156a385ff4e4948f53003eb161ff2df0088bb2

Qwen/Qwen-72B

1. YES 2. YES

__label__spa_Latn

# SLU11 - Tree-based models: Learning notebook ## Imports ```python from math import log2 import pandas as pd import numpy as np from sklearn.datasets import load_boston from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier from sklearn.metrics import mean_squared_error from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor from IPython.display import Image from utils.utils import ( make_data, separate_target_variable, process_categorical_features, visualize_tree ) ``` # Table of Contents 1. [Decision trees](#decision-trees) 2. [Tree-based ensembles](#tree-based-ensembles) 3. [Bagging with random forests](#bagging-with-random-forests) 4. [Boosting with gradient boosting](#boosting-with-gradient-boosting) # Decision trees <a class="anchor" id="decision-trees"></a> A **decision tree** is a decision support tool in a form of a tree-like structure, it can be used for classification or regression, being more used for classification, where each node is associated with a test on a feature, each branch represents an outcome of the test, and each leaf the final decision. In order to explain you better how **decision trees** work lets use an example, where according with the weather we want to know if we should go hiking. A simple **decision tree** can be represented as: *Fig. 1: A simple decision-tree used for classification (Quinlan, 1986).* This **decision tree**, displays a flow of conditional statements (i.e., `if Condition then Outcome`) where: * Each **node** represents a test on a feature (E.g. is it windy?) * Each **branch** represents the outcome of the test (E.g. as true or false) * Each **leaf** represents an outcome or decision (represented with N and P). The paths from root to leaf represent the rules, e.g., `if Outlook is Sunny and Humidity is Normal then Go Hiking`. ## Learning sets of rules as decision trees Typically, a decision tree is developed from the top-down (known as top-down induction), and there are several algorithms that can be used to build them, including: * **Iterative Dichotomiser 3 (ID3)**, for classification using categorical features (use of entropy and information gain as metric.) * **C4.5**, successor to ID3 to support non-categorical features * **Classification and Regression Trees (CART)**, generalizes C4.5 to support regression (use of Gini impurity as the metric). We follow ID3 ([Quinlan, 1986][1]), for binary classification using categorical features with a small set of possible values (i.e. low cardinality). [1]: http://hunch.net/~coms-4771/quinlan.pdf "Quinlan, J. 1986. Induction of Decision Trees. Machine Learning 1: 81-106." ```python data = make_data() ``` ### Algorithm overview Take an arbitrary training set $C = \{\textbf{x}_i, y_i\}_{i=1}^m$, a collection of labeled observations, with $y_i \in \{L_1, \dots, L_v\}$. The features vector is represented as $\textbf{x}_i = \{x_i^{(1)}, \dots, x_i^{(n)}\}$, where $x_i^{(j)}$ is the value of the $j$-th feature for the $i$-th observation. In ID3, $x_i^{(j)}$ can take on one of a fixed number of possible values $x_i^{(j)} \in \{A_1^{(j)}, \dots, A_w^{(j)}\}$. $$X = \begin{bmatrix} x_1^{(1)} & x_1^{(2)} & \dots & x_1^{(n)} \\ x_2^{(1)} & x_2^{(2)} & \dots & x_2^{(n)} \\ \dots & \dots & \dots & \dots \\ x_m^{(1)} & x_m^{(2)} & \dots & x_m^{(n)} \end{bmatrix}$$ ```python X, y = separate_target_variable(data) X ``` <div> <style scoped> .dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; } </style> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>Outlook</th> <th>Temperature</th> <th>Humidity</th> <th>Windy</th> </tr> </thead> <tbody> <tr> <th>0</th> <td>sunny</td> <td>hot</td> <td>high</td> <td>false</td> </tr> <tr> <th>1</th> <td>sunny</td> <td>hot</td> <td>high</td> <td>true</td> </tr> <tr> <th>2</th> <td>overcast</td> <td>hot</td> <td>high</td> <td>false</td> </tr> <tr> <th>3</th> <td>rain</td> <td>mild</td> <td>high</td> <td>false</td> </tr> <tr> <th>4</th> <td>rain</td> <td>cool</td> <td>normal</td> <td>false</td> </tr> <tr> <th>5</th> <td>rain</td> <td>cool</td> <td>normal</td> <td>false</td> </tr> <tr> <th>6</th> <td>overcast</td> <td>cool</td> <td>normal</td> <td>false</td> </tr> <tr> <th>7</th> <td>sunny</td> <td>mild</td> <td>high</td> <td>false</td> </tr> <tr> <th>8</th> <td>sunny</td> <td>cool</td> <td>normal</td> <td>false</td> </tr> <tr> <th>9</th> <td>rain</td> <td>mild</td> <td>normal</td> <td>false</td> </tr> <tr> <th>10</th> <td>sunny</td> <td>mild</td> <td>normal</td> <td>true</td> </tr> <tr> <th>11</th> <td>overcast</td> <td>mild</td> <td>high</td> <td>true</td> </tr> <tr> <th>12</th> <td>overcast</td> <td>hot</td> <td>normal</td> <td>false</td> </tr> <tr> <th>13</th> <td>rain</td> <td>mild</td> <td>high</td> <td>true</td> </tr> </tbody> </table> </div> This is a binary classification problem, where $y_i \in \{0, 1\}.$ $$y = \begin{bmatrix} y_1 \\ y_2 \\ \dots \\ y_3 \end{bmatrix}$$ ```python y ``` 0 0 1 0 2 1 3 1 4 1 5 0 6 1 7 0 8 1 9 1 10 1 11 1 12 1 13 0 Name: Class, dtype: int64 Now, imagine a test, $T$, on $x_i$, with possible outcomes $O_1, O_2, \dots, O_w$. It can be a condition on the features, for example. $T$ produces a partition $\{C_1, C_2, \dots, C_w\}$ of $C$, where $C_k$ contains those observations having outcome $O_k$. *Fig. 2: Partitioning of the objects in $C$ with a test $T$ (Quinlan, 1986).* We can recursively apply different tests to each of these partitions, creating smaller and smaller sub-partitions, until we get homogenous (i.e., single-class) leaves. The result of this process is a decision tree for all of $C$. This tree-building algorithm can be described in the following way: ``` ID3 (Data, Target, Attributes) If all examples are positive, Return the single-node tree Root, with label = 1. If all examples are negative, Return the single-node tree Root, with label = 0. Otherwise Begin A <- Pick the Attribute that best classifies examples. Decision tree for Root = A. For each possible value, O_i, of A, Add a new tree branch, corresponding to the test A = O_i. Let Data(v_i) be the subset of examples that have the value O_i for A. Below this new branch add the subtree ID3 (Data(O_i), Target, Attributes – {A}). End Return Root ``` But what is the **attribute that best classifies examples** at each step? As we will soon see, this is related with the concepts of **information gain** and **entropy**. ## Attribute selection A test will have a high **information gain** if it generates partitions with low [entropy](https://en.wikipedia.org/wiki/Entropy_(information_theory)). In general: the greater the homogeneity of a partition, the lower its entropy. In this case, a partition is said to be very homogeneous if the majority of its elements belong to a single class. Consider the problem of binary classification (it can be extended to support multi-class settings). Take $p$ as the probability of the positive class, i.e., the proportion of positive cases in the set. In this case, the entropy is given by: $$I(p) = - p \log_2 p - (1 - p) \log_2 (1-p)$$ It ranges between 0 and 1: * 0, when $p=1$ or $p=0$. We are in a situation of low entropy/high purity, because there is no "surprise" in the outcome. We say the information is minimum, because observing the class of an instance will not give us any new information - we already know what it will be. * 1, when $p=\frac{1}{2}$. We are in a situation of high entropy/low purity, because the "uncertainty" of the outcome is maximum. This is equivalent to saying that the information is maximum. Out of curiosity, entropy is measured in **bits** (hence the $log_2$ in the formula, since it tells you the number of digits you would need to represent a number in base 2). ```python def entropy(p): if 0 < p < 1: return -p * log2(p) - (1 - p) * log2(1 - p) else: return 0 ``` Let's compute the entropy for the entire data set: ```python def compute_probability(data): n = data.shape[0] f = (data['Class'] == 1).sum() return f / n p = compute_probability(data) ``` ```python entropy(p) ``` 0.9402859586706311 We have a fairly high entropy for the entire data set. This means that substantial proportions of the data set belong to each of the classes, as confirmed by the value of $p$ - the data is not homogenous. ```python p ``` 0.6428571428571429 Starting from a set with high entropy, we would like to select a test that divides it into partitions that are as homogeneous as possible. In the ideal case, each partition would be a leaf node, containing only instances from a single class. A test is restricted to branching on an attribute $A$ with values $\{A_1, A_2, \dots, A_v\}$, thus partitioning $C$ into $\{C_1, C_2, \dots, C_v\}$. The expected entropy of the test is obtained as a weighted average of the entropy of the resulting groupings: $$E(A) = \sum_{i=1}^v \frac{\|C_i\|}{\|C\|}I(p_i)$$ In short, and as expected, we are measuring an attribute's ability to generate homogeneous groupings. Let's calculate the expected information of the `Outlook` feature: ```python def mean_entropy(data, attribute): c_norm = data.shape[0] information = 0 values = data[attribute].unique() for value in values: group = data[data[attribute] == value] c_i_norm = group.shape[0] w = c_i_norm / c_norm p = compute_probability(group) e = entropy(p) information += w * e return information mean_entropy(data, 'Outlook') ``` 0.6935361388961918 Given this result, the `Outlook` feature yields partitions that have, on average, a much lower entropy than the entire data set. It is a good candidate for the first test (first node that is the root!) We call this loss of entropy the **information gain** of branching on an attribute $A$, and it is given by: $$IG(A) = I(p) - E(A)$$ where $I(p)$ is the entropy on the node over which the test is being performed, and $E(A)$ is the expected entropy of the test. Let's compute it. ```python def information_gain(data, attribute): p = compute_probability(data) i = entropy(p) e = mean_entropy(data, attribute) return i - e information_gain(data, 'Outlook') ``` 0.24674981977443933 To generate the simplest possible tree, it is a good choice to branch, at each step, on the attribute with the highest information gain. Let's find out which: ```python def examine_candidate_attributes(data, attributes): return { attribute:information_gain(data, attribute) for attribute in attributes } attributes = [c for c in data.columns if c is not 'Class'] examine_candidate_attributes(data, attributes) ``` {'Outlook': 0.24674981977443933, 'Temperature': 0.02922256565895487, 'Humidity': 0.15183550136234159, 'Windy': 0.02507817350585062} So, we would start by branching on the values of the `Outlook` attribute. ```python outlook_values = data['Outlook'].unique() outlook_values ``` array(['sunny', 'overcast', 'rain'], dtype=object) We repeat the process in each partition generated by the `Outlook` attribute: ```python for i, value in enumerate(outlook_values): partition = data[data['Outlook'] == value] results = examine_candidate_attributes(partition, attributes) print("\n---\n") print("Partition: Outlook == {}. \nResults:\n{}.".format(value, results)) ``` --- Partition: Outlook == sunny. Results: {'Outlook': 0.0, 'Temperature': 0.5709505944546686, 'Humidity': 0.9709505944546686, 'Windy': 0.01997309402197489}. --- Partition: Outlook == overcast. Results: {'Outlook': 0.0, 'Temperature': 0.0, 'Humidity': 0.0, 'Windy': 0.0}. --- Partition: Outlook == rain. Results: {'Outlook': 0.0, 'Temperature': 0.01997309402197489, 'Humidity': 0.01997309402197489, 'Windy': 0.3219280948873623}. Interestingly enough, none of the attributes provides any information gain in the `Outlook == overcast` case. Let's try to understand why: ```python data[data['Outlook'] == 'overcast'] ``` <div> <style scoped> .dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; } </style> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>Outlook</th> <th>Temperature</th> <th>Humidity</th> <th>Windy</th> <th>Class</th> </tr> </thead> <tbody> <tr> <th>2</th> <td>overcast</td> <td>hot</td> <td>high</td> <td>false</td> <td>1</td> </tr> <tr> <th>6</th> <td>overcast</td> <td>cool</td> <td>normal</td> <td>false</td> <td>1</td> </tr> <tr> <th>11</th> <td>overcast</td> <td>mild</td> <td>high</td> <td>true</td> <td>1</td> </tr> <tr> <th>12</th> <td>overcast</td> <td>hot</td> <td>normal</td> <td>false</td> <td>1</td> </tr> </tbody> </table> </div> As it turns out, this grouping is already homogeneous (all instances are positive) - it is already a leaf. We figured out our first rule: ``` if Outlook is Overcast then Go Hiking ``` Finally, we would continue partitioning recursively until all the resulting groupings are homogeneous (we obtain pure leaves), or until we have exhausted our features (in which case, we assign to the final leaves the majority class in their partition). ## Using decision trees The `sklearn` implementation uses an optimized version of the CART algorithm. This means that the resulting decision tree might be different than if you had used ID3. We won't go into this in detail, but don't worry - the principles behind it are very similar to what you've learned. ```python X_ = process_categorical_features(X) clf = DecisionTreeClassifier(criterion='entropy', random_state=101) clf.fit(X_, y) ``` DecisionTreeClassifier(criterion='entropy', random_state=101) Above, we do a trick to convert categorical variables into something more `sklearn`-friendly. (ignore it for now - you will learn all about it in due time.) Then, we train a `DecisionTreeClassifier` (refer to the [docs](https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html) for more information). Let's visualize the resulting tree: ```python class_names = ["Don't go hiking!", "Go hiking!"] t = visualize_tree(clf, X_.columns, class_names) Image(t) ``` On each node, we can see: * two different paths, indicated by each result of the test `(feature_value <= 0.5)`, applied to the current node. `True` means **all instances in this node for which `feature` IS NOT equal to `value`**. The left path is always True, and the right path is always False. * the entropy in that node. * the `value` array, which indicates how many samples reaching that node belong to each class (the classes are in ascending numerical order) * the name of the majority class in the node (in case of a tie, the first class in numerical order is taken) The CART algorithm can also be used for regression problems. In that case, you should use the `DecisionTreeRegressor` (refer to the [docs](https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeRegressor.html)). To visualize a simple example, check out [this page](https://scikit-learn.org/stable/auto_examples/tree/plot_tree_regression.html). ## Feature importance A great characteristic of decision trees is that they allow us to compute **feature importance**: a score for each feature, based on how useful they are at predicting the target variable. The importance of a feature is given by the decrease in node impurity (according to the criterion being used - in this case, the entropy), weighted by the proportion of samples reaching the node. We can calculate the feature importance in the following way: ```python feature_importances = pd.Series(data=clf.feature_importances_, index=X_.columns) feature_importances.sort_values(ascending=False) ``` Outlook_overcast 0.283411 Humidity_high 0.249079 Outlook_sunny 0.211799 Windy_true 0.179147 Temperature_mild 0.076563 Outlook_rain 0.000000 Temperature_cool 0.000000 Temperature_hot 0.000000 Humidity_normal 0.000000 Windy_false 0.000000 dtype: float64 By inspecting the visual representation of the tree, we can see that the `Windy_true` attribute has the highest information gain (from 1 to 0 on both leaves it generate), and therefore the highest decrease in node impurity. However, since not many samples reach that node (only 2 in the training set), this is not the most important feature, since it is not as relevant to predicting the class in the overall dataset. Compare it with the feature with the highest importance, `Outlook_overcast`, placed right at the root of the tree: despite not having as high of an information gain, it immediately allows us to classify 4 samples as "Go Hiking". ## Pros and cons ### Pros Decision trees are a straightforward way to represent rules that: * are simple to understand, interpret and visualize * require little to no data preparation (for example, don't require data scaling and normalization) * are able to handle numerical and categorical variables * missing values in the data doesn't affect (to a larger extent) the process of building the tree * are a white-box model, all decisions are replicable and easily explainable. ### Cons Decision trees are extremely flexible and prone to creating over-complex trees that: * small changes in the data can cause a large change in the structure of the decision tree causing instability * usually involves higher time to train (leading to an increase in price as the complexity and time increase) * Overfitting * Overfitting * Overfitting. (Repetition makes perfect.) Mechanisms such as pruning (removing sections of the tree) and setting the maximum depth of the tree help with overfitting. Let's see how we can configure the maximum tree depth with `sklearn`: ```python clf = DecisionTreeClassifier( criterion='entropy', max_depth=2, random_state=101 ) clf.fit(X_, y) ``` DecisionTreeClassifier(criterion='entropy', max_depth=2, random_state=101) ```python t = visualize_tree(clf, X_.columns, class_names) Image(t) ``` We can also set the minimum number of samples required to split a node, in order to avoid fully-grown trees. ```python clf = DecisionTreeClassifier( criterion='entropy', min_samples_split=5, random_state=101 ) clf.fit(X_, y) ``` DecisionTreeClassifier(criterion='entropy', min_samples_split=5, random_state=101) ```python t = visualize_tree(clf, X_.columns, class_names) Image(t) ``` These all help with controlling overfitting, but they might not be enough; and in fact, sometimes this approach is too heavy-handed, and might lead to underfitting. We will need to find a smarter way to control overfitting, while still allowing our trees to represent complex rules. Some final notes: * if the attributes are adequate, it is always possible to construct a decision-tree that correctly classifies every training instance. * attributes are **inadequate** if the data contains two objects that have identical values for each attribute and yet belong to different classes. * the key takeaway: **decision trees overfit like hell**. ## Tree-based ensembles <a class="anchor" id="tree-based-ensembles"></a> **Ensemble methods** combine the predictions of several models, known as **base learners** or **base estimators**. Each individual estimator in the ensemble is often a "weak learner" (i.e. has slightly better accuracy than random). However, combining the predictions of the entire ensemble, we often get better results that are less prone to overfitting, when compared to using a single, larger model. *Fig. 3: A simple ensemble model, using many trained models to generate a single prediction.* There are homogeneous and heterogenous ensembles, based on whether the base learners are all of the same type or not. We focus on homogenous ensembles of decision-trees, particularly: * Building several independent trees and then average their predictions, so that variance is reduced (i.e., **bagging**) * Building trees sequentially as to reduce the bias of the combined estimator (i.e., **boosting**). # Bagging with random forests <a class="anchor" id="bagging-with-random-forests"></a> Bootstrap aggregating, also known as bagging, consists in: 1. Creating several independent data sets 2. Training a model in each data set 3. Aggregating individual predictions. Bagging can be seen as training several independent models in parallel and averaging the predictions. Imagine the following example: you are experiencing a strange feeling in your nose, and want to get a diagnosis. You have the option of going to a single, extremely-specialized podiatrist (that's a foot doctor, in case you didn't know, and in this analogy, it represents a single large model), or you could get your diagnosis from an association of 500 3rd year university students of medicine (which in this analogy represent a bag of simpler, shallower models). Now, the podiatrist is very specialized: one might even say that he might have **overfit** to foot diseases. He might be able to extend his knowledge to your particular affliction and give a good diagnosis, but odds are he will diagnose you with something totally unrelated. The group of 3rd year medicine students, on the other hand, might lack individual expertise; but if each of them has at least attended *some* classes, and *if they haven't all attended the same classes*, it's very likely that their collective knowledge surpasses the podiatrist's, and that their majority vote will be the right diagnosis. This example illustrates the main strength of bagging, which is that several weak models can cancel each other's weaknesses, provided that they are highly independent and were exposed to different information. But how does this relate to decision trees, you might ask? Well, decision-trees don't simply overfit, they are also highly unstable: small variations in the data result in wildly different trees. This makes them particularly suited for bagging. ## Bagging Suppose you have a sequence of data sets $\{D_1, D_2, \dots, D_k\}$, with observations from the same underlying distribution $\mathcal{D}$. We can obtain an **ensemble of models**, $\{h_1, h_2, \dots, h_k\}$, by training a model in each data set. *Fig. 4: In bagging different data sets are generated from the main one, models are trained in parallel and predictions averaged.* By running the models in parallel, we get $\{\hat{y}_1\, \hat{y}_2\, \dots, \hat{y}_k\}$, a list of predictions from our ensemble. To obtain a single prediction we can then evaluate all models and aggregate the results by: * Averaging the $k$ predictions (regression) * Using majority voting to predict a class (classification). More often than not, however, we don't have multiple data sets. In this situation, we can do bootstrapping. ## Bootstrapping We can take repeated random samples with replacement $\{C^1, C^2, \dots, C^b\}$ from $C$, our full dataset: ```python def make_bootstrap_data(data, b): n = data.shape[0] return [data.sample(n=n, replace=True) for i in range(b)] bootstrap_data = make_bootstrap_data(data, 2) ``` Typically, the bootstrapped data sets are the same size as the original data set. ```python bootstrap_data[0] ``` <div> <style scoped> .dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; } </style> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>Outlook</th> <th>Temperature</th> <th>Humidity</th> <th>Windy</th> <th>Class</th> </tr> </thead> <tbody> <tr> <th>7</th> <td>sunny</td> <td>mild</td> <td>high</td> <td>false</td> <td>0</td> </tr> <tr> <th>8</th> <td>sunny</td> <td>cool</td> <td>normal</td> <td>false</td> <td>1</td> </tr> <tr> <th>4</th> <td>rain</td> <td>cool</td> <td>normal</td> <td>false</td> <td>1</td> </tr> <tr> <th>12</th> <td>overcast</td> <td>hot</td> <td>normal</td> <td>false</td> <td>1</td> </tr> <tr> <th>12</th> <td>overcast</td> <td>hot</td> <td>normal</td> <td>false</td> <td>1</td> </tr> <tr> <th>12</th> <td>overcast</td> <td>hot</td> <td>normal</td> <td>false</td> <td>1</td> </tr> <tr> <th>10</th> <td>sunny</td> <td>mild</td> <td>normal</td> <td>true</td> <td>1</td> </tr> <tr> <th>12</th> <td>overcast</td> <td>hot</td> <td>normal</td> <td>false</td> <td>1</td> </tr> <tr> <th>0</th> <td>sunny</td> <td>hot</td> <td>high</td> <td>false</td> <td>0</td> </tr> <tr> <th>6</th> <td>overcast</td> <td>cool</td> <td>normal</td> <td>false</td> <td>1</td> </tr> <tr> <th>4</th> <td>rain</td> <td>cool</td> <td>normal</td> <td>false</td> <td>1</td> </tr> <tr> <th>0</th> <td>sunny</td> <td>hot</td> <td>high</td> <td>false</td> <td>0</td> </tr> <tr> <th>2</th> <td>overcast</td> <td>hot</td> <td>high</td> <td>false</td> <td>1</td> </tr> <tr> <th>5</th> <td>rain</td> <td>cool</td> <td>normal</td> <td>false</td> <td>0</td> </tr> </tbody> </table> </div> ```python bootstrap_data[1] ``` <div> <style scoped> .dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; } </style> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>Outlook</th> <th>Temperature</th> <th>Humidity</th> <th>Windy</th> <th>Class</th> </tr> </thead> <tbody> <tr> <th>2</th> <td>overcast</td> <td>hot</td> <td>high</td> <td>false</td> <td>1</td> </tr> <tr> <th>12</th> <td>overcast</td> <td>hot</td> <td>normal</td> <td>false</td> <td>1</td> </tr> <tr> <th>3</th> <td>rain</td> <td>mild</td> <td>high</td> <td>false</td> <td>1</td> </tr> <tr> <th>9</th> <td>rain</td> <td>mild</td> <td>normal</td> <td>false</td> <td>1</td> </tr> <tr> <th>9</th> <td>rain</td> <td>mild</td> <td>normal</td> <td>false</td> <td>1</td> </tr> <tr> <th>2</th> <td>overcast</td> <td>hot</td> <td>high</td> <td>false</td> <td>1</td> </tr> <tr> <th>4</th> <td>rain</td> <td>cool</td> <td>normal</td> <td>false</td> <td>1</td> </tr> <tr> <th>8</th> <td>sunny</td> <td>cool</td> <td>normal</td> <td>false</td> <td>1</td> </tr> <tr> <th>11</th> <td>overcast</td> <td>mild</td> <td>high</td> <td>true</td> <td>1</td> </tr> <tr> <th>1</th> <td>sunny</td> <td>hot</td> <td>high</td> <td>true</td> <td>0</td> </tr> <tr> <th>4</th> <td>rain</td> <td>cool</td> <td>normal</td> <td>false</td> <td>1</td> </tr> <tr> <th>3</th> <td>rain</td> <td>mild</td> <td>high</td> <td>false</td> <td>1</td> </tr> <tr> <th>10</th> <td>sunny</td> <td>mild</td> <td>normal</td> <td>true</td> <td>1</td> </tr> <tr> <th>7</th> <td>sunny</td> <td>mild</td> <td>high</td> <td>false</td> <td>0</td> </tr> </tbody> </table> </div> We would now train a different decision tree in each data set and use voting to predict whether or not to go hiking. Bagging works very well in controlling overfitting and the generalization error in unstable models. If one of the models in the bag overfits to a certain noisy observation, it's very likely that its vote will be drowned out by the rest of the models in the ensemble. ## Random forests A **random forest** is an ensemble learning method created by bagging multiple decision trees. In random forests, bagging is used in tandem with random feature selection: * Datasets are generated from the original data, using bootstrapping (row sampling) * Then a tree is grown on each bootstrapped data set using random feature selection (column sampling). Random feature selection means that only a random subset of the features is available at each split. Randomizing features acts as a kind of regularization, further mitigating overfitting, because it forces each individual classifier to be as good as possible, while having access to limited information. This increases diversity inside the ensemble, which is often very beneficial. Fortunately, `sklearn` implements all this intricate logic for us. ```python rf = RandomForestClassifier( n_estimators=10, criterion='entropy', max_features=2, bootstrap=True ) rf.fit(X_, y) ``` RandomForestClassifier(criterion='entropy', max_features=2, n_estimators=10) For detailed information about the models, check the documentation: * RandomForestClassifier ([docs](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html)) * RandomForstsRegressor ([docs](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestRegressor.html)). Bagging is a great technique to reduce overfitting, and as such, to reduce the variance of our final predictions. This comes at the cost of interpretability - it is much easier to interpret the rules contained within a single decision tree, than it is to analyze the driving forces in a majority vote of hundreds or even thousands of models. # Boosting with gradient boosting <a class="anchor" id="boosting-with-gradient-boosting"></a> **Boosting** is a different ensemble learning technique. In this case, instead of training several base learners in parallel and averaging their predictions, we train them sequentially; and the input of each model is the residual error of the previous model. The general idea is to build strong ensembles by combining base learners sequentially, each of them correcting previous errors (and thus reducing bias). **Note:** this section can be pretty intimidating at first, but don't despair! It will be worth it in the end. ## Boosting Trees are grown sequentially, and each tree is created using information derived from the previous tree. In each iteration: 1. Errors and misclassifications of the past model are given increased weight in a new training data set 2. The current model is trained on the new training set, fitting the residual errors of the previous model. As such, each model specializes in correcting past mistakes and misclassifications. Intuitively, this produces an ensemble of models that are good in different "parts" of the training data, as they sequentially correct each other's mistakes. The final prediction is obtained by summing the predictions of each model in the ensemble. Boosting is less robust than bagging against overfitting, and as such, it is recommended to control the number of estimators used, the strength of each individual estimator, the learning rate, and use other regularization techniques. In this example we will use the [boston](https://www.cs.toronto.edu/~delve/data/boston/bostonDetail.html) house-prices data set (regression). ```python def prepare_boston(): boston = load_boston() X = pd.DataFrame(data=boston.data, columns=boston.feature_names) y = pd.Series(data=boston.target, name='price') return X, y X_boston, y_boston = prepare_boston() ``` ## What do we mean by "gradient" boosting To understand the meaning of **gradient boosting**, we need to review a couple of concepts. ### Loss function A loss function quantifies how bad our predictions are. An example is the squared error, seen below: $$L_i = (y_i - h(x_i))^2$$ As we can see, the square error increases with the square of the difference between each of our predictions, and the real value. The worse this error across all data samples, the worse will the overall model performance be. The training of an individual machine learning model is driven by the minimization the total loss, over all observations in the training set, with respect to the model's parameters $\theta$: $$\min_{\theta} J = \sum_{i=1}^N L(y_i, h(x_i, \theta))$$ $h(x_i, \theta)$ represents our model's predictions, or $\hat{y}$. ### Gradient descent The gradient of a loss function ($\nabla$), at each point, is its inclination or slope. It's the fancy term for the multi-variable generalization of the derivative, i.e., the partial derivatives of function $f$ at a given point. When training a model by gradient descent, we calculate, at each training step, the derivative of the loss $L$ with respect to the model's parameters, and then update the parameters by giving a small step in the opposite direction of this gradient - the direction in which the loss is decreasing: $$\theta^{n+1} = \theta^{n} - \eta \nabla_{\theta} L(y, \hat{y})$$ As such, at each step, we are trying to gradually move our model to a location in parameter space where the loss function has a lower value. ## Gradient boosting in detail We now have all pieces required to understand gradient boosting. Let's consider the case of a numerical target variable. We have our first model in the boosting ensemble, $F^{(1)}(x, \theta)$. This model achieves a certain loss, given by $L(\textbf{y}, F^{(1)}(x, \theta))$. We now want to add a second model, $h$, to improve our first model in a way that $$ F^{(1)}(x_1) + h(x_1) = y_1 \\ F^{(1)}(x_2) + h(x_2) = y_2 \\ ... $$ or equivalently, $$ h(x_1) = y_1 - F^{(1)}(x_1) \\ h(x_2) = y_2 - F^{(1)}(x_2) \\ ... $$ Maybe there isn't a single model that can achieve this. But perhaps some regression tree can do it approximately. We can try to fit it to the following data points: $$ (x_1, y_1 - F^{(1)}(x_1)) \\ (x_2, y_2 - F^{(1)}(x_2)) \\ ... $$ $y_i - F^{(1)}(x_i)$ are called **residuals**. The role of $h$ is to be strong where the initial model was weak. And if the new model $F^{(2)} = F^{(1)} + h$ still isn't good enough, we can fit an additional regression tree to its residuals, and so on and so forth. Taking a step back to our first model, imagine we are using the squared error loss function: $$ L(\textbf{y},F_1(x)) = (\textbf{y} - F^{(1)}(x))^2 $$ We want to minimize $J = \sum_i{L(y_i, F^{(1)}(x_i))}$ by adjusting $F^{(1)}(x_1)$, $F^{(1)}(x_2)$, ... Now, what we are truly adjusting during learning are the parameters $\theta$ of $F^{(1)}$. But if we take a functional perspective, we can observe that $F^{(1)}(x_i)$ are simply numbers - we can treat them as parameters and take derivatives: $$ \begin{align} \frac{\partial J}{\partial F^{(1)}(x_i)} & = \frac{\partial \sum_{j=0}^{n}{L(y_j, F^{(1)}(x_j))}}{\partial F^{(1)}(x_i)} \\ & = \frac{\partial L(y_i, F^{(1)}(x_i))}{\partial F^{(1)}(x_i)} \\ & = -2 (y_i - F^{(1)}(x_i)) \\ & = -2*residuals \end{align} $$ As you may have noticed, when the loss function is the squared error, the residuals are proportional to the negative gradients of the loss function! Thus arises the similarity with gradient descent: $$ \begin{align} F^{(2)}(x_i) & = F^{(1)}(x_i) + h(x_i) \\ & = F^{(1)}(x_i) + y_i - F^{(1)}(x_i) \\ & = F^{(1)}(x_i) - \frac{1}{2}\frac{\partial J}{\partial F^{(1)}(x_i)} \\ \end{align} $$ and $$ \theta^{n+1} = \theta^{n} - \eta \frac{\partial J}{\partial F(\theta_i)} $$ To summarize: for regression with **square loss**, * the residual <=> negative gradient * fitting h to the residual <=> fitting h to the negative gradient * adding a new estimator based on the residual <=> adding a new estimator based on the negative gradient When adding a new estimator to our boosting ensemble, we are actually minimizing a global loss function by using gradient descent, in function space! The final thing to understand here is that the concept of gradients is more useful than the concept of residuals, because it allows us to generalize to loss functions other than the squared error. As long as we fit each additional model to the negative gradients of the current global model, we will be minimizing our desired global loss function. ## In practice Let's implement one step of a boosting algorithm, for when the loss function is the mean squared error, based on what we have discussed so far! ### Initialization We initialize all $F^{(1)}(x_i)$ to a sensible constant, $F^{(1)}(x_i) = \gamma$. Since our goal is to minimize the mean squared error, we will use the mean value of the target variable in the training set. ```python y_boston_h0_pred = np.repeat(y_boston.mean(), y_boston.size) ``` We compute the mean squared error of this initial set of predictions. ```python mean_squared_error(y_boston, y_boston_h0_pred) ``` 84.41955615616556 ### Iterations #### Generating a new data set We build a new training set at the start of each iteration, by recomputing the target variable to be the gradient of the previous model. More concretely, at the $j$-th iteration we compute a new target variable $r^{(j)}_i$, corresponding to the gradient of the past iteration: $$r^{(j)}_{i} = \frac{\partial L(y_i, F^{(j-1)}(x_i))}{\partial F^{(j-1)}(x_i)} = -2(r^{(j-1)}_{i} - F^{(j-1)}(x_i))$$ For the first iteration: * $r^{(j-1)}_i = y_i$, the original targets * $F^{(j-1)}(x_i)) = F^{(1)}(x_i) = \gamma$ ```python def compute_gradient(y, y_pred): return -2 * (y - y_pred) y_boston_h0_residual = compute_gradient(y_boston, y_boston_h0_pred) ``` #### Training a decision-tree We now fit a new decision-tree to the negative gradient that we just calculated, $r^{(j)}_i$: ```python dt = DecisionTreeRegressor(max_depth=1) dt.fit(X_boston, y_boston_h0_residual) y_boston_h0_residual_pred = dt.predict(X_boston) ``` Typically, we will want to train the simplest, shallowest decision-trees as base learners, to avoid overfitting (which is why we are setting the maximum depth of the tree to one.) #### Updating the global model We now want to add the predictions made by this model (over the residuals) to the predictions made by the base model. The update rule goes as follows, where $\eta$ is a **learning rate** that controls the magnitude of the update and acts as a regularizer: $$F^{(j)}(x_i)) = F^{(j-1)}(x_i)) - \eta \cdot \frac{\partial L(y_i, F^{(j-1)}(x_i))}{\partial F^{(j-1)}(x_i)}$$ The learning rate is also known as the *shrinkage factor*, as it shrinks the impact of the corrections if $\eta$ between 0 and 1. Since we don't know the true value of $y_i$ at prediction time, we plug-in the prediction of the decision-tree we fit in the previous step: $$F^{(j)}(x_i)) \approx F^{(j-1)}(x_i)) - \eta \cdot \hat{r}^{(j)}_i(x_i) $$ If everything goes well, with each step we are moving closer and closer to the function that minimizes the squared error. ```python def update_predictions(previous_prediction, residual_prediction, lr): return previous_prediction - lr * residual_prediction y_boston_h1_pred = update_predictions(y_boston_h0_pred, y_boston_h0_residual_pred, lr=0.1) ``` Now, we compute the mean squared error for the updated predictions. ```python mean_squared_error(y_boston, y_boston_h1_pred) ``` 70.660188943705 Hurrah! The error decreased. We would continue the process until the error stopped decreasing, or until we detected signs of overfitting. ### Putting it all together Suppose we have $m$ individual decision-trees (boosting stages) The final prediction will be given by the sum of the initial constant and all the gradient-based corrections: $$F^m_i(x_i) = \gamma + \sum_{j=1}^m \eta \cdot \hat{r}^{(j)}_i(x_i)$$ Where $\hat{r}^{(j)}_i(x_i)$ is the output of a decision-tree that predicts the negative gradient of the previous iteration. A final note: don't worry if you didn't understand all the details of previous section - it was quite heavy on the mathematical side. Just make sure you understand the basics of boosting and the idea behind it, and `sklearn` has got you covered! ## With sklearn Enough with theory: `sklearn` to the rescue! Let's create a `GradientBoostingClassifier`, which can be used for classification problems: ```python gb = GradientBoostingClassifier( learning_rate=.1, n_estimators=10 ) gb.fit(X_, y) ``` GradientBoostingClassifier(n_estimators=10) #### Include sampling Some implementations provide the ability to sample observations and features at each iteration, similarly to what happens with Random Forests. Unsurprisingly, this reduces overfitting at the expense of increased bias. ```python gb = GradientBoostingClassifier( learning_rate=.1, n_estimators=10, subsample=.5 ) gb.fit(X_, y) ``` GradientBoostingClassifier(n_estimators=10, subsample=0.5) # Conclusion You are now armed with the power of bagging and boosting, two techniques you can easily use to obtain models with a lot of expressive power that also generalize better! Hopefully, you also got some insight into the world of more advanced machine learning techniques. Make sure to review this notebook well, and when you're ready, go solve the exercises. Good luck!

6bc88c3d1295c5d3a5407c8ef30965529b8e4621

ipynb

Jupyter Notebook

S01 - Bootcamp and Binary Classification/SLU11 - Tree-Based Models/Learning notebook.ipynb

FarhadManiCodes/batch5-students

3a147145dc4f4ac65a851542987cf687b9915d5b

2022-02-04T17:40:04.000Z

2022-03-26T18:03:12.000Z

S01 - Bootcamp and Binary Classification/SLU11 - Tree-Based Models/Learning notebook.ipynb

FarhadManiCodes/batch5-students

3a147145dc4f4ac65a851542987cf687b9915d5b

S01 - Bootcamp and Binary Classification/SLU11 - Tree-Based Models/Learning notebook.ipynb

FarhadManiCodes/batch5-students

3a147145dc4f4ac65a851542987cf687b9915d5b

2021-10-30T16:20:13.000Z

2021-11-25T12:09:31.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

```python import numpy as np import matplotlib.pyplot as plt from sympy import * f, d, D, z, kx = symbols('f,d,D,Z, K_x') z = symbols('Z') Delta = Symbol("Delta") eq_right = Delta * z eq_left = Abs(1/d-1/(d+Delta*d))*f*D*kx Eq(eq_right, eq_left) ``` $\displaystyle \Delta Z = D K_{x} f \left|{\frac{1}{\Delta d + d} - \frac{1}{d}}\right|$ ```python # intrinsics: [1137.952358814274, 1139.2455706836256, 1040.2907098789112, 764.4019425366827] # resolution: [2048, 1536] # assuming that first entry of intrinsics is the kx parameter [pixels/inches] # error for given measured diameter d on image plane in meters def error_function(d, delta_d): delta_Z = D*f*kx*abs(1/(d+delta_d) - 1/d)*10**(-3) # factor at the end converts it to meters from cm return delta_Z kx = 1137.952358814274/2.54 # to turn [pixels/inches] to [pixels/cm] ky = 1139.2455706836256/2.54 # to turn [pixels/inches] to [pixels/cm] num_of_samples = 2048 d_d = 3 f = 1 D = 10 # d is diameter of ball in pixels (only integer numbers) d = np.linspace(1, 2048, num_of_samples, endpoint=True) delta_Z = error_function(d, d_d) print(delta_Z.shape) pprint(delta_Z) fig, ax = plt.subplots(nrows=1, ncols=3) fig.set_size_inches(h=14, w=21) fig.subplots_adjust(left=0.05, bottom=0.05, right=0.95, top=0.9, wspace=0.25, hspace=0.25) distance = np.linspace(0,100, num_of_samples, endpoint=True) # different distances (camera frame) to scale x_error and y_error # delta_x is in pixels for delta_x in range(1,10): delta_X = distance*delta_x/(kx*f) ax[0].plot(distance, delta_X, label='with delta_x: {}'.format(delta_x)) for delta_y in range(1,10): delta_Y = distance*delta_y/(ky*f) ax[1].plot(distance, delta_Y, label='with delta_y: {}'.format(delta_y)) for delta_d in range(1,10): delta_Z = error_function(d[:30], delta_d) ax[2].plot(d[:30], delta_Z, label='with delta_d: {}'.format(delta_d)) ax[0].set_xlabel('distance in Z-direction in meters') ax[0].set_ylabel('error in X-direction in meters') ax[0].legend() ax[1].set_xlabel('distance in Z-direction in meters') ax[1].set_ylabel('error in Y-direction in meters') ax[1].legend() ax[2].set_xlabel('diameter d in pixels') ax[2].set_ylabel('error in Z-direction in meters') ax[2].legend() plt.show() ``` ```python ```

db7d93839ef39f15c445d821d7063fb3ad55a6db

ipynb

Jupyter Notebook

measurement_model.ipynb

nanaimi/aux_tools

397fd959d48b616c604ac490bc007aacc51cd6ed

measurement_model.ipynb

nanaimi/aux_tools

397fd959d48b616c604ac490bc007aacc51cd6ed

measurement_model.ipynb

nanaimi/aux_tools

397fd959d48b616c604ac490bc007aacc51cd6ed

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Poisson Distribution > ***GitHub***: https://github.com/czs108 ## Definition \begin{equation} P(X = r) = \frac{e^{-\lambda} \cdot {\lambda}^{r}}{r!} \end{equation} \begin{equation} \lambda = \text{The mean number of occurrences in the interval or the rate of occurrence.} \end{equation} If 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 \begin{equation} X \sim Po(\lambda) \end{equation} ## Expectation \begin{equation} E(X) = \lambda \end{equation} ## Variance \begin{equation} Var(X) = \lambda \end{equation} ## Approximation A *Binomial Distribution* $X \sim B(n,\, p)$ can be approximated by $X \sim Po(np)$ if $n$ is *large* and $p$ is *small*. Because 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)$: \begin{equation} E(X) = np \end{equation} \begin{equation} Var(X) \approx np \end{equation} The approximation is typically very close if $n > 50$ and $p < 0.1$.

28bd062f42e394a77e59fa24b9aceb6a9aecc546

ipynb

Jupyter Notebook

exercises/Poisson Distribution.ipynb

czs108/Probability-Theory-Exercises

60c6546db1e7f075b311d1e59b0afc3a13d93229

exercises/Poisson Distribution.ipynb

czs108/Probability-Theory-Exercises

60c6546db1e7f075b311d1e59b0afc3a13d93229

exercises/Poisson Distribution.ipynb

czs108/Probability-Theory-Exercises

60c6546db1e7f075b311d1e59b0afc3a13d93229

2022-03-21T05:04:07.000Z

2022-03-21T05:04:07.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

<h1>SymPy: Open Source Symbolic Mathematics</h1> ``` %load_ext sympyprinting ``` ``` from __future__ import division from sympy import * x, y, z = symbols("x y z") k, m, n = symbols("k m n", integer=True) f, g, h = map(Function, 'fgh') ``` <h2>Elementary operations</h2> ``` Rational(3,2)*pi + exp(I*x) / (x**2 + y) ``` ``` exp(I*x).subs(x,pi).evalf() ``` ``` e = x + 2*y ``` ``` srepr(e) ``` Add(Symbol(&apos;x&apos;), Mul(Integer(2), Symbol(&apos;y&apos;))) ``` exp(pi * sqrt(163)).evalf(50) ``` <h2>Algebra<h2> ``` ((x+y)**2 * (x+1)).expand() ``` ``` a = 1/x + (x*sin(x) - 1)/x display(a) simplify(a) ``` ``` solve(Eq(x**3 + 2*x**2 + 4*x + 8, 0), x) ``` [-2⋅ⅈ, 2⋅ⅈ, -2] ``` a, b = symbols('a b') Sum(6*n**2 + 2**n, (n, a, b)) ``` <h2>Calculus</h2> ``` limit((sin(x)-x)/x**3, x, 0) ``` ``` (1/cos(x)).series(x, 0, 6) ``` ``` diff(cos(x**2)**2 / (1+x), x) ``` ``` integrate(x**2 * cos(x), (x, 0, pi/2)) ``` ``` eqn = Eq(Derivative(f(x),x,x) + 9*f(x), 1) display(eqn) dsolve(eqn, f(x)) ```

650b9291537b166ff3d4655fe5673e07652a4d9f

ipynb

Jupyter Notebook

docs/examples/notebooks/sympy.ipynb

tinyclues/ipython

71e32606b0242772b81c9be0d40751ba47d95f2c

2016-05-26T10:57:18.000Z

2016-05-26T10:57:18.000Z

docs/examples/notebooks/sympy.ipynb

adgaudio/ipython

a924f50c0f7b84127391f1c396326258c2b303e2

docs/examples/notebooks/sympy.ipynb

adgaudio/ipython

a924f50c0f7b84127391f1c396326258c2b303e2

Qwen/Qwen-72B

1. YES 2. YES

__label__kor_Hang

## Multiple Linear Regression We will see how multiple input variables together influence the output variable, while also learning how the calculations differ from that of Simple LR model. We will also build a regression model using Python. At last, we will go deeper into Linear Regression and will learn things like Multicollinearity, Hypothesis Testing, Feature Selection, and much more. ```python # Importing required libraries import pandas as pd import numpy as np %matplotlib inline import matplotlib.pyplot as plt from mpl_toolkits import mplot3d from mpl_toolkits.mplot3d import Axes3D ``` ### Advertising Data We are going to use Advertising data which is available on the site of USC Marshall School of Business. The advertising data set consists of the sales of a product in 200 different markets, along with advertising budgets for three different media: TV, radio, and newspaper. Loading and plotting the Data ```python data = pd.read_csv("Advertising.csv") data.drop("Unnamed: 0", axis =1,inplace=True) data ``` <div> <style scoped> .dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; } </style> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>TV</th> <th>Radio</th> <th>Newspaper</th> <th>Sales</th> </tr> </thead> <tbody> <tr> <th>0</th> <td>230.1</td> <td>37.8</td> <td>69.2</td> <td>22.1</td> </tr> <tr> <th>1</th> <td>44.5</td> <td>39.3</td> <td>45.1</td> <td>10.4</td> </tr> <tr> <th>2</th> <td>17.2</td> <td>45.9</td> <td>69.3</td> <td>9.3</td> </tr> <tr> <th>3</th> <td>151.5</td> <td>41.3</td> <td>58.5</td> <td>18.5</td> </tr> <tr> <th>4</th> <td>180.8</td> <td>10.8</td> <td>58.4</td> <td>12.9</td> </tr> <tr> <th>...</th> <td>...</td> <td>...</td> <td>...</td> <td>...</td> </tr> <tr> <th>195</th> <td>38.2</td> <td>3.7</td> <td>13.8</td> <td>7.6</td> </tr> <tr> <th>196</th> <td>94.2</td> <td>4.9</td> <td>8.1</td> <td>9.7</td> </tr> <tr> <th>197</th> <td>177.0</td> <td>9.3</td> <td>6.4</td> <td>12.8</td> </tr> <tr> <th>198</th> <td>283.6</td> <td>42.0</td> <td>66.2</td> <td>25.5</td> </tr> <tr> <th>199</th> <td>232.1</td> <td>8.6</td> <td>8.7</td> <td>13.4</td> </tr> </tbody> </table> <p>200 rows × 4 columns</p> </div> ```python plt.scatter(data.TV, data.Sales, color='blue', label='TV', alpha=0.5) plt.scatter(data.Radio, data.Sales, color='red', label='radio', alpha=0.5) plt.scatter(data.Newspaper, data.Sales, color='green', label='newspaper', alpha=0.5) plt.legend(loc="lower right") plt.title("Sales vs. Advertising") plt.xlabel("Advertising [1000 $]") plt.ylabel("Sales [Thousands of units]") plt.grid() plt.show() ``` ---- #### Mathematically, general Linear Regression model can be expressed as: \begin{align} Y= β_0+ β_1 X_1+ β_2 X_2+⋯+ β_p X_p \end{align} Here, Y is the output variable, and X terms are the corresponding input variables.The first β term (βo) is the intercept constant and is the value of Y in absence of all predictors (i.e when all X terms are 0). Finding the values of these constants(β) is what regression model does by minimizing the error function and fitting the best line or hyperplane (depending on the number of input variables). This is done by minimizing the Residual Sum of Squares (RSS), which is obtained by squaring the differences between actual and predicted outcomes. \begin{align} RSS=∑_i^n(y_i-y ̂_i )^2 \end{align} Because this method finds the least sum of squares, it is also known as the **Ordinary Least Squares** (OLS) method. There are two primary ways to implement the OLS algorithm: **Scikit Learn** and **Statsmodels** #### SciKit Learn: Just import the Linear Regression module from the Sklearn package and fit the model on the data. This method is pretty straightforward and you can see how to use it below. ```python from sklearn.linear_model import LinearRegression sk_model = LinearRegression() sk_model.fit(data.drop('Sales', axis=1), data.Sales) ``` LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False) ```python print("Intercept: ", sk_model.intercept_) print("Coefficients: ", sk_model.coef_) ``` Intercept: 2.938889369459412 Coefficients: [ 0.04576465 0.18853002 -0.00103749] #### Statsmodels Another way is to use the Statsmodels package to implement OLS. Statsmodels is a Python package that allows performing various statistical tests on the data. We will use it here because it will be helpful for us later as well. ```python # Importing statsmodels import statsmodels.formula.api as sm # Fitting the OLS on data model = sm.ols('Sales ~ TV + Radio + Newspaper', data).fit() print(model.params) ``` Intercept 2.938889 TV 0.045765 Radio 0.188530 Newspaper -0.001037 dtype: float64 /usr/local/lib/python3.7/dist-packages/statsmodels/tools/_testing.py:19: FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead. import pandas.util.testing as tm These results can be interpreted as follows: * If we fix the budget for TV & newspaper, then increasing the radio budget by 1000 USD will lead to an increase in sales by around **189 units**(0.189*1000). * Similarly, by fixing the radio & newspaper, we infer an approximate rise of **46 units** of products per 1000 USD increase in the TV budget. * However, for the newspaper budget, since the coefficient is quite negligible (close to zero), it’s evident that the newspaper is not affecting the sales. In fact, it’s on the negative side of zero(-0.001) which, if the magnitude was big enough, could have meant that this agent is rather causing the sales to fall. But we cannot make that kind of inference with such negligible value. If sales is regressed solely on newspaper (as shown below), the slope coefficient will come out to be 0.055, which is significanly large as compared to what we saw above. ```python # Simple Linear regression for sales vs newspaper model_npaper = sm.ols('Sales ~ Newspaper', data).fit() print(model_npaper.params) ``` Intercept 12.351407 Newspaper 0.054693 dtype: float64 #### This is explained by **Multicollinearity** Let's plot and observe the correlations among the variables ```python data.corr() ``` <div> <style scoped> .dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; } </style> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>TV</th> <th>Radio</th> <th>Newspaper</th> <th>Sales</th> </tr> </thead> <tbody> <tr> <th>TV</th> <td>1.000000</td> <td>0.054809</td> <td>0.056648</td> <td>0.782224</td> </tr> <tr> <th>Radio</th> <td>0.054809</td> <td>1.000000</td> <td>0.354104</td> <td>0.576223</td> </tr> <tr> <th>Newspaper</th> <td>0.056648</td> <td>0.354104</td> <td>1.000000</td> <td>0.228299</td> </tr> <tr> <th>Sales</th> <td>0.782224</td> <td>0.576223</td> <td>0.228299</td> <td>1.000000</td> </tr> </tbody> </table> </div> #### Plotting the heatmap to visualize the Correlation ```python # Plotting correlation heatmap plt.ylim(-.5,3.5) plt.imshow(data.corr(), cmap=plt.cm.GnBu, interpolation='nearest',data=True) plt.colorbar() tick_marks = [i for i in range(len(data.columns))] plt.xticks(tick_marks, data.columns, rotation=45) plt.yticks(tick_marks, data.columns, rotation=45) # Putting annotations for i in range(len(data.columns)): for j in range(len(data.columns)): text = '%.2f'%(data.corr().iloc[i,j]) plt.text(i-0.2,j-0.1,text) ``` The correlation between newspaper and radio is 0.35. This indicates a fair relationship between newspaper and radio budgets. Hence, it can be inferred that → when the radio budget is increased for a product, there’s a tendency to spend more on newspapers as well. This is called Multicollinearity and is referred to as a situation in which two or more input variables are linearly related. Hence, even though the Multiple Regression model shows no impact on sales by the newspaper, the Simple Regression model still does due to this multicollinearity and the absence of other input variables. $Sales & Radio → probable causation Newspaper & Radio → multicollinearity Sales & Newspaper → transitive correlation$ --- ### Hypothesis Testing One of the fundamental questions that should be answered while running Multiple Linear Regression is, whether or not, at least one of the predictors is useful in predicting the output. We saw that the three predictors TV, radio and newspaper had a different degree of linear relationship with the sales. But what if the relationship is just by chance and there is no actual impact on sales due to any of the predictors? The model can only give us numbers to establish a close enough linear relationship between the response variable and the predictors. However, it cannot prove the credibility of these relationships. To have some confidence, we take help from statistics and do something known as a Hypothesis Test. We start by forming a Null Hypothesis and a corresponding Alternative Hypothesis. <center> NULL HYPOTHESIS </center> \begin{align} H_0 : \beta_1 = \beta_2 = ... = \beta_p = 0 \end{align} \begin{align} H_0 : \beta_TV = \beta_radio = \beta_newspaper = 0 \end{align} <center> ALTERNATIVE HYPOTHESIS </center> \begin{align} H_a : At \: least \: one \: \beta_i \: is \: non-zero \end{align} The hypothesis test is performed by using F-Statistic. The formula for this statistic contains Residual Sum of Squares (RSS) and the Total Sum of Squares (TSS), which we can calculate using the Statsmodels. ```python print(model.summary2()) ``` Results: Ordinary least squares ================================================================= Model: OLS Adj. R-squared: 0.896 Dependent Variable: Sales AIC: 780.3622 Date: 2021-03-09 18:29 BIC: 793.5555 No. Observations: 200 Log-Likelihood: -386.18 Df Model: 3 F-statistic: 570.3 Df Residuals: 196 Prob (F-statistic): 1.58e-96 R-squared: 0.897 Scale: 2.8409 ------------------------------------------------------------------ Coef. Std.Err. t P>|t| [0.025 0.975] ------------------------------------------------------------------ Intercept 2.9389 0.3119 9.4223 0.0000 2.3238 3.5540 TV 0.0458 0.0014 32.8086 0.0000 0.0430 0.0485 Radio 0.1885 0.0086 21.8935 0.0000 0.1715 0.2055 Newspaper -0.0010 0.0059 -0.1767 0.8599 -0.0126 0.0105 ----------------------------------------------------------------- Omnibus: 60.414 Durbin-Watson: 2.084 Prob(Omnibus): 0.000 Jarque-Bera (JB): 151.241 Skew: -1.327 Prob(JB): 0.000 Kurtosis: 6.332 Condition No.: 454 ================================================================= If the value of F-statistic is equal to or very close to 1, then the results are in favor of the Null Hypothesis and we fail to reject it. But as we can see that the F-statistic is many folds larger than 1, thus providing strong evidence against the Null Hypothesis (that all coefficients are zero). Hence, we **reject the Null Hypothesis** and are confident that at least one predictor is useful in predicting the output. *Note that F-statistic is not suitable when the number of predictors(p) is large, or if p is greater than the number of data samples (n).* Hence, we can say that at least one of the three advertising agents is useful in predicting sales. But to find out, which predictor or predictors are useful and which one are not, we do **Feature Selection** Two of the ways of doing Feature Selection are **Forward Selecton** & **Backward Selection** Let's proceed with forward selection. We start with a model without any predictor and just the intercept term. We then perform simple linear regression for each predictor to find the best performer(lowest RSS). We then add another variable to it and check for the best 2-variable combination again by calculating the lowest RSS(Residual Sum of Squares). After that the best 3-variable combination is checked, and so on. The approach is stopped when some stopping rule is satisfied. ```python # Defining the function to evaluate amodel def evaluateModel (model): print("RSS = ", ((data.sales - model.predict())**2).sum()) print("R2 = ", model.rsquared) ``` Single Predictor Models ```python # For TV model_TV = sm.ols('Sales ~ TV', data=data).fit() print("model_TV") print(model_TV.summary()) print("------------") # For radio model_radio = sm.ols('Sales ~ Radio', data=data).fit() print("model_radio") print(model_radio.summary()) print("------------") # For newspaper model_newspaper = sm.ols('Sales ~ Newspaper', data=data).fit() print("model_newspaper") print(model_newspaper.summary()) print("------------") ``` model_TV OLS Regression Results ============================================================================== Dep. Variable: Sales R-squared: 0.612 Model: OLS Adj. R-squared: 0.610 Method: Least Squares F-statistic: 312.1 Date: Tue, 09 Mar 2021 Prob (F-statistic): 1.47e-42 Time: 18:29:01 Log-Likelihood: -519.05 No. Observations: 200 AIC: 1042. Df Residuals: 198 BIC: 1049. Df Model: 1 Covariance Type: nonrobust ============================================================================== coef std err t P>|t| [0.025 0.975] ------------------------------------------------------------------------------ Intercept 7.0326 0.458 15.360 0.000 6.130 7.935 TV 0.0475 0.003 17.668 0.000 0.042 0.053 ============================================================================== Omnibus: 0.531 Durbin-Watson: 1.935 Prob(Omnibus): 0.767 Jarque-Bera (JB): 0.669 Skew: -0.089 Prob(JB): 0.716 Kurtosis: 2.779 Cond. No. 338. ============================================================================== Warnings: [1] Standard Errors assume that the covariance matrix of the errors is correctly specified. ------------ model_radio OLS Regression Results ============================================================================== Dep. Variable: Sales R-squared: 0.332 Model: OLS Adj. R-squared: 0.329 Method: Least Squares F-statistic: 98.42 Date: Tue, 09 Mar 2021 Prob (F-statistic): 4.35e-19 Time: 18:29:01 Log-Likelihood: -573.34 No. Observations: 200 AIC: 1151. Df Residuals: 198 BIC: 1157. Df Model: 1 Covariance Type: nonrobust ============================================================================== coef std err t P>|t| [0.025 0.975] ------------------------------------------------------------------------------ Intercept 9.3116 0.563 16.542 0.000 8.202 10.422 Radio 0.2025 0.020 9.921 0.000 0.162 0.243 ============================================================================== Omnibus: 19.358 Durbin-Watson: 1.946 Prob(Omnibus): 0.000 Jarque-Bera (JB): 21.910 Skew: -0.764 Prob(JB): 1.75e-05 Kurtosis: 3.544 Cond. No. 51.4 ============================================================================== Warnings: [1] Standard Errors assume that the covariance matrix of the errors is correctly specified. ------------ model_newspaper OLS Regression Results ============================================================================== Dep. Variable: Sales R-squared: 0.052 Model: OLS Adj. R-squared: 0.047 Method: Least Squares F-statistic: 10.89 Date: Tue, 09 Mar 2021 Prob (F-statistic): 0.00115 Time: 18:29:01 Log-Likelihood: -608.34 No. Observations: 200 AIC: 1221. Df Residuals: 198 BIC: 1227. Df Model: 1 Covariance Type: nonrobust ============================================================================== coef std err t P>|t| [0.025 0.975] ------------------------------------------------------------------------------ Intercept 12.3514 0.621 19.876 0.000 11.126 13.577 Newspaper 0.0547 0.017 3.300 0.001 0.022 0.087 ============================================================================== Omnibus: 6.231 Durbin-Watson: 1.983 Prob(Omnibus): 0.044 Jarque-Bera (JB): 5.483 Skew: 0.330 Prob(JB): 0.0645 Kurtosis: 2.527 Cond. No. 64.7 ============================================================================== Warnings: [1] Standard Errors assume that the covariance matrix of the errors is correctly specified. ------------ We observe that for model_TV, the RSS is least and R² value is the most among all the models. Hence we select model_TV as our base model to move forward. Now, we will add the radio and newspaper one by one and check the new values. ```python # For TV & radio model_TV_radio = sm.ols('Sales ~ TV + Radio', data=data).fit() print("model_TV_radio") print(model_TV_radio.summary()) print("------------") # For TV & newspaper model_TV_newspaper = sm.ols('Sales ~ TV + Newspaper', data=data).fit() print("model_TV_newspaper") print(model_TV_newspaper.summary()) print("------------") ``` model_TV_radio OLS Regression Results ============================================================================== Dep. Variable: Sales R-squared: 0.897 Model: OLS Adj. R-squared: 0.896 Method: Least Squares F-statistic: 859.6 Date: Tue, 09 Mar 2021 Prob (F-statistic): 4.83e-98 Time: 18:29:01 Log-Likelihood: -386.20 No. Observations: 200 AIC: 778.4 Df Residuals: 197 BIC: 788.3 Df Model: 2 Covariance Type: nonrobust ============================================================================== coef std err t P>|t| [0.025 0.975] ------------------------------------------------------------------------------ Intercept 2.9211 0.294 9.919 0.000 2.340 3.502 TV 0.0458 0.001 32.909 0.000 0.043 0.048 Radio 0.1880 0.008 23.382 0.000 0.172 0.204 ============================================================================== Omnibus: 60.022 Durbin-Watson: 2.081 Prob(Omnibus): 0.000 Jarque-Bera (JB): 148.679 Skew: -1.323 Prob(JB): 5.19e-33 Kurtosis: 6.292 Cond. No. 425. ============================================================================== Warnings: [1] Standard Errors assume that the covariance matrix of the errors is correctly specified. ------------ model_TV_newspaper OLS Regression Results ============================================================================== Dep. Variable: Sales R-squared: 0.646 Model: OLS Adj. R-squared: 0.642 Method: Least Squares F-statistic: 179.6 Date: Tue, 09 Mar 2021 Prob (F-statistic): 3.95e-45 Time: 18:29:01 Log-Likelihood: -509.89 No. Observations: 200 AIC: 1026. Df Residuals: 197 BIC: 1036. Df Model: 2 Covariance Type: nonrobust ============================================================================== coef std err t P>|t| [0.025 0.975] ------------------------------------------------------------------------------ Intercept 5.7749 0.525 10.993 0.000 4.739 6.811 TV 0.0469 0.003 18.173 0.000 0.042 0.052 Newspaper 0.0442 0.010 4.346 0.000 0.024 0.064 ============================================================================== Omnibus: 0.658 Durbin-Watson: 1.969 Prob(Omnibus): 0.720 Jarque-Bera (JB): 0.415 Skew: -0.093 Prob(JB): 0.813 Kurtosis: 3.122 Cond. No. 410. ============================================================================== Warnings: [1] Standard Errors assume that the covariance matrix of the errors is correctly specified. ------------ As we can see that our values have improved tremendously in TV & radio model. RSS has increased and R² has decreased further, as compared to model_TV. It’s a good sign. On the other hand, it's not the same for TV and newspaper. The values have improved slightly by adding newspaper too, but not as significantly as with the radio. Hence, at this step, we will proceed with the TV & radio model and will observe the difference when we add newspaper to this model. ```python # For TV, radio & newspaper model_all = sm.ols('Sales ~ TV + Radio + Newspaper', data=data).fit() print("model_all") print(model_all.summary()) print("------------") ``` model_all OLS Regression Results ============================================================================== Dep. Variable: Sales R-squared: 0.897 Model: OLS Adj. R-squared: 0.896 Method: Least Squares F-statistic: 570.3 Date: Tue, 09 Mar 2021 Prob (F-statistic): 1.58e-96 Time: 18:29:02 Log-Likelihood: -386.18 No. Observations: 200 AIC: 780.4 Df Residuals: 196 BIC: 793.6 Df Model: 3 Covariance Type: nonrobust ============================================================================== coef std err t P>|t| [0.025 0.975] ------------------------------------------------------------------------------ Intercept 2.9389 0.312 9.422 0.000 2.324 3.554 TV 0.0458 0.001 32.809 0.000 0.043 0.049 Radio 0.1885 0.009 21.893 0.000 0.172 0.206 Newspaper -0.0010 0.006 -0.177 0.860 -0.013 0.011 ============================================================================== Omnibus: 60.414 Durbin-Watson: 2.084 Prob(Omnibus): 0.000 Jarque-Bera (JB): 151.241 Skew: -1.327 Prob(JB): 1.44e-33 Kurtosis: 6.332 Cond. No. 454. ============================================================================== Warnings: [1] Standard Errors assume that the covariance matrix of the errors is correctly specified. ------------ The values have not improved with any significance. Hence, it’s imperative to not add newspaper and finalize the model with TV and radio as selected features. So our final model can be expressed as below: \begin{align} sales = 2.92 + 0.046*TV + 0.188*radio \end{align} Plotting the variables TV, radio, and sales in the 3D graph, we can visualize how our model has fit a regression plane to the data. ```python fig = plt.figure(figsize=(12,10)) ax = fig.add_subplot(211, projection='3d') fig.suptitle('Regression: Sales ~ TV & radio Advertising') # Defining z function (or sales in terms of TV and radio) def z_function(x,y): return (2.938889 + (0.045765*y) + (0.188530*x)) X, Y = np.meshgrid(range(0,50,2),range(0,300,10)) Z = z_function(X, Y) ## Creating Wireframe ax.plot_wireframe(X, Y, Z, color='black') ax.set_xlabel('x') ax.set_ylabel('y') ax.set_zlabel('z') ## Creating Surface plot ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap='winter', edgecolor='black', alpha=0.5) ## Adding Scatter Plot ax.scatter(data.Radio, data.TV, data.Sales, c='red', s=25) ## Adding labels ax.set_xlabel('Radio') ax.set_ylabel('TV') ax.set_zlabel('Sales') ax.text(0,150,1, '@DataScienceWithSan') ## Rotating for better view ax.view_init(10,30) ```

6da3c734da62ed5271f59e32d2cf68280e7323f2

ipynb

Jupyter Notebook

05_Multi Linear Regression/03_Advertisment_Solution.ipynb

kunalk3/eR_task

4d717680576bc62793c42840e772a28fb3f6c223

2021-02-25T13:58:57.000Z

2021-02-25T13:58:57.000Z

05_Multi Linear Regression/03_Advertisment_Solution.ipynb

kunalk3/eR_task

4d717680576bc62793c42840e772a28fb3f6c223

05_Multi Linear Regression/03_Advertisment_Solution.ipynb

kunalk3/eR_task

4d717680576bc62793c42840e772a28fb3f6c223

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# hw 6: estimators learning objectives: * solidify "what is an estimator" * evaluate the effectiveness of an estimator computationally (through simulation) * understand the notion of unbiasedness, consistency, and efficiency of an estimator and evaluate these qualities computationally (through simulation) ```julia using StatsBase using Random using Statistics using PyPlot using PyCall sns = pyimport("seaborn") sns.set_context("talk"); ``` ┌ Info: Recompiling stale cache file C:\Users\cartemic\.julia\compiled\v1.2\StatsBase\EZjIG.ji for StatsBase [2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91] └ @ Base loading.jl:1240 ### what is the most important problem in your field? (0) It is important to effectively communicate with people from different fields. Introduce yourself to someone in the class from a different field of study (someone you haven't met). Ask them, "what is the most important problem in your field of study?". Then, argue/explain what you think is the most important problem in *your* field of study. Write the name of the student you spoke with and their field of study. I'd also be interested to read about what you think is the most important problem in your field (a few sentences), but this is not required. ("field of study" can be as general as "chemistry" or as specific as "self-assembly of nanoparticles".) I spoke with Heather Miller, whose field is humanitarian engineering ### counting (1) A biologist takes a random sample of six fish from a lake. The lake has ten distinct species of fish. It is possible for the biologist to select more than one fish of any given species. e.g., one outcome is: one fish of species $X$, two fish of species $Y$, and four fish of species $Z$. How many different samples could the biologist draw from the lake? * the sampling is done without replacement, but this is irrelevant since the lake contains more than six fish of each species * the order in which the fish are sampled does not matter * fish of a given species are indistinguishable Essentially what this question comes down to is that we have 10 distinct bins (i.e. species), and we want to know how many ways we can split up 6 particles (samples) between them. Pretty neat how partitioning just kind of... works for multisets like that. Anyway, from our class notes there are ${n + k - 1 \choose k - 1}$ ways to partition $n$ particles into $k$ bins. Interestingly, there are also ${n + k - 1 \choose n}$ ways to partition the same $n$ particles into the same $k$ bins because $${{n + k - 1} \choose k - 1} = \frac{(n + k - 1)!}{(k-1)!(n+k-1-k+1)!} = \frac{(n+k-1)!}{(k-1)!n!}$$ is equivalent to $${n + k - 1 \choose n} = \frac{(n + k - 1)!}{n!(n+k-1-n)!} = \frac{(n+k-1)!}{n!(k-1)!}$$ which means that, generally, $${m + n \choose m} = {m + n \choose n}$$ which is pretty cool. ```julia function n_choose_k(n::Int, k::Int) # using multiple divide operations to avoid overflow for larger values # of n, k return Int(factorial(n) / factorial(k) / factorial(n - k)) end @assert n_choose_k(7, 5) == 21 sample_size = 6 num_species = 10 n = sample_size + num_species - 1 k = sample_size fish_partitions = n_choose_k(n, k) println("There are $fish_partitions samples of fish that the biologist could collect.") ``` There are 5005 samples of fish that the biologist could collect. ### capture, mark, release, recapture In ecology, one wishes to estimate the size of a population (e.g. turtles). It is too costly and impractical to count *every* member of a population. One strategy is to: 1. capture a random sample from the population, without replacement 2. mark/tag each member of this random sample 3. release the marked sample back into the population 4. after sufficient time has passed, recapture another sample 5. count the number of marked members from the recaptured sample We assume that: * when the captured and marked sample is released back into the wild, they randomly (homogenously) mix with the rest of the (unmarked) population before we recapture * marking a member of the population does not change its likelihood of being recaptured * the time between capture/mark/release and recapture/count is short enough to neglect deaths, births, and migration out of the population define the variables: * $n$: the total number of turtles in the population (unknown) * $k$: number of turtles captured, marked, and released in the first phase * $k_r$: number of turtles recaptured * $m$: the number of recaptured turtles that had marks on them ##### Lincoln-Petersen estimator A very intuitive estimator is found by imposing that the proportion found marked in the recaptured sample is equal to the proportion of the population that was captured/marked/released in the first phase. \begin{equation} \frac{k}{n}=\frac{m}{k_r} \end{equation} giving the Lincoln-Petersen estimator for the population size $n$: \begin{equation} \hat{n} = \frac{k k_r}{m} \end{equation} ##### Chapmen estimator Chapmen derived a different estimator that we will compare to the Lincoln-Petersen estimator below. \begin{equation} \hat{n} = \frac{(k + 1) (k_r +1)}{m+1} - 1 \end{equation} #### estimating the population of turtles on a small island We wish to estimate the population of turtles on a small island by a capture, mark, release, and recapture strategy. (2) create a mutable data structure `Turtle` that represents a turtle in the population. It should have a single attribute, `marked`, that indicates whether it has been marked or not. ```julia mutable struct Turtle marked::Bool function Turtle() # new turtles aren't marked new(false) end end @assert !Turtle().marked ``` (3) write a function `create_population(nb_turtles::Int)` that creates a population of `nb_turtles` unmarked `Turtle`s. return the turtles as an `Array{Turtle}`. ```julia function create_population(nb_turtles::Int) return [Turtle() for _ in 1:nb_turtles] end @assert create_population(4) isa Array{Turtle} ``` (4) write a function `count_marked(turtles::Array{Turtle})` that takes in a population of turtles and returns the number of these turtles that are marked. ```julia turtles = create_population(500) count_marked(turtles) # should return zero ``` ```julia function count_marked(turtles::Array{Turtle}) sum([t.marked for t in turtles]) end turtles = create_population(500) @assert count_marked(turtles) == 0 [turtles[i].marked = true for i in 1:5] @assert count_marked(turtles) == 5 # put the test turtles back in the pond [t.marked = false for t in turtles]; ``` (5) write a function `capture_mark_release!` that takes in two arguments: * `turtles::Array{Turtle}` the population of turtles * `nb_capture_mark_release::Int` the number of turtles to randomly capture (select without replacement) and mark and modifies the `marked` attribute of `nb_capture_mark_release` randomly selected turtles in `turtles` to denote that they have been marked. think about why the function has an `!`. ```julia turtles = create_population(500) capture_mark_release!(turtles, 45) count_marked(turtles) # should return 45 ``` ```julia function capture_mark_release!( turtles::Array{Turtle}, nb_capture_mark_release ) selected = sample(turtles, nb_capture_mark_release, replace=false) for t in selected t.marked = true end end turtles = create_population(100) capture_mark_release!(turtles, 30) @assert count_marked(turtles) == 30 ``` (6) write a function `recapture(turtles::Array{Turtle}, nb_recapture::Int)` that returns a random sample (without replacement) of `nb_recapture` turtles from `turtles` in the form of an `Array{Turtle}`. ```julia turtles = create_population(500) capture_mark_release!(turtles, 45) recaptured_turtles = recapture(turtles, 50) # should return Array{Turtle} with 50 elements ``` ```julia function recapture(turtles::Array{Turtle}, nb_recapture::Int) return sample(turtles, nb_recapture, replace=false) end turtles = create_population(500) capture_mark_release!(turtles, 45) @assert length(recapture(turtles, 50)) == 50 ``` (7) write two functions, one for each estimator: * `chapman_estimator(nb_capture_mark_release::Int, nb_recapture::Int, nb_marked_in_recaptured::Int)` * `lincoln_petersen_estimator(nb_capture_mark_release::Int, nb_recapture::Int, nb_marked_in_recaptured::Int)` that each take in the entire population of turtles (marked and unmarked), `turtles`, and the array of recaptured turtles, `recaptured_turtles`, and returns the respective estimate $\hat{n}$ of the number of turtles. here, `nb_capture_mark_release` is $k$, `nb_recapture` is $k_r$, and `nb_marked_in_recaptured` is $m$. ```julia function chapman_estimator( nb_capture_mark_release::Int, nb_recapture::Int, nb_marked_in_recaptured::Int ) return (nb_capture_mark_release + 1) * (nb_recapture + 1) / (nb_marked_in_recaptured + 1) - 1 end ``` chapman_estimator (generic function with 1 method) ```julia function lincoln_petersen_estimator( nb_capture_mark_release::Int, nb_recapture::Int, nb_marked_in_recaptured::Int ) return nb_capture_mark_release * nb_recapture / nb_marked_in_recaptured end ``` lincoln_petersen_estimator (generic function with 1 method) (8) write a function `sim_capture_mark_release_recapture` that takes in: * `nb_turtles::Int` $=n$ * `nb_capture_mark_release::Int` $=k$ * `nb_recapture::Int` $=k_r$ * `estimator::Function` either `chapman_estimator` or `lincoln_peterson_estimator` that you wrote above and returns $\hat{n}$, the estimate of the number of turtles in this simulation. use all of the functions you wrote above. ```julia nb_turtles = 200 nb_capture_mark_release = 50 nb_recapture = 42 estimator = lincoln_petersen_estimator n̂ = sim_capture_mark_release_recapture( nb_turtles, nb_capture_mark_release, nb_recapture, estimator ) ``` ```julia function sim_capture_mark_release_recapture( nb_turtles::Int, nb_capture_mark_release::Int, nb_recapture::Int, estimator::Function ) turtles = create_population(nb_turtles) capture_mark_release!(turtles, nb_capture_mark_release) new_turtles = recapture(turtles, nb_recapture) nb_marked_in_recaptured = count_marked(new_turtles) estimator(nb_capture_mark_release, nb_recapture, nb_marked_in_recaptured) end ``` sim_capture_mark_release_recapture (generic function with 1 method) (9) evaluate/compare the biasedness of the Chapman and Lincoln-Peterson estimators by plotting the distribution of $\hat{n}$ over many capture, mark, release, recapture simulations. Label which histogram corresponds to which estimator (in a legend if in the same histogram panel or in a title if in two subplots). plot as a vertical line the true number of turtles for comparison. print off the average and standard deviation of $\hat{n}$ over the simulations. ```julia nb_turtles = 200 nb_capture_mark_release = 50 nb_recapture = 42 sims_range = 1:5000 # number of simulations face_color = "#fcf8eb" estimators = Dict( "Chapman" => Dict( "function" => chapman_estimator, "̂n" => [NaN for _ in sims_range] ), "Lincoln-Petersen" => Dict( "function" => lincoln_petersen_estimator, "̂n" => [NaN for _ in sims_range] ) ) fig, ax = subplots(2, 1, figsize=(18, 8), sharey=true) bins = range(0, stop=2*nb_turtles, length=16) est_keys = collect(keys(estimators)) num_keys = length(est_keys) avgs = [NaN for _ in 1:num_keys] stds = [NaN for _ in 1:num_keys] for (plot, name) in enumerate(est_keys) for i in sims_range estimators[name]["̂n"][i] = sim_capture_mark_release_recapture( nb_turtles, nb_capture_mark_release, nb_recapture, estimators[name]["function"] ) end ax[plot].hist( estimators[name]["̂n"], alpha=0.7, color="C$plot", label=name, bins=bins, density=true ) ax[plot].axvline(nb_turtles, color="k") ax[plot].set_xlabel("Estimated # Turtles") ax[plot].set_ylabel("Simulation Density") ax[plot].set_title("$name Estimator", weight="bold") ax[plot].set_xlim([0, 2*nb_turtles]) ax[plot].set_facecolor(face_color) avgs[plot] = mean(estimators[name]["̂n"]) stds[plot] = std(estimators[name]["̂n"]) println(name) println("=" ^ length(name)) println("avg ̂n:\t", avgs[plot]) println("std ̂n:\t", stds[plot]) println() end fig.tight_layout() sns.despine() println() println("least biased:\t", est_keys[argmin(avgs .- nb_turtles)]) println("most efficient:\t", est_keys[argmin(stds)]) ``` (10) comment on which estimator, Chapman or Lincoln-Petersen, that appears to be most unbiased. Based on the above simulations, the Chapman estimator appears unbiased, as well as more efficient. (11) evaluate the consistency of the Lincoln-Petersen estimator by plotting the simulated distribution of $\hat{n}$ for several different values of `nb_recapture`. Use 10000 simulations for each value of `nb_recapture`. ```julia recapture_range = 50:25:150 fig, ax = subplots(1, 1, figsize=(18, 8)) bins = range(0, stop=2*nb_turtles, length=16) sims_range = 1:10000 color_norm = PyPlot.matplotlib.colors.Normalize(vmin=50, vmax=150) kr_to_color = PyPlot.cm.ScalarMappable( norm=color_norm, cmap=get_cmap("viridis") ).to_rgba for nb_recapture in recapture_range n = [sim_capture_mark_release_recapture( nb_turtles, nb_capture_mark_release, nb_recapture, chapman_estimator ) for _ in sims_range] ax.hist( n, label=nb_recapture, alpha=0.4, density=true, color=kr_to_color(nb_recapture) ) end ax.axvline(nb_turtles, color="k") ax.set_xlabel("Estimated # Turtles") ax.set_ylabel("Simulation Density") ax.set_title("Chapman Consistency Evaluation", weight="bold") ax.legend(title="# Recaptured", frameon=false) ax.set_xlim([0, 2*nb_turtles]) ax.set_facecolor(face_color) sns.despine() ```

0387d7762847a676d2151bb5692542b8488188a2

ipynb

Jupyter Notebook

Homework/Homework 6/Homework 6.ipynb

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

a2afe72b51a3b9e844de94d59961bedc3534a405

Homework/Homework 6/Homework 6.ipynb

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

a2afe72b51a3b9e844de94d59961bedc3534a405

Homework/Homework 6/Homework 6.ipynb

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

a2afe72b51a3b9e844de94d59961bedc3534a405

2019-10-02T16:11:36.000Z

2019-10-15T20:10:40.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Simple Linear Regression with NumPy In school, students are taught to draw lines like the following. $$ y = 2 x + 1$$ They'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. ```python # Import matplotlib. import matplotlib.pyplot as plt # Draw some axes. plt.plot([0, 10], [0, 0], 'k-') plt.plot([0, 0], [0, 10], 'k-') # Plot the red, blue and green lines. plt.plot([1, 1], [-1, 3], 'b:') plt.plot([-1, 1], [3, 3], 'r:') ``` [<matplotlib.lines.Line2D at 0x764f6b0>] ```python # Import matplotlib. import matplotlib.pyplot as plt # Draw some axes. plt.plot([-1, 10], [0, 0], 'k-') plt.plot([0, 0], [-1, 10], 'k-') # Plot the red, blue and green lines. plt.plot([1, 1], [-1, 3], 'b:') plt.plot([-1, 1], [3, 3], 'r:') # Plot the two points (1,3) and (2,5). plt.plot([1, 2], [3, 5], 'ko') # Join them with an (extending) green lines. plt.plot([-1, 10], [-1, 21], 'g-') # Set some reasonable plot limits. plt.xlim([-1, 10]) plt.ylim([-1, 10]) # Show the plot. plt.show() ``` Simple 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. *** ## Example (contrived and simulated) #### Scenario Suppose 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? #### Hypothesis When 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. #### Experiment You 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. #### Analysis Here we'll import the Python libraries we need for or investigations below. ```python # Make matplotlib show interactive plots in the notebook. %matplotlib inline ``` ```python # numpy efficiently deals with numerical multi-dimensional arrays. import numpy as np # matplotlib is a plotting library, and pyplot is its easy-to-use module. import matplotlib.pyplot as plt # This just sets the default plot size to be bigger. plt.rcParams['figure.figsize'] = (8, 6) ``` Ignore 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. ```python w = np.arange(0.0, 21.0, 1.0) d = 5.0 * w + 10.0 + np.random.normal(0.0, 5.0, w.size) ``` ```python np.random.normal(0.0, 5.0, w.size) ``` array([ 7.76864124, 4.85760018, -0.68109271, 0.31446679, -3.56635431, -2.88521706, 0.41894594, -6.38556658, -0.82708525, 6.32974283, -6.88184383, -14.09388547, -2.83531469, -4.51188494, 2.3780392 , 3.63282701, -2.92077605, 4.65775214, -3.35318035, -2.84539091, -1.14529207]) ```python # Let's have a look at w. w ``` array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20.]) ```python # Let's have a look at d. d ``` array([ 13.19872125, 17.74325632, 12.51455027, 18.84140841, 30.70536085, 37.39378596, 28.8508251 , 46.49083068, 49.42916434, 63.70874352, 61.62885712, 60.0283102 , 75.08469992, 81.9319978 , 79.69408215, 81.73271907, 84.66041043, 96.89873735, 106.22136569, 102.47469234, 113.93805149]) Let's have a look at the data from our experiment. ```python # Create the plot. plt.plot(w, d, 'k.') # Set some properties for the plot. plt.xlabel('Weight (KG)') plt.ylabel('Distance (CM)') # Show the plot. plt.show() ``` #### Model It 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. #### Straight lines All 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. #### Fitting the model To 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$. ```python # Plot w versus d with black dots. plt.plot(w, d, 'k.', label="Data") # Overlay some lines on the plot. x = np.arange(0.0, 21.0, 1.0) plt.plot(x, 5.0 * x + 10.0, 'r-', label=r"$5x + 10$") plt.plot(x, 6.0 * x + 5.0, 'g-', label=r"$6x + 5$") plt.plot(x, 5.0 * x + 15.0, 'b-', label=r"$5x + 15$") # Add a legend. plt.legend() # Add axis labels. plt.xlabel('Weight (KG)') plt.ylabel('Distance (CM)') # Show the plot. plt.show() ``` #### Calculating the cost You 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? It 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. $$ \sum_i (y_i - mx_i - c)^2 $$ Here $(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)$. Where 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$. Why 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. ```python # Calculate the cost of the lines above for the data above. cost = lambda m,c: np.sum([(d[i] - m * w[i] - c)**2 for i in range(w.size)]) print("Cost with m = %5.2f and c = %5.2f: %8.2f" % (5.0, 10.0, cost(5.0, 10.0))) print("Cost with m = %5.2f and c = %5.2f: %8.2f" % (6.0, 5.0, cost(6.0, 5.0))) print("Cost with m = %5.2f and c = %5.2f: %8.2f" % (5.0, 15.0, cost(5.0, 15.0))) ``` Cost with m = 5.00 and c = 10.00: 525.39 Cost with m = 6.00 and c = 5.00: 1551.12 Cost with m = 5.00 and c = 15.00: 1018.69 #### Minimising the cost We 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: $$ Cost(m, c) = \sum_i (y_i - mx_i - c)^2 $$ This 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. In 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$. Remember that in our dataset $x$ is called $w$ (for weight) and $y$ is called $d$ (for distance). We calculate $m$ and $c$ below. ```python # Calculate the best values for m and c. # First calculate the means (a.k.a. averages) of w and d. w_avg = np.mean(w) d_avg = np.mean(d) # Subtract means from w and d. w_zero = w - w_avg d_zero = d - d_avg # The best m is found by the following calculation. m = np.sum(w_zero * d_zero) / np.sum(w_zero * w_zero) # Use m from above to calculate the best c. c = d_avg - m * w_avg print("m is %8.6f and c is %6.6f." % (m, c)) ``` m is 5.154265 and c is 8.608328. 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. ```python np.polyfit(w, d, 1) ``` array([5.15426517, 8.60832781]) ```python # z=np.polyfit(w, d, 1) plt.plot(w, d, 'k.', label='Original data') plt.plot(z, 'b-', label='Best fit line') # Add axis labels and a legend. plt.xlabel('Weight (KG)') plt.ylabel('Distance (CM)') plt.legend() # Show the plot. plt.show() ``` #### Best fit line So, 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. ```python # Plot the best fit line. plt.plot(w, d, 'k.', label='Original data') plt.plot(w, m * w + c, 'b-', label='Best fit line') # Add axis labels and a legend. plt.xlabel('Weight (KG)') plt.ylabel('Distance (CM)') plt.legend() # Show the plot. plt.show() ``` Note that the $Cost$ of the best $m$ and best $c$ is not zero in this case. ```python print("Cost with m = %5.2f and c = %5.2f: %8.2f" % (m, c, cost(m, c))) ``` Cost with m = 5.15 and c = 8.61: 506.59 ### Summary In this notebook we: 1. Investigated the data. 2. Picked a model. 3. Picked a cost function. 4. Estimated the model parameter values that minimised our cost function. ### Advanced In the following sections we cover some of the more advanced concepts involved in fitting the line. #### Simulating data Earlier 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. We ran the following two commands to do this: ```python w = np.arange(0.0, 21.0, 1.0) d = 5.0 * w + 10.0 + np.random.normal(0.0, 5.0, w.size) ``` The 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. ```python np.arange(0.0, 21.0, 1.0) ``` array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20.]) 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. ```python 5.0 * w + 10.0 ``` array([ 10., 15., 20., 25., 30., 35., 40., 45., 50., 55., 60., 65., 70., 75., 80., 85., 90., 95., 100., 105., 110.]) It then adds an array of the same length containing random values. The values are taken from what is called the normal distribution with mean 0.0 and standard deviation 5.0. ```python np.random.normal(0.0, 5.0, w.size) ``` array([-1.46317757, 5.30481846, -3.49158247, -2.52540294, -1.37674985, -2.78091921, -7.5305471 , -8.2341408 , 1.44809467, -3.12508821, -0.06114925, 1.96890369, -2.53676148, 4.33296745, 2.43633524, -4.09099253, 1.74922495, 2.59597544, -0.68926184, -4.92585686, -2.78279611]) 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). ```python # Plot the normal distrution. normpdf = lambda mu, s, x: (1.0 / (2.0 * np.pi * s**2)) * np.exp(-((x - mu)**2)/(2 * s**2)) x = np.linspace(-20.0, 20.0, 100) y = normpdf(0.0, 5.0, x) plt.plot(x, y) plt.show() ``` The 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](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!) #### Plotting the cost function We 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: $$ Cost(m,c) = \sum_i (y_i - mx_i - c)^2 $$ To 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. ```python # This code is a little bit involved - don't worry about it. # Just look at the plot below. from mpl_toolkits.mplot3d import Axes3D # Ask pyplot a 3D set of axes. ax = plt.figure().gca(projection='3d') # Make data. mvals = np.linspace(4.5, 5.5, 100) cvals = np.linspace(0.0, 20.0, 100) # Fill the grid. mvals, cvals = np.meshgrid(mvals, cvals) # Flatten the meshes for convenience. mflat = np.ravel(mvals) cflat = np.ravel(cvals) # Calculate the cost of each point on the grid. C = [np.sum([(d[i] - m * w[i] - c)**2 for i in range(w.size)]) for m, c in zip(mflat, cflat)] C = np.array(C).reshape(mvals.shape) # Plot the surface. surf = ax.plot_surface(mvals, cvals, C) # Set the axis labels. ax.set_xlabel('$m$', fontsize=16) ax.set_ylabel('$c$', fontsize=16) ax.set_zlabel('$Cost$', fontsize=16) # Show the plot. plt.show() ``` #### Coefficient of determination Earlier 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$. For 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. The 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: $$ R^2 = 1 - \frac{\sum_i (y_i - m x_i - c)^2}{\sum_i (y_i - \bar{y})^2} $$ Note that sometimes the [*Pearson correlation coefficient*](https://en.wikipedia.org/wiki/Pearson_correlation_coefficient) is used instead of the R-squared value. You can just square the Pearson coefficient to get the R-squred value. ```python # Calculate the R-squared value for our data set. rsq = 1.0 - (np.sum((d - m * w - c)**2)/np.sum((d - d_avg)**2)) print("The R-squared value is %6.4f" % rsq) ``` The R-squared value is 0.9758 ```python # The same value using numpy. np.corrcoef(w, d)[0][1]**2 ``` 0.9758337791380363 #### The minimisation calculations Earlier we used the following calculation to calculate $m$ and $c$ for the line of best fit. The code was: ```python w_zero = w - np.mean(w) d_zero = d - np.mean(d) m = np.sum(w_zero * d_zero) / np.sum(w_zero * w_zero) c = np.mean(d) - m * np.mean(w) ``` In mathematical notation we write this as: $$ 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} $$ where $\bar{x}$ is the mean of $x$ and $\bar{y}$ that of $y$. Where 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! The 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. ###### Calculate the partial derivatives $$ \begin{align} Cost(m, c) &= \sum_i (y_i - mx_i - c)^2 \\[1cm] \frac{\partial Cost}{\partial m} &= \sum 2(y_i - m x_i -c)(-x_i) \\ &= -2 \sum x_i (y_i - m x_i -c) \\[0.5cm] \frac{\partial Cost}{\partial c} & = \sum 2(y_i - m x_i -c)(-1) \\ & = -2 \sum (y_i - m x_i -c) \\ \end{align} $$ ###### Set to zero $$ \begin{align} & \frac{\partial Cost}{\partial m} = 0 \\[0.2cm] & \Rightarrow -2 \sum x_i (y_i - m x_i -c) = 0 \\ & \Rightarrow \sum (x_i y_i - m x_i x_i - x_i c) = 0 \\ & \Rightarrow \sum x_i y_i - \sum_i m x_i x_i - \sum x_i c = 0 \\ & \Rightarrow m \sum x_i x_i = \sum x_i y_i - c \sum x_i \\[0.2cm] & \Rightarrow m = \frac{\sum x_i y_i - c \sum x_i}{\sum x_i x_i} \\[0.5cm] & \frac{\partial Cost}{\partial c} = 0 \\[0.2cm] & \Rightarrow -2 \sum (y_i - m x_i - c) = 0 \\ & \Rightarrow \sum y_i - \sum_i m x_i - \sum c = 0 \\ & \Rightarrow \sum y_i - m \sum_i x_i = c \sum 1 \\ & \Rightarrow c = \frac{\sum y_i - m \sum x_i}{\sum 1} \\ & \Rightarrow c = \frac{\sum y_i}{\sum 1} - m \frac{\sum x_i}{\sum 1} \\[0.2cm] & \Rightarrow c = \bar{y} - m \bar{x} \\ \end{align} $$ ###### Solve the simultaneous equations Here we let $n$ be the length of $x$, which is also the length of $y$. $$ \begin{align} & m = \frac{\sum_i x_i y_i - c \sum_i x_i}{\sum_i x_i x_i} \\[0.2cm] & \Rightarrow m = \frac{\sum x_i y_i - (\bar{y} - m \bar{x}) \sum x_i}{\sum x_i x_i} \\ & \Rightarrow m \sum x_i x_i = \sum x_i y_i - \bar{y} \sum x_i + m \bar{x} \sum x_i \\ & \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] & \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] & \Rightarrow m = \frac{\sum (x_i y_i) - n \bar{y} \bar{x}}{\sum (x_i x_i) - n \bar{x} \bar{x}} \\ & \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}} \\ & \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}} \\ & \Rightarrow m = \frac{\sum_i (x_i - \bar{x}) (y_i - \bar{y})}{\sum_i (x_i - \bar{x})^2} \\ \end{align} $$ #### End ```python ```

c6d6c8de8171f8aedd804b06ae6ed3ad2723e18e

ipynb

Jupyter Notebook

simple-linear-regression.ipynb

mikequaid/numpy

350e0dc3d2bc482c69be60b41619fc710a778eb3

simple-linear-regression.ipynb

mikequaid/numpy

350e0dc3d2bc482c69be60b41619fc710a778eb3

simple-linear-regression.ipynb

mikequaid/numpy

350e0dc3d2bc482c69be60b41619fc710a778eb3

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# ADM Quantities in terms of BSSN Quantities ## Author: Zach Etienne ### Formatting improvements courtesy Brandon Clark [comment]: <> (Abstract: TODO) **Module Status:** <font color='orange'><b> Self-Validated </b></font> **Validation Notes:** This tutorial module has been confirmed to be self-consistent with its corresponding NRPy+ module, as documented [below](#code_validation). **Additional validation tests may have been performed, but are as yet, undocumented. (TODO)** ### NRPy+ Source Code for this module: [ADM_in_terms_of_BSSN.py](../edit/BSSN/ADM_in_terms_of_BSSN.py) ## Introduction: This tutorial module constructs all quantities in the [ADM formalism](https://en.wikipedia.org/wiki/ADM_formalism) (see also Chapter 2 in Baumgarte & Shapiro's book *Numerical Relativity*) in terms of quantities in our adopted (covariant, tensor-rescaled) BSSN formalism. That is to say, we will write the ADM quantities $\left\{\gamma_{ij},K_{ij},\alpha,\beta^i\right\}$ and their derivatives in terms of the BSSN quantities $\left\{\bar{\gamma}_{ij},\text{cf},\bar{A}_{ij},\text{tr}K,\alpha,\beta^i\right\}$ and their derivatives. ### A Note on Notation: As is standard in NRPy+, * Greek indices refer to four-dimensional quantities where the zeroth component indicates temporal (time) component. * Latin indices refer to three-dimensional quantities. This is somewhat counterintuitive since Python always indexes its lists starting from 0. As a result, the zeroth component of three-dimensional quantities will necessarily indicate the first *spatial* direction. As a corollary, any expressions in NRPy+ involving mixed Greek and Latin indices will need to offset one set of indices by one; a Latin index in a four-vector will be incremented and a Greek index in a three-vector will be decremented (however, the latter case does not occur in this tutorial module). <a id='toc'></a> # Table of Contents $$\label{toc}$$ This module is organized as follows 1. [Step 1](#initializenrpy): Initialize core Python/NRPy+ modules 1. [Step 2](#threemetric): The ADM three-metric $\gamma_{ij}$ and its derivatives in terms of rescaled BSSN quantities 1. [Step 2.a](#derivatives_e4phi): Derivatives of $e^{4\phi}$ 1. [Step 2.b](#derivatives_adm_3metric): Derivatives of the ADM three-metric: $\gamma_{ij,k}$ and $\gamma_{ij,kl}$ 1. [Step 2.c](#christoffel): Christoffel symbols $\Gamma^i_{jk}$ associated with the ADM 3-metric $\gamma_{ij}$ 1. [Step 3](#extrinsiccurvature): The ADM extrinsic curvature $K_{ij}$ and its derivatives in terms of rescaled BSSN quantities 1. [Step 4](#code_validation): Code Validation against `BSSN.ADM_in_terms_of_BSSN` NRPy+ module 1. [Step 5](#latex_pdf_output): Output this module to $\LaTeX$-formatted PDF file <a id='initializenrpy'></a> # Step 1: Initialize core Python/NRPy+ modules \[Back to [top](#toc)\] $$\label{initializenrpy}$$ Let's start by importing all the needed modules from Python/NRPy+: ```python # Step 1.a: Import all needed modules from NRPy+ import sympy as sp import NRPy_param_funcs as par import indexedexp as ixp import grid as gri import finite_difference as fin import reference_metric as rfm # Step 1.b: Set the coordinate system for the numerical grid par.set_parval_from_str("reference_metric::CoordSystem","Spherical") # Step 1.c: Given the chosen coordinate system, set up # corresponding reference metric and needed # reference metric quantities # The following function call sets up the reference metric # and related quantities, including rescaling matrices ReDD, # ReU, and hatted quantities. rfm.reference_metric() # Step 1.d: Set spatial dimension (must be 3 for BSSN, as BSSN is # a 3+1-dimensional decomposition of the general # relativistic field equations) DIM = 3 # Step 1.e: Import all basic (unrescaled) BSSN scalars & tensors import BSSN.BSSN_quantities as Bq Bq.BSSN_basic_tensors() gammabarDD = Bq.gammabarDD cf = Bq.cf AbarDD = Bq.AbarDD trK = Bq.trK Bq.gammabar__inverse_and_derivs() gammabarDD_dD = Bq.gammabarDD_dD gammabarDD_dDD = Bq.gammabarDD_dDD Bq.AbarUU_AbarUD_trAbar_AbarDD_dD() AbarDD_dD = Bq.AbarDD_dD ``` <a id='threemetric'></a> # Step 2: The ADM three-metric $\gamma_{ij}$ and its derivatives in terms of rescaled BSSN quantities. \[Back to [top](#toc)\] $$\label{threemetric}$$ The ADM three-metric is written in terms of the covariant BSSN three-metric tensor as (Eqs. 2 and 3 of [Ruchlin *et al.*](https://arxiv.org/pdf/1712.07658.pdf)): $$ \gamma_{ij} = \left(\frac{\gamma}{\bar{\gamma}}\right)^{1/3} \bar{\gamma}_{i j}, $$ where $\gamma=\det{\gamma_{ij}}$ and $\bar{\gamma}=\det{\bar{\gamma}_{ij}}$. The "standard" BSSN conformal factor $\phi$ is given by (Eq. 3 of [Ruchlin *et al.*](https://arxiv.org/pdf/1712.07658.pdf)): \begin{align} \phi &= \frac{1}{12} \log\left(\frac{\gamma}{\bar{\gamma}}\right) \\ \implies e^{\phi} &= \left(\frac{\gamma}{\bar{\gamma}}\right)^{1/12} \\ \implies e^{4 \phi} &= \left(\frac{\gamma}{\bar{\gamma}}\right)^{1/3} \end{align} Thus the ADM three-metric may be written in terms of the BSSN three-metric and conformal factor $\phi$ as $$ \gamma_{ij} = e^{4 \phi} \bar{\gamma}_{i j}. $$ NRPy+'s implementation of BSSN allows for $\phi$ and two other alternative conformal factors to be defined: \begin{align} \chi &= e^{-4\phi} \\ W &= e^{-2\phi}, \end{align} Thus if `"BSSN_quantities::EvolvedConformalFactor_cf"` is set to `"chi"`, then \begin{align} \gamma_{ij} &= \frac{1}{\chi} \bar{\gamma}_{i j} \\ &= \frac{1}{\text{cf}} \bar{\gamma}_{i j}, \end{align} and if `"BSSN_quantities::EvolvedConformalFactor_cf"` is set to `"W"`, then \begin{align} \gamma_{ij} &= \frac{1}{W^2} \bar{\gamma}_{i j} \\ &= \frac{1}{\text{cf}^2} \bar{\gamma}_{i j}. \end{align} ```python # Step 2: The ADM three-metric gammaDD and its # derivatives in terms of BSSN quantities. gammaDD = ixp.zerorank2() exp4phi = sp.sympify(0) if par.parval_from_str("EvolvedConformalFactor_cf") == "phi": exp4phi = sp.exp(4*cf) elif par.parval_from_str("EvolvedConformalFactor_cf") == "chi": exp4phi = (1 / cf) elif par.parval_from_str("EvolvedConformalFactor_cf") == "W": exp4phi = (1 / cf**2) else: print("Error EvolvedConformalFactor_cf type = \""+par.parval_from_str("EvolvedConformalFactor_cf")+"\" unknown.") exit(1) for i in range(DIM): for j in range(DIM): gammaDD[i][j] = exp4phi*gammabarDD[i][j] ``` <a id='derivatives_e4phi'></a> ## Step 2.a: Derivatives of $e^{4\phi}$ \[Back to [top](#toc)\] $$\label{derivatives_e4phi}$$ To compute derivatives of $\gamma_{ij}$ in terms of BSSN variables and their derivatives, we will first need derivatives of $e^{4\phi}$ in terms of the conformal BSSN variable `cf`. \begin{align} \frac{\partial}{\partial x^i} e^{4\phi} &= 4 e^{4\phi} \phi_{,i} \\ \implies \frac{\partial}{\partial x^j} \frac{\partial}{\partial x^i} e^{4\phi} &= \frac{\partial}{\partial x^j} \left(4 e^{4\phi} \phi_{,i}\right) \\ &= 16 e^{4\phi} \phi_{,i} \phi_{,j} + 4 e^{4\phi} \phi_{,ij} \end{align} Thus computing first and second derivatives of $e^{4\phi}$ in terms of the BSSN quantity `cf` requires only that we evaluate $\phi_{,i}$ and $\phi_{,ij}$ in terms of $e^{4\phi}$ (computed above in terms of `cf`) and derivatives of `cf`: If `"BSSN_quantities::EvolvedConformalFactor_cf"` is set to `"phi"`, then \begin{align} \phi_{,i} &= \text{cf}_{,i} \\ \phi_{,ij} &= \text{cf}_{,ij} \end{align} If `"BSSN_quantities::EvolvedConformalFactor_cf"` is set to `"chi"`, then \begin{align} \text{cf} = e^{-4\phi} \implies \text{cf}_{,i} &= -4 e^{-4\phi} \phi_{,i} \\ \implies \phi_{,i} &= -\frac{e^{4\phi}}{4} \text{cf}_{,i} \\ \implies \phi_{,ij} &= -e^{4\phi} \phi_{,j} \text{cf}_{,i} -\frac{e^{4\phi}}{4} \text{cf}_{,ij}\\ &= -e^{4\phi} \left(-\frac{e^{4\phi}}{4} \text{cf}_{,j}\right) \text{cf}_{,i} -\frac{e^{4\phi}}{4} \text{cf}_{,ij} \\ &= \frac{1}{4} \left[\left(e^{4\phi}\right)^2 \text{cf}_{,i} \text{cf}_{,j} -e^{4\phi} \text{cf}_{,ij}\right] \\ \end{align} If `"BSSN_quantities::EvolvedConformalFactor_cf"` is set to `"W"`, then \begin{align} \text{cf} = e^{-2\phi} \implies \text{cf}_{,i} &= -2 e^{-2\phi} \phi_{,i} \\ \implies \phi_{,i} &= -\frac{e^{2\phi}}{2} \text{cf}_{,i} \\ \implies \phi_{,ij} &= -e^{2\phi} \phi_{,j} \text{cf}_{,i} -\frac{e^{2\phi}}{2} \text{cf}_{,ij}\\ &= -e^{2\phi} \left(-\frac{e^{2\phi}}{2} \text{cf}_{,j}\right) \text{cf}_{,i} -\frac{e^{2\phi}}{2} \text{cf}_{,ij} \\ &= \frac{1}{2} \left[e^{4\phi} \text{cf}_{,i} \text{cf}_{,j} -e^{2\phi} \text{cf}_{,ij}\right] \\ \end{align} ```python # Step 2.a: Derivatives of $e^{4\phi}$ phidD = ixp.zerorank1() phidDD = ixp.zerorank2() cf_dD = ixp.declarerank1("cf_dD") cf_dDD = ixp.declarerank2("cf_dDD","sym01") if par.parval_from_str("EvolvedConformalFactor_cf") == "phi": for i in range(DIM): phidD[i] = cf_dD[i] for j in range(DIM): phidDD[i][j] = cf_dDD[i][j] elif par.parval_from_str("EvolvedConformalFactor_cf") == "chi": for i in range(DIM): phidD[i] = -sp.Rational(1,4)*exp4phi*cf_dD[i] for j in range(DIM): phidDD[i][j] = sp.Rational(1,4)*( exp4phi**2*cf_dD[i]*cf_dD[j] - exp4phi*cf_dDD[i][j] ) elif par.parval_from_str("EvolvedConformalFactor_cf") == "W": exp2phi = (1 / cf) for i in range(DIM): phidD[i] = -sp.Rational(1,2)*exp2phi*cf_dD[i] for j in range(DIM): phidDD[i][j] = sp.Rational(1,2)*( exp4phi*cf_dD[i]*cf_dD[j] - exp2phi*cf_dDD[i][j] ) else: print("Error EvolvedConformalFactor_cf type = \""+par.parval_from_str("EvolvedConformalFactor_cf")+"\" unknown.") exit(1) exp4phidD = ixp.zerorank1() exp4phidDD = ixp.zerorank2() for i in range(DIM): exp4phidD[i] = 4*exp4phi*phidD[i] for j in range(DIM): exp4phidDD[i][j] = 16*exp4phi*phidD[i]*phidD[j] + 4*exp4phi*phidDD[i][j] ``` <a id='derivatives_adm_3metric'></a> ## Step 2.b: Derivatives of the ADM three-metric: $\gamma_{ij,k}$ and $\gamma_{ij,kl}$ \[Back to [top](#toc)\] $$\label{derivatives_adm_3metric}$$ Recall the relation between the ADM three-metric $\gamma_{ij}$, the BSSN conformal three-metric $\bar{\gamma}_{i j}$, and the BSSN conformal factor $\phi$: $$ \gamma_{ij} = e^{4 \phi} \bar{\gamma}_{i j}. $$ Now that we have constructed derivatives of $e^{4 \phi}$ in terms of the chosen BSSN conformal factor `cf`, and the [BSSN.BSSN_quantities module](../edit/BSSN/BSSN_quantities.py) ([**tutorial**](Tutorial-BSSN_quantities.ipynb)) defines derivatives of $\bar{\gamma}_{ij}$ in terms of rescaled BSSN variables, derivatives of $\gamma_{ij}$ can be immediately constructed using the product rule: \begin{align} \gamma_{ij,k} &= \left(e^{4 \phi}\right)_{,k} \bar{\gamma}_{i j} + e^{4 \phi} \bar{\gamma}_{ij,k} \\ \gamma_{ij,kl} &= \left(e^{4 \phi}\right)_{,kl} \bar{\gamma}_{i j} + \left(e^{4 \phi}\right)_{,k} \bar{\gamma}_{i j,l} + \left(e^{4 \phi}\right)_{,l} \bar{\gamma}_{ij,k} + e^{4 \phi} \bar{\gamma}_{ij,kl} \end{align} ```python # Step 2.b: Derivatives of gammaDD, the ADM three-metric gammaDDdD = ixp.zerorank3() gammaDDdDD = ixp.zerorank4() for i in range(DIM): for j in range(DIM): for k in range(DIM): gammaDDdD[i][j][k] = exp4phidD[k]*gammabarDD[i][j] + exp4phi*gammabarDD_dD[i][j][k] for l in range(DIM): gammaDDdDD[i][j][k][l] = exp4phidDD[k][l]*gammabarDD[i][j] + \ exp4phidD[k]*gammabarDD_dD[i][j][l] + \ exp4phidD[l]*gammabarDD_dD[i][j][k] + \ exp4phi*gammabarDD_dDD[i][j][k][l] ``` <a id='christoffel'></a> ## Step 2.c: Christoffel symbols $\Gamma^i_{jk}$ associated with the ADM 3-metric $\gamma_{ij}$ \[Back to [top](#toc)\] $$\label{christoffel}$$ The 3-metric analog to the definition of Christoffel symbol (Eq. 1.18) in Baumgarte & Shapiro's *Numerical Relativity* is given by $$ \Gamma^i_{jk} = \frac{1}{2} \gamma^{il} \left(\gamma_{lj,k} + \gamma_{lk,j} - \gamma_{jk,l} \right), $$ which we implement here: ```python # Step 2.c: 3-Christoffel symbols associated with ADM 3-metric gammaDD # Step 2.c.i: First compute the inverse 3-metric gammaUU: gammaUU, detgamma = ixp.symm_matrix_inverter3x3(gammaDD) GammaUDD = ixp.zerorank3() for i in range(DIM): for j in range(DIM): for k in range(DIM): for l in range(DIM): GammaUDD[i][j][k] += sp.Rational(1,2)*gammaUU[i][l]* \ (gammaDDdD[l][j][k] + gammaDDdD[l][k][j] - gammaDDdD[j][k][l]) ``` <a id='extrinsiccurvature'></a> # Step 3: The ADM extrinsic curvature $K_{ij}$ and its derivatives in terms of rescaled BSSN quantities. \[Back to [top](#toc)\] $$\label{extrinsiccurvature}$$ The ADM extrinsic curvature may be written in terms of the BSSN trace-free extrinsic curvature tensor $\bar{A}_{ij}$ and the trace of the ADM extrinsic curvature $K$: \begin{align} K_{ij} &= \left(\frac{\gamma}{\bar{\gamma}}\right)^{1/3} \bar{A}_{ij} + \frac{1}{3} \gamma_{ij} K \\ &= e^{4\phi} \bar{A}_{ij} + \frac{1}{3} \gamma_{ij} K \\ \end{align} We only compute first spatial derivatives of $K_{ij}$, as higher-derivatives are generally not needed: $$ K_{ij,k} = \left(e^{4\phi}\right)_{,k} \bar{A}_{ij} + e^{4\phi} \bar{A}_{ij,k} + \frac{1}{3} \left(\gamma_{ij,k} K + \gamma_{ij} K_{,k}\right) $$ which is expressed in terms of quantities already defined. ```python # Step 3: Define ADM extrinsic curvature KDD and # its first spatial derivatives KDDdD # in terms of BSSN quantities KDD = ixp.zerorank2() for i in range(DIM): for j in range(DIM): KDD[i][j] = exp4phi*AbarDD[i][j] + sp.Rational(1,3)*gammaDD[i][j]*trK KDDdD = ixp.zerorank3() trK_dD = ixp.declarerank1("trK_dD") for i in range(DIM): for j in range(DIM): for k in range(DIM): KDDdD[i][j][k] = exp4phidD[k]*AbarDD[i][j] + exp4phi*AbarDD_dD[i][j][k] + \ sp.Rational(1,3)*(gammaDDdD[i][j][k]*trK + gammaDD[i][j]*trK_dD[k]) ``` <a id='code_validation'></a> # Step 4: Code Validation against `BSSN.ADM_in_terms_of_BSSN` NRPy+ module \[Back to [top](#toc)\] $$\label{code_validation}$$ Here, as a code validation check, we verify agreement in the SymPy expressions between 1. this tutorial and 2. the NRPy+ [BSSN.ADM_in_terms_of_BSSN](../edit/BSSN/ADM_in_terms_of_BSSN.py) module. ```python all_passed=True def comp_func(expr1,expr2,basename,prefixname2="Bq."): if str(expr1-expr2)!="0": print(basename+" - "+prefixname2+basename+" = "+ str(expr1-expr2)) all_passed=False def gfnm(basename,idx1,idx2=None,idx3=None,idx4=None): if idx2==None: return basename+"["+str(idx1)+"]" if idx3==None: return basename+"["+str(idx1)+"]["+str(idx2)+"]" if idx4==None: return basename+"["+str(idx1)+"]["+str(idx2)+"]["+str(idx3)+"]" return basename+"["+str(idx1)+"]["+str(idx2)+"]["+str(idx3)+"]["+str(idx4)+"]" expr_list = [] exprcheck_list = [] namecheck_list = [] import BSSN.ADM_in_terms_of_BSSN as AB AB.ADM_in_terms_of_BSSN() namecheck_list.extend(["detgamma"]) exprcheck_list.extend([AB.detgamma]) expr_list.extend([detgamma]) for i in range(DIM): for j in range(DIM): namecheck_list.extend([gfnm("gammaDD",i,j),gfnm("gammaUU",i,j),gfnm("KDD",i,j)]) exprcheck_list.extend([AB.gammaDD[i][j],AB.gammaUU[i][j],AB.KDD[i][j]]) expr_list.extend([gammaDD[i][j],gammaUU[i][j],KDD[i][j]]) for k in range(DIM): namecheck_list.extend([gfnm("gammaDDdD",i,j,k),gfnm("GammaUDD",i,j,k),gfnm("KDDdD",i,j,k)]) exprcheck_list.extend([AB.gammaDDdD[i][j][k],AB.GammaUDD[i][j][k],AB.KDDdD[i][j][k]]) expr_list.extend([gammaDDdD[i][j][k],GammaUDD[i][j][k],KDDdD[i][j][k]]) for l in range(DIM): namecheck_list.extend([gfnm("gammaDDdDD",i,j,k,l)]) exprcheck_list.extend([AB.gammaDDdDD[i][j][k][l]]) expr_list.extend([gammaDDdDD[i][j][k][l]]) for i in range(len(expr_list)): comp_func(expr_list[i],exprcheck_list[i],namecheck_list[i]) if all_passed: print("ALL TESTS PASSED!") ``` ALL TESTS PASSED! <a id='latex_pdf_output'></a> # Step 5: Output this module to $\LaTeX$-formatted PDF file \[Back to [top](#toc)\] $$\label{latex_pdf_output}$$ The following code cell converts this Jupyter notebook into a proper, clickable $\LaTeX$-formatted PDF file. After the cell is successfully run, the generated PDF may be found in the root NRPy+ tutorial directory, with filename [Tutorial-ADM_in_terms_of_BSSN.pdf](Tutorial-ADM_in_terms_of_BSSN.pdf) (Note that clicking on this link may not work; you may need to open the PDF file through another means.) ```python !jupyter nbconvert --to latex --template latex_nrpy_style.tplx Tutorial-ADM_in_terms_of_BSSN.ipynb !pdflatex -interaction=batchmode Tutorial-ADM_in_terms_of_BSSN.tex !pdflatex -interaction=batchmode Tutorial-ADM_in_terms_of_BSSN.tex !pdflatex -interaction=batchmode Tutorial-ADM_in_terms_of_BSSN.tex !rm -f Tut*.out Tut*.aux Tut*.log ``` [NbConvertApp] Converting notebook Tutorial-ADM_in_terms_of_BSSN.ipynb to latex [NbConvertApp] Writing 60742 bytes to Tutorial-ADM_in_terms_of_BSSN.tex This is pdfTeX, Version 3.14159265-2.6-1.40.18 (TeX Live 2017/Debian) (preloaded format=pdflatex) restricted \write18 enabled. entering extended mode This is pdfTeX, Version 3.14159265-2.6-1.40.18 (TeX Live 2017/Debian) (preloaded format=pdflatex) restricted \write18 enabled. entering extended mode This is pdfTeX, Version 3.14159265-2.6-1.40.18 (TeX Live 2017/Debian) (preloaded format=pdflatex) restricted \write18 enabled. entering extended mode

538ba5f82d979edff77ab41d18c5a071e6f451c7

ipynb

Jupyter Notebook

Tutorial-ADM_in_terms_of_BSSN.ipynb

dinatraykova/nrpytutorial

74d1bab0c45380727975568ba956b69c082e2293

Tutorial-ADM_in_terms_of_BSSN.ipynb

dinatraykova/nrpytutorial

74d1bab0c45380727975568ba956b69c082e2293

Tutorial-ADM_in_terms_of_BSSN.ipynb

dinatraykova/nrpytutorial

74d1bab0c45380727975568ba956b69c082e2293

2019-11-14T03:31:18.000Z

2019-12-12T13:42:52.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# The positive predictive value ## Let's see this notebook in a better format : ### [HERE](http://www.reproducibleimaging.org/module-stats/05-PPV/) ## Some Definitions * $H_0$ : null hypothesis: The hypotheis that the effect we are testing for is null * $H_A$ : alternative hypothesis : Not $H_0$, so there is some signal * $T$ : The random variable that takes value "significant" or "not significant" * $T_S$ : Value of T when test is significant (eg $T = T_S$) - or, the event "the test is significant" * $T_N$ : Value of T when test is not significant (eg $T = T_N$) or, the event "the test is not significant" * $\alpha$ : false positive rate - probability to reject $H_0$ when $H_0$ is true ($H_A$ is false) * $\beta$ : false negative rate - probability to accept $H_0$ when $H_A$ is true ($H_0$ is false) power = $1-\beta$ where $\beta$ is the risk of *false negative* So, to compute power, *we need to know what is the risk of false negative*, ie, the risk to not show a significant effect while we have some signal (null is false). ## Some standard python imports ```python import matplotlib.pyplot as plt %matplotlib inline import numpy as np import scipy.stats as sst import matplotlib.pyplot as plt from __future__ import division #python 2.x legacy ``` ## A function to plot nicely some tables of probability ```python from sympy import symbols, Eq, solve, simplify, lambdify, init_printing, latex init_printing(use_latex=True, order='old') from sympy.abc import alpha, beta # get alpha, beta symbolic variables from IPython.display import HTML # Code to make HTML for a probability table def association_table(assocs, title): latexed = {'title': title} for key, value in assocs.items(): latexed[key] = latex(value) latexed['s_total'] = latex(assocs['t_s'] + assocs['f_s']) latexed['ns_total'] = latex(assocs['t_ns'] + assocs['f_ns']) return """<h3>{title}</h3> <TABLE><TR><TH>$H/T$<TH>$T_S$<TH>$T_N$ <TR><TH>$H_A$<TD>${t_s}$<TD>${t_ns}$ <TR><TH>$H_0$<TD>${f_s}$<TD>${f_ns}$ <TR><TH>Total<TD>${s_total}$<TD>${ns_total}$ </TABLE>""".format(**latexed) assoc = dict(t_s = 1 - beta, # H_A true, test significant = true positives t_ns = beta, # true, not significant = false negatives f_s = alpha, # false, significant = false positives f_ns = 1 - alpha) # false, not sigificant = true negatives HTML(association_table(assoc, 'Not considering prior')) ``` <h3>Not considering prior</h3> <TABLE><TR><TH>$H/T$<TH>$T_S$<TH>$T_N$ <TR><TH>$H_A$<TD>$1 - \beta$<TD>$\beta$ <TR><TH>$H_0$<TD>$\alpha$<TD>$1 - \alpha$ <TR><TH>Total<TD>$1 + \alpha - \beta$<TD>$1 + \beta - \alpha$ </TABLE> ```python ``` ## Derivation of Ionannidis / Button positive prediction value : PPV ### Recall some important statistic concepts: Marginalization and Baye theorem #### Marginalization $\newcommand{Frac}[2]{\frac{\displaystyle #1}{\displaystyle #2}}$ We now consider that the hypotheses are *random events*, so we have a probability associated to these events. Let's define some new terms: * $P(H_A)$ - prior probability of $H_A$ - probability of $H_A$ before the experiment. * $P(H_0)$ - prior probability of $H_0$ = $1 - Pr(H_A)$ - probability of null hypothesis before the experiment We are interested in updating the probability of $H_A$ and $H_0$ as a result of a test on some collected data. This updated probability is $P(H_A | T)$ - the probability of $H_A$ given the test result $T$. $P(H_A | T)$ is called the *posterior* probability because it is the probability after the test result is known. Lets imagine that the event A occurs under the events b1, b2, .., bn, these events bi are mutually exclusive and they represent all possibilities. For instance, the event "the test is significant" occurs under "H0" and "H1". The marginalization theorem is simply that $$ P(A) = \sum_{b_i} P(A,B=b_i) $$ In our previous example, $$ P(T_S) = \sum_{h=H_0, H_1} P(T_S, h) = P(T_S, H_0) + P(T_S, H_1) $$ Throughout $P(A, B)$ reads "Probability of A AND B". To simplify the notation, we note $P(B=b)$ as $P(b)$ #### Baye theorem Remembering [Bayes theorem](http://en.wikipedia.org/wiki/Bayes'_theorem#Derivation): $$P(A, B) = P(A | B) P(B)$$ and therefore $$P(A | B) = \Frac{P(B, A)}{P(B)} = \Frac{P(B | A) P(A)}{P(B)}$$ Putting marginalization and Bayes together we have : $$P(A) = \sum_{b_i} P(A|B=b_i) P(B=b_i)$$ Now, apply this to the probability of the test results $T$. The test takes a value either under $H_A$ or $H_0$. The probability of a *signficant* result of the test $T=T_S$ is : $Pr(T=T_S) = P(T_S) = Pr(T_S | H_A) Pr(H_A) + Pr(T_S | H_0) Pr(H_0)$ What is the posterior probability of $H_A$ given that the test is significant? $P(H_A | T_S) = \Frac{P(T_S | H_A) P(H_A)}{P(T_S)} = \Frac{P(T_S | H_A) P(H_A)}{P(T_S | H_A) Pr(H_A) + Pr(T_S | H_0) Pr(H_0)}$ We have $P(T_S | H_A)$, $P(T_S | H_0)$ from the first column of the table above. Substituting into the equation: $P(H_A | T_S) = \Frac{(1 - \beta) P(H_A)}{(1 - \beta) P(H_A) + \alpha P(H_0)}$ Defining: $\pi := Pr(H_A)$, hence: $1 - \pi = Pr(H_0)$ we have: $P(H_A | T_S) = \Frac{(1 - \beta) \pi}{(1 - \beta) \pi + \alpha (1 - \pi)}$ ```python from sympy.abc import pi # get symbolic variable pi post_prob = (1 - beta) * pi / ((1 - beta) * pi + alpha * (1 - pi)) post_prob ``` ```python assoc = dict(t_s = pi * (1 - beta), t_ns = pi * beta, f_s = (1 - pi) * alpha, f_ns = (1 - pi) * (1 - alpha)) HTML(association_table(assoc, r'Considering prior $\pi := P(H_A)$')) ``` <h3>Considering prior $\pi := P(H_A)$</h3> <TABLE><TR><TH>$H/T$<TH>$T_S$<TH>$T_N$ <TR><TH>$H_A$<TD>$\pi \left(1 - \beta\right)$<TD>$\beta \pi$ <TR><TH>$H_0$<TD>$\alpha \left(1 - \pi\right)$<TD>$\left(1 - \alpha\right) \left(1 - \pi\right)$ <TR><TH>Total<TD>$\alpha \left(1 - \pi\right) + \pi \left(1 - \beta\right)$<TD>$\beta \pi + \left(1 - \alpha\right) \left(1 - \pi\right)$ </TABLE> ## Retrieving the Ioannidis / Button et al formula Same as Ioannidis - do the derivation starting with odd ratios From Button et al., we have the positive predictive value PPV defined as : $$ PPV = \frac{(1-\beta)R}{(1-\beta)R + \alpha},\textrm{ with } R = P(H_1)/P(H_0) = P_1/P_0 = \pi / (1-\pi) $$ Hence, $$ PPV = \frac{(1-\beta)P_1}{P_0}\frac{P_0}{(1-\beta)P_1 + \alpha P_0} $$ $$ = \frac{(1-\beta)P_1}{(1-\beta)P_1 + \alpha P_0} $$ $$ = P(H_1, T_S) / P(T_S) = P(H_1 | T_S) $$ If we have 4 chances over 5 that $H_0$ is true, and one over five that $H_1$ true, then R = 1/5 / 4/5 = .25. If there's 30% power we have PPV = 50%. So, 50% chance that our result is indeed true. 80% power leads to 80% chance of $H_1$ to be true, knowing that we have detected an effect at the $\alpha$ risk of error. ### A small function to compute PPV ```python def PPV_OR(odd_ratio, power, alpha, verbose=True): """ returns PPV from odd_ratio, power and alpha parameters: ----------- odd_ratio: float P(H_A)/(1-P(H_A)) power: float Power for this study alpha: float type I risk of error Returns: ---------- float The positive predicted value """ ppv = (power*odd_ratio)/(power*odd_ratio + alpha) if verbose: print("With odd ratio=%3.2f, " "Power=%3.2f, alpha=%3.2f, " "We have PPV=%3.2f" %(odd_ratio,power,alpha,ppv)) return ppv ``` ```python one4sure = PPV_OR(1, 1, 0, verbose=False) assert one4sure == 1 zero4sure = PPV_OR(0, 1, 0.05, verbose=False) assert zero4sure == 0 weird2think = PPV_OR(1, 1, 1, verbose=False) assert weird2think == 0.5 ``` ### A small function for display ```python def plot_ppv(xvalues, yvalues, xlabel, ylabel, title): ''' simply plot yvalues against xvalues, with labels and title Parameters: ----------- xvalues, yvalues : iterables of numbers labels and title : string ''' fig = plt.figure(); axis = fig.add_subplot(1, 1, 1) axis.plot(xvalues, yvalues, color='red', marker='o', linestyle='dashed', linewidth=2, markersize=14); axis.set_xlabel(xlabel,fontsize=20); axis.set_ylabel(ylabel,fontsize=20); axis.set_title(figure_title, fontsize=20); return fig, axis ``` ### Example from Button et al, 2013 ```python # example from Button et al: P1 = 1/5, P0 = 4/5. R = 1/4 R = 1./5. Pw = .4 alph = .05 ppv = PPV_OR(R, Pw, alph) ``` With odd ratio=0.20, Power=0.40, alpha=0.05, We have PPV=0.62 ### Vary power ```python #----------------------------------------------------------------- # Vary power: R = .2 Pw = np.arange(.1,.80001,.1) alph = .20 ppvs = [PPV_OR(R, pw, alph, verbose = False) for pw in Pw] xlabel = 'Power' ylabel = 'PPV' figure_title = 'With an odd ratio H1/H0 = {odd_ratio}'.format(odd_ratio=R) #----------------------------------------------------------------- # print plot_ppv(Pw, ppvs, xlabel, ylabel, figure_title); ``` ### Vary odd ratio ```python #----------------------------------------------------------------- # Vary odd ratio: Pw = .4 alph = .05 odd_ratios = np.arange(.05,.5,.05) ppvs = [PPV_OR(R, Pw, alph, verbose = False) for R in odd_ratios] xlabel = 'odd_ratios' ylabel = 'PPV' figure_title = 'With a power of {power}'.format(power=Pw) #----------------------------------------------------------------- # print plot_ppv(odd_ratios, ppvs, xlabel, ylabel, figure_title); ``` ### Vary alpha ```python #----------------------------------------------------------------- # Vary alpha: Pw = .5 R = 1/5 alphas = np.arange(0, .2, 0.01)# [0.001, .005, 0.01, 0.05, 0.1] #, 0.2, 0.3, 0.4, 0.5] ppvs = [PPV_OR(R, Pw, alph, verbose = False) for alph in alphas] #----------------------------------------------------------------- # print xlabel = 'alpha' ylabel = 'PPV' figure_title = 'With a power of {power} and odd ratio of {odd_ratio}'.format( power=Pw, odd_ratio=R) plot_ppv(alphas, ppvs, xlabel, ylabel, figure_title); ``` # End of the PPV section ```python ``` ```python ```

c88ee41bd33e81eddda97893e5047d54154ae8f9

ipynb

Jupyter Notebook

notebooks/Positive-Predictive-Value.ipynb

ReproNim/stat-repronim-module

ccef0fa1d23d0023db4cbbfc1e3091037df77f3b

2020-02-27T19:04:46.000Z

2020-02-27T19:13:30.000Z

notebooks/Positive-Predictive-Value.ipynb

ReproNim/stat-repronim-module

ccef0fa1d23d0023db4cbbfc1e3091037df77f3b

2016-11-12T02:07:16.000Z

2020-06-11T10:47:46.000Z

notebooks/Positive-Predictive-Value.ipynb

ReproNim/stat-repronim-module

ccef0fa1d23d0023db4cbbfc1e3091037df77f3b

2016-11-03T18:03:01.000Z

2021-06-04T06:53:07.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

```python import numpy as np import dapy.filters as filters from dapy.models import NettoGimenoMendesModel import matplotlib.pyplot as plt %matplotlib inline plt.style.use('seaborn-white') plt.rcParams['figure.dpi'] = 100 ``` ## Model One-dimensional stochastic dynamical system due to Netto et al. [1] with state dynamics defined by discrete time map \begin{equation} x_{t+1} = \alpha x_t + \beta \frac{x_t}{1 + z_t^2} + \gamma \cos(\delta t) + \sigma_x u_t \end{equation} with $u_t \sim \mathcal{N}(0, 1) ~\forall t$ and $x_0 \sim \mathcal{N}(m, s^2)$. Observed process defined by \begin{equation} y_{t} = \epsilon x_t^2 + \sigma_y v_t \end{equation} with $v_t \sim \mathcal{N}(0, 1)$. Standard parameter values assumed here are $\alpha = 0.5$, $\beta = 25$, $\gamma = 8$, $\delta = 1.2$, $\epsilon = 0.05$, $m=10$, $s=5$, $\sigma_x^2 = 1$, $\sigma_y^2 = 1$ and $T = 200$ simulated time steps. ### References 1. M. L. A. Netto, L. Gimeno, and M. J. Mendes. A new spline algorithm for non-linear filtering of discrete time systems. *Proceedings of the 7th Triennial World Congress*, 1979. ```python model_params = { 'initial_state_mean': 10., 'initial_state_std': 5., 'state_noise_std': 1., 'observation_noise_std': 1., 'alpha': 0.5, 'beta': 25., 'gamma': 8, 'delta': 1.2, 'epsilon': 0.05, } model = NettoGimenoMendesModel(**model_params) ``` ## Generate data from model ```python num_observation_time = 100 observation_time_indices = np.arange(num_observation_time) seed = 20171027 rng = np.random.default_rng(seed) state_sequence, observation_sequence = model.sample_state_and_observation_sequences( rng, observation_time_indices) ``` <div style="line-height: 28px; width: 100%; display: flex; flex-flow: row wrap; align-items: center; position: relative; margin: 2px;"> <label style="margin-right: 8px; flex-shrink: 0; font-size: var(--jp-code-font-size, 13px); font-family: var(--jp-code-font-family, monospace);"> Sampling:&nbsp;100% </label> <div role="progressbar" aria-valuenow="1.0" aria-valuemin="0" aria-valuemax="1" style="position: relative; flex-grow: 1; align-self: stretch; margin-top: 4px; margin-bottom: 4px; height: initial; background-color: #eee;"> <div style="background-color: var(--jp-success-color1, #4caf50); position: absolute; bottom: 0; left: 0; width: 100%; height: 100%;"></div> </div> <div style="margin-left: 8px; flex-shrink: 0; font-family: var(--jp-code-font-family, monospace); font-size: var(--jp-code-font-size, 13px);"> 100/100 [00:00&lt;00:00, 21597.18time-steps/s] </div> </div> ```python fig, ax = plt.subplots(figsize=(12, 4)) ax.plot(observation_time_indices, state_sequence) ax.plot(observation_time_indices, observation_sequence, '.') ax.set_xlabel('Time index $t$') ax.set_ylabel('State') _ = ax.set_xlim(0, num_observation_time - 1) ax.legend(['$x_t$', '$y_t$'], ncol=4) fig.tight_layout() ``` ## Infer state from observations ```python def plot_results(results, z_reference=None, plot_traces=True, plot_region=False, trace_skip=1, trace_alpha=0.25): fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(12, 4)) ax.plot(results['z_mean_seq'][:, 0], 'g-', lw=1) if plot_region: ax.fill_between( np.arange(n_steps), results['z_mean_seq'][:, 0] - 3 * results['z_std_seq'][:, 0], results['z_mean_seq'][:, 0] + 3 * results['z_std_seq'][:, 0], alpha=0.25, color='g' ) if plot_traces: ax.plot(results['z_particles_seq'][:, ::trace_skip, 0], 'r-', lw=0.25, alpha=trace_alpha) if z_reference is not None: ax.plot(z_reference[:, 0], 'k--') ax.set_ylabel('State $z$') ax.set_xlabel('Time index $t$') fig.tight_layout() return fig, ax def plot_results(results, observation_time_indices, state_sequence=None, plot_particles=True, plot_region=False, particle_skip=5, trace_alpha=0.25): fig, ax = plt.subplots(sharex=True, figsize=(12, 4)) ax.plot(results['state_mean_sequence'][:, 0], 'g-', lw=1, label='Est. mean') if plot_region: ax.fill_between( observation_time_indices, results['state_mean_sequence'][:, 0] - 3 * results['state_std_sequence'][:, 0], results['state_mean_sequence'][:, 0] + 3 * results['state_std_sequence'][:, 0], alpha=0.25, color='g', label='Est. mean ± 3 standard deviation' ) if plot_particles: lines = ax.plot( observation_time_indices, results['state_particles_sequence'][:, ::particle_skip, 0], 'r-', lw=0.25, alpha=trace_alpha) lines[0].set_label('Particles') if state_sequence is not None: ax.plot(observation_time_indices, state_sequence[:, 0], 'k--', label='Truth') ax.set_ylabel('$x_t$') ax.legend(loc='upper center', ncol=4) ax.set_xlabel('Time index $t$') fig.tight_layout() return fig, ax ``` ### Ensemble Kalman filter (perturbed observations) ```python enkf = filters.EnsembleKalmanFilter() ``` ```python results_enkf = enkf.filter( model, observation_sequence, observation_time_indices, num_particle=500, rng=rng, return_particles=True) ``` <div style="line-height: 28px; width: 100%; display: flex; flex-flow: row wrap; align-items: center; position: relative; margin: 2px;"> <label style="margin-right: 8px; flex-shrink: 0; font-size: var(--jp-code-font-size, 13px); font-family: var(--jp-code-font-family, monospace);"> Filtering:&nbsp;100% </label> <div role="progressbar" aria-valuenow="1.0" aria-valuemin="0" aria-valuemax="1" style="position: relative; flex-grow: 1; align-self: stretch; margin-top: 4px; margin-bottom: 4px; height: initial; background-color: #eee;"> <div style="background-color: var(--jp-success-color1, #4caf50); position: absolute; bottom: 0; left: 0; width: 100%; height: 100%;"></div> </div> <div style="margin-left: 8px; flex-shrink: 0; font-family: var(--jp-code-font-family, monospace); font-size: var(--jp-code-font-size, 13px);"> 100/100 [00:00&lt;00:00, 427.09time-steps/s] </div> </div> ```python fig, axes = plot_results(results_enkf, observation_time_indices, state_sequence) ``` ### Ensemble Trasform Kalman filter (deterministic square root) ```python etkf = filters.EnsembleTransformKalmanFilter() ``` ```python results_etkf = etkf.filter( model, observation_sequence, observation_time_indices, num_particle=500, rng=rng, return_particles=True) ``` <div style="line-height: 28px; width: 100%; display: flex; flex-flow: row wrap; align-items: center; position: relative; margin: 2px;"> <label style="margin-right: 8px; flex-shrink: 0; font-size: var(--jp-code-font-size, 13px); font-family: var(--jp-code-font-family, monospace);"> Filtering:&nbsp;100% </label> <div role="progressbar" aria-valuenow="1.0" aria-valuemin="0" aria-valuemax="1" style="position: relative; flex-grow: 1; align-self: stretch; margin-top: 4px; margin-bottom: 4px; height: initial; background-color: #eee;"> <div style="background-color: var(--jp-success-color1, #4caf50); position: absolute; bottom: 0; left: 0; width: 100%; height: 100%;"></div> </div> <div style="margin-left: 8px; flex-shrink: 0; font-family: var(--jp-code-font-family, monospace); font-size: var(--jp-code-font-size, 13px);"> 100/100 [00:00&lt;00:00, 143.24time-steps/s] </div> </div> ```python fig, axes = plot_results(results_etkf, observation_time_indices, state_sequence) ``` ### Bootstrap particle filter ```python bspf = filters.BootstrapParticleFilter() ``` ```python results_bspf = bspf.filter( model, observation_sequence, observation_time_indices, num_particle=500, rng=rng, return_particles=True) ``` <div style="line-height: 28px; width: 100%; display: flex; flex-flow: row wrap; align-items: center; position: relative; margin: 2px;"> <label style="margin-right: 8px; flex-shrink: 0; font-size: var(--jp-code-font-size, 13px); font-family: var(--jp-code-font-family, monospace);"> Filtering:&nbsp;100% </label> <div role="progressbar" aria-valuenow="1.0" aria-valuemin="0" aria-valuemax="1" style="position: relative; flex-grow: 1; align-self: stretch; margin-top: 4px; margin-bottom: 4px; height: initial; background-color: #eee;"> <div style="background-color: var(--jp-success-color1, #4caf50); position: absolute; bottom: 0; left: 0; width: 100%; height: 100%;"></div> </div> <div style="margin-left: 8px; flex-shrink: 0; font-family: var(--jp-code-font-family, monospace); font-size: var(--jp-code-font-size, 13px);"> 100/100 [00:00&lt;00:00, 3062.47time-steps/s] </div> </div> ```python fig, axes = plot_results(results_bspf, observation_time_indices, state_sequence) ``` ### Ensemble transform particle filter ```python etpf = filters.EnsembleTransformParticleFilter() ``` ```python results_etpf = etpf.filter( model, observation_sequence, observation_time_indices, num_particle=500, rng=rng, return_particles=True) ``` <div style="line-height: 28px; width: 100%; display: flex; flex-flow: row wrap; align-items: center; position: relative; margin: 2px;"> <label style="margin-right: 8px; flex-shrink: 0; font-size: var(--jp-code-font-size, 13px); font-family: var(--jp-code-font-family, monospace);"> Filtering:&nbsp;100% </label> <div role="progressbar" aria-valuenow="1.0" aria-valuemin="0" aria-valuemax="1" style="position: relative; flex-grow: 1; align-self: stretch; margin-top: 4px; margin-bottom: 4px; height: initial; background-color: #eee;"> <div style="background-color: var(--jp-success-color1, #4caf50); position: absolute; bottom: 0; left: 0; width: 100%; height: 100%;"></div> </div> <div style="margin-left: 8px; flex-shrink: 0; font-family: var(--jp-code-font-family, monospace); font-size: var(--jp-code-font-size, 13px);"> 100/100 [00:02&lt;00:00, 41.33time-steps/s] </div> </div> ```python fig, axes = plot_results(results_etpf, observation_time_indices, state_sequence) ```

13ef3d9f741f183a0f37eacdc1ff4688d954795b

ipynb

Jupyter Notebook

notebooks/Netto_Gimeno_Mendes_1979_non_linear_model.ipynb

hassaniqbal209/data-assimilation

ec52d655395dbed547edf4b4f3df29f017633f1b

2020-07-29T07:46:39.000Z

2022-03-17T01:28:07.000Z

notebooks/Netto_Gimeno_Mendes_1979_non_linear_model.ipynb

hassaniqbal209/data-assimilation

ec52d655395dbed547edf4b4f3df29f017633f1b

2020-07-14T11:49:17.000Z

2020-07-29T07:43:22.000Z

notebooks/Netto_Gimeno_Mendes_1979_non_linear_model.ipynb

hassaniqbal209/data-assimilation

ec52d655395dbed547edf4b4f3df29f017633f1b

2020-07-14T11:34:24.000Z

2022-03-07T09:08:12.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Calculate near surface RH% using ERA-interim fields * 2-m dew point * 2-m temperature * surface pressure Once the yearly RH files are made, merge these data into a single file and put into the era merged time directory, then, regrid that file and place in the common grid file, such that this newly created variable has the same handling as variables processed by Python/format_raw_era_data.py NOTE: RH was calculated from raw, native (0.75 x 0.75 deg grid) era-interim nc data. These data live in a different project directory (metSpreadData). Link to documentations and instructions on how to calculate near surface relative humidity using ecmwf era-interim: https://www.ecmwf.int/en/faq/do-era-datasets-contain-parameters-near-surface-humidity \begin{align} RH=100\frac{es(T_{d})}{es(T)} \end{align} ### Saturation Specific Humidity Saturation specific humidity is expressed as a function of saturation water vapor pressure as: \begin{align} q_{sat} & = \frac{e_{sat}(T)\frac{R_{dry}}{R_{vapor}}}{p-(1-\frac{R_{dry}}{R_{vapor}})e_{sat}(T)} \end{align} where the saturation water vopor pressure ($e_{sat}$) is expressed with the Teten's formula: \begin{align} e_{sat}(T) & = a_{1}exp(a_{3}\frac{T - T_{0}}{T-a_{4}})\\ \\ a_{1} & = 611.21Pa \\ a_{3} & = 17.502 \\ a_{4} & = 32.19 \\ T_{0} & = 273.16 \end{align} ```python import numpy as np def calculat_svp(T, P): """Calculates and returns saturation vapor pressure (svp)""" # constants for saturation over water a1 = 611.21 # Pa a3 = 17.502 a4 = 32.19 # K To = 273.16 # K R_dry = 287. # J/kg/K gas constant of dry air R_vap = 461. # J/kg/K gas constant for water vapor e_sat = a1 * np.exp( a3 * (T-To)/(T-a4) ) # Saturation specific humidity (eqn 7.4) top = e_sat * R_dry / R_vap bottom = P - (1. - R_dry / R_vap) * e_sat q_sat = top / bottom return q_sat ``` ### Create 3D RH arrays ```python from netCDF4 import Dataset import os from matplotlib import pylab as plt dataDir = os.path.join("..","..","metSpreadData","ERA-Interim") def get_nc(var, year): """ Loads an era-interim netcdf file. Very simple. """ loadFile = os.path.join(dataDir, var + "_" + str(year) + ".nc") nc = Dataset(loadFile) vals = nc.variables[var][:] t = nc.variables["time"][:] lon = nc.variables["longitude"][:] lat = nc.variables["latitude"][:] nc.close() return vals, t, lon, lat def write_RH_nc(RH, t, x, y, year, dataDir): """ Writes a relative humidity netcdf file. """ outputFile = os.path.join(dataDir, "RH_" + str(year) + ".nc") ncFile = Dataset(outputFile, 'w', format='NETCDF4') ncFile.description = 'Relative Humidity (saturation pressure relative to water, Tetons eq.)' ncFile.location = 'Global' ncFile.createDimension('time', len(t) ) ncFile.createDimension('latitude', len(y) ) ncFile.createDimension('longitude', len(x) ) VAR_ = ncFile.createVariable("RH", 'f4',('time', 'latitude','longitude')) VAR_.long_name = "Relative Humidity" VAR_.units = "%" # Create time variable time_ = ncFile.createVariable('time', 'i4', ('time',)) time_.units = "hours since 1900-01-01 00:00:0.0" time_.calendar = "gregorian" # create lat variable latitude_ = ncFile.createVariable('latitude', 'f4', ('latitude',)) latitude_.units = 'degrees_north' # create longitude variable longitude_ = ncFile.createVariable('longitude', 'f4', ('longitude',)) longitude_.units = 'degrees_east' # Write the actual data to these dimensions VAR_[:] = RH time_[:] = t latitude_[:] = y longitude_[:] = x ncFile.close() ``` Generate the RH yearly files! ```python years = range(1983, 2017+1) for year in years : print("Making RH file for %i " % year) # Get the grids needed to calculate specific humidity t2m,t,x,y = get_nc("t2m", year) # 2 meter temperature d2m,t,x,y = get_nc("d2m", year) # 2 meter dew point sp,t,x,y = get_nc("sp", year) # Surface pressure RH = calculat_svp(d2m, sp) / calculat_svp(t2m, sp) * 100. write_RH_nc(RH, t, x, y, year, dataDir) ``` Making RH file for 1983 Making RH file for 1984 Making RH file for 1985 Making RH file for 1986 Making RH file for 1987 Making RH file for 1988 Making RH file for 1989 Making RH file for 1990 Making RH file for 1991 Making RH file for 1992 Making RH file for 1993 Making RH file for 1994 Making RH file for 1995 Making RH file for 1996 Making RH file for 1997 Making RH file for 1998 Making RH file for 1999 Making RH file for 2000 Making RH file for 2001 Making RH file for 2002 Making RH file for 2003 Making RH file for 2004 Making RH file for 2005 Making RH file for 2006 Making RH file for 2007 Making RH file for 2008 Making RH file for 2009 Making RH file for 2010 Making RH file for 2011 Making RH file for 2012 Making RH file for 2013 Making RH file for 2014 Making RH file for 2015 Making RH file for 2016 Making RH file for 2017 Show the last month for the last year output as an example of what these values and output look like. Make sure the dry places in the world have lower RH values. ```python plt.figure(dpi=150) plt.pcolor(x,y,RH[0,:,:]) plt.title("Example of RH% output for January 2017") plt.colorbar(extend="both", label="RH%") plt.xlabel("Longitude") plt.ylabel("Latitude") plt.show() ``` Merge yearly files and regrid - TODO: the code below is not working in a notebook, something strange with the call to Cdo() - These commands were issued at the command line using cdo on 11/24/2018. import globfrom cdo import * # python version cdo = Cdo()common_grid_txt = os.path.join(dataDir, 'COMMON_GRID.txt') files_to_merge = glob.glob(os.path.join(dataDir, "RH_*")) merged_time_file = os.path.join(dataDir, 'merged_time', 'RH_1983-2017.nc') common_grid_out = os.path.join(dataDir, 'merged_t_COMMON_GRID', 'RH_1983-2017.nc')cdo.mergetime(input=" ".join(files_to_merge), output=merged_time_file, options="-b F64")cdo.remapbil(common_grid_txt, input=merged_time_file, output=common_grid_out, options="-b F64")

bbb1577ca7810c11a711957f0d29f8707540a0d4

ipynb

Jupyter Notebook

Python/calculate_RH_from_d2m.ipynb

stevenjoelbrey/metSpread

38d667f0e2f58563345fed14132bb5a6eb7022af

Python/calculate_RH_from_d2m.ipynb

stevenjoelbrey/metSpread

38d667f0e2f58563345fed14132bb5a6eb7022af

Python/calculate_RH_from_d2m.ipynb

stevenjoelbrey/metSpread

38d667f0e2f58563345fed14132bb5a6eb7022af

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

<a href="https://colab.research.google.com/github/NeuromatchAcademy/course-content/blob/master/tutorials/W2D1_DeepLearning/W2D1_Tutorial1.ipynb" target="_parent"></a> &nbsp; <a href="https://kaggle.com/kernels/welcome?src=https://raw.githubusercontent.com/NeuromatchAcademy/course-content/master/tutorials/W2D1_DeepLearning/W2D1_Tutorial1.ipynb" target="_parent"></a> # Tutorial 1: Decoding Neural Responses **Week 2, Day 1: Deep Learning** **By Neuromatch Academy** **Content creators**: Jorge A. Menendez, Carsen Stringer **Content reviewers**: Roozbeh Farhoodi, Madineh Sarvestani, Kshitij Dwivedi, Spiros Chavlis, Ella Batty, Michael Waskom **Our 2021 Sponsors, including Presenting Sponsor Facebook Reality Labs** <p align='center'></p> --- # Tutorial Objectives *Estimated timing of tutorial: 1 hr, 20 minutes* In this tutorial, we'll use deep learning to decode stimulus information from the responses of sensory neurons. Specifically, we'll look at the activity of ~20,000 neurons in mouse primary visual cortex responding to oriented gratings recorded in [this study](https://www.biorxiv.org/content/10.1101/679324v2.abstract). Our task will be to decode the orientation of the presented stimulus from the responses of the whole population of neurons. We could do this in a number of ways, but here we'll use deep learning. Deep learning is particularly well-suited to this problem for a number of reasons: * The data are very high-dimensional: the neural response to a stimulus is a ~20,000 dimensional vector. Many machine learning techniques fail in such high dimensions, but deep learning actually thrives in this regime, as long as you have enough data (which we do here!). * As you'll be able to see below, different neurons can respond quite differently to stimuli. This complex pattern of responses will, therefore, require non-linear methods to be decoded, which we can easily do with non-linear activation functions in deep networks. * Deep learning architectures are highly flexible, meaning we can easily adapt the architecture of our decoding model to optimize decoding. Here, we'll focus on a single architecture, but you'll see that it can easily be modified with few changes to the code. More concretely, our goal will be learn how to: * Build a deep feed-forward network using PyTorch * Evaluate the network's outputs using PyTorch built-in loss functions * Compute gradients of the loss with respect to each parameter of the network using automatic differentiation * Implement gradient descent to optimize the network's parameters ```python # @title Tutorial slides # @markdown These are the slides for all videos in this tutorial. from IPython.display import IFrame IFrame(src=f"https://mfr.ca-1.osf.io/render?url=https://osf.io/vb7c4/?direct%26mode=render%26action=download%26mode=render", width=854, height=480) ``` ```python # @title Video 1: Decoding from neural data using feed-forward networks in pytorch from ipywidgets import widgets out2 = widgets.Output() with out2: from IPython.display import IFrame class BiliVideo(IFrame): def __init__(self, id, page=1, width=400, height=300, **kwargs): self.id=id src = 'https://player.bilibili.com/player.html?bvid={0}&page={1}'.format(id, page) super(BiliVideo, self).__init__(src, width, height, **kwargs) video = BiliVideo(id="BV1Xa4y1a7Jz", width=854, height=480, fs=1) print('Video available at https://www.bilibili.com/video/{0}'.format(video.id)) display(video) out1 = widgets.Output() with out1: from IPython.display import YouTubeVideo video = YouTubeVideo(id="SlrbMvvBOzM", width=854, height=480, fs=1, rel=0) print('Video available at https://youtube.com/watch?v=' + video.id) display(video) out = widgets.Tab([out1, out2]) out.set_title(0, 'Youtube') out.set_title(1, 'Bilibili') display(out) ``` This video covers the decoding task we will use in these tutorials, a linear network with one hidden layer, and how to build this in Pytorch. Generalized linear models were used as decoding and encoding models in W1D4 Machine Learning. A model that decodes a variable from neural activity can tell us *how much information* a brain area contains about that variable. An encoding model is a model from an input variable, like visual stimulus, to neural activity. The encoding model is meant to approximate the same transformation that the brain performs on input variables and therefore help us understand *how the brain represents information*. Today we will use deep neural networks to build these models because deep neural networks can approximate a wide range of non-linear functions and can be easily fit. --- # Setup ```python # Imports import os import numpy as np import torch from torch import nn from torch import optim import matplotlib as mpl from matplotlib import pyplot as plt ``` ```python #@title Data retrieval and loading import hashlib import requests fname = "W3D4_stringer_oribinned1.npz" url = "https://osf.io/683xc/download" expected_md5 = "436599dfd8ebe6019f066c38aed20580" if not os.path.isfile(fname): try: r = requests.get(url) except requests.ConnectionError: print("!!! Failed to download data !!!") else: if r.status_code != requests.codes.ok: print("!!! Failed to download data !!!") elif hashlib.md5(r.content).hexdigest() != expected_md5: print("!!! Data download appears corrupted !!!") else: with open(fname, "wb") as fid: fid.write(r.content) ``` ```python #@title Figure Settings %config InlineBackend.figure_format = 'retina' plt.style.use("https://raw.githubusercontent.com/NeuromatchAcademy/course-content/master/nma.mplstyle") ``` ```python # @title Plotting Functions def plot_data_matrix(X, ax): """Visualize data matrix of neural responses using a heatmap Args: X (torch.Tensor or np.ndarray): matrix of neural responses to visualize with a heatmap ax (matplotlib axes): where to plot """ cax = ax.imshow(X, cmap=mpl.cm.pink, vmin=np.percentile(X, 1), vmax=np.percentile(X, 99)) cbar = plt.colorbar(cax, ax=ax, label='normalized neural response') ax.set_aspect('auto') ax.set_xticks([]) ax.set_yticks([]) def plot_decoded_results(train_loss, test_loss, test_labels, predicted_test_labels): """ Plot decoding results in the form of network training loss and test predictions Args: train_loss (list): training error over iterations test_labels (torch.Tensor): n_test x 1 tensor with orientations of the stimuli corresponding to each row of train_data, in radians predicted_test_labels (torch.Tensor): n_test x 1 tensor with predicted orientations of the stimuli from decoding neural network """ # Plot results fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6)) # Plot the training loss over iterations of GD ax1.plot(train_loss) # Plot the testing loss over iterations of GD ax1.plot(test_loss) ax1.legend(['train loss', 'test loss']) # Plot true stimulus orientation vs. predicted class ax2.plot(stimuli_test.squeeze(), predicted_test_labels, '.') ax1.set_xlim([0, None]) ax1.set_ylim([0, None]) ax1.set_xlabel('iterations of gradient descent') ax1.set_ylabel('negative log likelihood') ax2.set_xlabel('true stimulus orientation ($^o$)') ax2.set_ylabel('decoded orientation bin') ax2.set_xticks(np.linspace(0, 360, n_classes + 1)) ax2.set_yticks(np.arange(n_classes)) class_bins = [f'{i * 360 / n_classes: .0f}$^o$ - {(i + 1) * 360 / n_classes: .0f}$^o$' for i in range(n_classes)] ax2.set_yticklabels(class_bins); # Draw bin edges as vertical lines ax2.set_ylim(ax2.get_ylim()) # fix y-axis limits for i in range(n_classes): lower = i * 360 / n_classes upper = (i + 1) * 360 / n_classes ax2.plot([lower, lower], ax2.get_ylim(), '-', color="0.7", linewidth=1, zorder=-1) ax2.plot([upper, upper], ax2.get_ylim(), '-', color="0.7", linewidth=1, zorder=-1) plt.tight_layout() def plot_train_loss(train_loss): plt.plot(train_loss) plt.xlim([0, None]) plt.ylim([0, None]) plt.xlabel('iterations of gradient descent') plt.ylabel('mean squared error') plt.show() ``` ```python # @title Helper Functions def load_data(data_name=fname, bin_width=1): """Load mouse V1 data from Stringer et al. (2019) Data from study reported in this preprint: https://www.biorxiv.org/content/10.1101/679324v2.abstract These data comprise time-averaged responses of ~20,000 neurons to ~4,000 stimulus gratings of different orientations, recorded through Calcium imaging. The responses have been normalized by spontaneous levels of activity and then z-scored over stimuli, so expect negative numbers. They have also been binned and averaged to each degree of orientation. This function returns the relevant data (neural responses and stimulus orientations) in a torch.Tensor of data type torch.float32 in order to match the default data type for nn.Parameters in Google Colab. This function will actually average responses to stimuli with orientations falling within bins specified by the bin_width argument. This helps produce individual neural "responses" with smoother and more interpretable tuning curves. Args: bin_width (float): size of stimulus bins over which to average neural responses Returns: resp (torch.Tensor): n_stimuli x n_neurons matrix of neural responses, each row contains the responses of each neuron to a given stimulus. As mentioned above, neural "response" is actually an average over responses to stimuli with similar angles falling within specified bins. stimuli: (torch.Tensor): n_stimuli x 1 column vector with orientation of each stimulus, in degrees. This is actually the mean orientation of all stimuli in each bin. """ with np.load(data_name) as dobj: data = dict(**dobj) resp = data['resp'] stimuli = data['stimuli'] if bin_width > 1: # Bin neural responses and stimuli bins = np.digitize(stimuli, np.arange(0, 360 + bin_width, bin_width)) stimuli_binned = np.array([stimuli[bins == i].mean() for i in np.unique(bins)]) resp_binned = np.array([resp[bins == i, :].mean(0) for i in np.unique(bins)]) else: resp_binned = resp stimuli_binned = stimuli # Return as torch.Tensor resp_tensor = torch.tensor(resp_binned, dtype=torch.float32) stimuli_tensor = torch.tensor(stimuli_binned, dtype=torch.float32).unsqueeze(1) # add singleton dimension to make a column vector return resp_tensor, stimuli_tensor def identityLine(): """ Plot the identity line y=x """ ax = plt.gca() lims = np.array([ax.get_xlim(), ax.get_ylim()]) minval = lims[:, 0].min() maxval = lims[:, 1].max() equal_lims = [minval, maxval] ax.set_xlim(equal_lims) ax.set_ylim(equal_lims) line = ax.plot([minval, maxval], [minval, maxval], color="0.7") line[0].set_zorder(-1) def get_data(n_stim, train_data, train_labels): """ Return n_stim randomly drawn stimuli/resp pairs Args: n_stim (scalar): number of stimuli to draw resp (torch.Tensor): train_data (torch.Tensor): n_train x n_neurons tensor with neural responses to train on train_labels (torch.Tensor): n_train x 1 tensor with orientations of the stimuli corresponding to each row of train_data, in radians Returns: (torch.Tensor, torch.Tensor): n_stim x n_neurons tensor of neural responses and n_stim x 1 of orientations respectively """ n_stimuli = train_labels.shape[0] istim = np.random.choice(n_stimuli, n_stim) r = train_data[istim] # neural responses to this stimulus ori = train_labels[istim] # true stimulus orientation return r, ori def stimulus_class(ori, n_classes): """Get stimulus class from stimulus orientation Args: ori (torch.Tensor): orientations of stimuli to return classes for n_classes (int): total number of classes Returns: torch.Tensor: 1D tensor with the classes for each stimulus """ bins = np.linspace(0, 360, n_classes + 1) return torch.tensor(np.digitize(ori.squeeze(), bins)) - 1 # minus 1 to accomodate Python indexing ``` --- # Section 1: Load and visualize data <details> <summary> <font color='blue'>Click here for text recap of relevant part of video </font></summary> We will be exploring neural activity in mice while the mice is viewing oriented grating stimuli on a screen in front of it. We record neural activity using a technique called two-photon calcium imaging, which allows us to record many thousands of neurons simultanously. The neurons light up when they fire. We then convert this imaging data to a matrix of neural responses by stimuli presented. For the purposes of this tutorial we are going to bin the neural responses and compute each neuron’s tuning curve. We used bins of 1 degree. We will use the response of all neurons in a single bin to try to predict which stimulus was shown. So we are going to be using the responses of 24000 neurons to try to predict 360 different possible stimulus conditions corresponding to each degree of orientation - which means we're in the regime of big data! </details> In the next cell, we have provided code to load the data and plot the matrix of neural responses. Next to it, we plot the tuning curves of three randomly selected neurons. These tuning curves are the averaged response of each neuron to oriented stimuli within 1$^\circ$, and since there are 360$^\circ$ in total, we have 360 responses. In the recording, there were actually thousands of stimuli shown, but in practice we often create these tuning curves because we want to visualize averaged responses with respect to the variable we varied in the experiment, in this case stimulus orientation. ```python #@title #@markdown Execute this cell to load and visualize data # Load data resp_all, stimuli_all = load_data() # argument to this function specifies bin width n_stimuli, n_neurons = resp_all.shape print(f'{n_neurons} neurons in response to {n_stimuli} stimuli') fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(2 * 6, 5)) # Visualize data matrix plot_data_matrix(resp_all[:, :100].T, ax1) # plot responses of first 100 neurons ax1.set_xlabel('stimulus') ax1.set_ylabel('neuron') # Plot tuning curves of three random neurons ineurons = np.random.choice(n_neurons, 3, replace=False) # pick three random neurons ax2.plot(stimuli_all, resp_all[:, ineurons]) ax2.set_xlabel('stimulus orientation ($^o$)') ax2.set_ylabel('neural response') ax2.set_xticks(np.linspace(0, 360, 5)) plt.tight_layout() ``` We will split our data into a training set and test set. In particular, we will have a training set of orientations (`stimuli_train`) and the corresponding responses (`resp_train`). Our testing set will have held-out orientations (`stimuli_test`) and the corresponding responses (`resp_test`). ```python #@title #@markdown Execute this cell to split into training and test sets # Set random seeds for reproducibility np.random.seed(4) torch.manual_seed(4) # Split data into training set and testing set n_train = int(0.6 * n_stimuli) # use 60% of all data for training set ishuffle = torch.randperm(n_stimuli) itrain = ishuffle[:n_train] # indices of data samples to include in training set itest = ishuffle[n_train:] # indices of data samples to include in testing set stimuli_test = stimuli_all[itest] resp_test = resp_all[itest] stimuli_train = stimuli_all[itrain] resp_train = resp_all[itrain] ``` --- # Section 2: Deep feed-forward networks in *pytorch* <details> <summary> <font color='blue'>Click here for text recap of relevant part of video </font></summary> We can build a linear network with no hidden layers, where the stimulus prediction $y$ is a product of weights $\mathbf{W}_{out}$ and neural responses $\mathbf{r}$ with an added term $\mathbf{b}$ which is called the bias term. When you fit a linear model such as this you minimize the squared error between the predicted stimulus $y$ and the true stimulus $\tilde{y}$, this is the “loss function”. \begin{align} L &= (y - \tilde{y})^2 \\ &= ((\mathbf{W}^{out} \mathbf{r} + \mathbf{b}) - \tilde{y})^2 \end{align} The solution to minimizing this loss function in a linear model can be found in closed form, and you learned how to solve this linear regression problem in the first week if you remember. If we use a simple linear model for this data we are able to predict the stimulus within 2-3 degrees. Let’s see if we can predict the neural activity better with a deep network. Let’s add a hidden layer with $M$ units to this linear model, where now the output $y$ is as follows: \begin{align} \mathbf{h} &= \mathbf{W}^{in} \mathbf{r} + \mathbf{b}^{in}, && [\mathbf{W}^{in}: M \times N,\, \mathbf{b}^{in}: M \times 1], \\ y &= \mathbf{W}^{out} \mathbf{h} + \mathbf{b}^{out}, && [\mathbf{W}^{out}: 1 \times M,\, \mathbf{b}^{in}: 1 \times 1], \end{align} Note this linear network with one hidden layer where $M$ hidden units is less than $N$ inputs is equivalent to performing [reduced rank regression](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3444519/), a technique that is useful for regularizing your regression model. Adding this hidden layer means the model now has a depth of $1$. The number of units $M$ is termed the width of the network. Increasing the depth and the width of the network can increase the expressivity of the model -- in other words how well it can fit complex non-linear functions. Many state-of-the-art models now have close to 100 layers! But for now let’s start with a model with a depth of $1$ and see if we can improve our prediction of the stimulus. See [bonus section 1](#b1) for a deeper discussion of what this choice entails, and when one might want to use deeper/shallower and wider/narrower architectures. The $M$-dimensional vector $\mathbf{h}$ denotes the activations of the **hidden layer** of the network. The blue components of this diagram denote the **parameters** of the network, which we will later optimize with gradient descent. These include all the weights and biases $\mathbf{W}^{in}, \mathbf{b}^{in}, \mathbf{W}^{out}, \mathbf{b}^{out}$. The **weights** are matrices of size (# of outputs, # of inputs) that are multiplied by the input of each layer, like the regression coefficients in linear regression. The **biases** are vectors of size (# of outputs, 1), like the intercept term in linear regression (see W1D3 for more details on multivariate linear regression). <p align="center"> </p> </details> We'll now build a simple deep neural network that takes as input a vector of neural responses and outputs a single number representing the decoded stimulus orientation. Let $\mathbf{r}^{(n)} = \begin{bmatrix} r_1^{(n)} & r_2^{(n)} & \ldots & r_N^{(n)} \end{bmatrix}^T$ denote the vector of neural responses (of neurons $1, \ldots, N$) to the $n$th stimulus. The network we will use is described by the following set of equations: \begin{align} \mathbf{h}^{(n)} &= \mathbf{W}^{in} \mathbf{r}^{(n)} + \mathbf{b}^{in}, && [\mathbf{W}^{in}: M \times N,\, \mathbf{b}^{in}: M \times 1], \\ y^{(n)} &= \mathbf{W}^{out} \mathbf{h}^{(n)} + \mathbf{b}^{out}, && [\mathbf{W}^{out}: 1 \times M,\, \mathbf{b}^{in}: 1 \times 1], \end{align} where $y^{(n)}$ denotes the scalar output of the network: the decoded orientation of the $n$-th stimulus. ### Section 2.1: Introduction to PyTorch *Estimated timing to here from start of tutorial: 16 min* Here, we'll use the **PyTorch** package to build, run, and train deep networks of this form in Python. PyTorch uses a data type called a `torch.Tensor`. `torch.Tensor`'s are effectively just like a `numpy` arrays, except that they have some important attributes and methods needed for automatic differentiation (to be discussed below). They also come along with infrastructure for easily storing and computing with them on GPU's, a capability we won't touch on here but which can be really useful in practice. <details> <summary> <font color='blue'>Click here for text recap of relevant part of video </font></summary> First we import the pytorch library called `torch` and its neural network module `nn`. Next we will create a class for the deep network called DeepNet. A class has functions which are called methods. A class in python is initialized using a method called `__init__`. In this case the init method is declared to takes two inputs (other than the `self` input which represents the class itself), which are `n_inputs` and `n_hidden`. In our case `n_inputs` is the number of neurons we are using to do the prediction, and `n_hidden` is the number of hidden units. We first call the super function to invoke the `nn.Module`’s init function. Next we add the hidden layer `in_layer` as an attribute of the class. It is a linear layer called `nn.Linear` with size `n_inputs` by `n_hidden`. Then we add a second linear layer `out_layer` of size `n_hidden` by `1`, because we are predicting one output - the orientation of the stimulus. PyTorch will initialize all weights and biases randomly. Note the number of hidden units `n_hidden` is a parameter that we are free to vary in deciding how to build our network. See [Bonus Section 1](#b1) for a discussion of how this architectural choice affects the computations the network can perform. Next we add another method to the class called `forward`. This is the method that runs when you call the class as a function. It takes as input `r` which is the neural responses. Then `r` is sent through the linear layers `in_layer` and `out_layer` and returns our prediction `y`. Let’s create an instantiation of this class called `net` with 200 hidden units with `net = DeepNet(n_neurons, 200)`. Now we can run the neural response through the network to predict the stimulus (`net(r)`); running the “net” this way calls the forward method. </details> The next cell contains code for building the deep network we defined above and in the video using the `nn.Module` base class for deep neural network models (documentation [here](https://pytorch.org/docs/stable/generated/torch.nn.Module.html?highlight=nn%20module#torch.nn.Module)). ```python class DeepNet(nn.Module): """Deep Network with one hidden layer Args: n_inputs (int): number of input units n_hidden (int): number of units in hidden layer Attributes: in_layer (nn.Linear): weights and biases of input layer out_layer (nn.Linear): weights and biases of output layer """ def __init__(self, n_inputs, n_hidden): super().__init__() # needed to invoke the properties of the parent class nn.Module self.in_layer = nn.Linear(n_inputs, n_hidden) # neural activity --> hidden units self.out_layer = nn.Linear(n_hidden, 1) # hidden units --> output def forward(self, r): """Decode stimulus orientation from neural responses Args: r (torch.Tensor): vector of neural responses to decode, must be of length n_inputs. Can also be a tensor of shape n_stimuli x n_inputs, containing n_stimuli vectors of neural responses Returns: torch.Tensor: network outputs for each input provided in r. If r is a vector, then y is a 1D tensor of length 1. If r is a 2D tensor then y is a 2D tensor of shape n_stimuli x 1. """ h = self.in_layer(r) # hidden representation y = self.out_layer(h) return y ``` ## Section 2.2: Activation functions *Estimated timing to here from start of tutorial: 25 min* ```python # @title Video 2: Nonlinear activation functions from ipywidgets import widgets out2 = widgets.Output() with out2: from IPython.display import IFrame class BiliVideo(IFrame): def __init__(self, id, page=1, width=400, height=300, **kwargs): self.id=id src = 'https://player.bilibili.com/player.html?bvid={0}&page={1}'.format(id, page) super(BiliVideo, self).__init__(src, width, height, **kwargs) video = BiliVideo(id="BV1m5411h7V5", width=854, height=480, fs=1) print('Video available at https://www.bilibili.com/video/{0}'.format(video.id)) display(video) out1 = widgets.Output() with out1: from IPython.display import YouTubeVideo video = YouTubeVideo(id="JAdukDCQALA", width=854, height=480, fs=1, rel=0) print('Video available at https://youtube.com/watch?v=' + video.id) display(video) out = widgets.Tab([out1, out2]) out.set_title(0, 'Youtube') out.set_title(1, 'Bilibili') display(out) ``` This video covers adding a nonlinear activation funciton, specifically a Rectified Linear Unit (ReLU), to the linear network. <details> <summary> <font color='blue'>Click here for text recap of video </font></summary> Note that the deep network we constructed above comprises solely **linear** operations on each layer: each layer is just a weighted sum of all the elements in the previous layer. It turns out that linear hidden layers like this aren't particularly useful, since a sequence of linear transformations is actually essentially the same as a single linear transformation. We can see this from the above equations by plugging in the first one into the second one to obtain \begin{equation} y^{(n)} = \mathbf{W}^{out} \left( \mathbf{W}^{in} \mathbf{r}^{(n)} + \mathbf{b}^{in} \right) + \mathbf{b}^{out} = \mathbf{W}^{out}\mathbf{W}^{in} \mathbf{r}^{(n)} + \left( \mathbf{W}^{out}\mathbf{b}^{in} + \mathbf{b}^{out} \right) \end{equation} In other words, the output is still just a weighted sum of elements in the input -- the hidden layer has done nothing to change this. To extend the set of computable input/output transformations to more than just weighted sums, we'll incorporate a **non-linear activation function** in the hidden units. This is done by simply modifying the equation for the hidden layer activations to be \begin{equation} \mathbf{h}^{(n)} = \phi(\mathbf{W}^{in} \mathbf{r}^{(n)} + \mathbf{b}^{in}) \end{equation} where $\phi$ is referred to as the activation function. Using a non-linear activation function will ensure that the hidden layer performs a non-linear transformation of the input, which will make our network much more powerful (or *expressive*, see [Bonus Section 1](#b1)). In practice, deep networks *always* use non-linear activation functions. The most common non-linearity used is the rectified linear unit (or ReLU), which is a max(0, x) function. At the beginning of neural network development, researchers experimented with different non-linearities such as sigmoid and tanh functions, but in the end they found that RELU activation functions worked the best. It works well because the gradient is able to back-propagate through the network as long as the input is positive - the gradient is 1 for all values of x greater than 0. If you use a saturating non-linearity then the gradients will be very small in the saturating regimes, reducing the effective computing regime of the unit. </details> #### Coding Exercise 2.2: Nonlinear Activations Create a new class `DeepNetReLU` by modifying our above deep network model to add a **non-linear activation** function $\phi$: \begin{equation} \mathbf{h}^{(n)} = \phi(\mathbf{W}^{in} \mathbf{r}^{(n)} + \mathbf{b}^{in}) \end{equation} We'll use the linear rectification function: \begin{equation} \phi(x) = \begin{cases} x & \text{if } x > 0 \\ 0 & \text{else} \end{cases} \end{equation} which can be implemented in PyTorch using `torch.relu()`. Hidden layers with this activation function are typically referred to as "**Re**ctified **L**inear **U**nits", or **ReLU**'s. Initialize this network with 10 hidden units and run on an example stimulus. **Hint**: you only need to modify the `forward()` method of the above `DeepNet()` class to include `torch.relu()`. We then initialize and run this network. We use it to decode stimulus orientation (true stimulus given by `ori`) from a vector of neural responses `r` to the very first stimulus. Note that when the initialized network class is called as a function on an input (e.g. `net(r)`), its `.forward()` method is called. This is a special property of the `nn.Module` class. Note that the decoded orientations at this point will be nonsense, since the network has been initialized with random weights. Below, we'll learn how to optimize these weights for good stimulus decoding. ```python class DeepNetReLU(nn.Module): """ network with a single hidden layer h with a RELU """ def __init__(self, n_inputs, n_hidden): super().__init__() # needed to invoke the properties of the parent class nn.Module self.in_layer = nn.Linear(n_inputs, n_hidden) # neural activity --> hidden units self.out_layer = nn.Linear(n_hidden, 1) # hidden units --> output def forward(self, r): ############################################################################ ## TO DO for students: write code for computing network output using a ## rectified linear activation function for the hidden units # Fill out function and remove raise NotImplementedError("Student exercise: complete DeepNetReLU forward") ############################################################################ h = ... # h is size (n_inputs, n_hidden) y = ... # y is size (n_inputs, 1) return y # Set random seeds for reproducibility np.random.seed(1) torch.manual_seed(1) # Initialize a deep network with M=200 hidden units net = DeepNetReLU(n_neurons, 200) # Get neural responses (r) to and orientation (ori) to one stimulus in dataset r, ori = get_data(1, resp_train, stimuli_train) # using helper function get_data # Decode orientation from these neural responses using initialized network out = net(r) # compute output from network, equivalent to net.forward(r) print('decoded orientation: %.2f degrees' % out) print('true orientation: %.2f degrees' % ori) ``` ```python # to_remove solution class DeepNetReLU(nn.Module): """ network with a single hidden layer h with a RELU """ def __init__(self, n_inputs, n_hidden): super().__init__() # needed to invoke the properties of the parent class nn.Module self.in_layer = nn.Linear(n_inputs, n_hidden) # neural activity --> hidden units self.out_layer = nn.Linear(n_hidden, 1) # hidden units --> output def forward(self, r): h = torch.relu(self.in_layer(r)) # h is size (n_inputs, n_hidden) y = self.out_layer(h) # y is size (n_inputs, 1) return y # Set random seeds for reproducibility np.random.seed(1) torch.manual_seed(1) # Initialize a deep network with M=200 hidden units net = DeepNetReLU(n_neurons, 200) # Get neural responses (r) to and orientation (ori) to one stimulus in dataset r, ori = get_data(1, resp_train, stimuli_train) # using helper function get_data # Decode orientation from these neural responses using initialized network out = net(r) # compute output from network, equivalent to net.forward(r) print('decoded orientation: %.2f degrees' % out) print('true orientation: %.2f degrees' % ori) ``` You should see that the decoded orientation is 0.17 $^{\circ}$ while the true orientation is 139.00 $^{\circ}$. --- # Section 3: Loss functions and gradient descent ```python # @title Video 3: Loss functions & gradient descent from ipywidgets import widgets out2 = widgets.Output() with out2: from IPython.display import IFrame class BiliVideo(IFrame): def __init__(self, id, page=1, width=400, height=300, **kwargs): self.id=id src = 'https://player.bilibili.com/player.html?bvid={0}&page={1}'.format(id, page) super(BiliVideo, self).__init__(src, width, height, **kwargs) video = BiliVideo(id="BV19k4y1271n", width=854, height=480, fs=1) print('Video available at https://www.bilibili.com/video/{0}'.format(video.id)) display(video) out1 = widgets.Output() with out1: from IPython.display import YouTubeVideo video = YouTubeVideo(id="aEtKpzEuviw", width=854, height=480, fs=1, rel=0) print('Video available at https://youtube.com/watch?v=' + video.id) display(video) out = widgets.Tab([out1, out2]) out.set_title(0, 'Youtube') out.set_title(1, 'Bilibili') display(out) ``` This video covers loss functions, gradient descent, and how to implement these in Pytorch. ### Section 3.1: Loss functions *Estimated timing to here from start of tutorial: 40 min* Because the weights of the network are currently randomly chosen, the outputs of the network are nonsense: the decoded stimulus orientation is nowhere close to the true stimulus orientation. We'll shortly write some code to change these weights so that the network does a better job of decoding. But to do so, we first need to define what we mean by "better". One simple way of defining this is to use the squared error \begin{equation} L = (y - \tilde{y})^2 \end{equation} where $y$ is the network output and $\tilde{y}$ is the true stimulus orientation. When the decoded stimulus orientation is far from the true stimulus orientation, $L$ will be large. We thus refer to $L$ as the **loss function**, as it quantifies how *bad* the network is at decoding stimulus orientation. <details> <summary> <font color='blue'>Click here for text recap of relevant part of video </font></summary> First we run the neural responses through the network `net` to get the output `out`. Then we declare our loss function, we will use the built in `nn.MSELoss` function for this purpose: `loss_fn = nn.MSELoss()`. This loss function takes two inputs, the network output `out` and the true stimulus orientations `ori` and finds the mean squared error: `loss = loss_fn(out, ori)`. Specifically, it will take as arguments a **batch** of network outputs $y_1, y_2, \ldots, y_P$ and corresponding target outputs $\tilde{y}_1, \tilde{y}_2, \ldots, \tilde{y}_P$, and compute the **mean squared error (MSE)** \begin{equation} L = \frac{1}{P}\sum_{n=1}^P \left(y^{(n)} - \tilde{y}^{(n)}\right)^2 \end{equation} where $P$ is the number of different stimuli in a batch, called the *batch size*. **Computing MSE** Evaluate the mean squared error for a deep network with $M=10$ rectified linear units, on the decoded orientations from neural responses to 20 random stimuli. ```python # Set random seeds for reproducibility np.random.seed(1) torch.manual_seed(1) # Initialize a deep network with M=10 hidden units net = DeepNetReLU(n_neurons, 10) # Get neural responses to first 20 stimuli in the data set r, ori = get_data(20, resp_train, stimuli_train) # Decode orientation from these neural responses out = net(r) # Initialize PyTorch mean squared error loss function (Hint: look at nn.MSELoss) loss_fn = nn.MSELoss() # Evaluate mean squared error loss = loss_fn(out, ori) print('mean squared error: %.2f' % loss) ``` You should see a mean squared error of 42949.14. ### Section 3.2: Optimization with gradient descent *Estimated timing to here from start of tutorial: 50 min* <details> <summary> <font color='blue'>Click here for text recap of relevant part of video </font></summary> Next we minimize this loss function using gradient descent. In **gradient descent** we compute the gradient of the loss function with respect to each parameter (all W’s and b’s). We then update the parameters by subtracting the learning rate times the gradient. Let’s visualize this loss function $L$ with respect to a weight $w$. If the gradient is positive (the slope $\frac{dL}{dw}$ > 0) as in this case then we want to move in the opposite direction which is negative. So we update the $w$ accordingly in the negative direction on each iteration. Once the iterations complete the weight will ideally be at a value that minimizes the cost function. In reality these cost functions are not convex like this one and depend on hundreds of thousands of parameters. There are tricks to help navigate this rocky cost landscape such as adding momentum or changing the optimizer but we won’t have time to get into that today. There are also ways to change the architecture of the network to improve optimization, such as including skip connections. These skip connections are used in residual networks and allow for the optimization of many layer networks. </details> ```python #@markdown Execute this cell to view gradient descent gif from IPython.display import Image Image(url='https://github.com/NeuromatchAcademy/course-content/blob/master/tutorials/static/grad_descent.gif?raw=true') ``` We'll use the **gradient descent (GD)** algorithm to modify our weights to reduce the loss function, which consists of iterating three steps. 1. **Evaluate the loss** on the training data, ``` out = net(train_data) loss = loss_fn(out, train_labels) ``` where `train_data` are the network inputs in the training data (in our case, neural responses), and `train_labels` are the target outputs for each input (in our case, true stimulus orientations). 2. **Compute the gradient of the loss** with respect to each of the network weights. In PyTorch, we can do this with the `.backward()` method of the loss `loss`. Note that the gradients of each parameter need to be cleared before calling `.backward()`, or else PyTorch will try to accumulate gradients across iterations. This can again be done using built-in optimizers via the method `.zero_grad()`. Putting these together we have ``` optimizer.zero_grad() loss.backward() ``` 3. **Update the network weights** by descending the gradient. In Pytorch, we can do this using built-in optimizers. We'll use the `optim.SGD` optimizer (documentation [here](https://pytorch.org/docs/stable/optim.html#torch.optim.SGD)) which updates parameters along the negative gradient, scaled by a learning rate. To initialize this optimizer, we have to tell it * which parameters to update, and * what learning rate to use For example, to optimize *all* the parameters of a network `net` using a learning rate of .001, the optimizer would be initialized as follows ``` optimizer = optim.SGD(net.parameters(), lr=.001) ``` where `.parameters()` is a method of the `nn.Module` class that returns a [Python generator object](https://wiki.python.org/moin/Generators) over all the parameters of that `nn.Module` class (in our case, $\mathbf{W}^{in}, \mathbf{b}^{in}, \mathbf{W}^{out}, \mathbf{b}^{out}$). After computing all the parameter gradients in step 2, we can then update each of these parameters using the `.step()` method of this optimizer, ``` optimizer.step() ``` In the next exercise, we'll give you a code skeleton for implementing the GD algorithm. Your job will be to fill in the blanks. For the mathematical details of the GD algorithm, see [bonus section 2.1](#b21). In this case we are using gradient descent (not *stochastic* gradient descent) because we are computing the gradient over ALL training data at once. Normally there is too much training data to do this in practice, and for instance the neural responses may be divided into sets of 20 stimuli. An **epoch** in deep learning is defined as the forward and backward pass of all the training data through the network. We will run the forward and backward pass of the network here for 20 **epochs**, in practice training may require thousands of epochs. See [bonus section 2.2](#b22) for a more detailed discussion of stochastic gradient descent. #### Coding Exercise 3.2: Gradient descent in PyTorch Complete the function `train()` that uses the gradient descent algorithm to optimize the weights of a given network. This function takes as input arguments * `net`: the PyTorch network whose weights to optimize * `loss_fn`: the PyTorch loss function to use to evaluate the loss * `train_data`: the training data to evaluate the loss on (i.e. neural responses to decode) * `train_labels`: the target outputs for each data point in `train_data` (i.e. true stimulus orientations) We will then train a neural network on our data and plot the loss (mean squared error) over time. When we run this function, behind the scenes PyTorch is actually changing the parameters inside this network to make the network better at decoding, so its weights will now be different than they were at initialization. ```python def train(net, loss_fn, train_data, train_labels, n_epochs=50, learning_rate=1e-4): """Run gradient descent to opimize parameters of a given network Args: net (nn.Module): PyTorch network whose parameters to optimize loss_fn: built-in PyTorch loss function to minimize train_data (torch.Tensor): n_train x n_neurons tensor with neural responses to train on train_labels (torch.Tensor): n_train x 1 tensor with orientations of the stimuli corresponding to each row of train_data n_epochs (int, optional): number of epochs of gradient descent to run learning_rate (float, optional): learning rate to use for gradient descent Returns: (list): training loss over iterations """ # Initialize PyTorch SGD optimizer optimizer = optim.SGD(net.parameters(), lr=learning_rate) # Placeholder to save the loss at each iteration train_loss = [] # Loop over epochs for i in range(n_epochs): ###################################################################### ## TO DO for students: fill in missing code for GD iteration raise NotImplementedError("Student exercise: write code for GD iterations") ###################################################################### # compute network output from inputs in train_data out = ... # compute network output from inputs in train_data # evaluate loss function loss = loss_fn(out, train_labels) # Clear previous gradients ... # Compute gradients ... # Update weights ... # Store current value of loss train_loss.append(loss.item()) # .item() needed to transform the tensor output of loss_fn to a scalar # Track progress if (i + 1) % (n_epochs // 5) == 0: print(f'iteration {i + 1}/{n_epochs} | loss: {loss.item():.3f}') return train_loss # Set random seeds for reproducibility np.random.seed(1) torch.manual_seed(1) # Initialize network with 10 hidden units net = DeepNetReLU(n_neurons, 10) # Initialize built-in PyTorch MSE loss function loss_fn = nn.MSELoss() # Run gradient descent on data train_loss = train(net, loss_fn, resp_train, stimuli_train) # Plot the training loss over iterations of GD plot_train_loss(train_loss) ``` ```python # to_remove solution def train(net, loss_fn, train_data, train_labels, n_epochs=50, learning_rate=1e-4): """Run gradient descent to opimize parameters of a given network Args: net (nn.Module): PyTorch network whose parameters to optimize loss_fn: built-in PyTorch loss function to minimize train_data (torch.Tensor): n_train x n_neurons tensor with neural responses to train on train_labels (torch.Tensor): n_train x 1 tensor with orientations of the stimuli corresponding to each row of train_data n_epochs (int, optional): number of epochs of gradient descent to run learning_rate (float, optional): learning rate to use for gradient descent Returns: (list): training loss over iterations """ # Initialize PyTorch SGD optimizer optimizer = optim.SGD(net.parameters(), lr=learning_rate) # Placeholder to save the loss at each iteration train_loss = [] # Loop over epochs for i in range(n_epochs): # compute network output from inputs in train_data out = net(train_data) # compute network output from inputs in train_data # evaluate loss function loss = loss_fn(out, train_labels) # Clear previous gradients optimizer.zero_grad() # Compute gradients loss.backward() # Update weights optimizer.step() # Store current value of loss train_loss.append(loss.item()) # .item() needed to transform the tensor output of loss_fn to a scalar # Track progress if (i + 1) % (n_epochs // 5) == 0: print(f'iteration {i + 1}/{n_epochs} | loss: {loss.item():.3f}') return train_loss # Set random seeds for reproducibility np.random.seed(1) torch.manual_seed(1) # Initialize network with 10 hidden units net = DeepNetReLU(n_neurons, 10) # Initialize built-in PyTorch MSE loss function loss_fn = nn.MSELoss() # Run gradient descent on data train_loss = train(net, loss_fn, resp_train, stimuli_train) # Plot the training loss over iterations of GD with plt.xkcd(): plot_train_loss(train_loss) ``` **We can further improve our model - please see the Bonus Tutorial when you have time to dive deeper into this model by evaluating and improving its performance by visualizing the weights, looking at performance on test data, switching to a new loss function and adding regularization.** --- # Summary *Estimated timing of tutorial: 1 hour, 20 minutes* We have now covered a number of common and powerful techniques for applying deep learning to decoding from neural data, some of which are common to almost any machine learning problem: * Building and training deep networks using the **PyTorch** `nn.Module` class and built-in **optimizers** * Choosing **loss functions** An important aspect of this tutorial was the `train()` function we wrote in coding exercise 3.2. Note that it can be used to train *any* network to minimize *any* loss function on *any* training data. This is the power of using PyTorch to train neural networks and, for that matter, **any other model**! There is nothing in the `nn.Module` class that forces us to use `nn.Linear` layers that implement neural network operations. You can actually put anything you want inside the `.__init__()` and `.forward()` methods of this class. As long as its parameters and computations involve only `torch.Tensor`'s, and the model is differentiable, you'll then be able to optimize the parameters of this model in exactly the same way we optimized the deep networks here. What kinds of conclusions can we draw from these sorts of analyses? If we can decode the stimulus well from visual cortex activity, that means that there is information about this stimulus available in visual cortex. Whether or not the animal uses that information to make decisions is not determined from an analysis like this. In fact mice perform poorly in orientation discrimination tasks compared to monkeys and humans, even though they have information about these stimuli in their visual cortex. Why do you think they perform poorly in orientation discrimination tasks? See [this paper](https://www.biorxiv.org/content/10.1101/679324v2) for some potential hypotheses, but this is totally an open question! --- # Bonus <a name='b1'></a> ## Bonus Section 1: Neural network *depth*, *width* and *expressivity* Two important architectural choices that always have to be made when constructing deep feed-forward networks like those used here are * the number of hidden layers, or the network's *depth* * the number of units in each layer, or the layer *widths* Here, we restricted ourselves to networks with a single hidden layer with a width of $M$ units, but it is easy to see how this code could be adapted to arbitrary depths. Adding another hidden layer simply requires adding another `nn.Linear` module to the `__init__()` method and incorporating it into the `.forward()` method. The depth and width of a network determine the set of input/output transormations that it can perform, often referred to as its *expressivity*. The deeper and wider the network, the more *expressive* it is; that is, the larger the class of input/output transformations it can compute. In fact, it turns out that an infinitely wide *or* infinitely deep networks can in principle [compute (almost) *any* input/output transformation](https://en.wikipedia.org/wiki/Universal_approximation_theorem). A classic mathematical demonstration of the power of depth is given by the so-called [XOR problem](https://medium.com/@jayeshbahire/the-xor-problem-in-neural-networks-50006411840b#:~:text=The%20XOr%2C%20or%20%E2%80%9Cexclusive%20or,value%20if%20they%20are%20equal.). This toy problem demonstrates how even a single hidden layer can drastically expand the set of input/output transformations a network can perform, relative to a shallow network with no hidden layers. The key intuition is that the hidden layer allows you to represent the input in a new format, which can then allow you to do almost anything you want with it. The *wider* this hidden layer, the more flexibility you have in this representation. In particular, if you have more hidden units than input units, then the hidden layer representation of the input is higher-dimensional than the raw data representation. This higher dimensionality effectively gives you more "room" to perform arbitrary computations in. It turns out that even with just this one hidden layer, if you make it wide enough you can actually approximate any input/output transformation you want. See [here](http://neuralnetworksanddeeplearning.com/chap4.html) for a neat visual demonstration of this. In practice, however, it turns out that increasing depth seems to grant more expressivity with fewer units than increasing width does (for reasons that are not well understood). It is for this reason that truly *deep* networks are almost always used in machine learning, which is why this set of techniques is often referred to as *deep* learning. That said, there is a cost to making networks deeper and wider. The bigger your network, the more parameters (i.e. weights and biases) it has, which need to be optimized! The extra expressivity afforded by higher width and/or depth thus carries with it (at least) two problems: * optimizing more parameters usually requires more data * a more highly parameterized network is more prone to overfit to the training data, so requires more sophisticated optimization algorithms to ensure generalization ## Bonus Section 2: Gradient descent <a name='b21'></a> ### Bonus Section 2.1: Gradient descent equations Here we provide the equations for the three steps of the gradient descent algorithm, as applied to our decoding problem: 1. **Evaluate the loss** on the training data. For a mean squared error loss, this is given by \begin{equation} L = \frac{1}{P}\sum_{n=1}^P (y^{(n)} - \tilde{y}^{(n)})^2 \end{equation} where $y^{(n)}$ denotes the stimulus orientation decoded from the population response $\mathbf{r}^{(n)}$ to the $n$th stimulus in the training data, and $\tilde{y}^{(n)}$ is the true orientation of that stimulus. $P$ denotes the total number of data samples in the training set. In the syntax of our `train()` function above, $\mathbf{r}^{(n)}$ is given by `train_data[n, :]` and $\tilde{y}^{(n)}$ by `train_labels[n]`. 2. **Compute the gradient of the loss** with respect to each of the network weights. In our case, this entails computing the quantities \begin{equation} \frac{\partial L}{\partial \mathbf{W}^{in}}, \frac{\partial L}{\partial \mathbf{b}^{in}}, \frac{\partial L}{\partial \mathbf{W}^{out}}, \frac{\partial L}{\partial \mathbf{b}^{out}} \end{equation} Usually, we would require lots of math in order to derive each of these gradients, and lots of code to compute them. But this is where PyTorch comes to the rescue! Using a cool technique called [automatic differentiation](https://en.wikipedia.org/wiki/Automatic_differentiation), PyTorch automatically calculates these gradients when the `.backward()` function is called. More specifically, when this function is called on a particular variable (e.g. `loss`, as above), PyTorch will compute the gradients with respect to each network parameter. These are computed and stored behind the scenes, and can be accessed through the `.grad` attribute of each of the network's parameters. As we saw above, however, we actually never need to look at or call these gradients when implementing gradient descent, as this can be taken care of by PyTorch's built-in optimizers, like `optim.SGD`. 3. **Update the network weights** by descending the gradient: \begin{align} \mathbf{W}^{in} &\leftarrow \mathbf{W}^{in} - \alpha \frac{\partial L}{\partial \mathbf{W}^{in}} \\ \mathbf{b}^{in} &\leftarrow \mathbf{b}^{in} - \alpha \frac{\partial L}{\partial \mathbf{b}^{in}} \\ \mathbf{W}^{out} &\leftarrow \mathbf{W}^{out} - \alpha \frac{\partial L}{\partial \mathbf{W}^{out}} \\ \mathbf{b}^{out} &\leftarrow \mathbf{b}^{out} - \alpha \frac{\partial L}{\partial \mathbf{b}^{out}} \end{align} where $\alpha$ is called the **learning rate**. This **hyperparameter** of the SGD algorithm controls how far we descend the gradient on each iteration. It should be as large as possible so that fewer iterations are needed, but not too large so as to avoid parameter updates from skipping over minima in the loss landscape. While the equations written down here are specific to the network and loss function considered in this tutorial, the code provided above for implementing these three steps is completely general: no matter what loss function or network you are using, exactly the same commands can be used to implement these three steps. The way that the gradients are calculated is called **backpropagation**. We have a loss function: \begin{align} L &= (y - \tilde{y})^2 \\ &= (\mathbf{W}^{out} \mathbf{h} - \tilde{y})^2 \end{align} where $\mathbf{h} = \phi(\mathbf{W}^{in} \mathbf{r} + \mathbf{b}^{in})$ You may see that $\frac{\partial L}{\partial \mathbf{W}^{out}}$ is simple to calculate as it is on the outside of the equation (it is also a vector in this case, not a matrix, so the derivative is standard): \begin{equation} \frac{\partial L}{\partial \mathbf{W}^{out}} = 2 (\mathbf{h} - \tilde{y}) \end{equation} Now let's compute the derivative with respect to $\mathbf{W}^{in}$ using the chain rule. Note it is only positive if the output is positive due to the RELU $\phi$: \begin{align} \frac{\partial L}{\partial \mathbf{W}^{in}} &= \begin{cases} \frac{\partial L}{\partial \mathbf{W}^{out}} \frac{\partial \mathbf{h}}{\partial \mathbf{W}^{in}} & \text{if } \mathbf{h} > 0 \\ 0 & \text{else} \end{cases} \\ &= \begin{cases} 2 (\mathbf{h} - \tilde{y}) \mathbf{r}^\top & \text{if } \mathbf{h} > 0 \\ 0 & \text{else} \end{cases} \end{align} It is most efficient to compute the derivative once for the last layer, then once for the next layer and multiply by the previous layer's derivative and so on using the chain rule. Each of these operations is relatively fast, making training of deep networks feasible. The command `loss.backward()` computes these gradients for the defined `loss` with respect to each network parameter. The computation is done using [automatic differentiation](https://en.wikipedia.org/wiki/Automatic_differentiation), which implements backpropagation. Note that this works no matter how big/small the network is, allowing us to perform gradient descent for any deep network model built using PyTorch. <a name='b22'></a> ### Bonus Section 2.2: *Stochastic* gradient descent (SGD) vs. gradient descent (GD) In this tutorial, we used the gradient descent algorithm, which differs in a subtle yet very important way from the more commonly used **stochastic gradient descent (SGD)** algorithm. The key difference is in the very first step of each iteration, where in the GD algorithm we evaluate the loss *at every data sample in the training set*. In SGD, on the other hand, we evaluate the loss only at a random subset of data samples from the full training set, called a **mini-batch**. At each iteration, we randomly sample a mini-batch to perform steps 1-3 on. All the above equations still hold, but now the $P$ data samples $\mathbf{r}^{(n)}, \tilde{y}^{(n)}$ denote a mini-batch of $P$ random samples from the training set, rather than the whole training set. There are several reasons why one might want to use SGD instead of GD. The first is that the training set might be too big, so that we actually can't actually evaluate the loss on every single data sample in it. In this case, GD is simply infeasible, so we have no choice but to turn to SGD, which bypasses the restrictive memory demands of GD by sub-sampling the training set into smaller mini-batches. But, even when GD is feasible, SGD turns out to often be better. The stochasticity induced by the extra random sampling step in SGD effectively adds some noise in the search for local minima of the loss function. This can be really useful for avoiding potential local minima, and enforce that whatever minimum is converged to is a good one. This is particularly important when networks are wider and/or deeper, in which case the large number of parameters can lead to overfitting. Here, we used only GD because (1) it is simpler, and (2) it suffices for the problem being considered here. Because we have so many neurons in our data set, decoding is not too challenging and doesn't require a particularly deep or wide network. The small number of parameters in our deep networks therefore can be optimized without a problem using GD.

1d92fc3d10dd29e692b0535d6bc23aa0620b7bfa

ipynb

Jupyter Notebook

tutorials/W2D1_DeepLearning/W2D1_Tutorial1.ipynb

Beilinson/course-content

b74c630bec7002abe2f827ff8e0707f9bbb43f82

tutorials/W2D1_DeepLearning/W2D1_Tutorial1.ipynb

Beilinson/course-content

b74c630bec7002abe2f827ff8e0707f9bbb43f82

tutorials/W2D1_DeepLearning/W2D1_Tutorial1.ipynb

Beilinson/course-content

b74c630bec7002abe2f827ff8e0707f9bbb43f82

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# 亜臨界ホップ分岐の標準形 \begin{equation} \begin{aligned} \dot{x}_0 = \lambda x_0 - \omega x_1 + x_0 \left[ c_1 (x_0^2 + x_1^2) - (x_0^2 + x_1^2)^2 \right],\\ \dot{x}_1 = \omega x_0 + \lambda x_1 + x_1 \left[ c_1 (x_0^2 + x_1^2) - (x_0^2 + x_1^2)^2 \right],\\ \end{aligned} \end{equation} ```python import numpy as np import pathfollowing as pf from scipy.integrate import ode, solve_ivp from scipy.linalg import solve import matplotlib.pyplot as plt import seaborn as sns %matplotlib inline sns.set('poster', 'whitegrid', 'dark', rc={"lines.linewidth": 2, 'grid.linestyle': '-'}) ``` ベクトル場とその微分 ```python c_lyap = 0.25 def f(x, a): A = np.array([[a[0], -1.0],[1.0, a[0]]]) r = x@x return A @ x + r*(c_lyap - r)*x def fx(x, a): r = x @ x a00 = a[0] + r*(c_lyap - r) + 2*(c_lyap - 2*r)*x[0]**2 a01 = -1.0 + 2*x[0]*x[1]*(c_lyap - 2*r) a10 = 1.0 + 2*x[0]*x[1]*(c_lyap - 2*r) a11 = a[0] + r*(c_lyap-r)+2*(c_lyap-2*r)*x[1]**2 return np.array([[a00, a01],[a10, a11]]) def fa(x, a): return np.array([x[0], x[1]]) ``` 一段射撃法の定式化 ```python def func(x, a): T = x[-1] def f2(t, y): return T * f(y, a) r = ode(f2).set_integrator('dop853') y0 = np.copy(x[:-1]) h = 1.0 r.set_initial_value(y0, 0.0) y1 = r.integrate(r.t+h) x1 = np.zeros(len(x)) x1[:-1] = y1 - y0 x1[-1] = y0[0] return x1 def dfdx(x, a): def df2(t, y, n): z = np.zeros((n+1)*(n+2)) z[:n] = y[n] * f(y[:n], a) z[n] = 0.0 J = np.zeros((n+1, n+1)) J[:n, :n] = y[n] * fx(y[:n], a) J[:n, n] = f(y[:n], a) for m in range(n+1): z[(n+1)*(m+1):(n+1)*(m+2)] = J @ y[(n+1)*(m+1):(n+1)*(m+2)] return z r = ode(df2).set_integrator('dop853') n = len(x)-1 y0 = np.zeros((n+1)*(n+2)) I = np.identity(n+1) y0[:n+1] = np.copy(x) for m in range(n+1): y0[(n+1)*(m+1):(n+1)*(m+2)] = I[:,m] h = 1.0 r.set_initial_value(y0, 0.0).set_f_params(n) y1 = r.integrate(r.t+h) A = -np.identity(n+1) for m in range(n+1): A[:-1,m] += y1[(n+1)*(m+1):(n+1)*(m+2)-1] A[-1,:] = 0.0 A[-1,0] = 1.0 return A def dfda(x, a): T = x[-1] def df2(t, y, n): z = np.zeros(2*(n+1)) z[:n] = T * f(y[:n], np.array([y[n]])) z[n] = 0.0 J = np.zeros((n+1, n+1)) J[:n, :n] = fx(y[:n], np.array([y[n]])) J[:n, n] = fa(y[:n], np.array([y[n]])) z[n+1:] = T * J @ y[n+1:] return z r = ode(df2).set_integrator('dop853') n = len(x)-1 y0 = np.zeros(2*(n+1)) y0[:n] = np.copy(x[:-1]) y0[n] = a[0] y0[-1] = 1.0 h = 1.0 r.set_initial_value(y0, 0.0).set_f_params(n) y1 = r.integrate(r.t+h) y1[-1] = 0.0 return y1[n+1:] ``` 一段射撃法のニュートン法 ```python x = np.array([0.0, 0.5, 2*np.pi]) a = np.array([0.00]) y = np.copy(x) for m in range(10): b = func(y, a) A = dfdx(y, a) y -= solve(A, b) print(y, np.linalg.norm(b)) ``` [0. 0.50000006 6.28318561] 1.534154170863662e-07 [0. 0.50000006 6.28318561] 4.9608493090846714e-14 [0. 0.50000006 6.28318561] 1.047382306668854e-15 [0. 0.50000006 6.28318561] 2.159233940399377e-15 [0. 0.50000006 6.28318561] 1.790180836524724e-15 [0. 0.50000006 6.28318561] 3.6691989157368576e-15 [0. 0.50000006 6.28318561] 2.5823128856601336e-15 [0. 0.50000006 6.28318561] 4.742874840267547e-16 [0. 0.50000006 6.28318561] 5.900916318210353e-16 [0. 0.50000006 6.28318561] 3.0967063759893227e-15 一段射撃法の追跡 ```python x=np.array([0.0, 0.5, 2*np.pi]) a=np.array([0.0]) bd,bp,lp=pf.pathfollow(x, a, func, dfdx, dfda,nmax=20, h=0.05, epsr=1.0e-10, epsb=1.0e-10, quiet=False) ``` # TY a x R 0.015023155570483651 0.0 -0.4014886326913046 -1.1210151741032572 R 0.035917260293237226 0.0 -0.5137134389482804 -1.0830209867548288 R 0.06238882678998029 0.0 -0.598635550276071 -1.0336654249654065 R 0.09366115556610179 0.0 -0.6596456895451372 -0.9906320993827148 R 0.12878337264553655 0.0 -0.7049271175618399 -0.9606197790481326 R 0.16687167400969033 0.0 -0.7411210689365288 -0.9433512479878107 R 0.20720964186011206 0.0 -0.7720442328849861 -0.9359801983313732 R 0.249254084532369 0.0 -0.7995859087257013 -0.9355073217026986 R 0.2926045087542456 0.0 -0.8246703700354263 -0.939585814511053 R 0.3369675354791696 0.0 -0.8477989761336331 -0.9465799839662211 R 0.3821271995562121 0.0 -0.8692906175761658 -0.9554041805435147 R 0.4279228184124911 0.0 -0.8893765913715667 -0.9653493846126342 R 0.47423331226694254 0.0 -0.9082387879660252 -0.9759536058460752 R 0.5209660539735923 0.0 -0.9260254818232135 -0.9869139548929227 R 0.5680492881279677 0.0 -0.9428602121660424 -0.9980308609630433 R 0.6154266565926063 0.0 -0.958846830250254 -1.0091720497059906 R 0.6630533271597377 0.0 -0.9740734149750584 -1.0202498422828012 R 0.7108932242619 0.0 -0.9886152742495733 -1.0312065207193601 R 0.7589170001148506 0.0 -1.002537020127154 -1.0420044666419417 R 0.8071005408438864 0.0 -1.0158947050854057 -1.052620089102601 一段射撃法では不安定なリミットサイクルを上手く追跡できない ```python bd2,bp2,lp2=pf.pathfollow(x, a, func, dfdx, dfda,nmax=160, h=-0.01, epsr=1.0e-10, epsb=1.0e-10, quiet=True) ``` 2段射撃法の定式化 ```python Npts = 2 def func(x, a): T = x[-1] def f2(t, y): return T * f(y, a) r = ode(f2).set_integrator('dop853', atol=1.0e-14, rtol=1.0e-14) n = (len(x) - 1) // Npts h = 1.0 / Npts x1 = np.zeros(len(x)) y0 = np.copy(x[:n]) r.set_initial_value(y0, 0.0) y1 = r.integrate(r.t+h) x1[:n] = y1 - x[n:2*n] y0 = np.copy(x[n:2*n]) r.set_initial_value(y0, 0.0) y1 = r.integrate(r.t+h) x1[n:2*n] = y1 - x[:n] x1[-1] = x[0] return x1 def dfdx(x, a): def df2(t, y, n): z = np.zeros((n+1)*(n+2)) z[:n] = y[n] * f(y[:n], a) z[n] = 0.0 J = np.zeros((n+1, n+1)) J[:n, :n] = y[n] * fx(y[:n], a) J[:n, n] = f(y[:n], a) for m in range(n+1): z[(n+1)*(m+1):(n+1)*(m+2)] = J @ y[(n+1)*(m+1):(n+1)*(m+2)] return z r = ode(df2).set_integrator('dop853', atol=1.0e-14, rtol=1.0e-14) n = (len(x)-1) // Npts h = 1.0 / Npts A = np.zeros((len(x), len(x))) y0 = np.zeros((n+1)*(n+2)) I = np.identity(n+1) y0[:n] = x[:n] y0[n] = x[-1] for m in range(n+1): y0[(n+1)*(m+1):(n+1)*(m+2)] = I[:,m] r.set_initial_value(y0, 0.0).set_f_params(n) y1 = r.integrate(r.t+h) for m in range(n): A[:n,m] = y1[(n+1)*(m+1):(n+1)*(m+1)+n] A[:n, n:2*n] = -np.identity(n) A[:n, -1] = y1[-(n+1):-1] y0 = np.zeros((n+1)*(n+2)) y0[:n] = x[n:2*n] y0[n] = x[-1] for m in range(n+1): y0[(n+1)*(m+1):(n+1)*(m+2)] = I[:,m] r.set_initial_value(y0, 0.0).set_f_params(n) y1 = r.integrate(r.t+h) for m in range(n): A[n:2*n,n+m] = y1[(n+1)*(m+1):(n+1)*(m+1)+n] A[n:2*n, :n] = -np.identity(n) A[n:2*n, -1] = y1[-(n+1):-1] A[-1,0] = 1.0 return A def dfda(x, a): T = x[-1] def df2(t, y, n): z = np.zeros(2*(n+1)) z[:n] = T * f(y[:n], np.array([y[n]])) z[n] = 0.0 J = np.zeros((n+1, n+1)) J[:n, :n] = fx(y[:n], np.array([y[n]])) J[:n, n] = fa(y[:n], np.array([y[n]])) z[n+1:] = T * J @ y[n+1:] return z n = (len(x) - 1) // Npts h = 1.0 / Npts r = ode(df2).set_integrator('dop853', atol=1e-14, rtol=1e-14) b = np.zeros(len(x)) y0 = np.zeros(2*(n+1)) y0[:n] = np.copy(x[:n]) y0[n] = a[0] y0[-1] = 1.0 r.set_initial_value(y0, 0.0).set_f_params(n) y1 = r.integrate(r.t+h) b[:n] = y1[n+1:2*n+1] y0[:n] = np.copy(x[n:2*n]) y0[n] = a[0] y0[-1] = 1.0 r.set_initial_value(y0, 0.0).set_f_params(n) y1 = r.integrate(r.t+h) b[n:2*n] = y1[n+1:2*n+1] return b ``` ２段射撃法のニュートン法 ```python x = np.array([0.0, 0.5, 0.0, -0.5, 2*np.pi]) a = np.array([0.0]) y = np.copy(x) for m in range(10): b = func(y, a) A = dfdx(y, a) y -= solve(A, b) print(y[:2], y[-1], np.linalg.norm(b)) ``` [1.03152808e-30 5.00000000e-01] 6.283185307179601 5.9170423507905885e-15 [-3.85185989e-33 5.00000000e-01] 6.283185307179601 3.4577177419348924e-16 [-3.85185989e-33 5.00000000e-01] 6.283185307179601 1.422896290682169e-16 [-3.85185989e-33 5.00000000e-01] 6.283185307179601 1.42289629068217e-16 [-3.85185989e-33 5.00000000e-01] 6.283185307179601 1.4228962906821706e-16 [-3.85185989e-33 5.00000000e-01] 6.283185307179601 1.422896290682171e-16 [-3.85185989e-33 5.00000000e-01] 6.283185307179601 1.422896290682171e-16 [-3.85185989e-33 5.00000000e-01] 6.283185307179601 1.422896290682171e-16 [-3.85185989e-33 5.00000000e-01] 6.283185307179601 1.422896290682171e-16 [-3.85185989e-33 5.00000000e-01] 6.283185307179601 1.422896290682171e-16 ２段射撃法の追跡 ```python x=np.array([0.0, 0.5, 0.0, -0.5, 2*np.pi]) a=np.array([0.0]) bd,bp,lp=pf.pathfollow(x, a, func, dfdx, dfda,nmax=20, h=0.05, epsr=1.0e-10, epsb=1.0e-10, quiet=False) ``` # TY a x R 0.010238862505482822 -5.403755707824863e-32 -0.3662316500243911 -1.5498606621213413 R 0.023739873764932994 -4.733750501935393e-33 -0.4553158497308608 -1.4976143607705639 R 0.04071774492605943 -4.733750501935393e-33 -0.5326683322583992 -1.4215795060654648 R 0.06124544544111728 -4.733750501935393e-33 -0.595783057204346 -1.33786000086712 R 0.08524514750751452 -4.733750501935393e-33 -0.645843059581797 -1.258955671257655 R 0.11250697657464735 -4.733750501935393e-33 -0.6859340014747413 -1.1920208867688635 R 0.14272871566530332 -4.733750501935393e-33 -0.719272411828372 -1.1394278395780593 R 0.17556223958176542 -4.733750501935393e-33 -0.7482786043200086 -1.1004645408132008 R 0.2106536541412975 -4.733750501935393e-33 -0.7744508738274067 -1.0730099622800326 R 0.24767068404422057 -4.733750501935393e-33 -0.7986132498030031 -1.0546474955082767 R 0.28631720026645063 -4.733750501935393e-33 -0.8212010575834192 -1.043208091386597 R 0.3263380778023389 -4.733750501935393e-33 -0.8424572605441736 -1.0369422447846928 R 0.367518134342238 -4.733750501935393e-33 -0.8625378665466908 -1.034511606951831 R 0.40967811560807316 -4.733750501935393e-33 -0.8815600443684318 -1.0349175874854633 R 0.45266963470701993 -4.733750501935393e-33 -0.8996216456621391 -1.0374220910433045 R 0.49637011577806034 -4.733750501935393e-33 -0.9168085306160499 -1.0414800539483653 R 0.5406782309452516 -4.733750501935393e-33 -0.9331973200173574 -1.0466875369358697 R 0.5855099985558622 -4.733750501935393e-33 -0.9488566373477703 -1.0527435057737162 R 0.6307955473406922 -4.733750501935393e-33 -0.963847921027768 -1.0594221907336139 R 0.6764764793878222 -4.733750501935393e-33 -0.9782261306327295 -1.0665531933909338 ```python x=np.array([0.0, 0.5, 0.0, -0.5, 2*np.pi]) a=np.array([0.0]) bd2,bp2,lp2=pf.pathfollow(x, a, func, dfdx, dfda,nmax=70, h=-0.01, epsr=1.0e-10, epsb=1.0e-10, quiet=False) ``` # TY a x R -0.0016825386140757964 7.02246187503377e-32 -0.253373901911225 -1.5594923177185995 R -0.003250526669919375 -9.500955706734343e-33 -0.23495225480671061 -1.554225015837006 R -0.004707045164395174 -4.1717537362564895e-32 -0.21684026359514308 -1.5468666346052207 R -0.006055255185025018 -4.745611209927768e-33 -0.19910931589742567 -1.5374020664495056 R -0.007298384840448311 6.937419267494025e-33 -0.18182701631679232 -1.5258313322500723 R -0.008439716743882195 2.1403554471442047e-32 -0.16505638049320132 -1.512169384074778 R -0.009482576120891142 -3.182652306984614e-32 -0.14885513870366288 -1.4964457011495438 R -0.010430319595285854 -1.9254836635551235e-32 -0.1332751587127739 -1.4787036956990314 R -0.011286324690703826 -2.3660363989649884e-33 -0.11836199364344027 -1.4589999486902951 R -0.012053980070587788 -8.15659325687763e-32 -0.10415455686249707 -1.4374032980901197 R -0.012736676526062455 1.2532475427875193e-31 -0.09068492238716055 -1.413993803993903 R -0.01333779870965182 -1.6902129538851887e-32 -0.07797824621488383 -1.3888616159242642 R -0.013860717602919558 2.6857825741020185e-32 -0.06605280133070679 -1.362105767782887 R -0.014308783697889401 -1.394509914872856e-32 -0.054920116993636824 -1.3338329254439085 R -0.014685320865443788 -2.9327019841978325e-34 -0.04458521126164959 -1.3041561108907922 R -0.014993620878689641 1.4120792175793725e-32 -0.03504690457576111 -1.2731934252215826 R -0.015236938555380698 -2.560586211890893e-32 -0.026298201560356352 -1.241066790883206 R -0.015418487480769441 -2.0065881480611696e-32 -0.018326727968370305 -1.2079007312479293 R -0.015541436270575885 2.2033632912675172e-33 -0.011115209854372206 -1.1738212032129862 R -0.015608905332941564 1.7828107967090242e-32 -0.004641982538141977 -1.1389544959791036 L -0.0156250000111336 4.593689218450005e-32 R -0.015623964088195335 -4.399922198324964e-32 0.0011184823347377155 -1.103426206626107 R -0.015589628605790393 3.202952976089426e-32 0.006195042381084744 -1.0673603006244607 R -0.01550885961884735 1.486508627666432e-32 0.01061935236929509 -1.030878263057281 R -0.015384560878159328 -1.2433754754900076e-33 0.014425342875801725 -0.9940983441247259 R -0.015219577809270248 -8.002791040535006e-33 0.01764871694459497 -0.9571349004944583 R -0.015016696438177901 -4.801393121692155e-33 0.02032647075184356 -0.92009783227188 R -0.014778642553314594 1.4581306494120055e-32 0.022496443075133994 -0.8830921138044552 R -0.01450808107363924 1.2399363924074191e-33 0.024196897223117287 -0.8462174152105282 R -0.014207615594889327 3.3847388567702675e-32 0.025466138017625466 -0.8095678104316425 R -0.013879788088257948 -9.544221565995105e-33 0.026342165451563405 -0.7732315667399483 R -0.013527078727935607 3.4788174538783335e-32 0.02686236578172633 -0.737291009975498 R -0.013151905826081452 6.0372022905579326e-33 0.027063240061055163 -0.7018224593255217 R -0.01275662585582855 -1.3691208466656678e-32 0.02698016947061885 -0.6668962251702814 R -0.012343533544876328 4.380385838663099e-33 0.02664721627547096 -0.6325766633876211 R -0.011914862024080257 -9.663232139807833e-32 0.026096958795552194 -0.5989222795100413 R -0.011472782947019975 1.975291754548149e-33 0.02536035857838516 -0.5659858766452528 R -0.011019407010201982 1.975291754548149e-33 0.0244666567454681 -0.5338147383355227 R -0.010556783702487468 9.863896643218951e-33 0.023443299348405482 -0.5024508470879117 R -0.010086901902417945 9.863896643218951e-33 0.022315886177793884 -0.47193112340875404 R -0.009611690030057338 1.9752891526190395e-33 0.021108142978135572 -0.4422876876554451 R -0.009133016288377569 1.9752891526190395e-33 0.019841913542047705 -0.4135481366208599 R -0.008652688893396631 -5.207157985932626e-34 0.01853716943421786 -0.3857358309986061 R -0.008172456288500477 -2.092009165413256e-33 0.01721203500158411 -0.35887018973805873 R -0.007694007339320203 4.943245187978106e-32 0.015882825442390388 -0.33296698772980665 R -0.007218971506382985 3.98410225662768e-32 0.014564095843033737 -0.30803865368339045 R -0.006748918993544735 -9.281342647265258e-33 0.013268699241951051 -0.28409456546403644 R -0.006285360870901335 1.0054099562571345e-32 0.012007851939089972 -0.2611413405391832 R -0.005829749171520191 -5.033408734445277e-32 0.010791204433264303 -0.23918311954546376 R -0.005383476961893109 -2.967228418416021e-33 0.009626916534295201 -0.2182218413202301 R -0.004947878386515336 3.97635009002737e-33 0.008521735359177319 -0.19825750804726577 R -0.004524228687443472 -3.8615639129132616e-33 0.007481075079187902 -0.1792884394432921 R -0.00411374420006816 1.7393139021441016e-32 0.006509097436007451 -0.16131151516028142 R -0.0037175823266748795 2.6781642490740776e-34 0.0056087921881079845 -0.14432240479882824 R -0.0033368414896467248 4.361491661919753e-35 0.00478205678293946 -0.1283157851208176 R -0.0029725610664046343 -2.0631705852600443e-32 0.004029774675169233 -0.1132855442165176 R -0.0026257213083543747 -7.227249565150428e-33 0.0033518918261041947 -0.09922497252345197 R -0.002297243246276104 -3.057875973042373e-33 0.0027474910243355296 -0.08612694071346937 R -0.0019879885846666606 2.0300780705111897e-33 0.002214863762799272 -0.07398406456210362 R -0.0016987595876376352 1.2618591781704367e-32 0.0017515794930291011 -0.06278885699217213 R -0.0014302989589630704 1.3220683442614323e-32 0.0013545521539083819 -0.05253386754346646 R -0.0011832897188841205 -1.3609665858538619e-33 0.0010201039401040912 -0.0432118095639032 R -0.0009583550802136594 -1.2838213124605414e-32 0.0007440263351997581 -0.03481567544637829 R -0.0007560583262075292 2.9926311315617922e-33 0.0005216384868919923 -0.027338840251318962 R -0.0005769026925587485 1.2084793488618262e-32 0.00034784304707438115 -0.02077515405908025 R -0.00042133125572308094 6.599873378810254e-33 0.00021717963879318026 -0.015119023390295569 R -0.00028972682961939285 4.7552921664299147e-32 0.00012387614548361973 -0.010365482017378391 R -0.0001824118725240042 2.4217752809700947e-32 6.189804611899412e-05 -0.006510251467824137 R -9.964840567176564e-05 2.8478822538315235e-32 2.4996043417941123e-05 -0.0035497914909131197 R -4.163794423291495e-05 -6.99758518339629e-32 6.752251495610047e-06 -0.001481340724932748 R -8.521433803888265e-06 -1.335534449656945e-31 6.252247051094989e-07 -0.00030294776310889576 ```python bd_r = np.array([bd[m]['a'][0] for m in range(len(bd))]) bd_x = np.array([bd[m]['x'][1] for m in range(len(bd))]) bd2_r = np.array([bd2[m]['a'][0] for m in range(len(bd2))]) bd2_x = np.array([bd2[m]['x'][1] for m in range(len(bd2))]) ``` ```python fig = plt.figure(figsize=(8, 5)) ax = fig.add_subplot(111) ax.set_xlim(-0.1,0.1) ax.set_ylim(0, 0.8) ax.set_xlabel(r"$\lambda$") ax.set_ylabel("$x_1$") ax.plot(bd_r, bd_x, '-k') ax.plot(bd2_r, bd2_x, '-k') # plt.savefig("bd_hopf_sub.pdf", bbox_inches='tight') ``` Ｎ段射撃法の定式化 ```python Npts = 4 def func(x, a): T = x[-1] def f2(t, y): return T * f(y, a) r = ode(f2).set_integrator('dop853', atol=1.0e-14, rtol=1.0e-14) n = (len(x) - 1) // Npts h = 1.0 / Npts x1 = np.zeros(len(x)) for k in range(Npts-1): y0 = np.copy(x[k*n:(k+1)*n]) r.set_initial_value(y0, 0.0) y1 = r.integrate(r.t+h) x1[k*n:(k+1)*n] = y1 - x[(k+1)*n:(k+2)*n] y0 = np.copy(x[-(n+1):-1]) r.set_initial_value(y0, 0.0) y1 = r.integrate(r.t+h) x1[-(n+1):-1] = y1 - x[:n] x1[-1] = x[0] return x1 def dfdx(x, a): def df2(t, y, n): z = np.zeros((n+1)*(n+2)) z[:n] = y[n] * f(y[:n], a) z[n] = 0.0 J = np.zeros((n+1, n+1)) J[:n, :n] = y[n] * fx(y[:n], a) J[:n, n] = f(y[:n], a) for m in range(n+1): z[(n+1)*(m+1):(n+1)*(m+2)] = J @ y[(n+1)*(m+1):(n+1)*(m+2)] return z r = ode(df2).set_integrator('dop853', atol=1.0e-14, rtol=1.0e-14) n = (len(x)-1) // Npts h = 1.0 / Npts A = np.zeros((len(x), len(x))) I = np.identity(n+1) for k in range(Npts-1): y0 = np.zeros((n+1)*(n+2)) y0[:n] = x[k*n:(k+1)*n] y0[n] = x[-1] for m in range(n+1): y0[(n+1)*(m+1):(n+1)*(m+2)] = I[:,m] r.set_initial_value(y0, 0.0).set_f_params(n) y1 = r.integrate(r.t+h) for m in range(n): A[k*n:(k+1)*n,k*n+m] = y1[(n+1)*(m+1):(n+1)*(m+1)+n] A[k*n:(k+1)*n, (k+1)*n:(k+2)*n] = -np.identity(n) A[k*n:(k+1)*n, -1] = y1[-(n+1):-1] y0 = np.zeros((n+1)*(n+2)) y0[:n] = x[-(n+1):-1] y0[n] = x[-1] for m in range(n+1): y0[(n+1)*(m+1):(n+1)*(m+2)] = I[:,m] r.set_initial_value(y0, 0.0).set_f_params(n) y1 = r.integrate(r.t+h) for m in range(n): A[-(n+1):-1,-(n+1)+m] = y1[(n+1)*(m+1):(n+1)*(m+1)+n] A[-(n+1):-1, :n] = -np.identity(n) A[-(n+1):-1, -1] = y1[-(n+1):-1] A[-1,0] = 1.0 return A def dfda(x, a): T = x[-1] def df2(t, y, n): z = np.zeros(2*(n+1)) z[:n] = T * f(y[:n], np.array([y[n]])) z[n] = 0.0 J = np.zeros((n+1, n+1)) J[:n, :n] = fx(y[:n], np.array([y[n]])) J[:n, n] = fa(y[:n], np.array([y[n]])) z[n+1:] = T * J @ y[n+1:] return z n = (len(x) - 1) // Npts h = 1.0 / Npts r = ode(df2).set_integrator('dop853', atol=1e-14, rtol=1e-14) b = np.zeros(len(x)) for k in range(Npts-1): y0 = np.zeros(2*(n+1)) y0[:n] = np.copy(x[k*n:(k+1)*n]) y0[n] = a[0] y0[-1] = 1.0 r.set_initial_value(y0, 0.0).set_f_params(n) y1 = r.integrate(r.t+h) b[k*n:(k+1)*n] = y1[n+1:2*n+1] y0[:n] = np.copy(x[-(n+1):-1]) y0[n] = a[0] y0[-1] = 1.0 r.set_initial_value(y0, 0.0).set_f_params(n) y1 = r.integrate(r.t+h) b[-(n+1):-1] = y1[n+1:2*n+1] return b ``` ```python x = np.array([0.0, 0.5, -0.5, 0.0, 0.0, -0.5, 0.5, 0.0, 2*np.pi]) a = np.array([0.0]) y = np.copy(x) for m in range(10): b = func(y, a) A = dfdx(y, a) y -= solve(A, b) print(y[:2], y[-1], np.linalg.norm(b)) ``` [7.00143703e-31 5.00000000e-01] 6.283185307179599 3.660606886031751e-15 [6.4594719e-34 5.0000000e-01] 6.283185307179599 5.5511151231256336e-17 [6.4594719e-34 5.0000000e-01] 6.283185307179599 5.551115123125776e-17 [6.4594719e-34 5.0000000e-01] 6.283185307179599 5.5511151231257796e-17 [6.4594719e-34 5.0000000e-01] 6.283185307179599 5.5511151231257815e-17 [6.4594719e-34 5.0000000e-01] 6.283185307179599 5.551115123125783e-17 [6.4594719e-34 5.0000000e-01] 6.283185307179599 5.551115123125783e-17 [6.4594719e-34 5.0000000e-01] 6.283185307179599 5.551115123125783e-17 [6.4594719e-34 5.0000000e-01] 6.283185307179599 5.5511151231257815e-17 [6.4594719e-34 5.0000000e-01] 6.283185307179599 5.5511151231257815e-17 ```python x = np.array([0.0, 0.5, -0.5, 0.0, 0.0, -0.5, 0.5, 0.0, 2*np.pi]) a=np.array([0.0]) bd2,bp2,lp2=pf.pathfollow(x, a, func, dfdx, dfda,nmax=70, h=-0.01, epsr=1.0e-10, epsb=1.0e-10, quiet=False) ``` # TY a x R -0.001210268696060905 7.198167504054491e-32 -0.2587215678218521 -2.1918394978718214 R -0.0023612070190184293 -7.21711024583157e-32 -0.24552966875223967 -2.188928139255222 R -0.00345408333781922 -8.814414118241897e-33 -0.23248150764202807 -2.184435318491585 R -0.004490171124609288 -1.8836903516904824e-31 -0.21960270477940474 -2.1783524761134347 R -0.005470747503757936 7.587450033747564e-33 -0.20691807158734546 -2.1706766196547833 R -0.006397091866208182 1.218589692112546e-32 -0.19445146066600277 -2.161410283164076 R -0.007270484549517834 5.966658182570574e-32 -0.18222562760231445 -2.1505614493633103 R -0.008092205583572721 2.527208452493161e-33 -0.17026210563868416 -2.138143436274803 R -0.008863533501607799 3.4767697796386317e-31 -0.1585810940735847 -2.12417475045875 R -0.009585744215846688 -6.254627325329278e-32 -0.14720136104662054 -2.1086789092818727 R -0.010260109956806077 6.568973293615825e-32 -0.13614016114321376 -2.091684234867552 R -0.010887898275042022 -7.37911432883456e-33 -0.12541316804322206 -2.073223622561223 R -0.011470371103924827 2.6897639083149237e-32 -0.11503442223685624 -2.0533342868804954 R -0.012008783881813432 4.5094954688537154e-32 -0.10501629364293395 -2.032057488010041 R -0.012504384731871241 4.4044516986361624e-32 -0.09536945879114277 -2.0094382419466923 R -0.012958413697611647 -1.8013976989168722e-32 -0.08610289207343917 -1.985525017404777 R -0.013372102032167852 -8.057160079642488e-33 -0.07722387043117984 -1.9603694225568327 R -0.013746671539196217 3.591256326304304e-32 -0.06873799072507682 -1.934025884614749 R -0.014083333963255493 -2.2369431992181358e-32 -0.060649198934828244 -1.9065513251547643 R -0.014383290427469855 1.15808779063889e-31 -0.05295983025446071 -1.878004833959784 R -0.014647730916249378 5.589821366067934e-32 -0.04567065908753618 -1.8484473439992686 R -0.014877833800841966 4.67864545963793e-33 -0.038780957902853 -1.8179413099935147 R -0.015074765405485647 -7.872565909864388e-33 -0.03228856388506306 -1.7865503928201891 R -0.015239679611956656 4.771081554658003e-32 -0.02618995230471244 -1.7543391518201017 R -0.015373717500330621 7.089405839613484e-32 -0.02048031553706693 -1.7213727468501026 R -0.01547800702381367 -2.94317736596072e-32 -0.015153646677448116 -1.6877166517173021 R -0.015553662715546762 1.49905132741321e-32 -0.010202826730966983 -1.6534363804136183 R -0.015601785425338808 6.455549030347572e-32 -0.005619714395063983 -1.618597227355915 R -0.015623462084343755 7.581441856016526e-32 -0.0013952375024328264 -1.5832640226273966 L -0.015624999996993403 -2.63228903061851e-32 R -0.015619765495758407 -1.9510485983096633e-32 0.002480514751760856 -1.5475009030127767 R -0.015591754149684547 -1.197455159271e-32 0.006018199612507215 -1.5113710994247993 R -0.015540472060374497 -1.4979111444372854e-32 0.009229129345413008 -1.4749367411349137 R -0.015466948532945649 1.107177705805614e-32 0.012125181464125485 -1.4382586780564164 R -0.015372198412488495 -4.8646439332687734e-33 0.014718710058294211 -1.401396315003434 R -0.015257221408811679 1.0759128892130986e-32 0.01702246168260961 -1.3644074735020226 R -0.015123002394409972 6.708355767788752e-33 0.01904949232825777 -1.3273482597343906 R -0.01497051123049537 -6.25985072474833e-33 0.02081308886988497 -1.2902729544744174 R -0.01480070270515486 -1.2593205181380003e-32 0.022326694106522722 -1.2532339179992278 R -0.014614516483455256 -8.624459643725233e-33 0.023603835867839713 -1.2162815105693687 R -0.014412877068305048 -4.3883776714409886e-33 0.02465806039186443 -1.1794640278742656 R -0.014196693770944185 -6.505417479332634e-34 0.02550287012338774 -1.1428276507734112 R -0.013966860690010966 -5.4069674959442654e-33 0.026151666029330105 -1.106416408609622 R -0.013724256698189849 2.5626020839866466e-33 0.02661769447876687 -1.0702721553284724 R -0.0134697454355274 1.8020379419666742e-34 0.02691399869103761 -1.0344345576065397 R -0.013204175308541026 1.6375931021328905e-32 0.027053374715691886 -0.9989410941701473 R -0.012928379494330415 1.5353178967911281e-33 0.02704833187260692 -0.9638270654741721 R -0.012643175948949334 5.914909028621731e-34 0.026911057549703788 -0.9291256129072064 R -0.012349367419347565 -7.421523867591449e-33 0.026653386228965858 -0.8948677466936453 R -0.012047741458253014 1.8629519679389478e-32 0.026286772588768968 -0.8610823816741386 R -0.011739070441416399 9.262296157643818e-32 0.025822268511741398 -0.827796380162724 R -0.011424111586686124 -1.8188678061306044e-32 0.025270503812238027 -0.7950346011010523 R -0.011103606974430504 2.744298127360088e-32 0.024641670485688556 -0.7628199547563483 R -0.010778283568866 -5.214762502343715e-33 0.023945510273508244 -0.7311734622398115 R -0.010448853239901116 8.115620501449142e-33 0.02319130533141326 -0.7001143191548607 R -0.010116012785135707 -6.26792995076934e-33 0.022387871785872183 -0.669659962719967 R -0.009780443951700272 -9.816435376251078e-33 0.02154355596253014 -0.6398261417474992 R -0.009442813457655765 -6.272002525047159e-33 0.020666233071698133 -0.6106269888980855 R -0.009103773012706201 -8.248277365433435e-33 0.019763308139014297 -0.5820750946686282 R -0.008763959338011008 3.371553482219906e-33 0.018841718974002195 -0.5541815826110104 R -0.008423994184912879 -3.03490866095637e-32 0.01790794097519896 -0.5269561853172688 R -0.008084484352429866 -6.376702031941655e-33 0.01696799357758452 -0.5004073207452406 R -0.007746021703378907 -3.70464754869927e-32 0.016027448156055026 -0.4745421684962132 R -0.0074091831790322905 -5.677314539924261e-32 0.015091437207383552 -0.44936674569244794 R -0.0070745308122285334 -1.1998506857394412e-32 0.014164664642421327 -0.42488598213770623 R -0.006742611738876729 5.822282226640375e-32 0.013251417029970262 -0.4011037944776565 R -0.006413958207823184 -2.162844721481795e-33 0.012355575643730528 -0.37802315910921935 R -0.006089087589058139 2.1181091615919165e-32 0.011480629173833308 -0.3556461836185353 R -0.005768502380266706 9.778225375746458e-33 0.010629686974595308 -0.33397417655598655 R -0.005452690211734032 3.1168339841328094e-32 0.009805492730238896 -0.31300771538381444 R -0.005142123849644269 -2.2825041836206972e-32 0.009010438430213584 -0.29274671245701456

578d019d016e5c34da29309d1a28e9c9ae10eed6

ipynb

Jupyter Notebook

notebooks/continuation/subhopf.ipynb

tmiyaji/sgc164

660f61b72a3898f8e287feb464134f5c48f9383e

2021-02-01T15:29:43.000Z

2021-10-01T13:20:21.000Z

notebooks/continuation/subhopf.ipynb

tmiyaji/sgc164

660f61b72a3898f8e287feb464134f5c48f9383e

notebooks/continuation/subhopf.ipynb

tmiyaji/sgc164

660f61b72a3898f8e287feb464134f5c48f9383e

2020-12-20T07:46:22.000Z

2020-12-20T07:46:22.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__yue_Hant

# One-dimensional Lagrange Interpolation The 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: \begin{equation} \hat f(x)={L^I}(x)f^I \end{equation} In 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. The $I$ Lagrange polynomial is given by the recursive expression: \begin{equation} {L^I}(x)=\prod_{J=1, J \ne I}^{n}{\frac{{\left( {x - {x^J}} \right)}}{{\left( {{x^I} - {x^J}} \right)}}} \end{equation} in the domain $x\in[-1.0,1.0]$. We 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$. ```python from __future__ import division import numpy as np from scipy import interpolate import sympy as sym import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D ``` ```python %matplotlib notebook sym.init_printing() ``` First we use a function to generate the Lagrage polynomial of order $order$ at point $i$ ```python def basis_lagrange(x_data, var, cont): """Find the basis for the Lagrange interpolant""" prod = sym.prod((var - x_data[i])/(x_data[cont] - x_data[i]) for i in range(len(x_data)) if i != cont) return sym.simplify(prod) ``` we now define the function $ f(x)=x^3+4x^2-10 $: ```python fun = lambda x: x**3 + 4*x**2 - 10 ``` ```python x = sym.symbols('x') x_data = np.array([-1, 1, 0]) f_data = fun(x_data) ``` And obtain the Lagrange polynomials using: ```python basis = [] for cont in range(len(x_data)): basis.append(basis_lagrange(x_data, x, cont)) sym.pprint(basis[cont]) ``` x⋅(x - 1) ───────── 2 x⋅(x + 1) ───────── 2 2 - x + 1 which are shown in the following plots/ ```python npts = 101 x_eval = np.linspace(-1, 1, npts) basis_num = sym.lambdify((x), basis, "numpy") # Create a lambda function for the polynomials ``` ```python plt.figure(figsize=(6, 4)) for k in range(3): y_eval = basis_num(x_eval)[k] plt.plot(x_eval, y_eval) ``` <IPython.core.display.Javascript object> ```python y_interp = sym.simplify(sum(f_data[k]*basis[k] for k in range(3))) y_interp ``` Now we plot the complete approximating polynomial, the actual function and the points where the function was known. ```python y_interp = sum(f_data[k]*basis_num(x_eval)[k] for k in range(3)) y_original = fun(x_eval) plt.figure(figsize=(6, 4)) plt.plot(x_eval, y_original) plt.plot(x_eval, y_interp) plt.plot([-1, 1, 0], f_data, 'ko') plt.show() ``` <IPython.core.display.Javascript object> The next cell change the format of the Notebook. ```python from IPython.core.display import HTML def css_styling(): styles = open('../styles/custom_barba.css', 'r').read() return HTML(styles) css_styling() ```

58a534a611940b799937c611a4ccef212bf5295a

ipynb

Jupyter Notebook

notebooks/.ipynb_checkpoints/LAGRANGE1D-checkpoint.ipynb

jomorlier/FEM-Notes

3b81053aee79dc59965c3622bc0d0eb6cfc7e8ae

2020-04-15T01:53:14.000Z

2020-04-15T01:53:14.000Z

notebooks/.ipynb_checkpoints/LAGRANGE1D-checkpoint.ipynb

jomorlier/FEM-Notes

3b81053aee79dc59965c3622bc0d0eb6cfc7e8ae

notebooks/.ipynb_checkpoints/LAGRANGE1D-checkpoint.ipynb

jomorlier/FEM-Notes

3b81053aee79dc59965c3622bc0d0eb6cfc7e8ae

2020-05-25T17:19:53.000Z

2020-05-25T17:19:53.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Density Operator and Matrix ## Imports ```python from IPython.display import display ``` ```python # TODO: there is a bug in density.py that is preventing this from working, uncomment to reproduce # from sympy import init_printing # init_printing(use_latex=True) ``` ```python from sympy import * from sympy.core.trace import Tr from sympy.physics.quantum import * from sympy.physics.quantum.density import * from sympy.physics.quantum.spin import ( Jx, Jy, Jz, Jplus, Jminus, J2, JxBra, JyBra, JzBra, JxKet, JyKet, JzKet, ) ``` ## Basic density operator Create a density matrix using symbolic states: ```python psi = Ket('psi') phi = Ket('phi') ``` ```python d = Density((psi,0.5),(phi,0.5)); d ``` Density((|psi>, 0.5),(|phi>, 0.5)) ```python d.states() ``` (|psi>, |phi>) ```python d.probs() ``` (0.5, 0.5) ```python d.doit() ``` 0.5*|phi><phi| + 0.5*|psi><psi| ```python Dagger(d) ``` Density((|psi>, 0.5),(|phi>, 0.5)) ```python A = Operator('A') ``` ```python d.apply_op(A) ``` Density((A*|psi>, 0.5),(A*|phi>, 0.5)) ## Density operator for spin states Now create a density operator using spin states: ```python up = JzKet(S(1)/2,S(1)/2) down = JzKet(S(1)/2,-S(1)/2) ``` ```python d2 = Density((up,0.5),(down,0.5)); d2 ``` Density((|1/2,1/2>, 0.5),(|1/2,-1/2>, 0.5)) ```python represent(d2) ``` Matrix([ [0.5, 0], [ 0, 0.5]]) ```python d2.apply_op(Jz) ``` Density((Jz*|1/2,1/2>, 0.5),(Jz*|1/2,-1/2>, 0.5)) ```python qapply(_) ``` Density((hbar*|1/2,1/2>/2, 0.5),(-hbar*|1/2,-1/2>/2, 0.5)) ```python qapply((Jy*d2).doit()) ``` 0.5*Jy*|1/2,-1/2><1/2,-1/2| + 0.5*Jy*|1/2,1/2><1/2,1/2| ## Evaluate entropy of the density matrices ```python entropy(d2) ``` log(2)/2 ```python entropy(represent(d2)) ``` log(2)/2 ```python entropy(represent(d2,format="numpy")) ``` (0.69314718055994529-0j) ```python entropy(represent(d2,format="scipy.sparse")) ``` (0.69314718055994529-0j) ## Density operators with tensor products ```python A, B, C, D = symbols('A B C D',commutative=False) t1 = TensorProduct(A,B,C) d = Density([t1, 1.0]) d.doit() t2 = TensorProduct(A,B) t3 = TensorProduct(C,D) d = Density([t2, 0.5], [t3, 0.5]) d.doit() ``` 0.5*(A*Dagger(A))x(B*Dagger(B)) + 0.5*(C*Dagger(C))x(D*Dagger(D)) ```python d = Density([t2+t3, 1.0]) d.doit() ``` 1.0*(A*Dagger(A))x(B*Dagger(B)) + 1.0*(A*Dagger(C))x(B*Dagger(D)) + 1.0*(C*Dagger(A))x(D*Dagger(B)) + 1.0*(C*Dagger(C))x(D*Dagger(D)) ## Trace operators on density operators with spin states ```python d = Density([JzKet(1,1),0.5],[JzKet(1,-1),0.5]); t = Tr(d); t ``` Tr(Density((|1,1>, 0.5),(|1,-1>, 0.5))) ```python t.doit() ``` 1.00000000000000 ## Partial Trace on density operators with mixed state ```python A, B, C, D = symbols('A B C D',commutative=False) t1 = TensorProduct(A,B,C) d = Density([t1, 1.0]) d.doit() t2 = TensorProduct(A,B) t3 = TensorProduct(C,D) d = Density([t2, 0.5], [t3, 0.5]) d ``` Density((AxB, 0.5),(CxD, 0.5)) ```python tr = Tr(d,[1]) tr.doit() ``` 0.5*A*Dagger(A)*Tr(B*Dagger(B)) + 0.5*C*Dagger(C)*Tr(D*Dagger(D)) ## Partial trace on density operators with spin states ```python tp1 = TensorProduct(JzKet(1,1), JzKet(1,-1)) ``` Trace out the `0` index: ```python d = Density([tp1,1]); t = Tr(d,[0]) t ``` Tr((|1,1>x|1,-1>, 1)) ```python t.doit() ``` |1,-1><1,-1| Trace out the `1` index: ```python t = Tr(d,[1]) t ``` Tr((|1,1>x|1,-1>, 1)) ```python t.doit() ``` |1,1><1,1| ## Examples of `qapply()` on density matrices with spin states ```python psi = Ket('psi') phi = Ket('phi') u = UnitaryOperator() d = Density((psi,0.5),(phi,0.5)); d qapply(u*d) ``` O*Density((|psi>, 0.5),(|phi>, 0.5)) ```python up = JzKet(S(1)/2, S(1)/2) down = JzKet(S(1)/2, -S(1)/2) d = Density((up,0.5),(down,0.5)) uMat = Matrix([[0,1],[1,0]]) qapply(uMat*d) ``` Matrix([ [ 0, Density((|1/2,1/2>, 0.5),(|1/2,-1/2>, 0.5))], [Density((|1/2,1/2>, 0.5),(|1/2,-1/2>, 0.5)), 0]]) ## Example of `qapply()` on density matrices with qubits ```python from sympy.physics.quantum.gate import UGate from sympy.physics.quantum.qubit import Qubit uMat = UGate((0,), Matrix([[0,1],[1,0]])) d = Density([Qubit('0'),0.5],[Qubit('1'), 0.5]) d ``` Density((|0>, 0.5),(|1>, 0.5)) ```python #after applying Not gate qapply(uMat*d) ``` U((0,),Matrix([ [0, 1], [1, 0]]))*Density((|0>, 0.5),(|1>, 0.5))

bd0b0a21c066c3979424793b744f88d6214a8f24

ipynb

Jupyter Notebook

notebooks/density.ipynb

gvvynplaine/quantum_notebooks

58783823596465fe2d6c494c2cc3a53ae69a9752

2017-10-17T22:44:27.000Z

2022-03-28T06:26:46.000Z

notebooks/density.ipynb

gvvynplaine/quantum_notebooks

58783823596465fe2d6c494c2cc3a53ae69a9752

2017-10-09T05:16:41.000Z

2018-09-22T03:08:29.000Z

notebooks/density.ipynb

gvvynplaine/quantum_notebooks

58783823596465fe2d6c494c2cc3a53ae69a9752

2017-10-09T04:22:19.000Z

2022-03-28T06:25:21.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__yue_Hant

# 베타 분포 베타 분포(Beta distribution)는 다른 확률 분포와 달리 자연계에 존재하는 데이터의 분포를 묘사하기 보다는 베이지안 추정의 결과를 묘사하기위한 목적으로 주로 사용된다. 베이지안 추정(Bayesian estimation)은 추정하고자 하는 모수의 값을 하나의 숫자로 나타내는 것이 아니라 분포로 묘사한다. 베타 분포의 확률 밀도 함수는 $a$와 $b$라는 두 개의 모수(parameter)를 가지며 수학적으로 다음과 같이 정의된다. $$ \begin{align} \text{Beta}(x;a,b) & = \frac{\Gamma(a+b)}{\Gamma(a)\Gamma(b)}\, x^{a-1}(1-x)^{b-1} \end{align} $$ 이 식에서 $$ \Gamma(a) = \int_0^\infty x^{a-1} e^{-x}\, dx $$ 베타 분포의 확률 밀도 함수는 그림에서 볼 수 있듯이 0부터 1까지만의 값을 가진다. 이러한 함수를 finite support를 가진다고 한다. ```python xx = np.linspace(0, 1, 1000) plt.subplot(221) plt.fill(xx, sp.stats.beta(1.0001, 1.0001).pdf(xx)); plt.ylim(0, 6) plt.title("(A) a=1, b=1") plt.subplot(222) plt.fill(xx, sp.stats.beta(4, 2).pdf(xx)); plt.ylim(0, 6) plt.title("(B) a=4, b=2, mode={0}".format((4-1)/(4+2-2))) plt.subplot(223) plt.fill(xx, sp.stats.beta(8, 4).pdf(xx)); plt.ylim(0, 6) plt.title("(C) a=8, b=4, mode={0}".format((8-1)/(8+4-2))) plt.subplot(224) plt.fill(xx, sp.stats.beta(30, 12).pdf(xx)); plt.ylim(0, 6) plt.title("(D) a=30, b=12, mode={0}".format((30-1)/(30+12-2))) plt.tight_layout() plt.show() ``` 위 그림이 베이지안 추정 결과라면 각각은 모수에 대해 다음과 같이 추정한 것과 같다. * (A): 추정할 수 없다. (정보가 없음) * (B): 모수값이 0.75일 가능성이 가장 크다. (정확도 낮음) * (C): 모수값이 0.70일 가능성이 가장 크다. (정확도 중간) * (D): 모수값이 0.725일 가능성이 가장 크다. (정확도 높음) 베타 분포의 기댓값, 최빈값, 분산은 각각 다음과 같다. * 기댓값 $$E[x] = \dfrac{a}{a+b}$$ * 최빈값 $$\dfrac{a - 1}{a+b - 2}$$ * 분산 $$\text{Var}[x] = \dfrac{ab}{(a+b)^2(a+b+1)}$$

6ed1612186260640ac73e5737fbb551c9c74097d

ipynb

Jupyter Notebook

10. 기초 확률론3 - 확률 분포 모형/08. 베타 분포 (파이썬 버전).ipynb

zzsza/Datascience_School

da27ac760ca8ad1a563a0803a08b332d560cbdc0

2017-04-30T06:17:21.000Z

2022-01-07T07:50:11.000Z

10. 기초 확률론3 - 확률 분포 모형/08. 베타 분포 (파이썬 버전).ipynb

yeajunseok/Datascience_School

da27ac760ca8ad1a563a0803a08b332d560cbdc0

10. 기초 확률론3 - 확률 분포 모형/08. 베타 분포 (파이썬 버전).ipynb

yeajunseok/Datascience_School

da27ac760ca8ad1a563a0803a08b332d560cbdc0

2017-04-09T16:51:49.000Z

2022-01-23T20:30:48.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__kor_Hang

# Likevektskonsentrasjoner i en syre-base likevekt Her skal vi regne på en syre-baselikevekt, vi tar utgangspunkt i eksempel 16.8 (side 562) fra læreboken der vi blir bedt om å finne pH i 0.036 M HNO$_2$: $$\text{HNO}_2 \rightleftharpoons \text{NO}_2^{-} + \text{H}^{+},$$ $$K_{a} = 4.5 \times 10^{-4}.$$ Vi skal løse denne oppgaven ved å bruke Python. For å kunne regne symbolsk skal vi bruke et bibliotek som heter [SymPy](https://www.sympy.org/). ```python import sympy as sym # Importer SymPy ``` ```python # Definer størrelsene vi kjenner START_KONSENTRASJON = 0.036 KA = 4.5e-4 ``` Over har vi listet opp hva vi kjenner. La oss også liste opp alle de ukjente som vi skal bestemme: - $[\text{HNO}_2]$ ved likevekt. - $[\text{NO}_2^{-}]$ ved likevekt. - $[\text{H}^{+}]$ ved likevekt. Vi har altså tre ukjente. La oss definere de som størrelser (spesifikt som [SymPy-symboler](https://docs.sympy.org/latest/tutorial/intro.html#a-more-interesting-example)) slik at vi kan regne med de (dette blir litt som når vi introduserer $x$ osv. for ukjente størrelser i ligninger vi skriver for hånd): ```python # Vi definerer de ukjente størrelsene. For å spare litt skriving bruker vi # - HA for syren HNO2 # - A for den korresponderende basen NO_2^- # - H for H^+ c_HA, c_A, c_H = sym.symbols('c_HA c_A c_H') ``` Vi har nå definert konsentrasjonene. Disse er foreløpig ukjente. For å bestemme de, så trenger vi noen ligninger som relaterer de til hverandre. Mulige slike ligninger er: - syre-basekonstanten - elektronøytralitet - massebalanser ```python # La oss begynne med syre-basekonstanten. # Her sier vi at (c_A * c_H)/c_HA skal være lik ("sym.Eq") KA: ligning1 = sym.Eq((c_A * c_H)/c_HA, KA) ``` Vi kan be SymPy skrive ut hva denne ligningen er, for å sjekke at den ser ut som vi hadde tenkt: ```python ligning1 ``` Den neste ligningen vi kan benytte oss av, er at det må være like mye negativ og positiv ladning. Her er det bare to ladede forbindelser, og de har motsatt fortegn. Det betyr at $[\text{A}]^- = [\text{H}]^+$. La oss skrive det som en ligning: ```python # Elektronøytralitet: ligning2 = sym.Eq(c_A, c_H) ``` ```python # Skriv ut denne ligningen også, for å dobbeltsjekke: ligning2 ``` I kjemiske reaksjoner er massen bevart (med mindre det skjer noen kjernereaksjoner som endrer typen av grunnstoffer). Det er litt omstendelig å jobbe med massebalanser, så vi skriver det her heller som en molbalanse. Tankegangen er som følger: Vi har oppgitt startkonsentrasjonen av HNO$_2$, hvis vi vet volumet, så vet vi også hvor mange mol HNO$_2$ vi har i starten. Men da vet vi også hvor mange mol av grunnstoffene H, N og O vi har i systemet vårt. Disse moltallene endres ikke, men mengden av HNO$_2$ kan endres. Altså: generelt i kjemiske reaksjoner så endres ikke grunnstoffene, men hvordan de er koblet sammen endres. Vi kan derfor her lage tre massebalanser: - En for hydrogen, - En for nitrogen, - En for oksygen. La oss bruke nitrogen: - Antall mol av nitrogen totalt er lik antall mol av HNO$_2$ vi startet med. - Ved likevekt er antall mol nitrogen totalt i systemet lik antall mol av HNO$_2$ pluss antall mol av NO$_2^-$ (siden det er bare i disse to stoffene vi finner nitrogen, og det er ett nitrogen i hver av disse forbindelsene). Med symboler (vi deler på et volumet for å gjøre om til konsentrasjon): $$[\text{HNO}_3]_{\text{start}} = [\text{HNO}_3]_{\text{likevekt}} + [\text{NO}_2^-]_{\text{likevekt}} $$ La oss formulere det som en ligning: ```python ligning3 = sym.Eq(START_KONSENTRASJON, c_HA + c_A) ``` ```python # Skriv ut ligning3 for dobbeltsjekk: ligning3 ``` Vi har nå tre ligninger og vi har tre ukjente. Dette kan vi (eller i dette tilfellet, SymPy) løse: ```python løsninger = sym.solve([ligning1, ligning2, ligning3], [c_HA, c_A, c_H], dict=True) ``` Her får vi to løsninger: ```python løsninger ``` En av løsningene SymPy fant gir negative konsentrasjoner. Dette er en ugyldig løsning og vi beholder bare den som har kun positive løsninger: ```python # Vis gyldige løsninger: gyldige = [] for løsning in løsninger: if all(i > 0 for i in løsning.values()): gyldige.append(løsning) print('Gyldig løsning:') print(f'- [HA] = {løsning.get(c_HA)}') print(f'- [A^-] = {løsning.get(c_A)}') print(f'- [H^+] = {løsning.get(c_H)}') ``` ```python # La oss finne pH: ph = -sym.log(gyldige[0].get(c_H), 10) ``` ```python # La oss skrive ut verdien, for å få numerisk verdi, ber vi SymPy evaluere uttrykket: print(f'pH = {ph.evalf()}') ``` Til sammenligning sier læreboka: $\text{pH} = 2.42$.

ff1c29ec23b2753bd8589738623ceb70c76c0631

ipynb

Jupyter Notebook

jupyter/syrebase/syrebase.ipynb

andersle/kj1000

9d68e9810c5541ebbe2e4559df8d066a85780129

jupyter/syrebase/syrebase.ipynb

andersle/kj1000

9d68e9810c5541ebbe2e4559df8d066a85780129

2021-06-21T15:04:15.000Z

2021-11-10T10:58:07.000Z

jupyter/syrebase/syrebase.ipynb

andersle/kj1000

9d68e9810c5541ebbe2e4559df8d066a85780129

Qwen/Qwen-72B

1. YES 2. YES

__label__nob_Latn

```python from galgebra.ga import Ga from sympy import symbols from galgebra.printer import Format Format() coords = (et,ex,ey,ez) = symbols('t,x,y,z',real=True) base=Ga('e*t|x|y|z',g=[1,-1,-1,-1],coords=symbols('t,x,y,z',real=True),wedge=False) potential=base.mv('phi','vector',f=True) potential ``` \begin{equation*}phi = \phi ^{t} \boldsymbol{e}_{t} + \phi ^{x} \boldsymbol{e}_{x} + \phi ^{y} \boldsymbol{e}_{y} + \phi ^{z} \boldsymbol{e}_{z}\end{equation*} ```python field=base.grad*potential field ``` \begin{equation*}\left ( \partial_{t} \phi ^{t} + \partial_{x} \phi ^{x} + \partial_{y} \phi ^{y} + \partial_{z} \phi ^{z} \right ) + \left ( \partial_{x} \phi ^{t} + \partial_{t} \phi ^{x} \right ) \boldsymbol{e}_{tx} + \left ( \partial_{y} \phi ^{t} + \partial_{t} \phi ^{y} \right ) \boldsymbol{e}_{ty} + \left ( \partial_{z} \phi ^{t} + \partial_{t} \phi ^{z} \right ) \boldsymbol{e}_{tz} + \left ( \partial_{y} \phi ^{x} - \partial_{x} \phi ^{y} \right ) \boldsymbol{e}_{xy} + \left ( \partial_{z} \phi ^{x} - \partial_{x} \phi ^{z} \right ) \boldsymbol{e}_{xz} + \left ( \partial_{z} \phi ^{y} - \partial_{y} \phi ^{z} \right ) \boldsymbol{e}_{yz}\end{equation*} ```python grad_field = base.grad*field grad_field ``` \begin{equation*}\left ( \partial^{2}_{t} \phi ^{t} - \partial^{2}_{x} \phi ^{t} - \partial^{2}_{y} \phi ^{t} - \partial^{2}_{z} \phi ^{t} \right ) \boldsymbol{e}_{t} + \left ( \partial^{2}_{t} \phi ^{x} - \partial^{2}_{x} \phi ^{x} - \partial^{2}_{y} \phi ^{x} - \partial^{2}_{z} \phi ^{x} \right ) \boldsymbol{e}_{x} + \left ( \partial^{2}_{t} \phi ^{y} - \partial^{2}_{x} \phi ^{y} - \partial^{2}_{y} \phi ^{y} - \partial^{2}_{z} \phi ^{y} \right ) \boldsymbol{e}_{y} + \left ( \partial^{2}_{t} \phi ^{z} - \partial^{2}_{x} \phi ^{z} - \partial^{2}_{y} \phi ^{z} - \partial^{2}_{z} \phi ^{z} \right ) \boldsymbol{e}_{z}\end{equation*} ```python part=field.proj([base.mv()[0]^base.mv()[1]]) part ``` \begin{equation*}\left ( \partial_{x} \phi ^{t} + \partial_{t} \phi ^{x} \right ) \boldsymbol{e}_{tx}\end{equation*} ```python dpart = base.grad*part dpart ``` \begin{equation*}\left ( - \partial^{2}_{x} \phi ^{t} - \partial_{t}\partial_{x} \phi ^{x} \right ) \boldsymbol{e}_{t} + \left ( \partial^{2}_{t} \phi ^{x} + \partial_{t}\partial_{x} \phi ^{t} \right ) \boldsymbol{e}_{x} + \left ( - \partial_{x}\partial_{y} \phi ^{t} - \partial_{t}\partial_{y} \phi ^{x} \right ) \boldsymbol{e}_{txy} + \left ( - \partial_{x}\partial_{z} \phi ^{t} - \partial_{t}\partial_{z} \phi ^{x} \right ) \boldsymbol{e}_{txz}\end{equation*}

80b34e5cf6b2d4173d98d854c8435e03f70c3487

ipynb

Jupyter Notebook

examples/ipython/second_derivative.ipynb

pygae/galgebra

3a53b29fb141be1ae47d8df8fc7005c10869cded

2018-09-18T12:30:14.000Z

2022-03-16T08:02:48.000Z

examples/ipython/second_derivative.ipynb

caiomrcs/galgebra

3a53b29fb141be1ae47d8df8fc7005c10869cded

2018-09-19T01:42:30.000Z

2022-01-18T14:02:00.000Z

examples/ipython/second_derivative.ipynb

caiomrcs/galgebra

3a53b29fb141be1ae47d8df8fc7005c10869cded

2019-02-22T08:25:50.000Z

2022-01-15T05:20:22.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Homework 2 **For exercises in the week 20-25.11.19** **Points: 6 + 1b** Please solve the problems at home and bring to class a [declaration form](http://ii.uni.wroc.pl/~jmi/Dydaktyka/misc/kupony-klasyczne.pdf) to indicate which problems you are willing to present on the blackboard. ## Problem 1 [1p] Let $(x^{(i)},y^{(i)})$ be a data sample with $x^{(i)}\in\mathbb{R}^D$, $y^{(i)}\in\mathbb{R}$. Let $\Theta \in\mathbb{R}^D$ a parameter vector. Find the closed form solution $\Theta^*$ to $$ \min_\Theta \left(\frac{1}{2}\sum_i (\Theta^Tx^{(i)} - y^{(i)})^2 + \frac{\lambda}{2}\sum_{d=1}^D \Theta_d^2\right). $$ ## Problem 2 [1p] Let $v\in\mathbb{R}^D$ be a vector. Define the gradient of $f(v)\in\mathbb{R}$ with respect to $v$ to be $\frac{\partial f}{\partial v} = \left[\frac{\partial f(v)}{\partial v_1}, \frac{\partial f(v)}{\partial v_2}, ..., \frac{\partial f(v)}{\partial v_D}\right]$ Find the following functions' gradients with respect to vector $[x, y, z]^T$: 1. $f_1([x, y, z]^T) = x + y$ 2. $f_2([x, y, z]^T) = xy$ 3. $f_3([x, y, z]^T) = x^2y^2$ 4. $f_4([x, y, z]^T) = (x + y)^2$ 5. $f_5([x, y, z]^T) = x^4 + x^2 y z + x y^2 z + z^4$ 6. $f_6([x, y, z]^T) = e^{x + 2y}$ 7. $f_7([x, y, z]^T) = \frac{1}{x y^2}$ 8. $f_8([x, y, z]^T) = ax + by + c$ 9. $f_9([x, y, z]^T) = \tanh(ax + by + c)$ ## Problem 3 [0.5p] Find the following functions' gradients or Jacobians with respect to vector $\mathbf{x}$, where $\mathbf{x}, \mathbf{b} \in \mathbb{R}^{n}$, $\mathbf{W} \in \mathbb{R}^{n \times n}$: 1. $\mathbf{W} \mathbf{x} + \mathbf{b}$ 2. $\mathbf{x}^T \mathbf{W} \mathbf{x}$, ## Problem 4 [1p] Find the derivative of $-\log(S(\mathbf{x})_j)$, where $S$ is the softmax function (https://en.wikipedia.org/wiki/Softmax_function) and we are interested in the derivative over the $j$-th output of the Softmax. ## Problem 5 [0.5p] Consider a dataset with 400 examples of class C1 and 400 of class C2. Let tree A have 2 leaves with class distributions: | Tree A | C1 | C2 | |----------|-------|-----| | Leaf 1 | 100 | 300 | | Leaf 2 | 300 | 100 | and let tree B have 2 leaves with class distribution: | Tree B | C1 | C2 | |----------|-------|-----| | Leaf 1 | 200 | 400 | | Leaf 2 | 200 | 0 | What is the misclassification rate for both trees? Which tree is more pure according to Gini or Infogain? ## Problem 6 [1p] Consider regresion problem, with $M$ predictors $h_m(x)$ trained to aproximate a target $y$. Define the error to be $\epsilon_m(x) = h_m(x) - y$. Suppose you train $M$ independent classifiers with average least squares error $$ E_{AV} = \frac{1}{M}\sum_{m=1}^M \mathbb{E}_{x}[\epsilon_m(x)^2]. $$ Further assume that the errors have zero mean and are uncorrelated: $$ \mathbb{E}_{x}[\epsilon_m(x)] = 0\qquad\text{ and }\qquad\mathbb{E}_{x}[\epsilon_m(x)\epsilon_l(x)] = 0\text{ for } m \neq l $$ Let the mean predictor be $$ h_M(x) = \frac{1}{M}h_m(x). $$ What is the average error of $h_M(x)$? ## Problem 7 [1p] Suppose you work on a binary classification problem and train 3 weak classifiers. You combine their prediction by voting. Can the training error rate of the voting ensemble smaller that the error rate of the individual weak predictors? Can it be larger? Show an example or prove infeasibility. ## Problem 8 [1 bonus point] While on a walk, you notice that a locomotive has the serial number 50. Assuming that all locomotives used by PKP (the Polish railroad operator) are numbered using consecutive natural numbers, what is your estimate of $N$ the total number of locomotives operated by PKP? Tell why the Maximum Likelihood principle may not yield satisfactory results. Use the Bayesian approach to find the posterior distribution over the number of locomotives. Then compute the expected count of locomotives. For the prior use the power law: \begin{equation} p(N) = \frac{1}{N^\alpha}\frac{1}{\zeta(\alpha,1)}, \end{equation} where the $\zeta(s,q)=\sum_{n=0}^{\infty}\frac{1}{(q+n)^s}$ is the Hurwitz Zeta function (https://en.wikipedia.org/wiki/Hurwitz_zeta_function) available in Python as `scipy.special.zeta`. The use of the power law is motivated by the observation that the frequency of occurrence of a company is inversely proportional to its size (see also: R.L. Axtell, Zipf distribution of US firm sizes https://www.sciencemag.org/content/293/5536/1818). How would your estimate change after seeing 5 locomotives, with the biggest serial number among them being 50? **Note**: During the Second World War, a similar problem was encountered while trying to estimate the total German tank production from the serial numbers of captured machines. The statistical estimates were the most precise!

1c50bf310106f232668dd6294f9c9ba1199121f1

ipynb

Jupyter Notebook

ML/Homework2/Homework2.ipynb

TheFebrin/DataScience

3e58b89315960e7d4896e44075a8105fcb78f0c0

ML/Homework2/Homework2.ipynb

TheFebrin/DataScience

3e58b89315960e7d4896e44075a8105fcb78f0c0

ML/Homework2/Homework2.ipynb

TheFebrin/DataScience

3e58b89315960e7d4896e44075a8105fcb78f0c0

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Maximum likelihood Estimation (MLE) based on http://python-for-signal-processing.blogspot.com/2012/10/maximum-likelihood-estimation-maximum.html ## Simulate coin flipping - [Bernoulli distribution](https://en.wikipedia.org/wiki/Bernoulli_distribution) is the probability distribution of a random variable which takes the value 1 with probability $p$ and the value 0 with probability $q = 1 - p$ - [scipy.stats.bernoulli](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.bernoulli.html) ```python import numpy as np from scipy.stats import bernoulli np.random.seed(123456789) p_true = 1/2 # this is the value we will try to estimate from the observed data fp = bernoulli(p_true) def sample(n=10): """ simulate coin flipping """ return fp.rvs(n) # flip it n times xs = sample(100) # generate some samples ``` ## Find maximum of Bernoulli distribution Single experiment $$\phi(x) = p ^ {x} * (1 - p) ^ { 1 - x }$$ Series of experiments $$\mathcal{L}(p|x) = \prod_{i=1}^{n} p^{x_{i}}*(p-1)^{1-x_{i}}$$ ### Hints - [sympy.diff()](http://docs.sympy.org/dev/modules/core.html#sympy.core.function.diff) - [sympy.expand()](http://docs.sympy.org/dev/modules/core.html#sympy.core.function.expand) - [sympy.expand_log()](http://docs.sympy.org/dev/modules/core.html#sympy.core.function.expand_log) - [sympy.solve()](http://docs.sympy.org/dev/modules/core.html#sympy.core.function.solve) - [sympy.symbols()](http://docs.sympy.org/dev/modules/core.html#symbols) - [sympy gotchas](http://docs.sympy.org/dev/tutorial/gotchas.html) ```python import sympy from sympy.abc import x p = sympy.symbols('p', positive=True) phi = p ** x * (1 - p) ** (1 - x) L = np.prod([phi.subs(x, i) for i in xs]) # objective function to maximize log_L = sympy.expand_log(sympy.log(L)) sol = sympy.solve(sympy.diff(log_L, p), p)[0] ``` ```python import matplotlib.pyplot as plt x_space = np.linspace(1/100, 1, 100, endpoint=False) plt.plot(x_space, list(map(sympy.lambdify(p, log_L, 'numpy'), x_space)), sol, log_L.subs(p, sol), 'o', p_true, log_L.subs(p, p_true), 's', ) plt.xlabel('$p$', fontsize=18) plt.ylabel('Likelihood', fontsize=18) plt.title('Estimate not equal to true value', fontsize=18) plt.grid(True) plt.show() ``` ## Empirically examine the behavior of the maximum likelihood estimator - [evalf()](http://docs.sympy.org/dev/modules/core.html#module-sympy.core.evalf) ```python def estimator_gen(niter=10, ns=100): """ generate data to estimate distribution of maximum likelihood estimator' """ x = sympy.symbols('x', real=True) phi = p**x*(1-p)**(1-x) for i in range(niter): xs = sample(ns) # generate some samples from the experiment L = np.prod([phi.subs(x,i) for i in xs]) # objective function to maximize log_L = sympy.expand_log(sympy.log(L)) sol = sympy.solve(sympy.diff(log_L, p), p)[0] yield float(sol.evalf()) entries = list(estimator_gen(100)) # this may take awhile, depending on how much data you want to generate plt.hist(entries) # histogram of maximum likelihood estimator plt.title('$\mu={:3.3f},\sigma={:3.3f}$'.format(np.mean(entries), np.std(entries)), fontsize=18) plt.show() ``` ## Dynamic of MLE by length sample sequence ```python def estimator_dynamics(ns_space, num_tries = 20): for ns in ns_space: estimations = list(estimator_gen(num_tries, ns)) yield np.mean(estimations), np.std(estimations) ns_space = list(range(10, 100, 5)) entries = list(estimator_dynamics(ns_space)) entries_mean = list(map(lambda e: e[0], entries)) entries_std = list(map(lambda e: e[1], entries)) plt.errorbar(ns_space, entries_mean, entries_std, fmt='-o') plt.show() ``` ```python ```

4940682496d40fe493ef3f22d66b75e23e264263

ipynb

Jupyter Notebook

mle.ipynb

hyzhak/mle

257d8046a950b7381052cc56d9931cf98aeb0a5c

2017-10-22T09:29:36.000Z

2017-10-22T09:29:36.000Z

mle.ipynb

hyzhak/mle

257d8046a950b7381052cc56d9931cf98aeb0a5c

mle.ipynb

hyzhak/mle

257d8046a950b7381052cc56d9931cf98aeb0a5c

2019-01-23T04:46:01.000Z

2020-04-21T18:38:49.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# From transfer function to difference equation In approximately the middle of Peter Corke's lecture [Introduction to digital control](https://youtu.be/XuR3QKVtx-g?t=34m56s), he explaines how to go from a transfer function description of a controller (or compensator) to a difference equation that can be implemented on a microcontroller. The idea is to recognize that the term $$ sX(s) $$ in a transfer function is the laplace transform of the derivative of $x(t)$, \begin{equation} sX(s) + x(0) \quad \overset{\mathcal{L}}{\longleftrightarrow} \quad \frac{d}{dt} x(t), \end{equation} where the inital value $x(0)$ is often taken to be zero. We then make use of a discrete approximation of the derivative $$ \frac{d}{dt}x(t) \approx \frac{x(t-h) - x(t)}{h}, $$ where $h$ is the time between the samples in the sampled version of signal $x(t)$. The steps to convert the system on transfer function form $$ Y(s) = F(s)U(s) = \frac{s+b}{s+a}U(s) $$ are to write $$ (s+a)Y(s) = (s+b)U(s) $$ $$ sY(s) + aY(s) = sU(s) + bU(s), $$ take the inverse Laplace transform $$ \frac{d}{dt} y + ay = \frac{d}{dt} u + bu$$ and use the discrete approximation of the derivative $$ \frac{y_k - y_{k-1}}{h} + ay_k = \frac{u_k - u_{k-1}}{h} + bu_k $$ which can be written $$ (1+ah) y_k = y_{k-1} + u_k - u_{k-1} + bh u_k,$$ or $$ y_k = \frac{1}{1+ah} y_{k-1} + \frac{1+bh}{1+ah}u_k - \frac{1}{1+ah}u_{k-1}. $$ ## Example With the system $$ F(s) = \frac{s+1}{s+2} $$ and the sampling time $$ h=0.1 $$ we get the difference equation $$ y_k = \frac{1}{1.2}y_{k-1} + \frac{1.1}{1.2}u_k - \frac{1}{1.2} u_{k-1}. $$ Let's implement the system and see how the discrete approximation compares to the continuous-time system for the case of a step-response. ```python import numpy as np import scipy.signal as signal import matplotlib.pyplot as plt %matplotlib inline # Define the continuous-time linear time invariant system F a = 2 b = 1 num = [1, b] den = [1, a] F = signal.lti(num, den) # Plot a step response (t, y) = signal.step(F) plt.figure(figsize=(14,6)) plt.plot(t, y, linewidth=2) # Solve the difference equation y_k = c y_{k-1} + d_0 u_k + d_1 u_{k-1} h = 0.1 # The sampling time c = 1.0/(1 + a*h) d0 = (1 + b*h) / (1 + a*h) d1 = -c td = np.arange(35)* h #The sampling time instants ud = np.ones(35) # The input signal is a step, limited in time to 3.5 seconds yd = np.zeros(35) # A vector to hold the discrete output signal yd[0] = c*0 + d0*ud[0] - d1*0 # The first sample of the output signal for k in range(1,35): # And then the rest yd[k] = c*yd[k-1] + d0*ud[k] + d1*ud[k-1] plt.plot(td, yd, 'o', markersize=8) plt.xlim([0, 3.5]) plt.ylim([0, 1]) plt.legend(('Continuous-time system', 'Discrete approximation')) ``` ## Exercise 1. Why is the error in the discrete approximation larger in the beginning than at the end of the step-response? 2. Make a discrete approximation of the transfer function $$ F(s) = \frac{3}{s+3} $$ using the sampling time $$ h=0.2 $$ Then simulate and plot a step-response for the continuous- and discrete system, following the example above. *Hint*: Copy the python code for the example above into the code cell below and modify for the exercise. ```python ## Your python code goes here ``` # Recursively computing values of a polynomial using difference equations In the lecture by Peter Corke, he talks about the historical importance of difference equations for computing values of a polynomial. Let's look at this in some more detail. ## A first order polynomial Consider the polynomial $$ p(x) = 4x + 2. $$ The first difference is $$ \Delta p(x) = p(x) - p(x-h) = 4x + 2 - \big( 4(x-h) + 2 \big) = 4h, $$ and the second order difference is zero (as are all higher order differences): $$ \Delta^2 p(x) = \Delta p(x) - \Delta p(x-h) = 4h - 4h = 0. $$ Using the firs order difference, we can also write the second order difference $ \Delta p(x) - \Delta p(x-h) = \Delta^2 p(x) $ as $$ p(x) - p(x-h) - \Delta p(x-h) = \Delta^2p(x) $$ or $$ p(x) = p(x-h) + \Delta p(x-h) + \Delta^2 p(x)$$ which for the first order polynomial above becomes $$ p(x) = p(x-h) + \Delta p(x-h) = p(x-h) + 4h. $$ ```python def p1(x): return 4*x + 2 # Our first-order polynomial # Compute values for x=[0,0.2, 0.4, ... 2] recursively using the difference equation h = 0.2 x = h*np.arange(11) # Gives the array [0,0.2, 0.4, ... 2] pd = np.zeros(11) d1 = 4*h # Need to compute the first value as the initial value for the difference equation, pd[0] = p1(x[0]) for k in range(1,10): # Solve difference equation pd[k] = pd[k-1] + d1 plt.figure(figsize=(14,6)) plt.plot(x, p1(x), linewidth=2) plt.plot(x, pd, 'ro') ``` ## Second order polynomial For a second order polynomial $$ p(x) = a_0x^2 + a_1x + a_2 $$ we have $$ p''(x) = 2a_0, $$ and the differences $$ \Delta p(x) = p(x) - p(x-h) = a_0x^2 + a_1x + a_2 - \big( a_0(x-h)^2 + a_1(x-h) + a_2 \big) = h(2a_0x + a_1) -a_0h^2, $$ $$ \Delta^2 p(x) = \Delta p(x) - \Delta p(x-h) = h(2a_0x+a_1) - a_0h^2 - \big( h(2a_0(x-h) + a_1) - a_0 h^2 \big) = h^22a_0 $$ Recall the difference equation using the second order difference $$ p(x) = p(x-h) + \Delta p(x-h) + \Delta^2 p(x)$$ We now get $$ p(x) = p(x-h) + \Delta p(x-h) + \Delta^2 p(x) = p(x-h) + \Delta p(x-h) + h^2 2 a_0,$$ or, using the definition of the first-order difference $\Delta p(x-h)$ $$ p(x) = 2p(x-h) - p(x-2h) + h^2 2 a_0,$$ Consider the second order polynomial $$ p(x) = 2x^2 - 3x + 2, $$ and compute values using the difference equation. ```python a0 = 2 a1 = -3 a2 = 2 def p2(x): return a0*x**2 + a1*x + a2 # Our second-order polynomial # Compute values for x=[0,0.2, 0.4, ... 8] recursively using the difference equation h = 0.2 x = h*np.arange(41) # Gives the array [0,0.2, 0.4, ... 2] d1 = np.zeros(41) # The first differences pd = np.zeros(41) d2 = h**2*2*a0 # The constant, second difference # Need to compute the first two values to get the initial values for the difference equation, pd[0] = p2(x[0]) pd[1] = p2(x[1]) for k in range(2,41): # Solve difference equation pd[k] = 2*pd[k-1] - pd[k-2] + d2 plt.figure(figsize=(14,6)) plt.plot(x, p2(x), linewidth=2) # Evaluating the polynomial plt.plot(x, pd, 'ro') # The solution using the difference equation ``` ## Exercise What order would the difference equation be for computing valuse of a third-order polynomial? What is the difference equation? ```python ```

b951561490a92e552738afa4fd29e0043a64cb6c

ipynb

Jupyter Notebook

discrete-time-systems/notebooks/Simple-approximation.ipynb

kjartan-at-tec/mr2007-computerized-control

16e35f5007f53870eaf344eea1165507505ab4aa

2020-11-07T05:20:37.000Z

2020-12-22T09:46:13.000Z

discrete-time-systems/notebooks/Simple-approximation.ipynb

alfkjartan/control-computarizado

5b9a3ae67602d131adf0b306f3ffce7a4914bf8e

2020-06-12T20:44:41.000Z

2020-06-12T20:49:00.000Z

discrete-time-systems/notebooks/Simple-approximation.ipynb

kjartan-at-tec/mr2007-computerized-control

16e35f5007f53870eaf344eea1165507505ab4aa

2021-03-14T03:55:27.000Z

2021-03-14T03:55:27.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

```julia using CSV using DataFrames using PyPlot using ScikitLearn # machine learning package using StatsBase using Random using LaTeXStrings # for L"$x$" to work instead of needing to do "\$x\$" using Printf using PyCall sns = pyimport("seaborn") # (optional)change settings for all plots at once, e.g. font size rcParams = PyPlot.PyDict(PyPlot.matplotlib."rcParams") rcParams["font.size"] = 16 # (optional) change the style. see styles here: https://matplotlib.org/3.1.1/gallery/style_sheets/style_sheets_reference.html PyPlot.matplotlib.style.use("seaborn-white") ``` ## classifying breast tumors as malignant or benign source: [UCI Machine Learning Repository](https://archive.ics.uci.edu/ml/datasets/Breast+Cancer+Wisconsin+(Diagnostic)) > 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. The 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`. ```julia df = CSV.read("breast_cancer_data.csv") df[!, :class] = map(row -> row == "B" ? 0 : 1, df[:, :outcome]) first(df, 5) ``` <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 × 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> ## visualize the two classes distributed in feature space Where SVM just computes a dividing plane, logistic regression calculates a probability that each point is in a partaicular class ```julia markers = Dict("M" => "x", "B" => "o") fig, ax = subplots(figsize=(8, 8)) ax.set_xlabel("mean radius") ax.set_ylabel("mean smoothness") ax.set_facecolor("#efefef") for df_c in groupby(df, :outcome) outcome = df_c[1, :outcome] ax.scatter(df_c[:, :mean_radius], df_c[:, :mean_smoothness], label="$outcome", marker=markers[outcome], alpha=0.5) end legend() axis("equal") sns.despine() ``` ## get data ready for classifiation in scikitlearn scikitlearn takes as input: * a feature matrix `X`, which must be `n_samples` by `n_features` * a target vector `y`, which must be `n_samples` long (of course) ```julia n_tumors = nrow(df) X = zeros(n_tumors, 2) y = zeros(n_tumors) for (i, tumor) in enumerate(eachrow(df)) X[i, 1] = tumor[:mean_radius] X[i, 2] = tumor[:mean_smoothness] y[i] = tumor[:class] end X # look at y too! ``` 300×2 Array{Float64,2}: 13.85 1.495 9.668 2.275 9.295 2.388 19.69 4.585 9.755 1.243 16.11 4.533 14.78 2.45 15.78 3.598 15.71 1.972 14.68 3.195 13.71 3.856 21.09 4.414 11.31 1.831 ⋮ 11.08 1.719 18.94 5.486 15.32 4.061 14.25 5.373 20.6 5.772 8.671 1.435 11.64 2.155 12.06 1.171 13.88 1.709 14.9 3.466 19.59 2.916 14.81 1.677 ## logistic regression let $\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: \begin{equation} \log \frac{Pr(T=1 | \mathbf{x})}{1-Pr(T=1 | \mathbf{x})} = \beta_0 + \boldsymbol \beta^\intercal \mathbf{x} \end{equation} where $\beta_0$ is the intercept and $\boldsymbol \beta \in \mathbb{R}$ are the weights for the features. we will use scikitlearn to learn the $\beta_0$ and $\boldsymbol \beta$ that maximize the likelihood. ```julia @sk_import linear_model : LogisticRegression ``` PyObject <class 'sklearn.linear_model.logistic.LogisticRegression'> $$\vec{\nabla}_{\vec{B}}\ell = \vec{0}$$ ```julia # default LR in sklearn has an L1 regularization, so we have to set penalty to none to fit this model # solver minimizes grad_b l = 0 lr = LogisticRegression(penalty="none", solver="newton-cg") lr.fit(X, y) println("β = ", lr.coef_) println("β₀ = ", lr.intercept_) ``` β = [1.168660778217552 0.9420681231447384] β₀ = [-19.387890643955803] prediction of the probability that a new tumor is 0 (benign) or 1 (malignant) ```julia # x = [20.0 5.0] x = [15.0 2.5] lr.predict(x) # should be malignant for x 0 lr.predict_proba(x) # [Pr(y=0|x) PR(y-1|x)] ``` 1×2 Array{Float64,2}: 0.378201 0.621799 ## visualize the learned model $Pr(T=1|\mathbf{x})$ ```julia radius = 5:0.25:30 smoothness = 0.0:0.25:20.0 lr_prediction = zeros(length(smoothness), length(radius)) for i = 1:length(radius) for j = 1:length(smoothness) # consider this feature vector x = [radius[i] smoothness[j]] # use logistic regression to predict P(y=1|x) lr_prediction[j, i] = lr.predict_proba(x)[2] # second elem bc want y=1 end end ``` ```julia fig, ax = subplots(figsize=(8, 8)) ax.set_xlabel("mean radius") ax.set_ylabel("mean smoothness") asdf = ax.pcolor(radius, smoothness, lr_prediction, cmap="viridis", vmin=0.0, vmax=1.0) colorbar(asdf, label="Pr(y=1|x)") sns.despine() ``` ## making decisions: the ROC curve this depends on the cost of a false positive versus false negative. (here, "positive" is defined as testing positive for "malignant") > "I equally value minimizing (1) false positives and (2) false negatives." $\implies$ choose $Pr(T=1|\mathbf{x})=0.5$ as the decision boundary. > "I'd rather predict that a benign tumor is malignant (false positive) than predict that a malignant tumor is benign (false negative)." $\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... the 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. ```julia @sk_import metrics : roc_curve @sk_import metrics : auc ``` WARNING: redefining constant roc_curve PyObject <function auc at 0x7fe80b1fb7b8> ```julia ``` ```julia ``` ```julia ``` tradeoff: * threshold too small: classify all of the tumors as malignant, false positive rate very high * threshold too large: classify all of the tumors as benign, false negative rate very high somewhere in the middle (but still depending on the cost of a false positive versus false negative) is where we should operate. the `auc`, area under the curve, has a probabilistic interpretation: > 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) **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.

e7737278b9c9cc4d8c6a6510dd6d77d372dbb9d0

ipynb

Jupyter Notebook

In-Class Notes/Logistic Regression/.ipynb_checkpoints/logistic regression_sparse-checkpoint.ipynb

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

a2afe72b51a3b9e844de94d59961bedc3534a405

In-Class Notes/Logistic Regression/.ipynb_checkpoints/logistic regression_sparse-checkpoint.ipynb

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

a2afe72b51a3b9e844de94d59961bedc3534a405

In-Class Notes/Logistic Regression/.ipynb_checkpoints/logistic regression_sparse-checkpoint.ipynb

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

a2afe72b51a3b9e844de94d59961bedc3534a405

2019-10-02T16:11:36.000Z

2019-10-15T20:10:40.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

```python from sympy import symbols, cos, sin, pi, simplify, pprint, tan, expand_trig, sqrt, trigsimp, atan2 from sympy.matrices import Matrix ``` ```python # rotation matrices in x, y, z axes def rotx(q): sq, cq = sin(q), cos(q) r = Matrix([ [1., 0., 0.], [0., cq,-sq], [0., sq, cq] ]) return r def roty(q): sq, cq = sin(q), cos(q) r = Matrix([ [ cq, 0., sq], [ 0., 1., 0.], [-sq, 0., cq] ]) return r def rotz(q): sq, cq = sin(q), cos(q) r = Matrix([ [cq,-sq, 0.], [sq, cq, 0.], [0., 0., 1.] ]) return r ``` ```python def pose(theta, alpha, a, d): # returns the pose T of one joint frame i with respect to the previous joint frame (i - 1) # given the parameters: # theta: theta[i] # alpha: alpha[i-1] # a: a[i-1] # d: d[i] r11, r12 = cos(theta), -sin(theta) r23, r33 = -sin(alpha), cos(alpha) r21 = sin(theta) * cos(alpha) r22 = cos(theta) * cos(alpha) r31 = sin(theta) * sin(alpha) r32 = cos(theta) * sin(alpha) y = -d * sin(alpha) z = d * cos(alpha) T = Matrix([ [r11, r12, 0.0, a], [r21, r22, r23, y], [r31, r32, r33, z], [0.0, 0.0, 0.0, 1] ]) T = simplify(T) return T ``` ```python # get the pose (homogenous transforms) of each joint wrt to previous joint q1, q2, q3, q4, q5, q6= symbols('q1:7') d90 = pi / 2 T01 = pose(q1, 0, 0, 0.75) T12 = pose(q2 - d90, -d90, 0.35, 0) T23 = pose(q3, 0, 1.25, 0) T34 = pose(q4, -d90, -0.054, 1.5) T45 = pose(q5, d90, 0, 0) T56 = pose(q6, -d90, 0, 0) T6g = pose(0, 0, 0, 0.303) T0g_a = simplify(T01 * T12 * T23 * T34 * T45 * T56 * T6g) ``` ```python # Total transform wrt gripper given # yaw (alpha), pitch (beta), roll (beta) # position px, py, pz px, py, pz = symbols('px py pz', real = True) alpha, beta, gamma = symbols('alpha beta gamma', real = True) R = rotz(alpha) * roty(beta) * rotx(gamma) * (rotz(pi) * roty(-pi/2)).T T0g_b = Matrix([ [R[0, 0], R[0, 1], R[0, 2], px], [R[1, 0], R[1, 1], R[1, 2], py], [R[2, 0], R[2, 1], R[2, 2], pz], [0, 0, 0, 1] ]) T0g_b = simplify(trigsimp(T0g_b)) print(T0g_b) ``` Matrix([ [1.0*sin(alpha)*sin(gamma) + sin(beta)*cos(alpha)*cos(gamma), 1.0*sin(alpha)*cos(gamma) - 1.0*sin(beta)*sin(gamma)*cos(alpha), 1.0*cos(alpha)*cos(beta), px], [sin(alpha)*sin(beta)*cos(gamma) - 1.0*sin(gamma)*cos(alpha), -1.0*sin(alpha)*sin(beta)*sin(gamma) - 1.0*cos(alpha)*cos(gamma), 1.0*sin(alpha)*cos(beta), py], [ 1.0*cos(beta)*cos(gamma), -1.0*sin(gamma)*cos(beta), -1.0*sin(beta), pz], [ 0, 0, 0, 1]]) ```python ''' px, py, pz = 0.49792, 1.3673, 2.4988 roll, pitch, yaw = 0.366, -0.078, 2.561 q1: 1.01249809363771 q2: -0.275800363737724 q3: -0.115686651053751 q4: 1.63446527240323 q5: 1.52050002599430 q6: -0.815781306199679 ''' Tb = T0g_b.evalf(subs = { gamma: 0.366, #roll beta: -0.078, #pitch alpha: 2.561, #yaw px: 0.49792, py: 1.3673, pz: 2.4988 }) print() pprint(Tb) print() print(T0g_b) ``` ⎡0.257143295038827 0.48887208255965 -0.833595473062543 0.49792⎤ ⎢ ⎥ ⎢0.259329420712765 0.796053601157403 0.54685182237706 1.3673 ⎥ ⎢ ⎥ ⎢0.93092726749696 -0.356795110642117 0.0779209320563015 2.4988 ⎥ ⎢ ⎥ ⎣ 0 0 0 1.0 ⎦ Matrix([ [1.0*sin(alpha)*sin(gamma) + sin(beta)*cos(alpha)*cos(gamma), 1.0*sin(alpha)*cos(gamma) - 1.0*sin(beta)*sin(gamma)*cos(alpha), 1.0*cos(alpha)*cos(beta), px], [sin(alpha)*sin(beta)*cos(gamma) - 1.0*sin(gamma)*cos(alpha), -1.0*sin(alpha)*sin(beta)*sin(gamma) - 1.0*cos(alpha)*cos(gamma), 1.0*sin(alpha)*cos(beta), py], [ 1.0*cos(beta)*cos(gamma), -1.0*sin(gamma)*cos(beta), -1.0*sin(beta), pz], [ 0, 0, 0, 1]]) ```python Ta = T0g_a.evalf(subs = { q1: 1.01249809363771, q2: -0.275800363737724, q3: -0.115686651053751, q4: 1.63446527240323, q5: 1.52050002599430, q6: -0.815781306199679 }) print() pprint(Ta) print() print(T0g_a) ``` ⎡0.257143295038831 0.488872082559654 -0.83359547306254 0.497920000000004⎤ ⎢ ⎥ ⎢0.259329420712762 0.796053601157401 0.546851822377065 1.36729999999999 ⎥ ⎢ ⎥ ⎢0.93092726749696 -0.356795110642117 0.0779209320563043 2.49880000000001 ⎥ ⎢ ⎥ ⎣ 0 0 0 1.0 ⎦ Matrix([ [((sin(q1)*sin(q4) + sin(q2 + q3)*cos(q1)*cos(q4))*cos(q5) + sin(q5)*cos(q1)*cos(q2 + q3))*cos(q6) - (-sin(q1)*cos(q4) + sin(q4)*sin(q2 + q3)*cos(q1))*sin(q6), -((sin(q1)*sin(q4) + sin(q2 + q3)*cos(q1)*cos(q4))*cos(q5) + sin(q5)*cos(q1)*cos(q2 + q3))*sin(q6) + (sin(q1)*cos(q4) - sin(q4)*sin(q2 + q3)*cos(q1))*cos(q6), -(sin(q1)*sin(q4) + sin(q2 + q3)*cos(q1)*cos(q4))*sin(q5) + cos(q1)*cos(q5)*cos(q2 + q3), -0.303*sin(q1)*sin(q4)*sin(q5) + 1.25*sin(q2)*cos(q1) - 0.303*sin(q5)*sin(q2 + q3)*cos(q1)*cos(q4) - 0.054*sin(q2 + q3)*cos(q1) + 0.303*cos(q1)*cos(q5)*cos(q2 + q3) + 1.5*cos(q1)*cos(q2 + q3) + 0.35*cos(q1)], [ ((sin(q1)*sin(q2 + q3)*cos(q4) - sin(q4)*cos(q1))*cos(q5) + sin(q1)*sin(q5)*cos(q2 + q3))*cos(q6) - (sin(q1)*sin(q4)*sin(q2 + q3) + cos(q1)*cos(q4))*sin(q6), -((sin(q1)*sin(q2 + q3)*cos(q4) - sin(q4)*cos(q1))*cos(q5) + sin(q1)*sin(q5)*cos(q2 + q3))*sin(q6) - (sin(q1)*sin(q4)*sin(q2 + q3) + cos(q1)*cos(q4))*cos(q6), -(sin(q1)*sin(q2 + q3)*cos(q4) - sin(q4)*cos(q1))*sin(q5) + sin(q1)*cos(q5)*cos(q2 + q3), 1.25*sin(q1)*sin(q2) - 0.303*sin(q1)*sin(q5)*sin(q2 + q3)*cos(q4) - 0.054*sin(q1)*sin(q2 + q3) + 0.303*sin(q1)*cos(q5)*cos(q2 + q3) + 1.5*sin(q1)*cos(q2 + q3) + 0.35*sin(q1) + 0.303*sin(q4)*sin(q5)*cos(q1)], [ -(sin(q5)*sin(q2 + q3) - cos(q4)*cos(q5)*cos(q2 + q3))*cos(q6) - sin(q4)*sin(q6)*cos(q2 + q3), (sin(q5)*sin(q2 + q3) - cos(q4)*cos(q5)*cos(q2 + q3))*sin(q6) - sin(q4)*cos(q6)*cos(q2 + q3), -sin(q5)*cos(q4)*cos(q2 + q3) - sin(q2 + q3)*cos(q5), -0.303*sin(q5)*cos(q4)*cos(q2 + q3) - 0.303*sin(q2 + q3)*cos(q5) - 1.5*sin(q2 + q3) + 1.25*cos(q2) - 0.054*cos(q2 + q3) + 0.75], [ 0, 0, 0, 1]])

7f2212b18becef5505df731d3b029b917e679d6e

ipynb

Jupyter Notebook

notebooks/total_transform.ipynb

mithi/arm-ik

e7e87ef0e43b04278d2300f67d863c3f7eafb77e

2017-07-29T11:40:03.000Z

2022-02-28T14:49:48.000Z

notebooks/total_transform.ipynb

mithi/arm-ik

e7e87ef0e43b04278d2300f67d863c3f7eafb77e

notebooks/total_transform.ipynb

mithi/arm-ik

e7e87ef0e43b04278d2300f67d863c3f7eafb77e

2017-10-27T13:30:21.000Z

2022-02-10T10:08:42.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__kor_Hang

## Ainsley Works on Problem Sets Ainsley sits down on Sunday night to finish S problem sets, where S is a random variable that is equally likely to be 1, 2, 3, or 4. She learns C concepts from the problem sets and drinks D energy drinks to stay awake, where C and D are random and depend on how many problem sets she does. You know that $p_{C|S}(c|s) = 1/(2s+1)$ for $c \in \{ 0,1,\ldots ,2s\}.$ For each problem set she completes, regardless of concepts learned, she independently decides to have an energy drink with probability $q.$ That is, the number of energy drinks she has is binomial with parameters $q$ and $S:$ $$\begin{eqnarray} p_{D\mid S}(d\mid s) &= \begin{cases} {s \choose d}\, q^d\, (1-q)^{s-d} & d \in \{0,\ldots,s\} \\ 0 & \text{otherwise} \end{cases} \end{eqnarray}$$ where ${n \choose k} = \frac{n!}{k!\, (n-k)!}.$ **Question:** Does the conditional entropy $H(C\mid S=s)$ decrease, stay the same, or increase as $s$ increases from $1$ to $4?$ [$\times $] It decreases. <br> [$\times $] It stays the same<br> [$\checkmark$] It increases. **Solution:** Conditioned on $S=s, C$ is uniform from $0$ to $2s.$ $$\begin{align} H(C|S=s)&= \sum _{c=0}^{2s} p_{C|S}(c|s) \log \frac{1}{p_{C|S}(c|s)}\\ &= \sum _{c=0}^{2s} \frac{1}{2s+1} \log \frac{1}{\frac{1}{2s+1}}\\ &= \log \frac{1}{\frac{1}{2s+1}}\\ &= \log (2s+1) \end{align}$$ As $s$ increases, so does $\log (2s+1).$ We can also see this intuitively: as $s$ increases, $c$ is uniform over a broader range of possibilities, which implies a higher entropy. ```python %matplotlib inline from numpy import log2, arange import matplotlib.pyplot as plt f = lambda x: - x * log2(x) g = lambda s: (2*s + 1) * f(1/(2*s+1)) s = arange(1, 5, 1) plt.plot(s, g(s), '-', s, g(s), 'ro') plt.xlabel("$s$") plt.ylabel("$H(C\mid S=s)$") plt.show() ``` **Question:** The next morning, her roommate notices that Ainsley drank $d$ energy drinks. What is the expected number of concepts that she learned? You should derive a general expression for this although in the answer boxes below we only ask you to evaluate the expression for specific choices of $d$ and $q.$ If you're general expression is correct, your answers to these should also be correct. (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.) 1. When $q=0.2, \mathbb {E}[C | D = 1] =$ {{ans1}} 2. When $q=0.5, \mathbb {E}[C | D = 2] =$ {{ans2}} 3. When $q=0.7, \mathbb {E}[C | D = 3] =$ {{ans3}} **Solution:** We are interested in $\mathbb {E}[C|D=d].$ Since we are given information about $C$ conditioned on $S,$ we will condition on $S$ and use total expectation. We will also use the fact that $C$ and $D$ are conditionally independent given $S:$ $$\begin{align} \mathbb {E}[C|D=d] &= \sum _{s=1}^4 \mathbb {E}[C|D=d, S=s] \mathbb {P}(S=s | D=d)\\ \text {(by conditional independence)} &= \sum _{s=1}^4 \mathbb {E}[C|S=s] p_{S|D}(s|d)\\ \text {(by Bayes' rule)} &= \sum _{s=1}^4 \mathbb {E}[C|S=s] \frac{p_{D|S}(d|s) p_ S(s)}{p_ D(d)}\\ &= \frac{\sum _{s=1}^4 \left(\sum _{c=0}^{2s} c \frac{1}{2s+1}\right) p_{D|S}(d|s) p_ S(s)}{\sum _{s=1}^4 p_{D|S}(d|s) p_ S(s)} \\ &=\frac{\sum _{s=1}^4 s \cdot p_{D|S}(d|s) }{\sum _{s=1}^4 p_{D|S}(d|s)}\\ \text {(since $p_{D|S}(d|s) = 0$ for $s < d$)}&= \frac{\sum _{s=d}^4 s \cdot p_{D|S}(d|s) }{\sum _{s=d}^4 p_{D|S}(d|s)} \\ &=\frac{\sum _{s=d}^4 s {s \choose d} q^ d (1-q)^{s-d}}{\sum _{s=d}^4 {s \choose d} q^ d (1-q)^{s-d}} \end{align}$$ Another solution that works is to compute $p_{C|D}(\cdot \mid d)$ and compute the expectation with respect to this distribution. This leads to a very similar set of steps as above. ```python from scipy.misc import comb f = lambda s, d, q : comb(s, d) * (q ** d) * ((1 - q) ** (s - d)) ED = lambda d, q : sum([s * f(s, d, q) for s in range(d, 5)]) / \ sum([f(s, d, q) for s in range(d, 5)]) ans1 = "{0:.3f}".format(ED(1, 0.2)) ans2 = "{0:.3f}".format(ED(2, 0.5)) ans3 = "{0:.3f}".format(ED(3, 0.7)) ``` **Question:** Is the mutual information $I(C ; D)$ greater than, less than, or equal to zero? You should assume that $q$ lies in the range $0 < q < 1.$ [$\checkmark$] Greater than 0<br> [$\times $] Less than 0 <br> [$\times $] Equal to 0 **Solution:** $\boxed {\text {Greater than zero}}.$ Since the conditional expectation in the previous part depends on $d,$ we can infer that they are not independent. We can also justify this intuitively: for example, knowing that $D=4$ guarantees that $S=4,$ and therefore changes our belief about $C$ (i.e., $C$ is more likely to take on higher values). ## Consecutive Sixes **Question:** On average, how many times do you have to roll a fair six-sided die before getting two consecutive sixes? Hint: Use total expectation. **Solution:** Let $\mu = \mathbb {E}[\# \text { rolls until we get two consecutive 6's}].$ The problem can be broken up into two events (that forms a partition of the sample space): - Event 1: The very first time we roll a 6, the roll right afterward is also a 6. The probability of this first event is $1/6.$ You can think of it as we will, with probability $1,$ roll a 6 in a finite amount of time, and then it's just the next roll that we are looking at the probability for, and rolling a 6 in this next roll happens with probability $1/6.$ (Note that the probability that we never see a 6 is $\lim _{n \rightarrow \infty } (5/6)^ n = 0.$) Conditioned on this first event, let's compute the expected number of rolls until we get two consecutive 6's: The expected number of rolls until the first 6 is the expectation of a $\text {Geo}(1/6)$ random variable, which is $1/(1/6) = 6.$ The event we are conditioning on says that the next roll is a 6, so there the conditional expectation here is just $6 + 1 = 7$ rolls. - Event 2: The very first time we roll a 6, the roll right afterward is not a 6. The probability for this second event is $5/6,$ i.e., the roll right after getting the first 6 is not a 6. Conditioned on this second event, let's compute the expected number of rolls until we get two consecutive 6's: The expected number of rolls until the first 6 is 6 rolls (again, this is the expectation of a $\text {Geo}(1/6)$ random variable), and then the 7th roll is not a 6. And then we restart the whole process over. So the conditional expectation for this case is $7 + \mu.$ Now using the law of total expectation, $$\begin{align} \mu &= 7 \cdot \frac16 + (7 + \mu ) \frac56 \\ &= \frac76 + \frac{35}6 + \frac{5}{6}\mu\\ &= \frac{42}6 + \frac{5}{6}\mu , \end{align}$$ so $$\frac16 \mu = \frac{42}6,\qquad {\text {i.e.,}}\qquad \mu = \boxed {42}.$$ ```python ```

0015f8de6c6d57b341e26dce75a57c961cf09b16

ipynb

Jupyter Notebook

week04/06 Homework.ipynb

infimath/Computational-Probability-and-Inference

e48cd52c45ffd9458383ba0f77468d31f781dc77

2019-04-04T03:07:47.000Z

2019-04-04T03:07:47.000Z

week04/06 Homework.ipynb

infimath/Computational-Probability-and-Inference

e48cd52c45ffd9458383ba0f77468d31f781dc77

week04/06 Homework.ipynb

infimath/Computational-Probability-and-Inference

e48cd52c45ffd9458383ba0f77468d31f781dc77

2021-02-27T05:33:49.000Z

2021-02-27T05:33:49.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Efficiency Analysis ## Objective and Prerequisites How can mathematical optimization be used to measure the efficiency of an organization? Find out in this example, where you’ll learn how to formulate an Efficiency Analysis model as a linear programming problem using the Gurobi Python API and then generate an optimal solution with the Gurobi Optimizer. This model is example 22 from the fifth edition of Model Building in Mathematical Programming by H. Paul Williams on pages 278-280 and 335-336. This example is at the intermediate level, where we assume that you know Python and the Gurobi Python API and that you have some knowledge of building mathematical optimization models. **Download the Repository** <br /> You can download the repository containing this and other examples by clicking [here](https://github.com/Gurobi/modeling-examples/archive/master.zip). **Gurobi License** <br /> In order to run this Jupyter Notebook properly, you must have a Gurobi license. If you do not have one, you can request an [evaluation license](https://www.gurobi.com/downloads/request-an-evaluation-license/?utm_source=3PW&utm_medium=OT&utm_campaign=WW-MU-MUI-OR-O_LEA-PR_NO-Q3_FY20_WW_JPME_Efficiency_Analysis_COM_EVAL_GitHub&utm_term=Efficiency%20Analysis&utm_content=C_JPM) as a *commercial user*, or download a [free license](https://www.gurobi.com/academia/academic-program-and-licenses/?utm_source=3PW&utm_medium=OT&utm_campaign=WW-MU-EDU-OR-O_LEA-PR_NO-Q3_FY20_WW_JPME_Efficiency_Analysis_COM_EVAL_GitHub&utm_term=Efficiency%20Analysis&utm_content=C_JPM) as an *academic user*. ## Background The Data Envelopment Analysis (DEA) is a nonparametric problem in operations research and economics whose solution is an estimation of production frontiers. It is used to empirically measure the productive efficiency of decision making units (DMUs). There are a number of linear programming formulations of the DEA problem. Fuller coverage of the subject can be found in Farrell (1957), Charnes et al. (1978) and Thanassoulis et al. (1987). The formulation given by H.P. Williams is described in Land (1991). This formulation is the dual model of a model commonly used that relies on finding weighted ratios of outputs to inputs. We will use the formulation that is commonly used and can be found in Cooper et al. (2007). The Data Envelopment Analysis has been used to evaluate the performance of many different kinds of entities engaged in many different activities, and in many different contexts in many different countries. Examples include the maintenance activities of U.S. Air Force bases in different geographic locations, or police forces in England and Wales as well as the performance of branch banks in Cyprus and Canada and the efficiency of universities in performing their education and research functions in the U.S., England and France. The DEA approach is concerned with evaluations of *efficiency*. The most common measure of efficiency takes the form of a ratio like the following one: $$ \text{efficiency} = \frac{\text{output}}{\text{input}} $$ ## Model Formulation Assume there is a set of DMUs. Some common input and output items for each of these DMUs are selected as follows: 1. Numerical data are available for each input and output, with the data assumed to be positive, for all DMUs. 2. The items (inputs, outputs and choice of DMUs) should reflect an analyst's or a manager's interest in the components that will enter into the relative efficiency evaluations of the DMUs. 3. In principle, smaller input amounts are preferable and larger output amounts are preferable so the efficiency scores should reflect these principles. 4. The measurement units of the different inputs and outputs do not need to be congruent. Some may involve a number of persons, or areas of floor space, money expended, etc. ### Fractional problem formulation The proposed measure of the efficiency of a target DMU $k$ is obtained as the maximum of a ratio of weighted outputs to weighted inputs subject to the condition that the similar ratios for every DMU be less than or equal to one. ### Sets and indices $j,k \in \text{DMUS}$: Indices and set of DMUs, where $k$ represents the target DMU. $i \in \text{Inputs}$: Index and set of inputs. $r \in \text{Outputs}$: Index and set of outputs. ### Parameters $\text{invalue}_{i,j} > 0$: Value of input $i$ for DMU $j$. $\text{outvalue}_{r,j} > 0$: Value of output $r$ for DMU $j$. ### Decision Variables $u_{r} \geq 0$: Weight of output $r$. $v_{i} \geq 0$: Weight of input $i$. ### Objective function **Target DMU Efficiency**: Maximize efficiency at the target DMU $k$. $$ \text{Maximize} \quad E_k = \frac{\sum_{r \in \text{Outputs}} \text{outvalue}_{r,k}*u_{r}}{\sum_{i \in \text{Inputs}} \text{invalue}_{i,k}*v_{i}} \tag{FP0} $$ ### Constraints **Efficiency ratios**: The efficiency of a DMU is a number between $[0,1]$. \begin{equation} \frac{\sum_{r \in \text{Outputs}} \text{outvalue}_{r,j}*u_{r}}{\sum_{i \in \text{Inputs}} \text{invalue}_{i,j}*v_{i}} \leq 1 \quad \forall j \in \text{DMUS} \tag{FP1} \end{equation} ### Linear programming problem formulation This linear programming formulation can be found in the book by Cooper et al. (2007). ### Objective function **Target DMU Efficiency**: Maximize efficiency at the target DMU $k$. $$ \text{Maximize} \quad E_k = \sum_{r \in \text{Outputs}} \text{outvalue}_{r,k}*u_{r} \tag{LP0} $$ ### Constraints **Efficiency ratio**: The efficiency of a DMU is a number between $[0,1]$. \begin{equation} \sum_{r \in \text{Outputs}} \text{outvalue}_{r,j}*u_{r} - \sum_{i \in \text{Inputs}} \text{invalue}_{i,k}*v_{i} \leq 0 \quad \forall j \in \text{DMUS} \tag{LP1} \end{equation} **Normalization**: This constraint ensures that the denominator of the objective function of the fractional problem is equal to one. \begin{equation} \sum_{i \in \text{Inputs}} \text{invalue}_{i,k}*v_{i} = 1 \tag{LP2} \end{equation} It is easy to verify that the fractional problem and the linear programming problem are equivalent. Let's assume that the denominator of the efficiency ratio constraints of the fractional problem is positive for all DMUs, then we can obtain the constraints $LP1$ by multiplying both sides of the constraints $FP1$ by the denominator. Next, we set the denominator of $FP0$ eqaul to 1 and define constraint $LP2$, and then maximize the numerator, resulting in the objective function $LP0$. ### Definition of efficiency 1. $DMU_k$ is efficient if the optimal objective function value $E_{k}^{*} = 1$. 2. Otherwise, $DMU_k$ is inefficient. ## Problem Description A car manufacturer wants to evaluate the efficiencies of different garages that have been granted a license to sell its cars. Each garage has a certain number of measurable ‘inputs’: * Staff * Showroom Space * Population in category 1 * Population in category 2 * Enquiries Alpha model * Enquiries Beta model Each garage also has a certain number of measurable ‘outputs’: * Number Sold of different brands of car * annual Profit The following table gives the inputs and outputs for each of the 28 franchised garages. The goal is to identify efficient and inefficient garages and their input-output weights. In order to solve this problem, it is necessary to solve the LP model for each garage. --- ## Python Implementation We import the Gurobi Python Module and other Python libraries. ### Helper Functions * `solve_DEA` builds and solves the LP model. ```python import numpy as np import pandas as pd from itertools import product import gurobipy as gp from gurobipy import GRB # tested with Python 3.7.0 & Gurobi 9.1.0 ``` ```python def solve_DEA(target, verbose=True): # input-output values for the garages inattr = ['staff', 'showRoom', 'Population1', 'Population2', 'alphaEnquiries', 'betaEnquiries'] outattr = ['alphaSales', 'BetaSales', 'profit'] dmus, inputs, outputs = gp.multidict({ 'Winchester': [{'staff': 7, 'showRoom': 8, 'Population1': 10, 'Population2': 12, 'alphaEnquiries': 8.5, 'betaEnquiries': 4}, {'alphaSales': 2, 'BetaSales': 0.6, 'profit': 1.5}], 'Andover': [{'staff': 6, 'showRoom': 6, 'Population1': 20, 'Population2': 30, 'alphaEnquiries': 9, 'betaEnquiries': 4.5}, {'alphaSales': 2.3, 'BetaSales': 0.7, 'profit': 1.6}], 'Basingstoke': [{'staff': 2, 'showRoom': 3, 'Population1': 40, 'Population2': 40, 'alphaEnquiries': 2, 'betaEnquiries': 1.5}, {'alphaSales': 0.8, 'BetaSales': 0.25, 'profit': 0.5}], 'Poole': [{'staff': 14, 'showRoom': 9, 'Population1': 20, 'Population2': 25, 'alphaEnquiries': 10, 'betaEnquiries': 6}, {'alphaSales': 2.6, 'BetaSales': 0.86, 'profit': 1.9}], 'Woking': [{'staff': 10, 'showRoom': 9, 'Population1': 10, 'Population2': 10, 'alphaEnquiries': 11, 'betaEnquiries': 5}, {'alphaSales': 2.4, 'BetaSales': 1, 'profit': 2}], 'Newbury': [{'staff': 24, 'showRoom': 15, 'Population1': 15, 'Population2': 13, 'alphaEnquiries': 25, 'betaEnquiries': 1.9}, {'alphaSales': 8, 'BetaSales': 2.6, 'profit': 4.5}], 'Portsmouth': [{'staff': 6, 'showRoom': 7, 'Population1': 50, 'Population2': 40, 'alphaEnquiries': 8.5, 'betaEnquiries': 3}, {'alphaSales': 2.5, 'BetaSales': 0.9, 'profit': 1.6}], 'Alresford': [{'staff': 8, 'showRoom': 7.5, 'Population1': 5, 'Population2': 8, 'alphaEnquiries': 9, 'betaEnquiries': 4}, {'alphaSales': 2.1, 'BetaSales': 0.85, 'profit': 2}], 'Salisbury': [{'staff': 5, 'showRoom': 5, 'Population1': 10, 'Population2': 10, 'alphaEnquiries': 5, 'betaEnquiries': 2.5}, {'alphaSales': 2, 'BetaSales': 0.65, 'profit': 0.9}], 'Guildford': [{'staff': 8, 'showRoom': 10, 'Population1': 30, 'Population2': 35, 'alphaEnquiries': 9.5, 'betaEnquiries': 4.5}, {'alphaSales': 2.05, 'BetaSales': 0.75, 'profit': 1.7}], 'Alton': [{'staff': 7, 'showRoom': 8, 'Population1': 7, 'Population2': 8, 'alphaEnquiries': 3, 'betaEnquiries': 2}, {'alphaSales': 1.9, 'BetaSales': 0.70, 'profit': 0.5}], 'Weybridge': [{'staff': 5, 'showRoom': 6.5, 'Population1': 9, 'Population2': 12, 'alphaEnquiries': 8, 'betaEnquiries': 4.5}, {'alphaSales': 1.8, 'BetaSales': 0.63, 'profit': 1.4}], 'Dorchester': [{'staff': 6, 'showRoom': 7.5, 'Population1': 10, 'Population2': 10, 'alphaEnquiries': 7.5, 'betaEnquiries': 4}, {'alphaSales': 1.5, 'BetaSales': 0.45, 'profit': 1.45}], 'Bridport': [{'staff': 11, 'showRoom': 8, 'Population1': 8, 'Population2': 10, 'alphaEnquiries': 10, 'betaEnquiries': 6}, {'alphaSales': 2.2, 'BetaSales': 0.65, 'profit': 2.2}], 'Weymouth': [{'staff': 4, 'showRoom': 5, 'Population1': 10, 'Population2': 10, 'alphaEnquiries': 7.5, 'betaEnquiries': 3.5}, {'alphaSales': 1.8, 'BetaSales': 0.62, 'profit': 1.6}], 'Portland': [{'staff': 3, 'showRoom': 3.5, 'Population1': 3, 'Population2': 20, 'alphaEnquiries': 2, 'betaEnquiries': 1.5}, {'alphaSales': 0.9, 'BetaSales': 0.35, 'profit': 0.5}], 'Chichester': [{'staff': 5, 'showRoom': 5.5, 'Population1': 8, 'Population2': 10, 'alphaEnquiries': 7, 'betaEnquiries': 3.5}, {'alphaSales': 1.2, 'BetaSales': 0.45, 'profit': 1.3}], 'Petersfield': [{'staff': 21, 'showRoom': 12, 'Population1': 6, 'Population2': 6, 'alphaEnquiries': 15, 'betaEnquiries': 8}, {'alphaSales': 6, 'BetaSales': 0.25, 'profit': 2.9}], 'Petworth': [{'staff': 6, 'showRoom': 5.5, 'Population1': 2, 'Population2': 2, 'alphaEnquiries': 8, 'betaEnquiries': 5}, {'alphaSales': 1.5, 'BetaSales': 0.55, 'profit': 1.55}], 'Midhurst': [{'staff': 3, 'showRoom': 3.6, 'Population1': 3, 'Population2': 3, 'alphaEnquiries': 2.5, 'betaEnquiries': 1.5}, {'alphaSales': 0.8, 'BetaSales': 0.20, 'profit': 0.45}], 'Reading': [{'staff': 30, 'showRoom': 29, 'Population1': 120, 'Population2': 80, 'alphaEnquiries': 35, 'betaEnquiries': 20}, {'alphaSales': 7, 'BetaSales': 2.5, 'profit': 8}], 'Southampton': [{'staff': 25, 'showRoom': 16, 'Population1': 110, 'Population2': 80, 'alphaEnquiries': 27, 'betaEnquiries': 12}, {'alphaSales': 6.5, 'BetaSales': 3.5, 'profit': 5.4}], 'Bournemouth': [{'staff': 19, 'showRoom': 10, 'Population1': 90, 'Population2': 22, 'alphaEnquiries': 25, 'betaEnquiries': 13}, {'alphaSales': 5.5, 'BetaSales': 3.1, 'profit': 4.5}], 'Henley': [{'staff': 7, 'showRoom': 6, 'Population1': 5, 'Population2': 7, 'alphaEnquiries': 8.5, 'betaEnquiries': 4.5}, {'alphaSales': 1.2, 'BetaSales': 0.48, 'profit': 2}], 'Maidenhead': [{'staff': 12, 'showRoom': 8, 'Population1': 7, 'Population2': 10, 'alphaEnquiries': 12, 'betaEnquiries': 7}, {'alphaSales': 4.5, 'BetaSales': 2, 'profit': 2.3}], 'Fareham': [{'staff': 4, 'showRoom': 6, 'Population1': 1, 'Population2': 1, 'alphaEnquiries': 7.5, 'betaEnquiries': 3.5}, {'alphaSales': 1.1, 'BetaSales': 0.48, 'profit': 1.7}], 'Romsey': [{'staff': 2, 'showRoom': 2.5, 'Population1': 1, 'Population2': 1, 'alphaEnquiries': 2.5, 'betaEnquiries': 1}, {'alphaSales': 0.4, 'BetaSales': 0.1, 'profit': 0.55}], 'Ringwood': [{'staff': 2, 'showRoom': 3.5, 'Population1': 2, 'Population2': 2, 'alphaEnquiries': 1.9, 'betaEnquiries': 1.2}, {'alphaSales': 0.3, 'BetaSales': 0.09, 'profit': 0.4}] }) ### Create LP model model = gp.Model('DEA') # Decision variables wout = model.addVars(outattr, name="outputWeight") win = model.addVars(inattr, name="inputWeight") # Constraints ratios = model.addConstrs( ( gp.quicksum(outputs[h][r]*wout[r] for r in outattr ) - gp.quicksum(inputs[h][i]*win[i] for i in inattr ) <= 0 for h in dmus ), name='ratios' ) normalization = model.addConstr((gp.quicksum(inputs[target][i]*win[i] for i in inattr ) == 1 ), name='normalization') # Objective function model.setObjective( gp.quicksum(outputs[target][r]*wout[r] for r in outattr ), GRB.MAXIMIZE) # Run optimization engine if not verbose: model.params.OutputFlag = 0 model.optimize() # Print results print(f"\nThe efficiency of target DMU {target} is {round(model.objVal,3)}") print("__________________________________________________________________") print(f"The weights for the inputs are:") for i in inattr: print(f"For {i}: {round(win[i].x,3)} ") print("__________________________________________________________________") print(f"The weights for the outputs are") for r in outattr: print(f"For {r} is: {round(wout[r].x,3)} ") print("__________________________________________________________________\n\n") return model.objVal ``` ## Input Data We define the list of garages. ```python dmus = ['Winchester','Andover','Basingstoke', 'Poole', 'Woking','Newbury','Portsmouth','Alresford','Salisbury','Guildford','Alton','Weybridge', 'Dorchester', 'Bridport', 'Weymouth', 'Portland', 'Chichester', 'Petersfield', 'Petworth', 'Midhurst', 'Reading', 'Southampton', 'Bournemouth', 'Henley', 'Maidenhead', 'Fareham', 'Romsey', 'Ringwood'] ``` --- ## Output Report We print out the efficiency score of each garage and its associated input and output weights. ```python # Solving DEA model for each DMU performance = {} for h in dmus: performance[h] = solve_DEA(h, verbose=False) ``` Using license file c:\gurobi\gurobi.lic The efficiency of target DMU Winchester is 0.835 __________________________________________________________________ The weights for the inputs are: For staff: 0.012 For showRoom: 0.0 For Population1: 0.0 For Population2: 0.002 For alphaEnquiries: 0.095 For betaEnquiries: 0.02 __________________________________________________________________ The weights for the outputs are For alphaSales is: 0.113 For BetaSales is: 0.004 For profit is: 0.404 __________________________________________________________________ The efficiency of target DMU Andover is 0.917 __________________________________________________________________ The weights for the inputs are: For staff: 0.115 For showRoom: 0.03 For Population1: 0.0 For Population2: 0.0 For alphaEnquiries: 0.014 For betaEnquiries: 0.0 __________________________________________________________________ The weights for the outputs are For alphaSales is: 0.399 For BetaSales is: 0.0 For profit is: 0.0 __________________________________________________________________ The efficiency of target DMU Basingstoke is 1.0 __________________________________________________________________ The weights for the inputs are: For staff: 0.429 For showRoom: 0.0 For Population1: 0.0 For Population2: 0.0 For alphaEnquiries: 0.071 For betaEnquiries: 0.0 __________________________________________________________________ The weights for the outputs are For alphaSales is: 1.25 For BetaSales is: 0.0 For profit is: 0.0 __________________________________________________________________ The efficiency of target DMU Poole is 0.864 __________________________________________________________________ The weights for the inputs are: For staff: 0.0 For showRoom: 0.019 For Population1: 0.0 For Population2: 0.001 For alphaEnquiries: 0.081 For betaEnquiries: 0.0 __________________________________________________________________ The weights for the outputs are For alphaSales is: 0.065 For BetaSales is: 0.0 For profit is: 0.366 __________________________________________________________________ The efficiency of target DMU Woking is 0.845 __________________________________________________________________ The weights for the inputs are: For staff: 0.015 For showRoom: 0.0 For Population1: 0.0 For Population2: 0.001 For alphaEnquiries: 0.062 For betaEnquiries: 0.032 __________________________________________________________________ The weights for the outputs are For alphaSales is: 0.0 For BetaSales is: 0.218 For profit is: 0.314 __________________________________________________________________ The efficiency of target DMU Newbury is 1.0 __________________________________________________________________ The weights for the inputs are: For staff: 0.0 For showRoom: 0.0 For Population1: 0.0 For Population2: 0.0 For alphaEnquiries: 0.0 For betaEnquiries: 0.526 __________________________________________________________________ The weights for the outputs are For alphaSales is: 0.0 For BetaSales is: 0.0 For profit is: 0.222 __________________________________________________________________ The efficiency of target DMU Portsmouth is 1.0 __________________________________________________________________ The weights for the inputs are: For staff: 0.149 For showRoom: 0.0 For Population1: 0.0 For Population2: 0.0 For alphaEnquiries: 0.0 For betaEnquiries: 0.036 __________________________________________________________________ The weights for the outputs are For alphaSales is: 0.4 For BetaSales is: 0.0 For profit is: 0.0 __________________________________________________________________ The efficiency of target DMU Alresford is 1.0 __________________________________________________________________ The weights for the inputs are: For staff: 0.0 For showRoom: 0.0 For Population1: 0.0 For Population2: 0.002 For alphaEnquiries: 0.098 For betaEnquiries: 0.026 __________________________________________________________________ The weights for the outputs are For alphaSales is: 0.081 For BetaSales is: 0.005 For profit is: 0.413 __________________________________________________________________ The efficiency of target DMU Salisbury is 1.0 __________________________________________________________________ The weights for the inputs are: For staff: 0.087 For showRoom: 0.0 For Population1: 0.0 For Population2: 0.0 For alphaEnquiries: 0.113 For betaEnquiries: 0.0 __________________________________________________________________ The weights for the outputs are For alphaSales is: 0.5 For BetaSales is: 0.0 For profit is: 0.0 __________________________________________________________________ The efficiency of target DMU Guildford is 0.802 __________________________________________________________________ The weights for the inputs are: For staff: 0.014 For showRoom: 0.0 For Population1: 0.0 For Population2: 0.0 For alphaEnquiries: 0.075 For betaEnquiries: 0.036 __________________________________________________________________ The weights for the outputs are For alphaSales is: 0.062 For BetaSales is: 0.0 For profit is: 0.397 __________________________________________________________________ The efficiency of target DMU Alton is 1.0 __________________________________________________________________ The weights for the inputs are: For staff: 0.0 For showRoom: 0.0 For Population1: 0.0 For Population2: 0.0 For alphaEnquiries: 0.333 For betaEnquiries: 0.0 __________________________________________________________________ The weights for the outputs are For alphaSales is: 0.0 For BetaSales is: 1.429 For profit is: 0.0 __________________________________________________________________ The efficiency of target DMU Weybridge is 0.854 __________________________________________________________________ The weights for the inputs are: For staff: 0.149 For showRoom: 0.0 For Population1: 0.028 For Population2: 0.0 For alphaEnquiries: 0.0 For betaEnquiries: 0.0 __________________________________________________________________ The weights for the outputs are For alphaSales is: 0.379 For BetaSales is: 0.0 For profit is: 0.122 __________________________________________________________________ The efficiency of target DMU Dorchester is 0.867 __________________________________________________________________ The weights for the inputs are: For staff: 0.014 For showRoom: 0.0 For Population1: 0.0 For Population2: 0.003 For alphaEnquiries: 0.118 For betaEnquiries: 0.0 __________________________________________________________________ The weights for the outputs are For alphaSales is: 0.11 For BetaSales is: 0.0 For profit is: 0.484 __________________________________________________________________ The efficiency of target DMU Bridport is 0.982 __________________________________________________________________ The weights for the inputs are: For staff: 0.0 For showRoom: 0.002 For Population1: 0.0 For Population2: 0.002 For alphaEnquiries: 0.096 For betaEnquiries: 0.0 __________________________________________________________________ The weights for the outputs are For alphaSales is: 0.06 For BetaSales is: 0.0 For profit is: 0.387 __________________________________________________________________ The efficiency of target DMU Weymouth is 1.0 __________________________________________________________________ The weights for the inputs are: For staff: 0.25 For showRoom: 0.0 For Population1: 0.0 For Population2: 0.0 For alphaEnquiries: 0.0 For betaEnquiries: 0.0 __________________________________________________________________ The weights for the outputs are For alphaSales is: 0.556 For BetaSales is: 0.0 For profit is: 0.0 __________________________________________________________________ The efficiency of target DMU Portland is 1.0 __________________________________________________________________ The weights for the inputs are: For staff: 0.0 For showRoom: 0.0 For Population1: 0.032 For Population2: 0.0 For alphaEnquiries: 0.452 For betaEnquiries: 0.0 __________________________________________________________________ The weights for the outputs are For alphaSales is: 0.0 For BetaSales is: 0.0 For profit is: 2.0 __________________________________________________________________ The efficiency of target DMU Chichester is 0.825 __________________________________________________________________ The weights for the inputs are: For staff: 0.011 For showRoom: 0.008 For Population1: 0.0 For Population2: 0.002 For alphaEnquiries: 0.125 For betaEnquiries: 0.0 __________________________________________________________________ The weights for the outputs are For alphaSales is: 0.098 For BetaSales is: 0.0 For profit is: 0.545 __________________________________________________________________ The efficiency of target DMU Petersfield is 1.0 __________________________________________________________________ The weights for the inputs are: For staff: 0.0 For showRoom: 0.019 For Population1: 0.0 For Population2: 0.0 For alphaEnquiries: 0.04 For betaEnquiries: 0.021 __________________________________________________________________ The weights for the outputs are For alphaSales is: 0.167 For BetaSales is: 0.0 For profit is: 0.0 __________________________________________________________________ The efficiency of target DMU Petworth is 0.988 __________________________________________________________________ The weights for the inputs are: For staff: 0.0 For showRoom: 0.156 For Population1: 0.058 For Population2: 0.013 For alphaEnquiries: 0.0 For betaEnquiries: 0.0 __________________________________________________________________ The weights for the outputs are For alphaSales is: 0.141 For BetaSales is: 0.0 For profit is: 0.501 __________________________________________________________________ The efficiency of target DMU Midhurst is 0.889 __________________________________________________________________ The weights for the inputs are: For staff: 0.018 For showRoom: 0.0 For Population1: 0.0 For Population2: 0.011 For alphaEnquiries: 0.366 For betaEnquiries: 0.0 __________________________________________________________________ The weights for the outputs are For alphaSales is: 0.294 For BetaSales is: 0.047 For profit is: 1.431 __________________________________________________________________ The efficiency of target DMU Reading is 0.984 __________________________________________________________________ The weights for the inputs are: For staff: 0.001 For showRoom: 0.006 For Population1: 0.0 For Population2: 0.0 For alphaEnquiries: 0.023 For betaEnquiries: 0.0 __________________________________________________________________ The weights for the outputs are For alphaSales is: 0.019 For BetaSales is: 0.0 For profit is: 0.106 __________________________________________________________________ The efficiency of target DMU Southampton is 1.0 __________________________________________________________________ The weights for the inputs are: For staff: 0.0 For showRoom: 0.005 For Population1: 0.0 For Population2: 0.0 For alphaEnquiries: 0.028 For betaEnquiries: 0.012 __________________________________________________________________ The weights for the outputs are For alphaSales is: 0.0 For BetaSales is: 0.057 For profit is: 0.149 __________________________________________________________________ The efficiency of target DMU Bournemouth is 1.0 __________________________________________________________________ The weights for the inputs are: For staff: 0.0 For showRoom: 0.1 For Population1: 0.0 For Population2: 0.0 For alphaEnquiries: 0.0 For betaEnquiries: 0.0 __________________________________________________________________ The weights for the outputs are For alphaSales is: 0.0 For BetaSales is: 0.323 For profit is: 0.0 __________________________________________________________________ The efficiency of target DMU Henley is 1.0 __________________________________________________________________ The weights for the inputs are: For staff: 0.0 For showRoom: 0.161 For Population1: 0.007 For Population2: 0.0 For alphaEnquiries: 0.0 For betaEnquiries: 0.0 __________________________________________________________________ The weights for the outputs are For alphaSales is: 0.0 For BetaSales is: 0.0 For profit is: 0.5 __________________________________________________________________ The efficiency of target DMU Maidenhead is 1.0 __________________________________________________________________ The weights for the inputs are: For staff: 0.0 For showRoom: 0.122 For Population1: 0.004 For Population2: 0.0 For alphaEnquiries: 0.0 For betaEnquiries: 0.0 __________________________________________________________________ The weights for the outputs are For alphaSales is: 0.0 For BetaSales is: 0.5 For profit is: 0.0 __________________________________________________________________ The efficiency of target DMU Fareham is 1.0 __________________________________________________________________ The weights for the inputs are: For staff: 0.0 For showRoom: 0.0 For Population1: 0.0 For Population2: 1.0 For alphaEnquiries: 0.0 For betaEnquiries: 0.0 __________________________________________________________________ The weights for the outputs are For alphaSales is: 0.0 For BetaSales is: 2.083 For profit is: 0.0 __________________________________________________________________ The efficiency of target DMU Romsey is 1.0 __________________________________________________________________ The weights for the inputs are: For staff: 0.0 For showRoom: 0.0 For Population1: 0.0 For Population2: 0.0 For alphaEnquiries: 0.31 For betaEnquiries: 0.224 __________________________________________________________________ The weights for the outputs are For alphaSales is: 0.0 For BetaSales is: 0.0 For profit is: 1.818 __________________________________________________________________ The efficiency of target DMU Ringwood is 0.908 __________________________________________________________________ The weights for the inputs are: For staff: 0.0 For showRoom: 0.0 For Population1: 0.0 For Population2: 0.013 For alphaEnquiries: 0.512 For betaEnquiries: 0.0 __________________________________________________________________ The weights for the outputs are For alphaSales is: 0.299 For BetaSales is: 0.0 For profit is: 2.044 __________________________________________________________________ --- ## Analysis We identify which garages are efficient and which ones are inefficient, and provide the efficiency scores for each garage. ```python # Identifying efficient and inefficient DMUs # Sorting garages in descending efficiency number sorted_performance = {k: v for k, v in sorted(performance.items(), key=lambda item: item[1], reverse = True)} efficient = [] inefficient = [] for h in sorted_performance.keys(): if sorted_performance[h] >= 0.9999999: efficient.append(h) if sorted_performance[h] < 0.9999999: inefficient.append(h) print('____________________________________________') print(f"The efficient DMUs are:") for eff in efficient: print(f"The performance value of DMU {eff} is: {round(performance[eff],3)}") print('____________________________________________') print(f"The inefficient DMUs are:") for ine in inefficient: print(f"The performance value of DMU {ine} is: {round(performance[ine],3)}") ``` ____________________________________________ The efficient DMUs are: The performance value of DMU Newbury is: 1.0 The performance value of DMU Alresford is: 1.0 The performance value of DMU Salisbury is: 1.0 The performance value of DMU Alton is: 1.0 The performance value of DMU Weymouth is: 1.0 The performance value of DMU Petersfield is: 1.0 The performance value of DMU Southampton is: 1.0 The performance value of DMU Bournemouth is: 1.0 The performance value of DMU Maidenhead is: 1.0 The performance value of DMU Fareham is: 1.0 The performance value of DMU Romsey is: 1.0 The performance value of DMU Basingstoke is: 1.0 The performance value of DMU Portsmouth is: 1.0 The performance value of DMU Portland is: 1.0 The performance value of DMU Henley is: 1.0 ____________________________________________ The inefficient DMUs are: The performance value of DMU Petworth is: 0.988 The performance value of DMU Reading is: 0.984 The performance value of DMU Bridport is: 0.982 The performance value of DMU Andover is: 0.917 The performance value of DMU Ringwood is: 0.908 The performance value of DMU Midhurst is: 0.889 The performance value of DMU Dorchester is: 0.867 The performance value of DMU Poole is: 0.864 The performance value of DMU Weybridge is: 0.854 The performance value of DMU Woking is: 0.845 The performance value of DMU Winchester is: 0.835 The performance value of DMU Chichester is: 0.825 The performance value of DMU Guildford is: 0.802 ## References H. Paul Williams, Model Building in Mathematical Programming, fifth edition. Cooper, W. W, L. M. Seiford, K. Tone. (2007) Data Envelopment Analysis: A Comprehensive Text with Models, Applications, References and DEA-Solver Software. Second edition. Springer-Verlag US. Land, A. (1991) Data envelopment analysis, Chapter 5, in Operations Research in Management (eds S.C. Littlechild and M.F. Shutler), Prentice Hall, London. Farrell, M.J. (1957) The measurement of productive efficiency. Journal of the Royal Statistical Society, Series A, 120, 253–290. Charnes, A., Cooper, W.W. and Rhodes, E. (1978) Measuring the efficiency of decision making units. European Journal of Operational Research, 2, 429–444. Thanassoulis, E., Dyson, R.G. and Foster, M.J. (1987) Relative efficiency assessments using data envelopment analysis: an application to data on rates departments. Journal of the Operational Research Society, 5, 397–411. Copyright © 2020 Gurobi Optimization, LLC

e4279e7528ba062671618e83ce5ac32405490f98

ipynb

Jupyter Notebook

efficiency_analysis/efficiency_analysis.ipynb

Maninaa/modeling-examples

51575a453d28e1e9435abd865432955b182ba577

2021-11-29T07:42:12.000Z

2021-11-29T07:42:12.000Z

efficiency_analysis/efficiency_analysis.ipynb

Maninaa/modeling-examples

51575a453d28e1e9435abd865432955b182ba577

efficiency_analysis/efficiency_analysis.ipynb

Maninaa/modeling-examples

51575a453d28e1e9435abd865432955b182ba577

2021-11-29T07:41:53.000Z

2021-11-29T07:41:53.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__yue_Hant

# Bayes by Backprop An implementation of the algorithm described in https://arxiv.org/abs/1505.05424. This notebook accompanies the article at https://www.nitarshan.com/bayes-by-backprop. ```python %matplotlib inline import math import matplotlib.pyplot as plt import numpy as np import seaborn as sns import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim from tensorboardX import SummaryWriter from torchvision import datasets, transforms from torchvision.utils import make_grid from tqdm import tqdm, trange from copy import deepcopy writer = SummaryWriter() sns.set() sns.set_style("dark") sns.set_palette("muted") sns.set_color_codes("muted") ``` ```python DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu") LOADER_KWARGS = {'num_workers': 1, 'pin_memory': True} if torch.cuda.is_available() else {} print(torch.cuda.is_available()) ``` ## Data Preparation ```python BATCH_SIZE = 100 TEST_BATCH_SIZE = 5 train_loader = torch.utils.data.DataLoader( datasets.FashionMNIST( './fmnist', train=True, download=True, transform=transforms.ToTensor()), batch_size=BATCH_SIZE, shuffle=True, **LOADER_KWARGS) test_loader = torch.utils.data.DataLoader( datasets.FashionMNIST( './fmnist', train=False, download=True, transform=transforms.ToTensor()), batch_size=TEST_BATCH_SIZE, shuffle=False, **LOADER_KWARGS) # train_loader = torch.utils.data.DataLoader( # datasets.CIFAR10( # '../gitignored/data', train=True, download=True, # transform=transforms.ToTensor()), # batch_size=BATCH_SIZE, shuffle=True, **LOADER_KWARGS) # test_loader = torch.utils.data.DataLoader( # datasets.CIFAR10( # '../gitignored/data', train=False, download=True, # transform=transforms.ToTensor()), # batch_size=TEST_BATCH_SIZE, shuffle=False, **LOADER_KWARGS) TRAIN_SIZE = len(train_loader.dataset) TEST_SIZE = len(test_loader.dataset) NUM_BATCHES = len(train_loader) NUM_TEST_BATCHES = len(test_loader) CLASSES = 10 TRAIN_EPOCHS = 20 SAMPLES = 2 TEST_SAMPLES = 10 assert (TRAIN_SIZE % BATCH_SIZE) == 0 assert (TEST_SIZE % TEST_BATCH_SIZE) == 0 ``` ## Modelling $$\underline{\text{Reparameterized Gaussian}}$$ $$\begin{aligned} \theta &= (\mu, \rho)\\ \sigma &= \ln{(1+e^\rho)}\\ \mathcal{N}(x\vert \mu, \sigma) &= \frac{1}{\sqrt{2\pi}\sigma}e^{-\frac{(x-\mu)^2}{2\sigma^2}}\\ \ln{\mathcal{N}(x\vert \mu, \sigma)} &= -\ln{\sqrt{2\pi}} -\ln{\sigma} -\frac{(x-\mu)^2}{2\sigma^2}\\ P(\mathbf{w}) &= \prod_j{\mathcal{N}(\mathbf{w}_j \vert 0, \sigma^2)}\\ \ln{P(\mathbf{w})} &= \sum_j{\ln{\mathcal{N}(\mathbf{w}_j \vert 0, \sigma^2)}}\\ \end{aligned}$$ ```python class Gaussian(object): def __init__(self, mu, rho): super().__init__() self.mu = mu self.rho = rho self.normal = torch.distributions.Normal(0,1) self.mask = torch.ones_like(self.mu) @property def sigma(self): return torch.log1p(torch.exp(self.rho)) def sample(self): epsilon = self.normal.sample(self.rho.size()).to(DEVICE) return self.mu + (self.sigma * epsilon) * self.mask.to(self.mu.device) def log_prob(self, input): return (-math.log(math.sqrt(2 * math.pi)) - torch.log(self.sigma) - ((input - self.mu) ** 2) / (2 * self.sigma ** 2)).sum() ``` $$\underline{\text{Scale Mixture Gaussian}}$$ $$\begin{align} P(\mathbf{w}) &= \prod_j{\pi \mathcal{N}(\mathbf{w}_j \vert 0, \sigma_1^2) + (1-\pi) \mathcal{N}(\mathbf{w}_j \vert 0, \sigma_2^2)}\\ \ln{P(\mathbf{w})} &= \sum_j{\ln{(\pi \mathcal{N}(\mathbf{w}_j \vert 0, \sigma_1^2) + (1-\pi) \mathcal{N}(\mathbf{w}_j \vert 0, \sigma_2^2))}}\\ \end{align}$$ ```python class ScaleMixtureGaussian(object): def __init__(self, pi, sigma1, sigma2): super().__init__() self.pi = pi self.sigma1 = sigma1 self.sigma2 = sigma2 self.gaussian1 = torch.distributions.Normal(0,sigma1) self.gaussian2 = torch.distributions.Normal(0,sigma2) def log_prob(self, input): prob1 = torch.exp(self.gaussian1.log_prob(input)) prob2 = torch.exp(self.gaussian2.log_prob(input)) return (torch.log(self.pi * prob1 + (1-self.pi) * prob2)).sum() ``` $$\pi = \frac{1}{2}$$ $$-\ln{\sigma_1} = 0$$ $$-\ln{\sigma_2} = 6$$ ```python PI = 0.5 SIGMA_1 = torch.cuda.FloatTensor([math.exp(-0)]) SIGMA_2 = torch.cuda.FloatTensor([math.exp(-6)]) # def visualize_scale_mixture_components(): # def show_lines(): # pass # mix = ScaleMixtureGaussian(PI, SIGMA_1, SIGMA_2) # normal_1 = torch.distributions.Normal(0, SIGMA_1) # normal_2 = torch.distributions.Normal(0, SIGMA_2) # x_points = np.linspace(-5,5,10000) # d1 = np.array([torch.exp(normal_1.log_prob(float(c))) for c in x_points]) # d2 = np.array([torch.exp(normal_2.log_prob(float(c))) for c in x_points]) # d3 = np.array([torch.exp(mix.log_prob(float(c))) for c in x_points]) # plt.subplots(1,3,figsize=(14,4)) # plt.subplot(1,3,1) # plt.plot(x_points,d2,color="g") # plt.plot(x_points,d3,color="r") # plt.plot(x_points,d1,color="b") # plt.legend(["sigma2", "mix", "sigma1"]) # plt.ylim(0,0.5) # plt.subplot(1,3,2) # plt.plot(x_points,d1,color="b") # plt.plot(x_points,d2,color="g") # plt.plot(x_points,d3,color="r") # plt.legend(["sigma1", "sigma2", "mix"]) # plt.ylim(0,160) # plt.subplot(1,3,3) # plt.plot(x_points,d2,color="g") # plt.plot(x_points,d3,color="r") # plt.plot(x_points,d1,color="b") # plt.legend(["sigma2", "mix", "sigma1"]) # plt.ylim(0,80) # visualize_scale_mixture_components() ``` ```python class BayesianLinear(nn.Module): def __init__(self, in_features, out_features): super().__init__() self.in_features = in_features self.out_features = out_features # Weight parameters self.weight_mu = nn.Parameter(torch.Tensor(out_features, in_features).uniform_(-0.2, 0.2)) self.weight_rho = nn.Parameter(torch.Tensor(out_features, in_features).uniform_(-5,-4)) self.weight = Gaussian(self.weight_mu, self.weight_rho) # Bias parameters self.bias_mu = nn.Parameter(torch.Tensor(out_features).uniform_(-0.2, 0.2)) self.bias_rho = nn.Parameter(torch.Tensor(out_features).uniform_(-5,-4)) self.bias = Gaussian(self.bias_mu, self.bias_rho) # Prior distributions self.weight_prior = ScaleMixtureGaussian(PI, SIGMA_1, SIGMA_2) self.bias_prior = ScaleMixtureGaussian(PI, SIGMA_1, SIGMA_2) self.log_prior = 0 self.log_variational_posterior = 0 def forward(self, input, sample=False, calculate_log_probs=False): if self.training or sample: weight = self.weight.sample() bias = self.bias.sample() else: weight = self.weight.mu bias = self.bias.mu if self.training or calculate_log_probs: self.log_prior = self.weight_prior.log_prob(weight) + self.bias_prior.log_prob(bias) self.log_variational_posterior = self.weight.log_prob(weight) + self.bias.log_prob(bias) else: self.log_prior, self.log_variational_posterior = 0, 0 return F.linear(input, weight, bias) ``` ```python class BayesianNetwork(nn.Module): def __init__(self): super().__init__() self.l1 = BayesianLinear(28*28, 1200) # self.l1 = BayesianLinear(3*32*32, 1200) self.l2 = BayesianLinear(1200, 1200) self.l3 = BayesianLinear(1200, 10) def forward(self, x, sample=False): x = x.view(-1, 28*28) # x = x.view(-1, 3*32*32) x = F.relu(self.l1(x, sample)) x = F.relu(self.l2(x, sample)) x = F.log_softmax(self.l3(x, sample), dim=1) return x def log_prior(self): return self.l1.log_prior \ + self.l2.log_prior \ + self.l3.log_prior def log_variational_posterior(self): return self.l1.log_variational_posterior \ + self.l2.log_variational_posterior \ + self.l3.log_variational_posterior def sample_elbo(self, input, target, samples=SAMPLES): outputs = torch.zeros(samples, BATCH_SIZE, CLASSES).to(DEVICE) log_priors = torch.zeros(samples).to(DEVICE) log_variational_posteriors = torch.zeros(samples).to(DEVICE) for i in range(samples): outputs[i] = self(input, sample=True) log_priors[i] = self.log_prior() log_variational_posteriors[i] = self.log_variational_posterior() log_prior = log_priors.mean() log_variational_posterior = log_variational_posteriors.mean() negative_log_likelihood = F.nll_loss(outputs.mean(0), target, size_average=False) loss = (log_variational_posterior - log_prior)/NUM_BATCHES + negative_log_likelihood return loss, log_prior, log_variational_posterior, negative_log_likelihood net = BayesianNetwork().to(DEVICE) ``` ## Training ```python def write_weight_histograms(epoch): writer.add_histogram('histogram/w1_mu', net.l1.weight_mu,epoch) writer.add_histogram('histogram/w1_rho', net.l1.weight_rho,epoch) writer.add_histogram('histogram/w2_mu', net.l2.weight_mu,epoch) writer.add_histogram('histogram/w2_rho', net.l2.weight_rho,epoch) writer.add_histogram('histogram/w3_mu', net.l3.weight_mu,epoch) writer.add_histogram('histogram/w3_rho', net.l3.weight_rho,epoch) writer.add_histogram('histogram/b1_mu', net.l1.bias_mu,epoch) writer.add_histogram('histogram/b1_rho', net.l1.bias_rho,epoch) writer.add_histogram('histogram/b2_mu', net.l2.bias_mu,epoch) writer.add_histogram('histogram/b2_rho', net.l2.bias_rho,epoch) writer.add_histogram('histogram/b3_mu', net.l3.bias_mu,epoch) writer.add_histogram('histogram/b3_rho', net.l3.bias_rho,epoch) def write_loss_scalars(epoch, batch_idx, loss, log_prior, log_variational_posterior, negative_log_likelihood): writer.add_scalar('logs/loss', loss, epoch*NUM_BATCHES+batch_idx) writer.add_scalar('logs/complexity_cost', log_variational_posterior-log_prior, epoch*NUM_BATCHES+batch_idx) writer.add_scalar('logs/log_prior', log_prior, epoch*NUM_BATCHES+batch_idx) writer.add_scalar('logs/log_variational_posterior', log_variational_posterior, epoch*NUM_BATCHES+batch_idx) writer.add_scalar('logs/negative_log_likelihood', negative_log_likelihood, epoch*NUM_BATCHES+batch_idx) ``` ```python def train(net, optimizer, epoch): net.train() if epoch == 0: # write initial distributions write_weight_histograms(epoch) for batch_idx, (data, target) in enumerate(tqdm(train_loader)): data, target = data.to(DEVICE), target.to(DEVICE) net.zero_grad() loss, log_prior, log_variational_posterior, negative_log_likelihood = net.sample_elbo(data, target) loss.backward() optimizer.step() write_loss_scalars(epoch, batch_idx, loss, log_prior, log_variational_posterior, negative_log_likelihood) write_weight_histograms(epoch+1) ``` ```python optimizer = optim.Adam(net.parameters()) for epoch in range(TRAIN_EPOCHS): train(net, optimizer, epoch) ``` ```python backup_net = deepcopy(net) ``` ```python net = deepcopy(backup_net) ``` ```python # for name, module in net.named_modules(): # if name in ['l1', 'l2']: # breakpoint() ``` ```python all_scores = [] for name, module in net.named_modules(): if name in ['l1', 'l2']: # scores = - module.weight.sigma scores = torch.abs(module.weight.mu) / module.weight.sigma all_scores.append(scores.flatten()) ``` ```python all_scores = torch.cat([x for x in all_scores]) ``` ```python # all_scores ``` ```python # torch.histc(all_scores, 10) ``` ```python threshold, _ = torch.topk(all_scores, int(len(all_scores)*0.25), sorted=True) ``` ```python acceptable_score = threshold[-1] ``` ```python acceptable_score ``` ```python for name, module in net.named_modules(): if name in ['l1', 'l2']: mask = (torch.abs(module.weight.mu) / module.weight.sigma > acceptable_score) # mask = (- module.weight.sigma) > acceptable_score module.weight.mu = mask * module.weight.mu module.weight.mask = mask print(mask.sum().float() / torch.numel(mask)) ``` ## Evaluation ### Model Ensemble ```python def test_ensemble(): net.eval() correct = 0 corrects = np.zeros(TEST_SAMPLES+1, dtype=int) with torch.no_grad(): for data, target in test_loader: data, target = data.to(DEVICE), target.to(DEVICE) outputs = torch.zeros(TEST_SAMPLES+1, TEST_BATCH_SIZE, CLASSES).to(DEVICE) for i in range(TEST_SAMPLES): outputs[i] = net(data, sample=True) outputs[TEST_SAMPLES] = net(data, sample=False) output = outputs.mean(0) preds = preds = outputs.max(2, keepdim=True)[1] pred = output.max(1, keepdim=True)[1] # index of max log-probability corrects += preds.eq(target.view_as(pred)).sum(dim=1).squeeze().cpu().numpy() correct += pred.eq(target.view_as(pred)).sum().item() for index, num in enumerate(corrects): if index < TEST_SAMPLES: print('Component {} Accuracy: {}/{}'.format(index, num, TEST_SIZE)) else: print('Posterior Mean Accuracy: {}/{}'.format(num, TEST_SIZE)) print('Ensemble Accuracy: {}/{}'.format(correct, TEST_SIZE)) test_ensemble() ``` ### Model Uncertainty #### In-Domain Uncertainty ```python def show(img): npimg = img.numpy() plt.imshow(np.transpose(npimg, (1,2,0)), interpolation='nearest') ``` ```python fmnist_sample = iter(test_loader).next() fmnist_sample[0] = fmnist_sample[0].to(DEVICE) print(fmnist_sample[1]) sns.set_style("dark") show(make_grid(fmnist_sample[0].cpu())) ``` ```python net.eval() fmnist_outputs = net(fmnist_sample[0], True).max(1, keepdim=True)[1].detach().cpu().numpy() for _ in range(99): fmnist_outputs = np.append(fmnist_outputs, net(fmnist_sample[0], True).max(1, keepdim=True)[1].detach().cpu().numpy(), axis=1) sns.set_style("darkgrid") plt.subplots(5,1,figsize=(10,4)) for i in range(5): plt.subplot(5,1,i+1) plt.ylim(0,100) plt.xlabel("Categories") plt.xticks(range(10), ["Top", "Trouser", "Pullover", "Dress", "Coat", "Sandal", "Shirt", "Sneaker", "Bag", "Ankle Boot"]) plt.ylabel("Count") plt.yticks(range(50,101,50)) plt.hist(fmnist_outputs[i], np.arange(-0.5, 10, 1)) ``` #### Out-of-Domain Uncertainty ```python mnist_loader = torch.utils.data.DataLoader( datasets.MNIST('../gitignored/data', train=False, download=True, transform=transforms.ToTensor()), batch_size=5, shuffle=False) # mnist_loader = torch.utils.data.DataLoader( # datasets.SVHN('../gitignored/data', split='test', download=True, transform=transforms.ToTensor()), batch_size=5, shuffle=False) ``` ```python from sklearn import metrics import numpy as np def calculate_auroc(correct, predictions): fpr, tpr, thresholds = metrics.roc_curve(correct, predictions) auroc = metrics.auc(fpr, tpr) return auroc def calculate_aupr(correct, predictions): aupr = metrics.average_precision_score(correct, predictions) return aupr ``` ```python ood_labels = [] ood_scores = [] with torch.no_grad(): for data, _ in test_loader: data = data.to(DEVICE) out = net(data, True) probs = F.softmax(out, 1) max_probs, _ = probs.max(1) max_probs = max_probs.detach().cpu().numpy() ood_labels.append(np.ones_like(max_probs)) ood_scores.append(max_probs) for data, _ in mnist_loader: data = data.to(DEVICE) out = net(data, True) probs = F.softmax(out, 1) max_probs, _ = probs.max(1) max_probs = max_probs.detach().cpu().numpy() ood_labels.append(np.zeros_like(max_probs)) ood_scores.append(max_probs) ood_labels = np.concatenate(ood_labels) ood_scores = np.concatenate(ood_scores) ``` ```python ood_scores[10000:].mean() ``` ```python print(calculate_auroc(ood_labels, ood_scores)) print(calculate_aupr(ood_labels, ood_scores)) ``` ```python # 0.7348483900000001 # 0.7189197489131008 # 0.6768591982944069 # 0.495362640026969 # 0.657779435 # 0.6424149416360756 ``` ```python mnist_sample = iter(mnist_loader).next() mnist_sample[0] = mnist_sample[0].to(DEVICE) print(mnist_sample[1]) sns.set_style("dark") show(make_grid(mnist_sample[0].cpu())) ``` ```python net.eval() mnist_outputs = net(mnist_sample[0], True).max(1, keepdim=True)[1].detach().cpu().numpy() for _ in range(99): mnist_outputs = np.append(mnist_outputs, net(mnist_sample[0], True).max(1, keepdim=True)[1].detach().cpu().numpy(), axis=1) sns.set_style("darkgrid") plt.subplots(5,1,figsize=(10,4)) for i in range(5): plt.subplot(5,1,i+1) plt.ylim(0,100) plt.xlabel("Categories") plt.xticks(range(10), ["Top", "Trouser", "Pullover", "Dress", "Coat", "Sandal", "Shirt", "Sneaker", "Bag", "Ankle Boot"]) plt.ylabel("Count") plt.yticks(range(50,101,50)) plt.hist(mnist_outputs[i], np.arange(-0.5, 10, 1)) ``` ```python %load_ext watermark %watermark --updated --datename --python --machine --watermark -p torch,numpy,matplotlib,tensorboardX,torchvision,seaborn ```

61073acbd5cc447c0a6dcc612edf8628509f757e

ipynb

Jupyter Notebook

notebooks/Weight Uncertainty in Neural Networks.ipynb

MorganeAyle/SNIP-it

df2bf44d6d3f7e4ea7733242a79c916735a7b49e

notebooks/Weight Uncertainty in Neural Networks.ipynb

MorganeAyle/SNIP-it

df2bf44d6d3f7e4ea7733242a79c916735a7b49e

notebooks/Weight Uncertainty in Neural Networks.ipynb

MorganeAyle/SNIP-it

df2bf44d6d3f7e4ea7733242a79c916735a7b49e

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Controlled oscillator The controlled oscillator is an oscillator with an extra input that controls the frequency of the oscillation. To implement a basic oscillator, we would use a neural ensemble of two dimensions that has the following dynamics: $$ \dot{x} = \begin{bmatrix} 0 && - \omega \\ \omega && 0 \end{bmatrix} x $$ where the frequency of oscillation is $\omega \over {2 \pi}$ Hz. We need the neurons to represent three variables, $x_0$, $x_1$, and $\omega$. According the the dynamics principle of the NEF, in order to implement some particular dynamics, we need to convert this dynamics equation into a feedback function: $$ \begin{align} \dot{x} &= f(x) \\ &\implies f_{feedback}(x) = x + \tau f(x) \end{align} $$ where $\tau$ is the post-synaptic time constant of the feedback connection. In this case, the feedback function to be computed is $$ \begin{align} f_{feedback}(x) &= x + \tau \begin{bmatrix} 0 && - \omega \\ \omega && 0 \end{bmatrix} x \\ &= \begin{bmatrix} x_0 - \tau \cdot \omega \cdot x_1 \\ x_1 + \tau \cdot \omega \cdot x_0 \end{bmatrix} \end{align} $$ Since the neural ensemble represents all three variables but the dynamics only affects the first two ($x_0$, $x_1$), we need the feedback function to not affect that last variable. We do this by adding a zero to the feedback function. $$ f_{feedback}(x) = \begin{bmatrix} x_0 - \tau \cdot \omega \cdot x_1 \\ x_1 + \tau \cdot \omega \cdot x_0 \\ 0 \end{bmatrix} $$ We also generally want to keep the ranges of variables represented within an ensemble to be approximately the same. In this case, if $x_0$ and $x_1$ are between -1 and 1, $\omega$ will also be between -1 and 1, giving a frequency range of $-1 \over {2 \pi}$ to $1 \over {2 \pi}$. To increase this range, we introduce a scaling factor to $\omega$ called $\omega_{max}$. $$ f_{feedback}(x) = \begin{bmatrix} x_0 - \tau \cdot \omega \cdot \omega_{max} \cdot x_1 \\ x_1 + \tau \cdot \omega \cdot \omega_{max} \cdot x_0 \\ 0 \end{bmatrix} $$ ```python %matplotlib inline import matplotlib.pyplot as plt import nengo from nengo.processes import Piecewise ``` ## Step 1: Create the network ```python tau = 0.1 # Post-synaptic time constant for feedback w_max = 10 # Maximum frequency is w_max/(2*pi) model = nengo.Network(label='Controlled Oscillator') with model: # The ensemble for the oscillator oscillator = nengo.Ensemble(500, dimensions=3, radius=1.7) # The feedback connection def feedback(x): x0, x1, w = x # These are the three variables stored in the ensemble return x0 + w * w_max * tau * x1, x1 - w * w_max * tau * x0, 0 nengo.Connection(oscillator, oscillator, function=feedback, synapse=tau) # The ensemble for controlling the speed of oscillation frequency = nengo.Ensemble(100, dimensions=1) nengo.Connection(frequency, oscillator[2]) ``` ## Step 2: Create the input ```python with model: # We need a quick input at the beginning to start the oscillator initial = nengo.Node(Piecewise({0: [1, 0, 0], 0.15: [0, 0, 0]})) nengo.Connection(initial, oscillator) # Vary the speed over time input_frequency = nengo.Node( Piecewise({ 0: 1, 1: 0.5, 2: 0, 3: -0.5, 4: -1 })) nengo.Connection(input_frequency, frequency) ``` ## Step 3: Add Probes ```python with model: # Indicate which values to record oscillator_probe = nengo.Probe(oscillator, synapse=0.03) ``` ## Step 4: Run the Model ```python with nengo.Simulator(model) as sim: sim.run(5) ``` ## Step 5: Plot the Results ```python plt.figure() plt.plot(sim.trange(), sim.data[oscillator_probe]) plt.xlabel('Time (s)') plt.legend(['$x_0$', '$x_1$', r'$\omega$']); ```

8e57ed466a9d3feef61f5f036573451f75943f6d

ipynb

Jupyter Notebook

docs/examples/dynamics/controlled_oscillator.ipynb

pedrombmachado/nengo

abc85e1a75ce2f980e19eef195d98081f95efd28

docs/examples/dynamics/controlled_oscillator.ipynb

pedrombmachado/nengo

abc85e1a75ce2f980e19eef195d98081f95efd28

docs/examples/dynamics/controlled_oscillator.ipynb

pedrombmachado/nengo

abc85e1a75ce2f980e19eef195d98081f95efd28

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

--- # What are the marginal and the conditional probabilities? --- In this script, we show the 1-D marginal and 1-D conditional probability density functions (PDF) for a 2-D gaussian PDF. In its matrix-form, the equation for the 2-D gausian PDF reads like this: <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> where <blockquote> $ \begin{align} \bf{x} &= [x_{1} x_{2}]^\top \\ \bf{\mu} &= [\mu_{1} \mu_{2}]^\top \\ \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} \end{align} $ </blockquote> where $\rho$ is the correlation factor between the $x_{1}$ and $x_{2}$ data. ## A useful trick to generate a covariance matrix $\Sigma$ with desired features Instead of guessing the values of $\sigma_{x_{1}}$, $\sigma_{x_{2}}$ and $\rho$ to create a covariance matrix $\Sigma$ for visualization purpose, we can design it with some desired characteristics. Those are the principal axis variances $\sigma_{1}^2$ and $\sigma_{2}^2$, and the rotation angle $\theta$. First, we generate the covariance matrix of a correlated PDF with its principal axes oriented along the $x_{1}$ and $x_{2}$ axes. <blockquote> $\Sigma_{PA} = \begin{pmatrix} \sigma_{1}^2 & 0 \\ 0 & \sigma_{2}^2 \end{pmatrix}$ </blockquote> Next, we generate the rotation matrix for the angle $\theta$: <blockquote> $R = \begin{pmatrix} \cos{\theta} & -\sin{\theta} \\ \sin{\theta} & \cos{\theta} \end{pmatrix}$ </blockquote> The covariance matrix we are looking for is <blockquote> $\Sigma = R \Sigma_{PA} R^\top $ </blockquote> Hence, we only have to specify the values of $\sigma_{1}$ and $\sigma_{2}$ along principal axes and the rotation angle $\theta$. The correlation coefficient $\rho$ depends on the value of $\theta$: <blockquote> $\rho>0$ when $\theta>0$ </blockquote> <blockquote> $\rho<0$ when $\theta<0$ </blockquote> <br> N.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. ```python print(__doc__) # Author: Pierre Gravel <[email protected]> # License: BSD %matplotlib inline import numpy as np import matplotlib.pyplot as plt from matplotlib import cm from scipy import stats from scipy.stats import multivariate_normal import seaborn as sns sns.set(color_codes=True) # Used for reproductibility of the results np.random.seed(43) ``` Automatically created module for IPython interactive environment Here are the characteristics of the 2-D PDF we want to generate: ```python # Origin of the PDF Mu = np.array([0.5, 0.5]) # Individual standard deviations along the principal axes sigma = np.array([0.25, 0.05]) # Rotation angle for a negative correlation theta = -45. ``` Generate the covariance matrix $\Sigma$: ```python theta = np.radians(theta) c, s = np.cos(theta), np.sin(theta) # Rotation matrix R = np.array(((c, -s), (s, c))) # Covariance matrix for a PDF with its principal axes oriented along the x and y directions Sigma = np.array([[sigma[0]**2, 0.],[0., sigma[1]**2]]) # Covariance matrix after rotation Sigma = R.dot( Sigma.dot(R.T) ) ``` Generate a spatial grid where the various PDF will be evaluated locally. ```python x_min, x_max = 0., 1. y_min, y_max = 0., 1. nx, ny = 60, 60 x = np.linspace(x_min, x_max, nx) y = np.linspace(y_min, y_max, ny) xx, yy = np.meshgrid(x,y) pos = np.dstack((xx, yy)) ``` Get the marginal distributions $P(x)$ and $P(y)$. Each one is the probability of an event irrespective of the outcome of the other variable. ```python # Generator for the 2-D gaussian PDF model = multivariate_normal(Mu, Sigma) pdf = model.pdf(pos) # Project P(x,y) on the x axis to get the marginal 1-D distribution P(x) pdf_x = multivariate_normal.pdf(x, mean=Mu[0], cov=Sigma[0,0]) # Project P(x,y) on the y axis to get the marginal 1-D distribution P(y) pdf_y = multivariate_normal.pdf(y, mean=Mu[1], cov=Sigma[1,1]) ``` Get the conditional 1-D distributions $P(x|y=yc)$ and $P(y|x=xc)$. Each one is the probability of one event occurring in the presence of a second event. ```python # Vertical slice position xc = 0.3 # Horizontal slice position yc = 0.7 # Make a vertical slice of P(x,y) at x=xc to get the conditional 1-D distribution P(y|x=xc) P = np.empty([ny,2]) P[:,0] = xc P[:,1] = y pdf_xc = multivariate_normal.pdf(P, mean=Mu, cov=Sigma) # Make an horizontal slice of P(x,y) at y=yc to get the conditional 1-D distribution P(x|y=yc) P = np.empty([nx,2]) P[:,0] = x P[:,1] = yc pdf_yc = multivariate_normal.pdf(P, mean=Mu, cov=Sigma) ``` Show the various PDF. The color of each conditional 1-D distribution corresponds to its slice through the 2-D PDF. ```python fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2,2,figsize=(10,10)) # Display the 2-D PDF P(x,y) cset = ax1.contourf(xx, yy, pdf, zdir='z', cmap=cm.viridis, levels=7) ax1.plot([x_min, x_max], [yc, yc], linewidth=2.0, color='red') ax1.text(0.79, 0.72,'$x_{2} = 0.7$', fontsize=16, color='white') ax1.plot([xc, xc], [y_min, y_max], linewidth=2.0, color='green') ax1.text(0.31, 0.02,'$x_{1} = 0.3$', fontsize=16, color='white') ax1.set_xlabel('$x_{1}$',fontsize=18) ax1.set_ylabel('$x_{2}$',rotation=0,fontsize=18) ax1.xaxis.set_label_coords(0.5, -0.08) ax1.yaxis.set_label_coords(-0.08, 0.5) # Display the 1-D conditional PDF P(y|x=xc) ax2.plot(pdf_y, y, label='$P(x_{2})$', linewidth=3.0, color='black') ax2.plot(pdf_xc, y, label='$P(x_{2}|x_{1}=0.3)$', linewidth=2.0, color='green') ax2.set_ylabel('$x_{2}$',rotation=0,fontsize=18) ax2.set_xlabel('Probability Density',fontsize=18) ax2.xaxis.set_label_coords(0.5, -0.08) ax2.yaxis.set_label_coords(-0.08, 0.5) ax2.legend(loc='best',fontsize=14) # Display the 1-D conditional PDF P(x|y=yc) ax3.plot(x, pdf_x, label='$P(x_{1})$', linewidth=3.0, color='black') ax3.plot(x, pdf_yc, label='$P(x_{1}|x_{2}=0.7)$', linewidth=2.0, color='red') ax3.set_xlabel('$x_{1}$',fontsize=18) ax3.set_ylabel('Probability Density',fontsize=18) ax3.xaxis.set_label_coords(0.5, -0.08) ax3.yaxis.set_label_coords(-0.08, 0.5) ax3.legend(loc='best',fontsize=14) # Hide the unused fouth panel ax4.axis('off') fig.tight_layout() plt.savefig('Example_of_2D_PDF_with_conditional_1D.png') plt.savefig('Example_of_2D_PDF_with_conditional_1D.pdf') plt.show() ``` ```python ```

6392f9b66e7d0733bbc0d33d40004d0b38bfaa97

ipynb

Jupyter Notebook

generate_example_of_2D_PDF_with_conditional_1D_PDF.ipynb

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

a38ad6f960cc6b8155fad00e4c4562f5e459f248

generate_example_of_2D_PDF_with_conditional_1D_PDF.ipynb

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

a38ad6f960cc6b8155fad00e4c4562f5e459f248

generate_example_of_2D_PDF_with_conditional_1D_PDF.ipynb

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

a38ad6f960cc6b8155fad00e4c4562f5e459f248

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# BASIC CONTROLLERS This notebook describes the proportional, integral, and differential controllers. # Preliminaries ```python !pip install -q control !pip install -q tellurium !pip install -q controlSBML import control import controlSBML as ctl from IPython.display import HTML, Math import numpy as np import pandas as pd import matplotlib.pyplot as plt import sympy import tellurium as te ``` ```python TIMES = ctl.makeSimulationTimes(0, 5, 500) ``` # Antimony Model ```python # Constants CONSTANT_DCT = {"k1": 1, "k2": 2, "k3": 3, "k4": 4} s = sympy.Symbol("s") REF = 10 ``` ```python MODEL = """ $S1 -> S2; k1*$S1 J1: S2 -> S3; k2*S2 J2: S3 -> S2; k3*S3 J3: S2 -> ; k4*S2 k1 = 1 k2 = 2 k3 = 3 k4 = 4 $S1 = 10 S2 = 0 S3 = 0 S4 = 0 """ RR = te.loada(MODEL) RR.simulate() RR.plot() ``` # PID Controllers The controllers considered here are systems that input the control error and produce a control signal used to regulate the system under control. The input signal is $e(t)$ and the output signal is $u(t)$. A **proportional controller** has the parameter $k_P$. This controller outputs a signal that is proportional to the control error. That is, $u(t) = k_P e(t)$. The transfer function for this controller is $H_{P} (s) = k_p$. An **integral controller** has the parameter $k_I$. This controller outputs a signal that is proportional to the *integral* of the control error. That is, $u(t) = k_I \int_0^{t} e(\tau) d \tau$. The transfer function for this controller is $H_{I} (s) = \frac{k_I}{s}$. An **differential controller** has the parameter $k_D$. This controller outputs a signal that is proportional to the derivative of the control error. That is, $u(t) = k_D \frac{de(t)}{d t}$. The transfer function for this controller is $H_{D} (s) = s k_D$. These controllers can be used in combination. For example, a PI controller produces $u(t) = k_P e(t) + k_I \int_0^{t} e(\tau) d \tau + k_D \frac{d e(t)}{d t}$, and its transfer function is $H_{CPI}(s) = k_P + \frac{k_I}{s} + s k_D$. # Analysis in Discrete Time To improve our understanding of the different types of control, we'll do an analysis in discrete time. Let $n$ index the instances. Consider an input signal $e_n$ and an output signal $u_n$. Here's how the controllers work: * **Proportional control**. $u_n = k_P e_n$ * **Integral control**. $u_n = k_I \sum_{i=0}^n e_i$ * **Differential control**. $u_n = k_D (e_n - e_{n-1})$ Now let's create an envaluation environment. ## Analysis Codes ```python def evaluateController(e_vec, kp=0, ki=0, kd=0, is_plot=True, **kwargs): """ Plots the output of the controller for the signal. Parameters ---------- e_vec: list-float kp: float ki: float kd: float is_plot: bool kwargs: dict plot options Returns ------- np.array """ u_vec = [] e_last = e_vec[0] e_sum = e_vec[0] for e_val in e_vec[1:]: e_sum += e_val # u_val = kp*e_val u_val += ki*e_sum u_val += kd*(e_val - e_last) u_vec.append(u_val) # e_last = e_val # if is_plot: times = range(len(u_vec)) y_vec = e_vec[0:len(times)] df = pd.DataFrame({ "time": times, "e(t)": e_vec[0:len(times)], "u(t)": u_vec }) ts = ctl.Timeseries(df) title = "kp=%2.2f ki=%2.2f kd=%2.2f" % (kp, ki, kd) kwargs["title"] = title ctl.plotOneTS(ts, **kwargs) if False: if ax is None: _, ax = plt.subplots(1) ax.plot(range(len(u_vec)), u_vec, color="blue") ax.plot(times, y_vec, linestyle="--", color="black") ax.legend(["u(t)", "e(t)"]) ax.set_xlabel("time") ax.set_ylim([-1.5, 1.5]) title = "kp=%2.2f ki=%2.2f kd=%2.2f" % (kp, ki, kd) ax.set_title(title) return np.array(u_vec) # Tests e_vec = np.repeat(1, 10) u_vec = evaluateController(e_vec, kp=0, ki=0, kd=1, is_plot=False) assert(u_vec[0] == 0) print("OK!") ``` OK! ## Analysis What signals should we consider for $e(t)$? ```python step_input = np.repeat(1, 10) step_input = np.sin(0.1*np.array(range(100))) _ = evaluateController(step_input, kp=2, ylim=[-2,2], figsize=(5,5)) _ = evaluateController(step_input, ki=1, ylim=[-2,2], figsize=(5,5)) _ = evaluateController(step_input, kd=1, ylim=[-2,2], figsize=(5,5)) ``` # Analysis in Continuous Time We can analyze controllers by looking at their transfer functions by considering poles, DC gain, and step respoinse. $H_{PID} (s) = H_P(s) + H_I(s) + H_D(s) = k_P + \frac{k_I}{s} + s k_D$ ## Analysis Codes ```python def plotPIDStepResponse(kp=1, ki=0, kd=0, is_plot=True): """ Plots the step response of the PID controller. Parameters ---------- kp: float ki: float kd: float is_plot: bool Returns ------- control.TransferFunction """ tf = control.TransferFunction([kp], [1]) \ + control.TransferFunction([ki], [1, 0]) \ + control.TransferFunction([kd, 0], [1]) if is_plot: if len(tf.num[0][0]) > len(tf.den[0][0]): print("Improper transfer function. Cannot simulate.") else: result = control.step_response(tf) plt.plot(result.t.flatten(), result.y.flatten()) return tf # Tests tf = plotPIDStepResponse(kp=1, ki=0, kd=0, is_plot=False) assert(tf.dcgain() == 1) print("OK!") ``` OK! ```python # Find the DC gains for different variations of controllers print("kp=1: %2.2f" % plotPIDStepResponse(kp=1, ki=0, kd=0, is_plot=False).dcgain()) print("ki=1: %2.2f" % plotPIDStepResponse(kp=0, ki=1, kd=0, is_plot=False).dcgain()) ``` kp=1: 1.00 ki=1: inf ## Controller in Closed Loop ### Extending ``plotTF`` to PID Controllers ```python def plotTFs(Gs, kp=0, ki=0, kd=0, times=TIMES, ylim=None, title=None, is_plot=True): """ Constructs the transfer functions for the proportional controller, and filter. Calculates the transfer functions HRYs, HREs, HNYs, HDYs and plots them. Parameters ---------- Gs: control.TransferFunction kp: float ki: float kd: float times: list-float ylim: (float, float) limits of y-values title: str Returns ------- dct key: name of transfer function value: control.TransferFunction """ Cs = control.TransferFunction([kp], [1]) + control.TransferFunction([ki], [1, 0]) \ + control.TransferFunction([kd, 0], [1]) Fs = 1 denom = 1 + Cs*Gs*Fs # Construct the transfer functions tf_dct = { "HRYs": Cs*Gs/denom, "HREs": 1/denom, "HNYs": -Fs/denom, "HDYs": Cs/denom, } # Construct the plots _, ax = plt.subplots(1) for tf in tf_dct.values(): result = control.forced_response(tf, T=times, U=1) plt.plot(result.t.flatten(), result.y.flatten()) # Refine plots plt.legend(list(tf_dct.keys())) xmax = max(result.t.flatten()) plt.plot([0, xmax], [0, 0], linestyle="--", color="black") plt.plot([0, xmax], [1, 1], linestyle="--", color="grey") plt.ylim([-5, 5]) title = "kp=%2.2f ki=%2.2f kd=%2.2f" % (kp, ki, kd) plt.title(title) if not is_plot: plt.close() return tf_dct # Tests Gs = control.TransferFunction([2], [1, 3]) dct = plotTFs(Gs, kp=10, ylim=[0, 3], title="Example", is_plot=False) assert(len(dct) == 4) assert("TransferFunction" in str(type(dct["HRYs"]))) print("OK!") ``` OK! ```python dct["HRYs"] ``` $$\frac{20 s + 60}{s^2 + 26 s + 69}$$ ### Plots ```python for kp in [1, 5, 10, 20]: for ki in [1, 5, 10]: title = "kp: %2.1f ki: %2.1f" % (kp, ki) _ = plotTFs(Gs, kp=kp, ki=ki, title=title, ylim=[-1, 3]) ``` # Testbed ## Controller Factory **We need to extend ``makeController`` to PID** ```python # Extend to PID def makeController(name, kp=0, ki=0, kd=0): """ Creates a proportional controller as a NonlinearIOSystem with input "in" and output "out". Parameters ---------- name: str Name of the system kp: float ki: float kd: float Returns ------- control.NonlinearIOSystem """ def updfcn(time, x_vec, u_vec, params): """ Calculates the derivative of state. Parameters ---------- x_vec: array of dimension 2 0: last time 1: last input 2: sum of values u_vec: error signal input Returns ------- dtime: float derivative of time dinput: float derivative of input dsum: float derivative of sum """ try: u_val = u_vec[0] except: u_val = u_vec # dtime = time - x_vec[0] if np.isclose(dtime, 0): dinput = 0 dsum = 0 else: dinput = (u_val - x_vec[1])/dtime dsum = u_val/dtime return dtime, dinput, dsum def outfcn(_, x_vec, u_val, ___): # u: float (error signal) try: u_val = u_vec[0] except: u_val = u_vec return kp*(u_val) + ki*x_vec[2] + kd*(u_val - x_vec[1]) # return control.NonlinearIOSystem( updfcn, outfcn, inputs=['in'], outputs=['out'], states=["dtime", "dinput", "dsum"], name=name) # Tests controller = makeController("controller", kp=1, ki=1, kd=1) times = ctl.makeSimulationTimes() U = np.repeat(1, len(times)) U[0] = 1 result = control.input_output_response(controller, T=times, U=U) #trues = [r == kp*( t) for t, r in zip(result.t, result.outputs)] #assert(all(trues)) print("OK!") ``` OK! ## Closed Loop System ```python # Elements of the system factory = ctl.IOSystemFactory() kp = 100 ki = 0 kd = 0 # Create the elements of the feedback loop noise = factory.makeSinusoid("noise", 0, 20) disturbance = factory.makeSinusoid("disturbance", 0, 2) ctlsb = ctl.ControlSBML(MODEL, input_names=["S2"], output_names=["S3"]) system = ctlsb.makeNonlinearIOSystem("system") controller = factory.makePIDController("controller", kp=kp, ki=ki, kd=kd) fltr = factory.makePassthru("fltr") sum_Y_N = factory.makeAdder("sum_Y_N") sum_U_D = factory.makeAdder("sum_U_D") sum_R_F = factory.makeAdder("sum_R_F") ``` ```python # Create the closed loop system closed_loop = control.interconnect( [noise, disturbance, sum_Y_N, sum_R_F, sum_U_D, system, fltr, controller ], connections=[ ['controller.in', 'sum_R_F.out'], # e(t) ['sum_U_D.in1', 'controller.out'], # u(t) ['sum_U_D.in2', 'disturbance.out'], # d(t) ['system.S2', 'sum_U_D.out'], ['sum_Y_N.in1', 'system.S3'], # y(t) ['sum_Y_N.in2', 'noise.out'], # n(t) ['fltr.in', 'sum_Y_N.out'], ['sum_R_F.in1', '-fltr.out'], ], inplist=["sum_R_F.in2"], outlist=["sum_R_F.in2", "sum_Y_N.out", 'system.S2', 'system.S3'], ) ``` ## Plots We can use the transfer functions to guide our choice of parameters. Note that we it may be necessary to divide by $s$ to calculate the DC gain. ```python times = ctl.makeSimulationTimes(0, 50, 100) result = control.input_output_response(closed_loop, T=times, U=10) plt.plot(result.t, result.outputs[0].flatten()) plt.plot(result.t, result.outputs[1].flatten()) #plt.plot(result.t, result.outputs[2].flatten()) #plt.plot(result.t, result.outputs[3].flatten()) plt.ylim([5, 15]) legends = ["input", "output"] plt.legend(legends) ``` ## Transfer Function Analysis ```python # Linearized analysis print(kp, ki, kd) Gs = ctlsb.makeTransferFunction() dct = plotTFs(Gs, kp=kp, ki=ki, kd=kd, title=title, ylim=[-1, 3], is_plot=False) dct["HRYs"] ``` 100 0 0 $$\frac{200 s + 600}{s^2 + 206 s + 609}$$ ## Evaluation Environment We want to repeatedly evaluate different controller parameters. This is cumbersome to do if we have to rerun multiple cells and reset various parameters. It's much more efficient to create an evaluation function. ```python def runTestbed(model=MODEL, input_name="S2", output_name="S3", kp=0, ki=0, kd=0, noise_amp=0, disturbance_amp=0): """ Run the testbed and plot the results. Parameters ---------- model: str System under control input_name: str output_name: str kp: float ki: float kd: float noise_amp: float disturbance_amp: float Results ------- control.InterconnectedSystem """ ``` ```python def makeHRY(model=MODEL, input_name="S2", output_name="S3", time=0, kp=0, ki=0, kd=0): """ Calculates the transfer function from the reference input to the output. Parameters ---------- model: str input_name: str output_name: str time: float kp: float ki: float kd: float Returns ------- control.TransferFunction """ ctlsb = ctl.ControlSBML(MODEL, input_names=[input_name], output_names=[output_name]) Gs = ctlsb.makeTransferFunction(time=time) dct = plotTFs(Gs, kp=kp, ki=ki, kd=kd, is_plot=False) return dct["HRYs"] # TESTS tf = makeHRY() assert(tf.dcgain() == 0) ``` # More On Filters How do filters help with sinusoidal noise and disturbances? ```python # Create a testsbed factory = ctl.IOSystemFactory() fltr = factory.makeFilter("fltr", -50) noise = factory.makeSinusoid("noise", 1, 20) ``` ```python # Create the testbed test_bed = control.interconnect( [noise, fltr ], connections=[ ['fltr.in', 'noise.out'], # e(t) ], outlist=["fltr.out"], ) ``` ```python # Simulate it times = ctl.makeSimulationTimes(0, 20, 500) result = control.input_output_response(test_bed, T=times) plt.plot(result.t, result.outputs.flatten()) plt.ylim([-1, 1]) ```

a5b5b2661d68197a9bb5aa8266269420fea20084

ipynb

Jupyter Notebook

Lecture_19_20-Basic-Controllers/Basic-Controllers.ipynb

joseph-hellerstein/advanced-controls-lectures

dc43f6c3517616da3b0ea7c93192d911414ee202

Lecture_19_20-Basic-Controllers/Basic-Controllers.ipynb

joseph-hellerstein/advanced-controls-lectures

dc43f6c3517616da3b0ea7c93192d911414ee202

Lecture_19_20-Basic-Controllers/Basic-Controllers.ipynb

joseph-hellerstein/advanced-controls-lectures

dc43f6c3517616da3b0ea7c93192d911414ee202

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# 词频、互信息、信息熵发现中文新词 **新词发现**任务是中文自然语言处理的重要步骤。**新词**有“新”就有“旧”，属于一个相对个概念，在相对的领域（金融、医疗），在相对的时间（过去、现在）都存在新词。[文本挖掘](https://zh.wikipedia.org/wiki/文本挖掘)会先将文本[分词](https://zh.wikipedia.org/wiki/中文自动分词)，而通用分词器精度不过，通常需要添加**自定义字典**补足精度，所以发现新词并加入字典，成为文本挖掘的一个重要工作。 [**单词**](https://zh.wikipedia.org/wiki/單詞)的定义，来自维基百科的定义如下： >在语言学中，**单词**（又称为词、词语、单字；英语对应用语为“word”）是能独立运用并含有语义内容或语用内容（即具有表面含义或实际含义）的最小单位。单词的集合称为词汇、术语，例如：所有中文单词统称为“中文词汇”，医学上专用的词统称为“医学术语”等。词典是为词语提供音韵、词义解释、例句、用法等等的工具书，有的词典只修录特殊领域的词汇。 单从语义角度，“苹果“的法语是"pomme"，而“土豆”的法语是"pomme de terre"，若按上面的定义，“土豆”是要被拆的面目全非，但"pomme de terre"是却是表达“土豆”这个语义的最小单位；在机构名中，这类问题出现的更频繁，"Paris 3"是"巴黎第三大学"的简称，如果"Paris"和"3"分别表示地名和数字，那这两个就无法表达“巴黎第三大学”的语义。而中文也有类似的例子，“北京大学”的”北京“和”大学“都可以作为一个最小单位来使用，分别表示”地方名“和“大学”，如果这样分词，那么就可以理解为“北京的大学”了，所以“北京大学”是一个表达语义的最小单位。前几年有部电影《夏洛特烦恼》，我们是要理解为“夏洛特 烦恼“还是”夏洛 特 烦恼“，这就是很经典的分词问题。 但是从语用角度，这些问题似乎能被解决，我们知道"pomme de terre"在日常生活中一般作为“土豆”而不是“土里的苹果”，在巴黎学习都知道“Paris 3”，就像我们提到“北京大学”特指那所著名的高等学府一样。看过电影《夏洛特烦恼》的观众很容易的就能区分这个标题应该看为“夏洛 特 烦恼”。 发现新词的方法，《[互联网时代的社会语言学：基于SNS的文本数据挖掘](http://www.matrix67.com/blog/archives/5044]) 》一文，里面提到的给每一个文本串计算**文本片段**的**凝固程度**和文本串对外的使用**自由度**，通过设定阈值来将文本串分类为词和非词两类。原文给了十分通俗易懂的例子来解释凝固度和自动度。这里放上计算方法。这个方法还有许多地方需要优化，在之后的实践中慢慢调整了。 ## 文本片段 **文本片段**，最常用的方法就是[n元语法(ngram)](https://zh.wikipedia.org/wiki/N元语法)，将分本分成多个n长度的文本片段。数据结构，这里采用Trie树的方案，这个方案是简单容易实现，而且用Python的字典做Hash索引实现起来也很优美，唯独的一个问题是所有的数据都存在内存中，这会使得内存占用量非常大，如果要把这个工程化使用，还需要采用其他方案，比如硬盘检索。 <a href="https://upload.wikimedia.org/wikipedia/commons/b/be/Trie_example.svg " target="_blank"></a> ```python class TrieNode(object): def __init__(self, frequence=0, children_frequence=0, parent=None): self.parent = parent self.frequence = frequence self.children = {} self.children_frequence = children_frequence def insert(self, char): self.children_frequence += 1 self.children[char] = self.children.get(char, TrieNode(parent=self)) self.children[char].frequence += 1 return self.children[char] def fetch(self, char): return self.children[char] class TrieTree(object): def __init__(self, size=6): self._root = TrieNode() self.size = size def get_root(self): return self._root def insert(self, chunk): node = self._root for char in chunk: node = node.insert(char) if len(chunk) < self.size: # add symbol "EOS" at end of line trunck node.insert("EOS") def fetch(self, chunk): node = self._root for char in chunk: node = node.fetch(char) return node ``` Trie树的结构上，我添加了几个参数，parent，frequence，children_frequence，他们分别是： - parent，当前节点的父节点，如果是“树根”的时候，这个父节点为空； - frequence，当前节点出现的频次，在Trie树上，也可以表示某个文本片段的频次，比如"中国"，“国”这个节点的frequence是100的时候，“中国”俩字也出现了100次。这个可以作为最后的词频过滤用。 - children_frequence，当前接点下有子节点的"frequence"的总和。比如在刚才的例子上加上“中间”出现了99次，那么“中”这个节点的children_frequence的值是199次。 这样的构造让第二部分的计算更加方面。 这个任务中需要构建两棵Trie树，表示正向和反向两个字符片段集。 ## 自由度 **自由度**，使用信息论中的[信息熵](https://zh.wikipedia.org/wiki/熵_(信息论))构建文本片段左右熵，公式[1]。熵越大，表示该片段和左右邻字符相互关系的不稳定性越高，那么越有可能作为独立的片段使用。公式[1]第一个等号后面的I(x)表示x的自信息。 \begin{align} H(X) = \sum_{i} {\mathrm{P}(x_i)\,\mathrm{I}(x_i)} = -\sum_{i} {\mathrm{P}(x_i) \log \mathrm{P}(x_i)} [1] \end{align} ```python def calc_entropy(chunks, ngram): """计算信息熵 Args: chunks，是所有数据的文本片段 ngram，是Trie树 Return: word2entropy，返回一个包含每个chunk和对应信息熵的字典。 """ def entropy(sample, total): """Entropy""" s = float(sample) t = float(total) result = - s/t * math.log(s/t) return result def parse(chunk, ngram): node = ngram.fetch(chunk) total = node.children_frequence return sum([entropy(sub_node.frequence, total) for sub_node in node.children.values()]) word2entropy = {} for chunk in chunks: word2entropy[chunk] = parse(chunk, ngram) return word2entropy ``` ## 凝固度 **凝固度**，用信息论中的**互信息**表示，公式[2]。在概率论中，如果x跟y不相关，则p(x,y)=p(x)p(y)。二者相关性越大，则p(x,y)就相比于p(x)p(y)越大。用后面的式子可能更好理解，在y出现的情况下x出现的条件概率p(x|y)除以x本身出现的概率p(x)，自然就表示x跟y的相关程度。 \begin{align} I(x;y) = \log\frac{p(x,y)}{p(x)p(y)} = \log\frac{p(x|y)}{p(x)} = \log\frac{p(y|x)}{p(y)} [2] \end{align} 这里比较容易产生一个概念的混淆，维基百科将式[2]定义为[点互信息](https://en.wikipedia.org/wiki/Pointwise_mutual_information)，[互信息](https://zh.wikipedia.org/wiki/互信息)的定义如下： \begin{align} I(X;Y) = \sum_{y \in Y} \sum_{x \in X} p(x,y) \log{ \left(\frac{p(x,y)}{p(x)\,p(y)} \right) }\ [3] \end{align} 在傅祖芸编著的《信息论——基础理论与应用（第4版）》的绪论中，把式[2]定义为互信息，而式[3]定义为平均互信息，就像信息熵指的是**平均自信息**。 ```python def calc_mutualinfo(chunks, ngram): """计算互信息 Args: chunks，是所有数据的文本片段 ngram，是Trie树 Return: word2mutualinfo，返回一个包含每个chunk和对应互信息的字典。 """ def parse(chunk, root): sub_node_y_x = ngram.fetch(chunk) node = sub_node_y_x.parent sub_node_y = root.children[chunk[-1]] # 这里采用互信息log(p(y|x)/p(y))的计算方法 prob_y_x = float(sub_node_y_x.frequence) / node.children_frequence prob_y = float(sub_node_y.frequence) / root.children_frequence mutualinfo = math.log(prob_y_x / prob_y) return mutualinfo, sub_node_y_x.frequence word2mutualinfo = {} root = ngram.get_root() for chunk in chunks: word2mutualinfo[chunk] = parse(chunk, root) return word2mutualinfo ``` ## 过滤 最终计算得出互信息、信息熵，甚至也统计了词频，最后一步就是根据阈值对词进行过滤。 ```python def _fetch_final(fw_entropy， bw_entropy, fw_mi, bw_mi entropy_threshold=0.8, mutualinfo_threshold=7, freq_threshold=10): final = {} for k, v in fw_entropy.items(): last_node = self.fw_ngram if k[::-1] in bw_mi and k in fw_mi: mi_min = min(fw_mi[k][0], bw_mi[k[::-1]][0]) word_prob = min(fw_mi[k][1], bw_mi[k[::-1]][1]) if mi_min < mutualinfo_threshold: continue else: continue if word_prob < freq_threshold: continue if k[::-1] in bw_entropy: en_min = min(v, bw_entropy[k[::-1]]) if en_min < entropy_threshold: continue else: continue final[k] = (word_prob, mi_min, en_min) return final ``` ## 结果 最终，通过这个方法对这次十九大的开幕发言做的一个词汇发现，ngram的n=10，结果按词频排序输出，可以发现这次十九大谈了许多内容，不一一说了。这个结果还存在不少问题，比如“二〇”，这在阈值的设置上还不够准确，可以尝试使用机器学习的方法来获取阈值。 经济|70 改革|69 我们|64 必须|61 领导|60 完善|57 历史|44 不断|43 群众|43 教育|43 战略|42 思想|40 世界|39 问题|37 提高|37 组织|36 监督|35 加快|35 依法|34 精神|33 团结|33 复兴|32 保障|31 奋斗|30 根本|29 环境|29 军队|29 开放|27 服务|27 理论|26 干部|26 创造|26 基础|25 意识|25 维护|25 协商|24 解决|24 贯彻|23 斗争|23 目标|21 统筹|20 始终|19 方式|19 水平|19 科学|19 利益|19 市场|19 基层|19 积极|18 马克思|18 反对|18 道路|18 自然|18 增长|17 科技|17 稳定|17 原则|17 两岸|17 取得|16 质量|16 农村|16 矛盾|16 协调|15 巩固|15 收入|15 绿色|15 自觉|15 方针|15 纪律|15 长期|15 保证|15 同胞|15 命运|14 美好生活|14 五年|14 传统|14 繁荣|14 没有|14 使命|13 广泛|13 日益|13 价值|13 健康|13 资源|13 参与|13 突出|13 腐败|13 充分|13 梦想|13 任何|13 二〇|13 代表|12 阶段|12 深刻|12 布局|12 区域|12 贸易|12 核心|12 城乡|12 生态文明|12 工程|12 任务|12 地区|12 责任|12 认识|12 胜利|11 贡献|11 覆盖|11 生态环境|11 具有|11 面临|11 各种|11 培育|11 企业|11 继续|10 团结带领|10 提升|10 明显|10 弘扬|10 脱贫|10 贫困|10 标准|10 注重|10 基本实现|10 培养|10 青年|10 ## 代码下载地址 git clone https://github.com/Ushiao/new-word-discovery.git

8a7ccc78cd873593fa2d60702f23b2f60ce972a4

ipynb

Jupyter Notebook

docs/wordiscovery.ipynb

KunFly/new-word-discovery

ac9c15ea3b899cc279c721c1f45eaccc37cc9fb7

2018-01-04T02:43:53.000Z

2021-12-02T11:57:55.000Z

docs/wordiscovery.ipynb

KunFly/new-word-discovery

ac9c15ea3b899cc279c721c1f45eaccc37cc9fb7

2018-01-08T03:15:27.000Z

2020-07-24T05:48:41.000Z

docs/wordiscovery.ipynb

KunFly/new-word-discovery

ac9c15ea3b899cc279c721c1f45eaccc37cc9fb7

2018-01-04T02:43:53.000Z

2019-12-25T09:00:17.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__yue_Hant

This notebook is part of the `clifford` documentation: https://clifford.readthedocs.io/. # Application to Robotic Manipulators This notebook is intended to expand upon the ideas in part of the presentation [Robots, Ganja & Screw Theory](https://slides.com/hugohadfield/game2020) ## Serial manipulator [(slides)](https://slides.com/hugohadfield/game2020#/serial) Let's consider a 2-link 3 DOF arm. We'll model the links within the robot with rotors, which transform to the coordinate frame of the end of each link. This is very similar to the approach that would classically be taken with 4&times;4 matrices. We're going to define our class piecewise as we go along here. To aid that, we'll write a simple base class to let us do just that. In your own code, there's no need to do this. ```python class AddMethodsAsWeGo: @classmethod def _add_method(cls, m): if isinstance(m, property): name = (m.fget or m.fset).__name__ else: name = m.__name__ setattr(cls, name, m) ``` Let's start by defining some names for the links, and a place to store our parameters: ```python from enum import Enum class Links(Enum): BASE = 'b' SHOULDER = 's' UPPER = 'u' ELBOW = 'e' FOREARM = 'f' ENDPOINT = 'n' class SerialRobot(AddMethodsAsWeGo): def __init__(self, rho, l): self.l = l self.rho = rho self._thetas = (0, 0, 0) @property def thetas(self): return self._thetas ``` ### Forward kinematics [(slides)](https://slides.com/hugohadfield/game2020#/serial-forward-rotors) As a reminder, we can construct rotation and translation motors as: $$ \begin{align} T(a) &= \exp \left(\frac{1}{2} n_{\infty} \wedge a \right) \\ &= 1 + \frac{1}{2}n_{\infty} \wedge a \\ R(\theta, \hat B) &= \exp (\frac{1}{2} \theta \hat B) \\ &= \cos \frac{\theta}{2} + \sin \frac{\theta}{2} \hat B \end{align} $$ Applying these to our geometry, we get $$ \begin{align} R_{\text{base} \gets \text{shoulder}} &= R(\theta_0, e_1 \wedge e_3) \\ R_{\text{shoulder} \gets \text{upper arm}} &= R(\theta_1, e_1 \wedge e_2) \\ R_{\text{upper arm} \gets \text{elbow}} &= T(\rho e_1) \\ R_{\text{elbow} \gets \text{forearm}} &= R(\theta_2, e_1 \wedge e_2) \\ R_{\text{forearm} \gets \text{endpoint}} &= T(-l e_1)\\ \end{align} $$ From which we can get the overall rotor to the frame of the endpoint, and the positions $X$ and $Y$: $$ \begin{align} R_{\text{base} \gets \text{elbow}} &= R_{\text{base} \gets \text{shoulder}} R_{\text{shoulder} \gets \text{upper arm}} R_{\text{upper arm} \gets \text{elbow}} \\ X &= R_{\text{base} \gets \text{elbow}} n_0 \tilde R_{\text{base} \gets \text{elbow}} \\ R_{\text{base} \gets \text{endpoint}} &= R_{\text{base} \gets \text{shoulder}} R_{\text{shoulder} \gets \text{upper arm}} R_{\text{upper arm} \gets \text{elbow}} R_{\text{elbow} \gets \text{forearm}} R_{\text{forearm} \gets \text{endpoint}} \\ Y &= R_{\text{base} \gets \text{endpoint}} n_0 \tilde R_{\text{base} \gets \text{endpoint}} \\ \end{align} $$ We can write this as: ```python from clifford.g3c import * from clifford.tools.g3c import generate_translation_rotor, apply_rotor from clifford.tools.g3 import generate_rotation_rotor def _update_chain(rotors, a, b, c): rotors[a, c] = rotors[a, b] * rotors[b, c] @SerialRobot._add_method @SerialRobot.thetas.setter def thetas(self, value): theta0, theta1, theta2 = self._thetas = value # shorthands for brevity R = generate_rotation_rotor T = generate_translation_rotor rotors = {} rotors[Links.BASE, Links.SHOULDER] = R(theta0, e1, e3) rotors[Links.SHOULDER, Links.UPPER] = R(theta1, e1, e2) rotors[Links.UPPER, Links.ELBOW] = T(self.rho * e1) rotors[Links.ELBOW, Links.FOREARM] = R(theta2, e1, e2) rotors[Links.FOREARM, Links.ENDPOINT] = T(-self.l * e1) _update_chain(rotors, Links.BASE, Links.SHOULDER, Links.UPPER) _update_chain(rotors, Links.BASE, Links.UPPER, Links.ELBOW) _update_chain(rotors, Links.BASE, Links.ELBOW, Links.FOREARM) _update_chain(rotors, Links.BASE, Links.FOREARM, Links.ENDPOINT) self.rotors = rotors @SerialRobot._add_method @property def y_pos(self): return apply_rotor(eo, self.rotors[Links.BASE, Links.ENDPOINT]) @SerialRobot._add_method @property def x_pos(self): return apply_rotor(eo, self.rotors[Links.BASE, Links.ELBOW]) ``` Let's write a renderer so we can check this all works ```python from pyganja import GanjaScene def add_rotor(sc: GanjaScene, r, *, label=None, color=None, scale=0.1): """ show how a rotor transforms the axes at the origin """ y = apply_rotor(eo, r) y_frame = [ apply_rotor(d, r) for d in [up(scale*e1), up(scale*e2), up(scale*e3)] ] sc.add_object(y, label=label, color=color) sc.add_facet([y, y_frame[0]], color=(255, 0, 0)) sc.add_facet([y, y_frame[1]], color=(0, 255, 0)) sc.add_facet([y, y_frame[2]], color=(0, 0, 255)) @SerialRobot._add_method def to_scene(self): sc = GanjaScene() axis_scale = 0.1 link_scale = 0.05 arm_color = (192, 192, 192) base_obj = (up(0.2*e1)^up(0.2*e3)^up(-0.2*e1)).normal() sc.add_object(base_obj, color=0) shoulder_axis = [ apply_rotor(p, self.rotors[Links.BASE, Links.UPPER]) for p in [up(axis_scale*e3), up(-axis_scale*e3)] ] sc.add_facet(shoulder_axis, color=(0, 0, 128)) shoulder_angle = [ apply_rotor(eo, self.rotors[Links.BASE, Links.SHOULDER]), apply_rotor(up(axis_scale*e1), self.rotors[Links.BASE, Links.SHOULDER]), apply_rotor(up(axis_scale*e1), self.rotors[Links.BASE, Links.UPPER]), ] sc.add_facet(shoulder_angle, color=(0, 0, 128)) upper_arm_points = [ apply_rotor(up(link_scale*e3), self.rotors[Links.BASE, Links.UPPER]), apply_rotor(up(-link_scale*e3), self.rotors[Links.BASE, Links.UPPER]), apply_rotor(up(link_scale*e3), self.rotors[Links.BASE, Links.ELBOW]), apply_rotor(up(-link_scale*e3), self.rotors[Links.BASE, Links.ELBOW]) ] sc.add_facet(upper_arm_points[:3], color=arm_color) sc.add_facet(upper_arm_points[1:], color=arm_color) elbow_axis = [ apply_rotor(p, self.rotors[Links.BASE, Links.ELBOW]) for p in [up(axis_scale*e3), up(-axis_scale*e3)] ] sc.add_facet(elbow_axis, color=(0, 0, 128)) forearm_points = [ apply_rotor(up(link_scale*e3), self.rotors[Links.BASE, Links.FOREARM]), apply_rotor(up(-link_scale*e3), self.rotors[Links.BASE, Links.FOREARM]), apply_rotor(up(link_scale*e3), self.rotors[Links.BASE, Links.ENDPOINT]), apply_rotor(up(-link_scale*e3), self.rotors[Links.BASE, Links.ENDPOINT]) ] sc.add_facet(forearm_points[:3], color=arm_color) sc.add_facet(forearm_points[1:], color=arm_color) add_rotor(sc, self.rotors[Links.BASE, Links.ELBOW], label='x', color=(128, 128, 128)) add_rotor(sc, self.rotors[Links.BASE, Links.ENDPOINT], label='y', color=(128, 128, 128)) return sc ``` We can now instantiate our robot ```python serial_robot = SerialRobot(rho=1, l=0.5) ``` Choose a trajectory ```python import math theta_traj = [ (math.pi/6 + i*math.pi/12, math.pi/3 - math.pi/12*i, 3*math.pi/4) for i in range(3) ] ``` And plot the robot in each state, using `ipywidgets` ([docs](https://ipywidgets.readthedocs.io/)) to let us plot ganja side-by-side. Unfortunately, `pyganja` provides no mechanism to animate these plots from python. <div class="alert alert-info"> This will not render side-by-side in the online clifford documentation, but will in a local notebook. </div> ```python import ipywidgets from IPython.display import Latex, display from pyganja import draw outputs = [ ipywidgets.Output(layout=ipywidgets.Layout(flex='1')) for i in range(len(theta_traj)) ] for output, thetas in zip(outputs, theta_traj): with output: # interesting part here - run the forward kinematics, print the angles we used serial_robot.thetas = thetas display(Latex(r"$\theta_i = {:.2f}, {:.2f}, {:.2f}$".format(*thetas))) draw(serial_robot.to_scene(), scale=1.5) ipywidgets.HBox(outputs) ``` ### Inverse kinematics [(slides)](https://slides.com/hugohadfield/game2020#/serial-reverse) For the forward kinematics, we didn't actually need conformal geometric algebra at all&mdash;PGA would have done just fine, as all we needed were rotations and translations. The inverse kinematics of a serial manipulator is where CGA provide some nice tricks. There are three facts we know about the position $X$, each of which describes a constraint surface * $X$ must lie on a sphere with radius $l$ centered at $Y$, which can be written $$S^* = Y - \frac{1}{2}l^2n_\infty$$ * $X$ must lie on a sphere with radius $\rho$ centered at $n_o$, which can be written $$S_\text{base}^* = n_0 - \frac{1}{2}\rho^2n_\infty$$ * $X$ must lie on a plane through $n_o$, $e_3$, and $Y$, which can be written $$\Pi = n_0\wedge \operatorname{up}(e_3)\wedge Y\wedge n_\infty$$ Note that $\Pi = 0$ is possible iff $Y = \operatorname{up}(ke_3)$. For $X$ to satisfy all three constraints. we have \begin{align} S \wedge X = S_\text{base} \wedge X = \Pi \wedge X &= 0 \\ X \wedge (\underbrace{S \vee S_\text{base} \vee \Pi}_P) &= 0 \quad\text{If $\Pi \ne 0$} \\ X \wedge (\underbrace{S \vee S_\text{base}}_C) &= 0 \quad\text{otherwise} \\ \end{align} By looking at the grade of the term labelled $P$, we conclude it must be a point-pair&mdash;which tells us $X$ must lie in one of two locations. Similarly, $C$ must be a circle. ```python @SerialRobot._add_method def _get_x_constraints_for(self, Y): """ Get the space containing all possible elbow positions """ # strictly should be undual, but we don't have that in clifford S = (Y - 0.5*self.l**2*einf).dual() S_base = (eo - 0.5*self.rho**2*einf).dual() Pi = eo ^ up(e2) ^ Y ^ einf return S, S_base, Pi @SerialRobot._add_method def _get_x_positions_for(self, Y): """ Get the space containing all possible elbow positions """ S, S_base, Pi = self._get_x_constraints_for(Y) if Pi == 0: # any solution on the circle is OK return S & S_base else: # there are just two solutions return S & S_base & Pi ``` From the pointpair $P$ we can extract the two possible $X$ locations with: $$ X = \left[1 \pm \frac{P}{\sqrt{P\tilde{P}}}\right](P\cdot n_\infty) $$ To be considered a full solution to the inverse kinematics problem, we need to produce the angles $\theta_0, \theta_1, \theta_2$. We can do this as follows ```python @SerialRobot._add_method @SerialRobot.y_pos.setter def y_pos(self, Y): R = generate_rotation_rotor T = generate_translation_rotor rotors = {} rotors[Links.UPPER, Links.ELBOW] = T(self.rho * e1) rotors[Links.FOREARM, Links.ENDPOINT] = T(-self.l * e1) x_options = self._get_x_positions_for(Y) if x_options.grades == {3}: # no need to adjust the base angle theta_0 = self.thetas[0] rotors[Links.BASE, Links.SHOULDER] = self.rotors[Links.BASE, Links.SHOULDER] # remove the rotation from x, intersect it with the plane of the links x_options = x_options & (eo ^ up(e3) ^ up(e1) ^ einf) else: y_down = down(Y) theta0 = math.atan2(y_down[(3,)], y_down[(1,)]) rotors[Links.BASE, Links.SHOULDER] = R(theta0, e1, e3) # remove the first rotor from x x_options = apply_rotor(x_options, ~rotors[Links.BASE, Links.SHOULDER]) # project out one end of the point-pair x = (1 - x_options.normal()) * (x_options | einf) x_down = down(x) theta1 = math.atan2(x_down[(2,)], x_down[(1,)]) rotors[Links.SHOULDER, Links.UPPER] = R(theta1, e1, e2) _update_chain(rotors, Links.BASE, Links.SHOULDER, Links.UPPER) _update_chain(rotors, Links.BASE, Links.UPPER, Links.ELBOW) # remove the second rotor Y = apply_rotor(Y, ~rotors[Links.BASE, Links.ELBOW]) y_down = down(Y) theta2 = math.atan2(-y_down[(2,)], -y_down[(1,)]) rotors[Links.ELBOW, Links.FOREARM] = R(theta2, e1, e2) _update_chain(rotors, Links.BASE, Links.ELBOW, Links.FOREARM) _update_chain(rotors, Links.BASE, Links.FOREARM, Links.ENDPOINT) self._thetas = (theta0, theta1, theta2) self.rotors = rotors ``` Define a trajectory again, this time with a scene to render it: ```python y_traj = [ up(0.3*e3 + 0.8*e2 - 0.25*e1), up(0.6*e3 + 0.8*e2), up(0.9*e3 + 0.8*e2 + 0.25*e1) ] expected_scene = GanjaScene() expected_scene.add_facet(y_traj[0:2], color=(255, 128, 128)) expected_scene.add_facet(y_traj[1:3], color=(255, 128, 128)) ``` And we can run the inverse kinematics by setting `serial_robot.y_pos`: ```python outputs = [ ipywidgets.Output(layout=ipywidgets.Layout(flex='1')) for i in range(len(y_traj)) ] first = True for output, y in zip(outputs, y_traj): with output: # interesting part here - run the reverse kinematics, print the angles we used serial_robot.y_pos = y display(Latex(r"$\theta_i = {:.2f}, {:.2f}, {:.2f}$".format(*serial_robot.thetas))) sc = serial_robot.to_scene() # Show the spheres we used to construct the solution sc += expected_scene if first: extra_scene = GanjaScene() S, S_base, Pi = serial_robot._get_x_constraints_for(y) extra_scene.add_object(S_base, label='S_base', color=(255, 255, 128)) extra_scene.add_object(S, label='S', color=(255, 128, 128)) extra_scene.add_object(Pi, label='Pi', color=(128, 255, 192, 128)) sc += extra_scene draw(sc, scale=1.5) first = False ipywidgets.HBox(outputs) ``` ## Parallel manipulators For now, refer to the presentation [(slides)](https://slides.com/hugohadfield/game2020#/parallel) ### Inverse kinematics [(slides)](https://slides.com/hugohadfield/game2020#/agile-3dof-inverse) For now, refer to the presentation ### Forward kinematics [(slides)](https://slides.com/hugohadfield/game2020#/agile-2dof-forward) For now, refer to the presentation

972efbcd990bfccd5465fbb65f31e4556a341b6f

ipynb

Jupyter Notebook

docs/tutorials/cga/robotic-manipulators.ipynb

hugohadfield/clifford

3e15da3ba429c69a5a5a641f2103d7bcca42617d

2017-11-17T09:49:48.000Z

2022-03-21T22:02:25.000Z

docs/tutorials/cga/robotic-manipulators.ipynb

hugohadfield/clifford

3e15da3ba429c69a5a5a641f2103d7bcca42617d

2017-11-17T13:57:43.000Z

2022-01-20T09:40:15.000Z

docs/tutorials/cga/robotic-manipulators.ipynb

hugohadfield/clifford

3e15da3ba429c69a5a5a641f2103d7bcca42617d

2017-11-19T17:15:26.000Z

2022-01-15T05:18:27.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Modular Strided Intervals Fix $N \in \{1, \ldots, 2^{23} - 1\}$. The LLVM type $\texttt{i}N$ represents $N$-bit tuples: $\texttt{i}N := \{0, 1\}^N$ These tuples can be interpreted as elements of $\mathbb{Z}/{2^N}$ using the isomorphism $\phi_N$ together with an appropriate map of operations: $\phi_N \colon \texttt{i}N \rightarrow \mathbb{Z}/{2^N}, (b_0, \ldots, b_{N-1}) \mapsto \left(\sum_{k=0}^{N-1}b_k^k\right) + 2^N \mathbb{Z}$ An abstraction of $\mathbb{Z}$ and thefore also of $\texttt{i}N$ can be obtained by a generalization of intervals over $\mathbb{Z}$, represeted by the type $\mathrm{MSI}_N$ of _modular strided intervals (MSI)_: $\mathrm{MSI}_N := \{s[a, b]_N \mid a, b, s \in \mathbb{Z}/2^N\}$ The sematics of an MSI is given by the concetization function $\gamma_N$: $\gamma_N \colon \mathrm{MSI}_N \rightarrow \mathcal{P}(\mathbb{Z}/{2^N}), s[a, b]_N \mapsto \{k + 2^N \mathbb{Z} \mid k \in \mathbb{Z}, a \leq k, k \leq \min \{l \in \mathbb{Z} \mid a \leq k, l \equiv b \mod 2^N\}, k \equiv a \mod s\}$ ```python from itertools import count, takewhile from random import randint from sympy import gcd, lcm ``` ```python class MSI(object): """ Modular strided iterval """ def __init__(self, bit_width, begin, end, stride=1): self.bit_width = bit_width self.begin = begin self.end = end self.stride = stride def __eq__(self, other): return (self.bit_width == other.bit_width and self.stride == other.stride and self.begin == other.begin and self.end == other.end) def __repr__(self): return f'{self.stride}[{self.begin}, {self.end}]_{{{self.bit_width}}}' def __hash__(self): return (self.begin+23) * (self.end+29) * (self.stride+31) % 16777216 def _tuple_repr(self): return (self.bit_width, self.begin, self.end, self.stride) ``` ## Defining Functions and Predicates ```python # This predicate has not tests, it's an axiom. def valid(i): n, a, b, s = i._tuple_repr() if n <= 0: return False if a < 0 or 2**n <= a: return False if b < 0 or 2**n <= b: return False if s < 0 or 2**n <= s: return False return True ``` ```python def gamma(i): n = i.bit_width s = i.stride a = i.begin b = i.end if a <= i.end else i.end + 2**n return {k % 2**n for k in takewhile( lambda k: k <= b, (a+l*s for l in count()) if s > 0 else [a] )} ``` $\gamma_N$ is not injective, therefore normalization of MSIs is needed s.t. $\gamma_N$ restricted to $\{i \in \mathrm{MSI}_N \mid \mathrm{normal}(i)\}$ is injective. All other operatins on MSIs assume that there operands are normal and are expected to return a normal MSI. Expanation of $\textrm{normal}$: Fix $s[a, b]_N \in \textrm{MSI}_N$. Case 1: Assume $s = 0$. ```python def normal(i): n, a, b, s = i._tuple_repr() if s == 0 and a != b: return False if a == b and s != 0: return False if not b in gamma(i): return False a_ = a - s if a_ != a and a_ >= 0 and gamma(i) == gamma(MSI(n, a_, (b-s) % 2**n, s)): return False if b < a and gamma(i) == gamma(MSI(n, b, a, 2**n - s)): return False return True ``` ## Test sets of MSIs with theire respective concretizations ```python test_MSIs_handpicked_gamma = [ # normalized # no wraparound # strid = 0 # begin = 0 (MSI(4, 0, 0, 0), {0}), # begin > 0 (MSI(4, 3, 3, 0), {3}), # strid = 1 # begin = 0 # end < 2**N-1 (MSI(4, 0, 2, 1), {0, 1, 2}), # end = 2**N-1 (MSI(3, 0, 7, 1), {0, 1, 2, 3, 4, 5, 6, 7}), # begin > 0 (MSI(4, 3, 4, 1), {3, 4}), # stride > 1 # begin = 0 (MSI(4, 0, 4, 2), {0, 2, 4}), # begin > 0 (MSI(3, 1, 7, 3), {1, 4, 7}), (MSI(6, 6, 26, 10), {6, 16, 26}), # wraparound # stride = 1 (MSI(4, 14, 2, 1), {14, 15, 0, 1, 2}), # stride > 1 (MSI(4, 11, 4, 3), {1, 4, 11, 14})] test_MSIs_handpicked_gamma_unnormalized = [ # unnormalized # no wraparound # stride = 0 # begin = 0 (MSI(4, 0, 3, 0), {0}), # begin > 0 (MSI(4, 3, 8, 0), {3}), # stride = 1 # begin = 0 # end = begin (MSI(4, 0, 0, 1), {0}), # end != begin (MSI(2, 2, 1, 1), {0, 1, 2, 3}), # begin > 0 # end = begin (MSI(4, 3, 3, 1), {3}), # end != begin (MSI(3, 5, 4, 1), {0, 1, 2, 3, 4, 5, 6, 7}), # stride > 1 # begin = 0 (MSI(4, 0, 5, 2), {0, 2, 4}), (MSI(4, 0, 3, 5), {0}), # begin > 0 # end = begin - stride mod 2**N (MSI(4, 11, 7, 4), {3, 7, 11, 15}), # end != begin - stride mod 2**N (MSI(6, 6, 35, 10), {6, 16, 26}), (MSI(4, 3, 7, 5), {3}), # wraparound # stride = 0 (MSI(4, 5, 3, 0), {5}), # stride = 1 (MSI(3, 5, 4, 1), {0, 1, 2, 3, 4, 5, 6, 7}), (MSI(4, 15, 0, 1), {15, 0}), # stride > 1 # end = begin - stride mod 2**N (MSI(4, 10, 6, 4), {2, 6, 10, 14}), (MSI(4, 12, 2, 6), {2, 12}), # end != begin and != begin - stride mod 2**N (MSI(4, 13, 2, 8), {13}), (MSI(4, 11, 6, 3), {11, 14, 1, 4}), (MSI(4, 10, 9, 4), {2, 6, 10, 14}), (MSI(4, 12, 7, 6), {2, 12}) ] ``` ```python test_MSIs_handpicked = {} for i, _ in test_MSIs_handpicked_gamma: n = i.bit_width if n not in test_MSIs_handpicked: test_MSIs_handpicked[n] = [i] else: test_MSIs_handpicked[n].append(i) print('size: ' + ', '.join(f'{n}: {len(js)}' for n, js in test_MSIs_handpicked.items())) test_MSIs_handpicked_unnormalized = {} for i, _ in test_MSIs_handpicked_gamma_unnormalized: n = i.bit_width if n not in test_MSIs_handpicked_unnormalized: test_MSIs_handpicked_unnormalized[n] = [i] else: test_MSIs_handpicked_unnormalized[n].append(i) print('size: ' + ', '.join(f'{n}: {len(js)}' for n, js in test_MSIs_handpicked_unnormalized.items())) ``` size: 4: 7, 3: 2, 6: 1 size: 4: 16, 2: 1, 3: 2, 6: 1 ## Tests for gamma ```python def test_gamma(): failed = False for i, ks in test_MSIs_handpicked_gamma: if not gamma(i) == ks: failed = True print(f'{i}: {gamma(i)}, {ks}') if not failed: print('succeeded') def test_gamma_unnormalized(): failed = False for i, ks in test_MSIs_handpicked_gamma_unnormalized: if not gamma(i) == ks: failed = True print(f'{i}: {gamma(i)}, {ks}') if not failed: print('succeeded') ``` ```python test_gamma() test_gamma_unnormalized() ``` succeeded succeeded ## Normalization function ```python def normalize(i): n, a, b, s = i._tuple_repr() if s == 0: b = a else: b_ = b if a <= b else b+2**n b = (b_ - (b_-a) % s) % 2**n if a == b: s = 0 else: if 2**n % s == 0 and (a-b) % 2**n == s: a = a % s b = (a-s) % 2**n elif b == (a+s) % 2**n and b < a: a, b = b, a s = b-a return MSI(n, a, b, s) ``` ## Test sets and utility functions for testing Warning: `normal` is used in `unary_function_test` if the `unnormalized` parameter is `True`, but tested later. Therefore this parameter should not be set before `normal` is tested. ```python def test_set(bit_widths, begins, ends, strides, only_normal=True, print_stats=False): MSIs = {} for n in bit_widths: js = set() bs = begins(n) for b in bs: es = ends(n) for e in es: ss = strides(n) for s in ss: if only_normal: js.add(normalize(MSI(n, b, e, s))) else: js.add(MSI(n, b, e, s)) MSIs[n] = list(js) if print_stats: print('size: ' + ', '.join(f'{n}: {len(js)}' for n, js in MSIs.items())) if not only_normal: print('unnormalized: ' + ', '.join(f'{n}: {len(list(0 for j in js if not normal(j)))}' for n, js in MSIs.items())) return MSIs ``` ```python f = lambda n: list(range(2**n)) g = lambda n: list(range(2**n)) print('test_MSIs_4_exhaustive') test_MSIs_4_exhaustive = test_set(range(1, 4+1), f, g, f, print_stats=True) print('test_MSIs_4_exhaustive') test_MSIs_4_exhaustive_unnormalized = test_set(range(1, 4+1), f, g, f, only_normal=False, print_stats=True) ``` test_MSIs_4_exhaustive size: 1: 3, 2: 15, 3: 95, 4: 575 test_MSIs_4_exhaustive size: 1: 8, 2: 64, 3: 512, 4: 4096 unnormalized: 1: 5, 2: 49, 3: 417, 4: 3521 ```python f = lambda n: list(range(2**n)) g = lambda n: list(range(2**n)) print('test_MSIs_5_6_exhaustive') test_MSIs_5_6_exhaustive = test_set(range(5, 6+1), f, g, f, print_stats=True) print('test_MSIs_5_6_exhaustive') test_MSIs_5_6_exhaustive_unnormalized = test_set(range(5, 6+1), f, g, f, only_normal=False, print_stats=True) ``` test_MSIs_5_6_exhaustive size: 5: 3039, 6: 15231 test_MSIs_5_6_exhaustive size: 5: 32768, 6: 262144 unnormalized: 5: 29729, 6: 246913 ```python test_MSIs_6_exhaustive = { **test_MSIs_4_exhaustive, **test_MSIs_5_6_exhaustive } test_MSIs_6_exhaustive_unnormalized = { **test_MSIs_4_exhaustive_unnormalized, **test_MSIs_5_6_exhaustive_unnormalized } ``` ```python ks = [a+b for a in [0, 30] for b in [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 15]] ls = [30, 31, 32, 33, 35, 36, 40, 45] f = lambda _: ks print('test_MSIs_6_partial') test_MSIs_6_partial = test_set([6], f, g, f, print_stats=True) print('\ntest_MSIs_6_partial_unnormalized') test_MSIs_6_partial_unnormalized = test_set([6], f, f, f, only_normal=False, print_stats=True) ``` test_MSIs_6_partial size: 6: 4111 test_MSIs_6_partial_unnormalized size: 6: 10648 unnormalized: 6: 9309 ```python ks = [a+b for a in [0, 30, 60] for b in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 25]] ls = [0, 2, 3, 5, 6, 10, 15] f = lambda n: takewhile(lambda k: k < 2**n, ks) g = lambda n: (((15 if 2**n < 30 else 45) + 15 + a) % 2**n for a in ls) print('test_MSIs_8_partial') test_MSIs_8_partial = test_set([8], f, g, f, print_stats=True) print('\ntest_MSIs_8_partial_unnormalized') test_MSIs_8_partial_unnormalized = test_set([8], f, g, f, only_normal=False, print_stats=True) ``` test_MSIs_8_partial size: 8: 2438 test_MSIs_8_partial_unnormalized size: 8: 10647 unnormalized: 8: 9705 ```python f = lambda n: set(randint(0, 2**n-1) for _ in range(8)) g = lambda n: set(randint(0, 2**(n-1)-1) for _ in range(8)) print('test_MSIs_random') test_MSIs_random = test_set(range(5, 8+1), f, f, g, print_stats=True) print('\ntest_MSIs_random_unnormalized') test_MSIs_random_unnormalized = test_set(range(5, 8+1), f, f, g, only_normal=False, print_stats=True) ``` test_MSIs_random size: 5: 181, 6: 288, 7: 339, 8: 316 test_MSIs_random_unnormalized size: 5: 253, 6: 412, 7: 462, 8: 487 unnormalized: 5: 218, 6: 366, 7: 432, 8: 468 ```python def _unary_function_test(f, p, test_MSIs, test_count=0, fail_count=0, fail_lim=8): for n, js in test_MSIs.items(): print(f' testing bit width: {n}') for i in js: test_count += 1 x = f(i) if not p(n, i, x): fail_count += 1 print(f' {i}: {x}') if fail_count == fail_lim: return test_count, fail_count if test_count % 25000 == 0: print(f'- tested {test_count} arguments') return test_count, fail_count def unary_function_test(f, p, big=False, unnormalized=False): fail_lim = 16 if big else 8 test_count = fail_count = 0 print('testing MSIs with bit width up to 4 exhaustively') MSIs = test_MSIs_4_exhaustive_unnormalized if unnormalized else test_MSIs_4_exhaustive test_count, fail_count = _unary_function_test(f, p, MSIs, test_count, fail_count, fail_lim) if fail_count == fail_lim: return print('testing random MSIs with bit width from 5 to 8') MSIs = test_MSIs_random_unnormalized if unnormalized else test_MSIs_random test_count, fail_count = _unary_function_test(f, p, MSIs, test_count, fail_count, fail_lim) if fail_count == fail_lim: return if big: print('testing some MSIs with bit width 6') MSIs = test_MSIs_6_partial_unnormalized if unnormalized else test_MSIs_6_partial test_count, fail_count = _unary_function_test(f, p, MSIs, test_count, fail_count, fail_lim) if fail_count == fail_lim: return print('testing some MSIs with bit width 8') MSIs = test_MSIs_8_partial_unnormalized if unnormalized else test_MSIs_8_partial test_count, fail_count = _unary_function_test(f, p, MSIs, test_count, fail_count, fail_lim) if fail_count == fail_lim: return if fail_count == 0: print(f'succeeded (tested {test_count} arguments in total)') ``` ```python def _bin_fun_test(f, p, test_MSIs, test_count=0, fail_count=0, fail_lim=8): for n, js in test_MSIs.items(): print(f' testing bit width: {n}') for i in js: for j in js: test_count += 1 x = f(i, j) if not p(n, i, j, x): fail_count += 1 print(f' f {i} {j}: {x}') if fail_count == fail_lim: return test_count, fail_count if test_count % 25000 == 0: print(f'- tested {test_count} arguments') return test_count, fail_count def bin_fun_test(f, p, big=False, non_zero=False): fail_lim = 16 if big else 8 test_count = fail_count = 0 print('testing MSIs with bit width up to 4 exhaustively') test_count, fail_count = _bin_fun_test(f, p, test_MSIs_4_exhaustive, test_count, fail_count, fail_lim) if fail_count == fail_lim: return print('testing random MSIs with bit width from 5 to 8') test_count, fail_count = _bin_fun_test(f, p, test_MSIs_random, test_count, fail_count, fail_lim) if fail_count == fail_lim: return if big: print('testing some MSIs with bit width 6') test_count, fail_count = _bin_fun_test(f, p, test_MSIs_6_partial, test_count, fail_count, fail_lim) if fail_count == fail_lim: return print('testing some MSIs with bit width 8') test_count, fail_count = _bin_fun_test(f, p, test_MSIs_8_partial, test_count, fail_count, fail_lim) if fail_count == fail_lim: return if fail_count == 0: print(f'succeeded (tested {test_count} arguments in total)') ``` ```python def _bin_op_test(op_MSI, op, test_MSIs, test_count=0, fail_count=0, fail_lim=8, bad_args={}, bad_lim=8, non_zero=False): bad_precision = max(bad_args.values()) if len(bad_args) > 0 else 1 for n, js in test_MSIs.items(): print(f' testing bit width: {n}') for i in js: vals_i = gamma(i) for j in js: test_count += 1 vals_j = gamma(j) if non_zero and 0 in vals_j: vals_op = {op(n, k, l) for k in vals_i for l in vals_j if not l == 0} else: vals_op = {op(n, k, l) for k in vals_i for l in vals_j} vals_op_MSI = gamma(op_MSI(i, j)) if not vals_op <= vals_op_MSI: fail_count += 1 print(f' {i} op {j}: {op_MSI(i, j)}, {vals_op}, {vals_i}, {vals_j}') if fail_count == fail_lim: return test_count, fail_count, bad_args elif not len(vals_op) == 0: precision = len(vals_op) / (len(vals_op_MSI) * 2**n) if precision < bad_precision: if len(bad_args) == bad_lim: bad_args.pop(list(bad_args.keys())[list(bad_args.values()).index(bad_precision)]) bad_args[(i, j)] = precision bad_precision = max(bad_args.values()) if test_count % 25000 == 0: print(f'- tested {test_count} arguments') return test_count, fail_count, bad_args def bin_op_test(op_MSI, op, big=False, non_zero=False): fail_lim = bad_lim = 16 if big else 8 test_count = fail_count = 0 bad_args = {} print('testing MSIs with bit width up to 4 exhaustively') test_count, fail_count, bad_args = _bin_op_test(op_MSI, op, test_MSIs_4_exhaustive, test_count, fail_count, fail_lim, bad_args, bad_lim, non_zero=non_zero) if fail_count == fail_lim: return print('testing random MSIs with bit width from 5 to 8') test_count, fail_count, bad_args = _bin_op_test(op_MSI, op, test_MSIs_random, test_count, fail_count, fail_lim, bad_args, bad_lim, non_zero=non_zero) if fail_count == fail_lim: return if big: print('testing some MSIs with bit width 6') test_count, fail_count, bad_args = _bin_op_test(op_MSI, op, test_MSIs_6_partial, test_count, fail_count, fail_lim, bad_args, bad_lim, non_zero=non_zero) if fail_count == fail_lim: return print('testing some MSIs with bit width 8') test_count, fail_count, bad_args = _bin_op_test(op_MSI, op, test_MSIs_8_partial, test_count, fail_count, fail_lim, bad_args, bad_lim, non_zero=non_zero) if fail_count == fail_lim: return if fail_count == 0: print(f'succeeded (tested {test_count} arguments in total)') print('arguments with least precise results:') for (i, j), r in bad_args.items(): print(f'{i}, {j}: {r}') ``` ```python def _bin_rel_test(rel_MSI, rel, test_MSIs, test_count=0, fail_count=0, fail_lim=8): for n, js in test_MSIs.items(): print(f' testing bit width: {n}') for i in js: for j in js: test_count += 1 if not (rel_MSI(i, j) == rel(i, j)): fail_count += 1 print(f' {i} rel {j}: {rel_MSI(i, j)}') if fail_count == fail_lim: return test_count, fail_count if test_count % 25000 == 0: print(f'- tested {test_count} arguments') return test_count, fail_count def bin_rel_test(rel_MSI, rel, big=False): fail_lim = 16 if big else 8 test_count = fail_count = 0 print('testing MSIs with bit width up to 4 exhaustively') test_count, fail_count = _bin_rel_test(rel_MSI, rel, test_MSIs_4_exhaustive, test_count, fail_count, fail_lim) if fail_count == fail_lim: return print('testing random MSIs with bit width from 5 to 8') test_count, fail_count = _bin_rel_test(rel_MSI, rel, test_MSIs_random, test_count, fail_count, fail_lim) if fail_count == fail_lim: return if big: print('testing some MSIs with bit width 6') test_count, fail_count = _bin_rel_test(rel_MSI, rel, test_MSIs_6_partial, test_count, fail_count, fail_lim) if fail_count == fail_lim: return print('testing some MSIs with bit width 8') test_count, fail_count = _bin_rel_test(rel_MSI, rel, test_MSIs_8_partial, test_count, fail_count, fail_lim) if fail_count == fail_lim: return if fail_count == 0: print(f'succeeded (tested {test_count} arguments in total)') ``` ## Test for normal ```python def test_normal(): failed = False test_count = fail_count = 0 for n, js in test_MSIs_6_exhaustive.items(): equiv_classes = {} for i in js: a = frozenset(gamma(i)) if a in equiv_classes: equiv_classes[a].add(i) else: equiv_classes[a] = {i} for equiv_class in equiv_classes.values(): norm_forms = list(filter(normal, equiv_class)) test_count += 1 if len(norm_forms) != 1: failed = True fail_count += 1 if len(norm_forms) == 0: print(f'no normal form for {equiv_class}') else: print(f'multiple normal forms {norm_forms}') if fail_count > 8: return print(f'succeeded (tested {test_count} equivalence classes in total)') ``` ```python test_normal() ``` succeeded (tested 18958 equivalence classes in total) ## Helper functions ```python def bounds(i): n, a, b, _ = i._tuple_repr() if a <= b: return a, b, False else: return a, b + 2**n, True ``` ```python def contains(i, k): n, a, b, s = i._tuple_repr() if s == 0: return a == k elif a <= b: return a <= k and k <= b and (k - a) % s == 0 else: if k >= a: return (k - a) % s == 0 elif k <= b: return (k - b) % s == 0 else: return False ``` ```python def test_contains(): failed = False test_count = fail_count = 0 for n, js in test_MSIs_6_exhaustive.items(): for i in js: test_count += 1 a = gamma(i) for k in range(2**n): if k in a and not contains(i, k): failed = True fail_count += 1 print(f'{k} in gamma({i})') if k not in a and contains(i, k): failed = True fail_count += 1 print(f'{k} not in gamma({i})') if fail_count > 8: return print(f'succeeded (tested {test_count} arguments)') ``` ```python test_contains() ``` succeeded (tested 18958 arguments) ```python def leq_MSI(i, j, debug=False): n, a, b, s = i._tuple_repr() m, c, d, t = j._tuple_repr() assert n == m, 'strides must be equal' if s == 0: # i contains exactly 1 value return contains(j, a) elif t == 0: # j contains exactly 1 value return False elif b == (a+s) % 2**n: # i contains exactly 2 values return contains(j, a) and contains(j, b) elif s % t == 0: if 2**n % t == 0 and (c-d) % 2**n == t: # j represents a residue class of Z/t (=> t | 2**n) return (a-c) % t == 0 else: b_ = (b-a) % 2**n c_, d_ = (c-a) % 2**n, (d-a) % 2**n if d_ < c_ and c_ <= b_: # this branch may not return, but continue below [a...d_...c_...b_...] e_ = s * (d_ // s) f_ = (b_ - s * ((b_-c_) // s)) % s**n if (f_-e_) == s: if e_ < s: if contains(j, a) and c_ % t == 0: return True elif contains(j, b) and d_ % t == 0: return True if c_ <= d_: return c_ == 0 and b_ <= d_ else: return b_ <= d_ and (d_-b_) % t == 0 else: return False ``` ```python bin_rel_test(leq_MSI, lambda i, j: gamma(i) <= gamma(j)) ``` testing MSIs with bit width up to 4 exhaustively testing bit width: 1 testing bit width: 2 testing bit width: 3 testing bit width: 4 - tested 25000 arguments - tested 50000 arguments - tested 75000 arguments - tested 100000 arguments - tested 125000 arguments - tested 150000 arguments - tested 175000 arguments - tested 200000 arguments - tested 225000 arguments - tested 250000 arguments - tested 275000 arguments - tested 300000 arguments - tested 325000 arguments testing random MSIs with bit width from 5 to 8 testing bit width: 5 - tested 350000 arguments testing bit width: 6 - tested 375000 arguments - tested 400000 arguments - tested 425000 arguments - tested 450000 arguments testing bit width: 7 - tested 475000 arguments - tested 500000 arguments - tested 525000 arguments - tested 550000 arguments testing bit width: 8 - tested 575000 arguments - tested 600000 arguments - tested 625000 arguments succeeded (tested 645567 arguments in total) ```python lhs = MSI(3, 2, 0, 3) rhs = MSI(3, 5, 3, 3) res = leq_MSI(lhs, rhs) print(f'{lhs} leq {rhs} = {res}') print(f'{gamma(lhs)} leq {gamma(rhs)} = {gamma(lhs) <= gamma(rhs)}') leq_MSI(lhs, rhs, debug=True) ``` 3[2, 0]_{3} leq 3[5, 3]_{3} = False {0, 2, 5} leq {0, 3, 5} = False False ```python def size(i): n, a, b, s = i._tuple_repr() if s == 0: return 1 else: return ((b-a) % 2**n) // s + 1 ``` ```python unary_function_test(size, lambda n, i, s: s == len(gamma(i)), big=True) ``` testing MSIs with bit width up to 4 exhaustively testing bit width: 1 testing bit width: 2 testing bit width: 3 testing bit width: 4 testing random MSIs with bit width from 5 to 8 testing bit width: 5 testing bit width: 6 testing bit width: 7 testing bit width: 8 testing some MSIs with bit width 6 testing bit width: 6 testing some MSIs with bit width 8 testing bit width: 8 succeeded (tested 8386 arguments in total) ```python def lub(i, j, debug=False): n, a, b, s = i._tuple_repr() m, c, d, t = j._tuple_repr() assert n == m, 'strides must be equal' if b == (a+s) % 2**n and s >= 2**(n-1): if debug: print('correction 1') a, b = b, a s = 2**n - s if d == (c+t) % 2**n and t >= 2**(n-1): if debug: print('correction 2') c, d = d, c t = 2**n - t b_ = (b-a) % 2**n c_, d_ = (c-a) % 2**n, (d-a) % 2**n if debug: print(f'a: {a}, b: {b}, c: {c}, d: {d}') print(f'b_: {b_}, c_: {c_}, d_: {d_}') if (b_ < c_ and c_ < d_): # no overlapping regions if debug: print(f'case 0: b_: {b_}, c_: {c_}, d_: {d_}') u1 = int(gcd(gcd(s, t), (c-b) % 2**n)) e1, f1 = a, d u2 = int(gcd(gcd(s, t), (a-d) % 2**n)) e2, f2 = c, b opt1 = normalize(MSI(n, e1, f1, u1)) opt2 = normalize(MSI(n, e2, f2, u2)) if debug: print(f'opt2: {opt2}, opt1: {opt1}') if (size(opt1) < size(opt2)): return opt1 else: return opt2 elif d_ < c_ and c_ <= b_: # two overlapping regions if debug: print(f'case 1: b_: {b_}, c_: {c_}, d_: {d_}') u = int(gcd(gcd(s, t), gcd(c_ if c_ <= d_ else d_, 2**(n-1)))) e = a % u f = (e - u) % 2**n return normalize(MSI(n, e, f, u)) else: # one overlapping region if debug: print(f'case 2: b_: {b_}, c_: {c_}, d_: {d_}') e = a if c_ <= d_ else c f = b if d_ < b_ else d u = int(gcd(gcd(s, t), (c_ if c_ <= d_ else d_))) return normalize(MSI(n, e, f, u)) ``` ```python lhs, rhs = MSI(2, 0, 1, 1), MSI(2, 3, 3, 0) print(f'{lhs}, {rhs}: {gamma(lhs)}, {gamma(rhs)}') res = lub(lhs, rhs, debug=True) print(f'{res}: {gamma(res)}') print() res = lub(rhs, lhs, debug=True) print(f'{res}: {gamma(res)}') ``` 1[0, 1]_{2}, 0[3, 3]_{2}: {0, 1}, {3} a: 0, b: 1, c: 3, d: 3 b_: 1, c_: 3, d_: 3 case 2: b_: 1, c_: 3, d_: 3 1[0, 3]_{2}: {0, 1, 2, 3} a: 3, b: 3, c: 0, d: 1 b_: 0, c_: 1, d_: 2 case 0: b_: 0, c_: 1, d_: 2 opt2: 1[0, 3]_{2}, opt1: 1[3, 1]_{2} 1[3, 1]_{2}: {0, 1, 3} ```python bin_fun_test(lub, lambda n, i, j, x: gamma(i) | gamma(j) <= gamma(x) and lub(i, j) == lub(j, i)) ``` testing MSIs with bit width up to 4 exhaustively testing bit width: 1 testing bit width: 2 f 1[0, 1]_{2} 0[3, 3]_{2}: 1[0, 3]_{2} f 3[0, 3]_{2} 0[2, 2]_{2}: 1[0, 3]_{2} f 0[0, 0]_{2} 1[1, 2]_{2}: 1[0, 2]_{2} f 1[1, 2]_{2} 0[0, 0]_{2}: 1[0, 3]_{2} f 1[2, 3]_{2} 0[1, 1]_{2}: 1[0, 3]_{2} f 0[3, 3]_{2} 1[0, 1]_{2}: 1[3, 1]_{2} f 0[1, 1]_{2} 1[2, 3]_{2}: 1[1, 3]_{2} f 0[2, 2]_{2} 3[0, 3]_{2}: 1[2, 0]_{2} ```python lhs, rhs = MSI(3, 2, 0, 3), MSI(3, 4, 2, 3) print(f'{lhs}, {rhs}: {gamma(lhs)}, {gamma(rhs)}') res = lub(lhs, rhs, debug=True) print(f'{res}: {gamma(res)}') ``` 3[2, 0]_{3}, 3[4, 2]_{3}: {0, 2, 5}, {2, 4, 7} a: 2, b: 0, c: 4, d: 2 b_: 6, c_: 2, d_: 0 case 1: b_: 6, c_: 2, d_: 0 1[0, 7]_{3}: {0, 1, 2, 3, 4, 5, 6, 7} ```python lub(MSI(6, 1, 37, 6), MSI(6, 31, 7, 6)) ``` 2[1, 63]_{6} ```python def as_signed_int(n, k): return k if k < 2**(n-1) else k - 2**n ``` ```python def umax_MSI(i): n, a, b, s = i._tuple_repr() if a <= b: return b else: return 2**n - 1 - ((2**n - 1 - a) % s) ``` ```python def umin_MSI(i): n, a, b, s = i._tuple_repr() if a <= b: return a else: return b % s ``` ```python def smax_MSI(i): n, a, b, s = i._tuple_repr() a, b = as_signed_int(n, a), as_signed_int(n, b) if a <= b: return b % 2**n else: return 2**(n-1) - 1 - ((2**(n-1) - 1 - a) % s) ``` ```python def smin_MSI(i): n, a, b, s = i._tuple_repr() a, b = as_signed_int(n, a), as_signed_int(n, b) if a <= b: return a % 2**n else: b = b % 2**n return (((b + 2**(n-1)) % 2**n % s) - 2**(n-1)) % 2**n ``` ```python smin_MSI(MSI(2, 0, 3, 3)) ``` 3 ```python def ustride(i): n, a, b, s = i._tuple_repr() if a <= b: return s else: return int(gcd(s, a-b)) ``` ```python def sstride(i): n, a, b, s = i._tuple_repr() if as_signed_int(n, a) <= as_signed_int(n, b): return s else: return int(gcd(s, as_signed_int(n, a)-as_signed_int(n, b))) ``` ```python def pos_min(i): m = umin_MSI(i) if m < 2**(n-1): return m else: return None ``` ```python def neg_max(i): m = umax_MSI(i) if m < 2**(n-1): return None else: return m ``` ```python def sabsmin(i): n, a, b, s = i._tuple_repr() a_, b_ = as_singed_int(a), as_singed_int(b) if s == 0: return a elif b_ < 0: return b elif 0 < a_: return a else: x = a % s y = x - s return x if x <= y else y ``` ```python def absmax(i): a, b = as_singed_int(i.begin), as_singed_int(i.end) b if abs(a) <= abs(b) else a ``` ```python unary_function_test(umax_MSI, lambda n, i, k: max(gamma(i)) == k, big=True) ``` testing MSIs with bit width up to 4 exhaustively testing bit width: 1 testing bit width: 2 testing bit width: 3 testing bit width: 4 testing random MSIs with bit width from 5 to 8 testing bit width: 5 testing bit width: 6 testing bit width: 7 testing bit width: 8 testing some MSIs with bit width 6 testing bit width: 6 testing some MSIs with bit width 8 testing bit width: 8 succeeded (tested 8386 arguments in total) ```python unary_function_test(umin_MSI, lambda n, i, k: min(gamma(i)) == k, big=True) ``` testing MSIs with bit width up to 4 exhaustively testing bit width: 1 testing bit width: 2 testing bit width: 3 testing bit width: 4 testing random MSIs with bit width from 5 to 8 testing bit width: 5 testing bit width: 6 testing bit width: 7 testing bit width: 8 testing some MSIs with bit width 6 testing bit width: 6 testing some MSIs with bit width 8 testing bit width: 8 succeeded (tested 8386 arguments in total) ```python unary_function_test(smax_MSI, lambda n, i, k: max(map(lambda k: as_signed_int(n, k), gamma(i))) % 2**n == k, big=True) ``` testing MSIs with bit width up to 4 exhaustively testing bit width: 1 testing bit width: 2 testing bit width: 3 testing bit width: 4 testing random MSIs with bit width from 5 to 8 testing bit width: 5 testing bit width: 6 testing bit width: 7 testing bit width: 8 testing some MSIs with bit width 6 testing bit width: 6 testing some MSIs with bit width 8 testing bit width: 8 succeeded (tested 8386 arguments in total) ```python unary_function_test(smin_MSI, lambda n, i, k: min(map(lambda k: as_signed_int(n, k), gamma(i))) % 2**n == k, big=True) ``` testing MSIs with bit width up to 4 exhaustively testing bit width: 1 testing bit width: 2 testing bit width: 3 testing bit width: 4 testing random MSIs with bit width from 5 to 8 testing bit width: 5 testing bit width: 6 testing bit width: 7 testing bit width: 8 testing some MSIs with bit width 6 testing bit width: 6 testing some MSIs with bit width 8 testing bit width: 8 succeeded (tested 8386 arguments in total) ```python def as_unsigned(i): n, a, b, s = i._tuple_repr() if a <= b: return MSI(n, a, b, s) else: t = int(gcd(s, (a-b) & 2**n)) c = a % t d = (c-t) % 2**n return MSI(n, c, d, t) ``` ## Implementation of Operations ```python def add(i, j): n, a, b, s = i._tuple_repr() m, c, d, t = j._tuple_repr() assert n == m, 'strides must be equal' u = int(gcd(s, t)) b_ = b if a <= b else b + 2**n d_ = d if c <= d else d + 2**n e, f = a+c, b_+d_ if f-e < 2**n: u_ = u e_, f_ = e % 2**n, f % 2**n else: u_ = int(gcd(u, 2**n)) e_ = e % 2**n f_ = (e_-u_) % 2**n return normalize(MSI(n, e_, f_, u_)) ``` ```python bin_op_test(add, lambda n, a, b: (a+b) % 2**n) ``` testing MSIs with bit width up to 4 exhaustively testing bit width: 1 testing bit width: 2 testing bit width: 3 testing bit width: 4 - tested 25000 arguments - tested 50000 arguments - tested 75000 arguments - tested 100000 arguments - tested 125000 arguments - tested 150000 arguments - tested 175000 arguments - tested 200000 arguments - tested 225000 arguments - tested 250000 arguments - tested 275000 arguments - tested 300000 arguments - tested 325000 arguments testing random MSIs with bit width from 5 to 8 testing bit width: 5 - tested 350000 arguments testing bit width: 6 - tested 375000 arguments - tested 400000 arguments - tested 425000 arguments - tested 450000 arguments testing bit width: 7 - tested 475000 arguments - tested 500000 arguments - tested 525000 arguments testing bit width: 8 - tested 550000 arguments - tested 575000 arguments - tested 600000 arguments - tested 625000 arguments - tested 650000 arguments - tested 675000 arguments succeeded (tested 684701 arguments in total) arguments with least precise results: 133[8, 141]_{8}, 133[8, 141]_{8}: 4.57763671875e-05 133[8, 141]_{8}, 123[24, 147]_{8}: 4.57763671875e-05 133[8, 141]_{8}, 123[48, 171]_{8}: 4.57763671875e-05 123[24, 147]_{8}, 133[8, 141]_{8}: 4.57763671875e-05 187[53, 240]_{8}, 187[53, 240]_{8}: 4.57763671875e-05 117[56, 173]_{8}, 139[115, 254]_{8}: 4.57763671875e-05 117[56, 173]_{8}, 139[101, 240]_{8}: 4.57763671875e-05 17[101, 118]_{8}, 239[15, 254]_{8}: 4.57763671875e-05 ```python def sub(i, j): n, a, b, s = i._tuple_repr() m, c, d, t = j._tuple_repr() assert n == m, 'strides must be equal' u = int(gcd(s, t)) b_ = b if a <= b else b + 2**n d_ = d if c <= d else d + 2**n e, f = a-d_, b_-c if f-e < 2**n: u_ = u e_, f_ = e % 2**n, f % 2**n else: u_ = int(gcd(u, 2**n)) e_ = e % 2**n f_ = (e_-u_) % 2**n return normalize(MSI(n, e_, f_, u_)) ``` ```python bin_op_test(sub, lambda n, a, b: (a-b) % 2**n) ``` testing MSIs with bit width up to 4 exhaustively testing bit width: 1 testing bit width: 2 testing bit width: 3 testing bit width: 4 - tested 25000 arguments - tested 50000 arguments - tested 75000 arguments - tested 100000 arguments - tested 125000 arguments - tested 150000 arguments - tested 175000 arguments - tested 200000 arguments - tested 225000 arguments - tested 250000 arguments - tested 275000 arguments - tested 300000 arguments - tested 325000 arguments testing random MSIs with bit width from 5 to 8 testing bit width: 5 - tested 350000 arguments testing bit width: 6 - tested 375000 arguments - tested 400000 arguments - tested 425000 arguments - tested 450000 arguments testing bit width: 7 - tested 475000 arguments - tested 500000 arguments - tested 525000 arguments testing bit width: 8 - tested 550000 arguments - tested 575000 arguments - tested 600000 arguments - tested 625000 arguments - tested 650000 arguments - tested 675000 arguments succeeded (tested 684701 arguments in total) arguments with least precise results: 133[8, 141]_{8}, 133[8, 141]_{8}: 4.57763671875e-05 133[8, 141]_{8}, 123[24, 147]_{8}: 4.57763671875e-05 133[8, 141]_{8}, 123[48, 171]_{8}: 4.57763671875e-05 123[24, 147]_{8}, 133[8, 141]_{8}: 4.57763671875e-05 187[53, 240]_{8}, 187[53, 240]_{8}: 4.57763671875e-05 117[56, 173]_{8}, 139[115, 254]_{8}: 4.57763671875e-05 117[56, 173]_{8}, 139[101, 240]_{8}: 4.57763671875e-05 17[101, 118]_{8}, 239[15, 254]_{8}: 4.57763671875e-05 ```python def mul(i, j, debug=False): n, a, b, s = i._tuple_repr() m, c, d, t = j._tuple_repr() assert n == m, 'strides must be equal' m = 2**n u = int(gcd(a, s)) * int(gcd(c, t)) b_ = b if a <= b else b + m d_ = d if c <= d else d + m e, f = a*c, b_*d_ if f-e < m: u_ = u e_, f_ = e % m, f % m else: u_ = int(gcd(u, m)) e_ = e % m f_ = (e_-u_) % m if debug: print(f'u: {u}, e: {e}, f: {f}, u_: {u_}, e_: {e_}, f_: {f_}') return normalize(MSI(n, e_, f_, u_)) ``` ```python def urem(i, j, debug=False): n, _, _, s = i._tuple_repr() m, _, _, t = j._tuple_repr() assert n == m, 'strides must be equal' a, b = umin_MSI(i), umax_MSI(i) c, d = umin_MSI(j), umax_MSI(j) s, t = ustride(i), ustride(j) if c == 0: if t == 0: if debug: print('case 1') return MSI(n, 0, (-1) % 2**n, 1) else: c = t if b < c: if debug: print('case 2') return i elif t == 0: if a//c == b//c: if debug: print('case 3.1') return normalize(MSI(n, a % c, b % c, s)) else: if debug: print('case 3.2') u = int(gcd(s, c)) return normalize(MSI(n, a % u, c-1, u)) else: if debug: print('case 4') u = int(gcd(gcd(c, t), s)) return normalize(MSI(n, a % u, min(b, d-1), u)) ``` ```python bin_op_test(urem, lambda n, a, b: (a % b) % 2**n, big=False, non_zero=True) ``` ```python def udiv(i, j, debug=False): n, _, _, _ = i._tuple_repr() m, _, _, t = j._tuple_repr() assert n == m, 'strides must be equal' a, b = umin_MSI(i), umax_MSI(i) c, d = umin_MSI(j), umax_MSI(j) s = ustride(i) m = 2**n if c == 0: if t == 0: return MSI(n, 0, (-1) % 2**n, 1) else: c = ustride(j) s_ = int(gcd(a, s)) if t == 0: u = s_ // c u = u if u*c == s_ else 1 return normalize(MSI(n, a//c, b//c, u)) else: e, f = a//d, b//c return normalize(MSI(n, e, f, 1)) ``` ```python lhs, rhs = MSI(3, 1, 5, 1), MSI(3, 2, 0, 3) print(f'{lhs}, {rhs}: {gamma(lhs)}, {gamma(rhs)}') res = udiv(lhs, rhs, debug=True) print(f'{res}: {gamma(res)}') ``` 1[1, 5]_{3}, 3[2, 0]_{3}: {1, 2, 3, 4, 5}, {0, 2, 5} 1[0, 5]_{3}: {0, 1, 2, 3, 4, 5} ```python bin_op_test(udiv, lambda n, a, b: (a // b), big=False, non_zero=True) ``` testing MSIs with bit width up to 4 exhaustively testing bit width: 1 testing bit width: 2 testing bit width: 3 testing bit width: 4 - tested 25000 arguments - tested 50000 arguments - tested 75000 arguments - tested 100000 arguments - tested 125000 arguments - tested 150000 arguments - tested 175000 arguments - tested 200000 arguments - tested 225000 arguments - tested 250000 arguments - tested 275000 arguments - tested 300000 arguments - tested 325000 arguments testing random MSIs with bit width from 5 to 8 testing bit width: 5 - tested 350000 arguments testing bit width: 6 - tested 375000 arguments - tested 400000 arguments - tested 425000 arguments testing bit width: 7 - tested 450000 arguments - tested 475000 arguments - tested 500000 arguments - tested 525000 arguments testing bit width: 8 - tested 550000 arguments - tested 575000 arguments - tested 600000 arguments - tested 625000 arguments succeeded (tested 647793 arguments in total) arguments with least precise results: 74[178, 252]_{8}, 173[1, 174]_{8}: 4.650297619047619e-05 0[178, 178]_{8}, 173[1, 174]_{8}: 4.3890449438202246e-05 0[178, 178]_{8}, 220[1, 221]_{8}: 4.3645251396648046e-05 0[174, 174]_{8}, 173[1, 174]_{8}: 4.489942528735632e-05 0[174, 174]_{8}, 220[1, 221]_{8}: 4.464285714285714e-05 0[221, 221]_{8}, 173[1, 174]_{8}: 3.535067873303168e-05 0[221, 221]_{8}, 220[1, 221]_{8}: 3.535067873303168e-05 174[0, 174]_{8}, 220[1, 221]_{8}: 4.464285714285714e-05 ```python def rem(k, n): assert not n == 0, 'remainder by 0' if k > 0: return k % abs(n) else: return -(abs(k) % abs(n)) ``` ```python def div(k, n): assert not n == 0, 'division by 0' if k > 0: return k // n else: return -(abs(k) // n) ``` ```python def smin(n, k, l): k_, l_ = as_signed_int(n, k), as_signed_int(n, l) if k_ <= l_: return k_ else: return l_ def smax(n, k, l): k_, l_ = as_signed_int(n, k), as_signed_int(n, l) if k_ >= l_: return k_ else: return l_ ``` ```python def srem(i, j, debug=False): n, m = i.bit_width, j.bit_width assert n == m, 'strides must be equal' a, b = as_signed_int(n, smin_MSI(i)), as_signed_int(n, smax_MSI(i)) c, d = as_signed_int(n, smin_MSI(j)), as_signed_int(n, smax_MSI(j)) s, t = sstride(i), sstride(j) if debug: print(f'a: {a}, b: {b}, c: {c}, d: {d}, s: {s}, t: {t}') if d < 0: if debug: print('all negative') c, d = -d, -c elif c < 0: if debug: print('some negative') t_ = (d+c) % t c, d = min(-c % t, d % t), max(-c, d) t = gcd(t, t_) if debug: print(f'a: {a}, b: {b}, c: {c}, d: {d}, s: {s}, t: {t}') if c == 0: # remainder by bound not possible if t == 0: # definite remainder by 0 if debug: print('case 1') return MSI(n, 0, (-1) % 2**n, 1) else: # correct bound to avoid ramainder by 0 if debug: print('avoid 0') c = c+t # renormalize if c == d: if debug: print('renormalize') t = 0 if debug: print(f'a: {a}, b: {b}, c: {c}, d: {d}, s: {s}, t: {t}') absMaxI = max(abs(a), abs(b)) if absMaxI < c: # remainder has no effect if debug: print('case 2') return i elif t == 0: # remainder by constant if div(a, c) == div(b, c): # E x. x*c <= a <= b < (x+1)*c if debug: print('case 3') return normalize(MSI(n, rem(a, c) % 2**n, rem(b, c) % 2**n, s)) if debug: print(f'case 5') u = int(gcd(gcd(c, t), s)) e = a % u if 0 < a else max(a, 1-d + (a+d-1) % u) f = min(b, d-1) if 0 < b else (e-1) % u + 1 - u if debug: print(f'u: {u}, e: {e}, f: {f}, {a % u if 0 < a else 1-d + (a-d+1) % u}, {d-1 if 0 < b else (e-1) % u + 1 - u}') return normalize(MSI(n, e % 2**n, f % 2**n, u)) ``` ```python srem(MSI(3, 5, 6, 1), MSI(3, 2, 2, 0), debug=True) ``` a: -3, b: -2, c: 2, d: 2, s: 1, t: 0 a: -3, b: -2, c: 2, d: 2, s: 1, t: 0 a: -3, b: -2, c: 2, d: 2, s: 1, t: 0 case 3 7[0, 7]_{3} ```python def srem_cases(i, j): p = [] n, m = i.bit_width, j.bit_width assert n == m, 'strides must be equal' a, b = as_signed_int(n, smin_MSI(i)), as_signed_int(n, smax_MSI(i)) c, d = as_signed_int(n, smin_MSI(j)), as_signed_int(n, smax_MSI(j)) s, t = sstride(i), sstride(j) if append(p, d < 0) and d < 0: c, d = -d, -c elif append(p, c < 0) and c < 0: t_ = (d+c) % t append(p, -c % t <= d % t) append(p, -c <= d) c, d = min(-c % t, d % t), max(-c, d) t = gcd(t, t_) if append(p, c == 0) and c == 0: # remainder by bound not possible if append(p, t == 0) and t == 0: # definite remainder by 0 return MSI(n, 0, (-1) % 2**n, 1), p else: # correct bound to avoid ramainder by 0 c = c+t # renormalize if append(p, c == d) and c == d: t = 0 append(p, a >= 0) append(p, a >= b) append(p, abs(a) >= abs(b)) absMaxI = max(abs(a), abs(b)) if append(p, absMaxI < c) and absMaxI < c: # remainder has no effect return i, p elif append(p, t == 0) and t == 0: # remainder by constant if append(p, div(a, c) == div(b, c)) and div(a, c) == div(b, c): # E x. x*c <= a <= b < (x+1)*c return normalize(MSI(n, rem(a, c) % 2**n, rem(b, c) % 2**n, s)), p u = int(gcd(gcd(c, t), s)) if append(p, 0 < a) and 0 < a: e = a % u else: append(p, a >= 1-d + (a+d-1) % u) e = max(a, 1-d + (a+d-1) % u) if append(p, 0 < b) and 0 < b: append(p, b >= d-1) f = min(b, d-1) else: f = (e-1) % u + 1 - u return normalize(MSI(n, e % 2**n, f % 2**n, u)), p ``` ```python srem_cases(MSI(4, 2, 5, 3), MSI(4, 15, 3, 2)) ``` (1[0, 2]_{4}, [False, True, True, True, False, True, False, False, False, False, True, True, True]) ```python def append(xs, x): xs.append(x) return True ``` ```python def add_case(cases, path, ex): if cases is None: if len(path) == 0: return (True, True, ex) else: return (False, False, {path[0]: add_case(None, path[1:], ex), not path[0]: None}) else: fin0, a0, cs0 = cases if fin0: return cases else: b = path[0] fin1, a1, cs1 = add_case(cs0[b], path[1:], ex) fin = cs0[not b] is not None and cs0[not b][0] and fin1 return (fin, a0, {b: (fin1, a1, cs1), not b: cs0[not b]}) ``` ```python def gen_test_cases(f): cases = None for n in range(1, 4+1): for i in test_MSIs_6_exhaustive[n]: for j in test_MSIs_6_exhaustive[n]: _, path = f(i, j) cases = add_case(cases, path, (i, j)) if cases[0]: return cases return cases ``` ```python def get_cases(cases): if cases is None: return [] elif cases[1]: return [cases[2]] else: return get_cases(cases[2][True]) + get_cases(cases[2][False]) ``` ```python def find_unreachable_pathes(cases): if cases is None: return [p] elif cases[0]: return [] r = [] for b in [True, False]: if cases[2][b] is None: r += [[b]] else: r += [[b]+p for p in find_unreachable_pathes(cases[2][b])] return r ``` ```python cases = gen_test_cases(srem_cases) ``` ```python cs = get_cases(cases) ``` ```python len(cs) ``` 267 ```python cs[0] ``` (0[0, 0]_{1}, 0[1, 1]_{1}) ```python srem(MSI(2, 2, 2, 0), MSI(2, 2, 3, 1)) ``` 3[0, 3]_{2} ```python for lhs, rhs in cs: n, a, b, s = lhs._tuple_repr() _, c, d, t = rhs._tuple_repr() ref = srem(lhs, rhs) _, e, f, u = ref._tuple_repr() print(f'lhs = {{{n}, {a}, {b}, {s}}}; rhs = {{{n}, {c}, {d}, {t}}}; ref = {{{n}, {e}, {f}, {u}}};') print(f'res_p = lhs.srem({n}, rhs);'); print(f'res = *(static_cast<StridedInterval *>(res_p.get()));') print(f'if (res != ref) {{') print(f' errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\\n";') print(f'}}') ``` lhs = {1, 0, 0, 0}; rhs = {1, 1, 1, 0}; ref = {1, 0, 0, 0}; res_p = lhs.srem(1, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 1, 1, 0}; rhs = {2, 3, 3, 0}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 1, 1, 0}; rhs = {2, 2, 3, 1}; ref = {2, 0, 1, 1}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 1, 0}; rhs = {3, 5, 7, 1}; ref = {3, 0, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 1, 1}; rhs = {2, 2, 2, 0}; ref = {2, 0, 1, 1}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 2, 3, 1}; rhs = {3, 6, 6, 0}; ref = {3, 0, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 3, 1}; rhs = {3, 7, 7, 0}; ref = {3, 0, 0, 0}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 1, 1}; rhs = {2, 3, 3, 0}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 3, 1}; rhs = {3, 5, 7, 1}; ref = {3, 0, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 2, 1}; rhs = {3, 4, 6, 1}; ref = {3, 0, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 1, 1}; rhs = {2, 2, 3, 1}; ref = {2, 0, 1, 1}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 0, 1, 1}; rhs = {3, 5, 7, 1}; ref = {3, 0, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 3, 3, 0}; rhs = {2, 2, 2, 0}; ref = {2, 3, 3, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {1, 1, 1, 0}; rhs = {1, 1, 1, 0}; ref = {1, 0, 0, 0}; res_p = lhs.srem(1, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 3, 3, 0}; rhs = {2, 2, 3, 1}; ref = {2, 0, 3, 3}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 2, 2, 0}; rhs = {2, 2, 3, 1}; ref = {2, 0, 3, 3}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 3, 3}; rhs = {2, 2, 2, 0}; ref = {2, 0, 3, 3}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 5, 6, 1}; rhs = {3, 6, 6, 0}; ref = {3, 0, 7, 7}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 2, 1}; rhs = {2, 3, 3, 0}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 5, 1, 2}; rhs = {3, 5, 5, 0}; ref = {3, 6, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {1, 0, 1, 1}; rhs = {1, 1, 1, 0}; ref = {1, 0, 0, 0}; res_p = lhs.srem(1, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 1, 3, 2}; rhs = {2, 2, 3, 1}; ref = {2, 3, 1, 1}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 6, 5}; rhs = {3, 5, 7, 1}; ref = {3, 6, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 3, 3}; rhs = {2, 2, 3, 1}; ref = {2, 0, 3, 3}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 2, 1}; rhs = {2, 2, 3, 1}; ref = {2, 3, 1, 1}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 5, 1, 2}; rhs = {3, 5, 7, 1}; ref = {3, 6, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 2, 0, 1}; rhs = {2, 2, 3, 1}; ref = {2, 0, 3, 3}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 3, 1}; rhs = {3, 4, 4, 0}; ref = {3, 6, 3, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 3, 1}; rhs = {3, 5, 5, 0}; ref = {3, 6, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 3, 1}; rhs = {3, 7, 7, 0}; ref = {3, 0, 0, 0}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 3, 1}; rhs = {3, 5, 7, 1}; ref = {3, 6, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 7, 2, 1}; rhs = {3, 4, 6, 1}; ref = {3, 7, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 3, 1}; rhs = {3, 6, 7, 1}; ref = {3, 7, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 0, 0}; rhs = {2, 3, 1, 1}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 1, 1, 0}; rhs = {2, 3, 1, 1}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 0, 1, 1}; rhs = {3, 5, 3, 3}; ref = {3, 0, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 2, 3, 1}; rhs = {3, 6, 2, 2}; ref = {3, 0, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 3, 1}; rhs = {3, 7, 1, 1}; ref = {3, 0, 0, 0}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 1, 1}; rhs = {2, 3, 1, 1}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 7, 7, 0}; rhs = {3, 5, 3, 3}; ref = {3, 7, 7, 0}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 3, 3, 0}; rhs = {2, 3, 1, 1}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 6, 5}; rhs = {3, 5, 3, 3}; ref = {3, 1, 6, 5}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 5, 6, 1}; rhs = {3, 6, 2, 2}; ref = {3, 0, 7, 7}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 2, 1}; rhs = {2, 3, 1, 1}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 5, 1, 2}; rhs = {3, 5, 3, 3}; ref = {3, 6, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 3, 3}; rhs = {2, 3, 1, 1}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 7, 2, 1}; rhs = {3, 5, 3, 3}; ref = {3, 7, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 3, 1}; rhs = {3, 5, 3, 3}; ref = {3, 6, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 3, 1}; rhs = {3, 7, 1, 1}; ref = {3, 0, 0, 0}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 0, 0, 0}; rhs = {3, 5, 3, 1}; ref = {3, 0, 0, 0}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 3, 3, 0}; rhs = {3, 5, 3, 1}; ref = {3, 0, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 1, 0}; rhs = {3, 5, 3, 1}; ref = {3, 0, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 0, 2, 1}; rhs = {4, 10, 6, 3}; ref = {4, 0, 2, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 3, 1}; rhs = {3, 5, 3, 1}; ref = {3, 0, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 1, 3, 1}; rhs = {4, 9, 7, 1}; ref = {4, 0, 3, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 0, 3, 1}; rhs = {3, 5, 3, 1}; ref = {3, 0, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 0, 1, 1}; rhs = {3, 5, 3, 1}; ref = {3, 0, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 14, 14, 0}; rhs = {4, 10, 6, 3}; ref = {4, 14, 14, 0}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 7, 7, 0}; rhs = {3, 5, 3, 1}; ref = {3, 0, 7, 7}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 6, 0}; rhs = {3, 7, 2, 1}; ref = {3, 0, 7, 7}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 1, 14, 13}; rhs = {4, 10, 6, 3}; ref = {4, 1, 14, 13}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 2, 1}; rhs = {3, 5, 3, 1}; ref = {3, 6, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 6, 5}; rhs = {3, 5, 3, 1}; ref = {3, 6, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 0, 6, 6}; rhs = {3, 5, 3, 1}; ref = {3, 6, 0, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 5, 1}; rhs = {3, 5, 3, 1}; ref = {3, 6, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 5, 1, 2}; rhs = {3, 5, 3, 1}; ref = {3, 6, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 5, 7, 1}; rhs = {3, 5, 3, 1}; ref = {3, 6, 0, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 15, 2, 1}; rhs = {4, 10, 6, 3}; ref = {4, 15, 2, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 3, 1}; rhs = {3, 5, 3, 1}; ref = {3, 6, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 3, 15, 12}; rhs = {4, 9, 7, 1}; ref = {4, 15, 3, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 3, 1}; rhs = {3, 7, 2, 1}; ref = {3, 7, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 0, 0}; rhs = {2, 1, 3, 2}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 1, 1, 0}; rhs = {2, 1, 3, 2}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 1, 0}; rhs = {3, 3, 7, 2}; ref = {3, 0, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 0, 1, 1}; rhs = {3, 2, 6, 4}; ref = {3, 0, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 3, 1}; rhs = {3, 3, 7, 2}; ref = {3, 0, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 1, 3, 1}; rhs = {4, 1, 15, 2}; ref = {4, 0, 3, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 1, 1}; rhs = {2, 1, 3, 2}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 0, 1, 1}; rhs = {3, 3, 7, 2}; ref = {3, 0, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 7, 7, 0}; rhs = {3, 2, 6, 4}; ref = {3, 7, 7, 0}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 7, 7, 0}; rhs = {3, 3, 7, 2}; ref = {3, 0, 7, 7}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 3, 3, 0}; rhs = {2, 1, 3, 2}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 7, 1, 1}; rhs = {3, 2, 6, 4}; ref = {3, 7, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 2, 1}; rhs = {3, 3, 7, 2}; ref = {3, 6, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 6, 5}; rhs = {3, 3, 7, 2}; ref = {3, 6, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 0, 6, 6}; rhs = {3, 3, 7, 2}; ref = {3, 6, 0, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 2, 1}; rhs = {2, 1, 3, 2}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 5, 1, 2}; rhs = {3, 3, 7, 2}; ref = {3, 6, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 3, 3}; rhs = {2, 1, 3, 2}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 3, 15, 12}; rhs = {4, 4, 12, 8}; ref = {4, 3, 15, 12}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 3, 1}; rhs = {3, 3, 7, 2}; ref = {3, 6, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 3, 15, 12}; rhs = {4, 1, 15, 2}; ref = {4, 15, 3, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 3, 1}; rhs = {3, 1, 7, 6}; ref = {3, 0, 0, 0}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {1, 0, 0, 0}; rhs = {1, 0, 1, 1}; ref = {1, 0, 0, 0}; res_p = lhs.srem(1, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 1, 1, 0}; rhs = {2, 0, 3, 3}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 1, 1}; rhs = {2, 0, 2, 2}; ref = {2, 0, 1, 1}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 2, 3, 1}; rhs = {3, 0, 6, 6}; ref = {3, 0, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 3, 1}; rhs = {3, 0, 6, 6}; ref = {3, 0, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 1, 1}; rhs = {2, 0, 3, 3}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 3, 3, 0}; rhs = {2, 0, 2, 2}; ref = {2, 3, 3, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {1, 1, 1, 0}; rhs = {1, 0, 1, 1}; ref = {1, 0, 0, 0}; res_p = lhs.srem(1, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 3, 3}; rhs = {2, 0, 2, 2}; ref = {2, 0, 3, 3}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 5, 6, 1}; rhs = {3, 0, 6, 6}; ref = {3, 0, 7, 7}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 2, 1}; rhs = {2, 0, 3, 3}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 2, 4, 2}; rhs = {3, 0, 4, 4}; ref = {3, 6, 2, 2}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {1, 0, 1, 1}; rhs = {1, 0, 1, 1}; ref = {1, 0, 0, 0}; res_p = lhs.srem(1, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 3, 1}; rhs = {3, 0, 4, 4}; ref = {3, 6, 3, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 7, 3, 1}; rhs = {3, 0, 6, 6}; ref = {3, 7, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 3, 1}; rhs = {3, 0, 6, 6}; ref = {3, 7, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 0, 0}; rhs = {2, 0, 2, 1}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 1, 1, 0}; rhs = {2, 0, 2, 1}; ref = {2, 0, 1, 1}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 1, 0}; rhs = {3, 1, 5, 1}; ref = {3, 0, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 0, 1, 1}; rhs = {3, 2, 4, 2}; ref = {3, 0, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 3, 1}; rhs = {3, 1, 5, 1}; ref = {3, 0, 3, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 2, 1}; rhs = {3, 1, 5, 1}; ref = {3, 0, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 1, 1}; rhs = {2, 0, 2, 1}; ref = {2, 0, 1, 1}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 0, 1, 1}; rhs = {3, 1, 5, 1}; ref = {3, 0, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 7, 7, 0}; rhs = {3, 2, 4, 2}; ref = {3, 7, 7, 0}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 3, 3, 0}; rhs = {2, 0, 2, 1}; ref = {2, 0, 3, 3}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 2, 2, 0}; rhs = {2, 0, 2, 1}; ref = {2, 0, 3, 3}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 7, 1, 1}; rhs = {3, 2, 4, 2}; ref = {3, 7, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 1, 3, 2}; rhs = {2, 0, 2, 1}; ref = {2, 3, 1, 1}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 6, 5}; rhs = {3, 1, 5, 1}; ref = {3, 6, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 3, 3}; rhs = {2, 0, 2, 1}; ref = {2, 0, 3, 3}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 2, 1}; rhs = {2, 0, 2, 1}; ref = {2, 3, 1, 1}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 5, 1, 2}; rhs = {3, 2, 0, 3}; ref = {3, 6, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 2, 0, 1}; rhs = {2, 0, 2, 1}; ref = {2, 0, 3, 3}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 3, 15, 12}; rhs = {4, 4, 8, 4}; ref = {4, 3, 15, 12}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 3, 1}; rhs = {3, 1, 5, 1}; ref = {3, 6, 3, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 7, 2, 1}; rhs = {3, 1, 5, 1}; ref = {3, 7, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 3, 1}; rhs = {3, 1, 6, 5}; ref = {3, 7, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 0, 0, 0}; rhs = {3, 5, 1, 2}; ref = {3, 0, 0, 0}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 3, 3, 0}; rhs = {3, 5, 1, 2}; ref = {3, 0, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 1, 0}; rhs = {3, 5, 1, 2}; ref = {3, 0, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 0, 1, 1}; rhs = {4, 9, 3, 5}; ref = {4, 0, 1, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 3, 1}; rhs = {3, 5, 1, 2}; ref = {3, 0, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 2, 1}; rhs = {3, 4, 2, 3}; ref = {3, 0, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 0, 3, 1}; rhs = {3, 5, 1, 2}; ref = {3, 0, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 0, 1, 1}; rhs = {3, 5, 1, 2}; ref = {3, 0, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 15, 15, 0}; rhs = {4, 9, 3, 5}; ref = {4, 15, 15, 0}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 7, 7, 0}; rhs = {3, 5, 1, 2}; ref = {3, 0, 7, 7}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 5, 5, 0}; rhs = {3, 5, 1, 2}; ref = {3, 6, 0, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 1, 15, 14}; rhs = {4, 9, 3, 5}; ref = {4, 1, 15, 14}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 5, 3, 1}; rhs = {3, 4, 2, 3}; ref = {3, 5, 3, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 6, 5}; rhs = {3, 5, 1, 2}; ref = {3, 6, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 5, 7, 1}; rhs = {3, 4, 2, 3}; ref = {3, 5, 0, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 5, 1}; rhs = {3, 5, 1, 2}; ref = {3, 6, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 5, 1, 2}; rhs = {3, 5, 1, 2}; ref = {3, 6, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 5, 7, 1}; rhs = {3, 5, 1, 2}; ref = {3, 6, 0, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 3, 1}; rhs = {3, 5, 1, 2}; ref = {3, 6, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 7, 2, 1}; rhs = {3, 4, 2, 3}; ref = {3, 7, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 11, 10, 3}; rhs = {4, 12, 2, 3}; ref = {4, 13, 3, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 0, 0, 0}; rhs = {4, 11, 7, 6}; ref = {4, 0, 0, 0}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 7, 7, 0}; rhs = {4, 11, 7, 6}; ref = {4, 0, 6, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 5, 5, 0}; rhs = {4, 11, 7, 6}; ref = {4, 0, 5, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 0, 1, 1}; rhs = {4, 13, 7, 5}; ref = {4, 0, 1, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 1, 3, 1}; rhs = {4, 14, 4, 3}; ref = {4, 0, 3, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 1, 3, 1}; rhs = {4, 11, 7, 6}; ref = {4, 0, 3, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 0, 3, 3}; rhs = {4, 14, 4, 3}; ref = {4, 0, 3, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 0, 2, 1}; rhs = {4, 11, 7, 6}; ref = {4, 0, 2, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 15, 15, 0}; rhs = {4, 13, 7, 5}; ref = {4, 15, 15, 0}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 14, 14, 0}; rhs = {4, 11, 7, 6}; ref = {4, 14, 0, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 8, 8, 0}; rhs = {4, 11, 7, 6}; ref = {4, 10, 0, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 1, 15, 14}; rhs = {4, 13, 7, 5}; ref = {4, 1, 15, 14}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 10, 6, 1}; rhs = {4, 11, 7, 6}; ref = {4, 10, 6, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 12, 2, 3}; rhs = {4, 11, 7, 6}; ref = {4, 12, 2, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 10, 13, 3}; rhs = {4, 11, 7, 6}; ref = {4, 10, 0, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 1, 11, 1}; rhs = {4, 11, 7, 6}; ref = {4, 10, 6, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 9, 1, 1}; rhs = {4, 11, 7, 6}; ref = {4, 10, 1, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 9, 11, 1}; rhs = {4, 11, 7, 6}; ref = {4, 10, 0, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 11, 10, 3}; rhs = {4, 11, 7, 6}; ref = {4, 10, 6, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 3, 15, 12}; rhs = {4, 11, 7, 6}; ref = {4, 15, 3, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 11, 10, 3}; rhs = {4, 14, 4, 3}; ref = {4, 13, 3, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 0, 0, 0}; rhs = {3, 1, 5, 4}; ref = {3, 0, 0, 0}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 3, 3, 0}; rhs = {3, 1, 5, 4}; ref = {3, 0, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 1, 0}; rhs = {3, 1, 5, 4}; ref = {3, 0, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 0, 2, 1}; rhs = {4, 3, 11, 8}; ref = {4, 0, 2, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 3, 1}; rhs = {3, 1, 5, 4}; ref = {3, 0, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 1, 3, 1}; rhs = {4, 5, 13, 4}; ref = {4, 0, 3, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 0, 3, 1}; rhs = {3, 1, 5, 4}; ref = {3, 0, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 0, 1, 1}; rhs = {3, 1, 5, 4}; ref = {3, 0, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 14, 14, 0}; rhs = {4, 3, 11, 8}; ref = {4, 14, 14, 0}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 7, 7, 0}; rhs = {3, 1, 5, 4}; ref = {3, 0, 7, 7}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 5, 5, 0}; rhs = {3, 1, 5, 4}; ref = {3, 6, 0, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 1, 14, 13}; rhs = {4, 3, 11, 8}; ref = {4, 1, 14, 13}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 2, 1}; rhs = {3, 1, 5, 4}; ref = {3, 6, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 6, 5}; rhs = {3, 1, 5, 4}; ref = {3, 6, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 0, 6, 6}; rhs = {3, 1, 5, 4}; ref = {3, 6, 0, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 5, 1}; rhs = {3, 1, 5, 4}; ref = {3, 6, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 5, 1, 2}; rhs = {3, 1, 5, 4}; ref = {3, 6, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 5, 7, 1}; rhs = {3, 1, 5, 4}; ref = {3, 6, 0, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 15, 2, 1}; rhs = {4, 3, 11, 8}; ref = {4, 15, 2, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 3, 1}; rhs = {3, 1, 5, 4}; ref = {3, 6, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 3, 15, 12}; rhs = {4, 5, 13, 4}; ref = {4, 15, 3, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 11, 10, 3}; rhs = {4, 1, 13, 12}; ref = {4, 14, 2, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {1, 0, 1, 1}; rhs = {1, 0, 0, 0}; ref = {1, 0, 1, 1}; res_p = lhs.srem(1, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 0, 0}; rhs = {2, 0, 1, 1}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 1, 1, 0}; rhs = {2, 0, 1, 1}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 0, 1, 1}; rhs = {3, 0, 3, 3}; ref = {3, 0, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 2, 3, 1}; rhs = {3, 0, 2, 2}; ref = {3, 0, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 3, 1}; rhs = {3, 0, 1, 1}; ref = {3, 0, 0, 0}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 1, 1}; rhs = {2, 0, 1, 1}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 7, 7, 0}; rhs = {3, 0, 3, 3}; ref = {3, 7, 7, 0}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 3, 3, 0}; rhs = {2, 0, 1, 1}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 6, 5}; rhs = {3, 0, 3, 3}; ref = {3, 1, 6, 5}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 5, 6, 1}; rhs = {3, 0, 2, 2}; ref = {3, 0, 7, 7}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 2, 1}; rhs = {2, 0, 1, 1}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 5, 1, 2}; rhs = {3, 0, 3, 3}; ref = {3, 6, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 3, 3}; rhs = {2, 0, 1, 1}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 7, 2, 1}; rhs = {3, 0, 3, 3}; ref = {3, 7, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 3, 1}; rhs = {3, 0, 3, 3}; ref = {3, 6, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 3, 1}; rhs = {3, 0, 1, 1}; ref = {3, 0, 0, 0}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 0, 0, 0}; rhs = {3, 0, 3, 1}; ref = {3, 0, 0, 0}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 3, 3, 0}; rhs = {3, 0, 3, 1}; ref = {3, 0, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 1, 0}; rhs = {3, 0, 3, 1}; ref = {3, 0, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 0, 2, 1}; rhs = {4, 0, 6, 3}; ref = {4, 0, 2, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 3, 1}; rhs = {3, 0, 3, 1}; ref = {3, 0, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 1, 3, 1}; rhs = {4, 0, 5, 1}; ref = {4, 0, 3, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 0, 3, 1}; rhs = {3, 0, 3, 1}; ref = {3, 0, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 0, 1, 1}; rhs = {3, 0, 3, 1}; ref = {3, 0, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 14, 14, 0}; rhs = {4, 0, 6, 3}; ref = {4, 14, 14, 0}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 7, 7, 0}; rhs = {3, 0, 3, 1}; ref = {3, 0, 7, 7}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 6, 0}; rhs = {3, 0, 2, 1}; ref = {3, 0, 7, 7}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 1, 14, 13}; rhs = {4, 0, 6, 3}; ref = {4, 1, 14, 13}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 2, 1}; rhs = {3, 0, 3, 1}; ref = {3, 6, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 6, 5}; rhs = {3, 0, 3, 1}; ref = {3, 6, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 0, 6, 6}; rhs = {3, 0, 3, 1}; ref = {3, 6, 0, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 5, 1}; rhs = {3, 0, 3, 1}; ref = {3, 6, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 5, 1, 2}; rhs = {3, 0, 3, 1}; ref = {3, 6, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 5, 7, 1}; rhs = {3, 0, 3, 1}; ref = {3, 6, 0, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 15, 2, 1}; rhs = {4, 0, 6, 3}; ref = {4, 15, 2, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 3, 1}; rhs = {3, 0, 3, 1}; ref = {3, 6, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 3, 15, 12}; rhs = {4, 0, 5, 1}; ref = {4, 15, 3, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 3, 1}; rhs = {3, 0, 2, 1}; ref = {3, 7, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 0, 0}; rhs = {2, 1, 1, 0}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 1, 1, 0}; rhs = {2, 1, 1, 0}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 3, 3, 0}; rhs = {3, 1, 3, 1}; ref = {3, 0, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 1, 0}; rhs = {3, 1, 3, 1}; ref = {3, 0, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 0, 1, 1}; rhs = {3, 2, 3, 1}; ref = {3, 0, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 2, 3, 1}; rhs = {3, 2, 2, 0}; ref = {3, 0, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 3, 1}; rhs = {3, 3, 3, 0}; ref = {3, 0, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 1, 1}; rhs = {2, 1, 1, 0}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 3, 1}; rhs = {3, 1, 3, 1}; ref = {3, 0, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 1, 3, 1}; rhs = {4, 2, 7, 1}; ref = {4, 0, 3, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 0, 3, 1}; rhs = {3, 1, 3, 1}; ref = {3, 0, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 0, 1, 1}; rhs = {3, 1, 3, 1}; ref = {3, 0, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 7, 7, 0}; rhs = {3, 2, 3, 1}; ref = {3, 7, 7, 0}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 3, 3, 0}; rhs = {2, 1, 1, 0}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 7, 7, 0}; rhs = {3, 1, 3, 1}; ref = {3, 0, 7, 7}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 6, 0}; rhs = {3, 1, 2, 1}; ref = {3, 0, 7, 7}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 6, 5}; rhs = {3, 3, 3, 0}; ref = {3, 1, 6, 5}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 5, 6, 1}; rhs = {3, 2, 2, 0}; ref = {3, 0, 7, 7}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 2, 1}; rhs = {2, 1, 1, 0}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 5, 1, 2}; rhs = {3, 3, 3, 0}; ref = {3, 6, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {2, 0, 3, 3}; rhs = {2, 1, 1, 0}; ref = {2, 0, 0, 0}; res_p = lhs.srem(2, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 2, 1}; rhs = {3, 1, 3, 1}; ref = {3, 6, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 6, 5}; rhs = {3, 1, 3, 1}; ref = {3, 6, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 0, 6, 6}; rhs = {3, 1, 3, 1}; ref = {3, 6, 0, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 1, 5, 1}; rhs = {3, 1, 3, 1}; ref = {3, 6, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 5, 1, 2}; rhs = {3, 1, 3, 1}; ref = {3, 6, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 5, 7, 1}; rhs = {3, 1, 3, 1}; ref = {3, 6, 0, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 7, 2, 1}; rhs = {3, 3, 3, 0}; ref = {3, 7, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 3, 1}; rhs = {3, 3, 3, 0}; ref = {3, 6, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 3, 1}; rhs = {3, 1, 1, 0}; ref = {3, 0, 0, 0}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 3, 1}; rhs = {3, 1, 3, 1}; ref = {3, 6, 2, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {4, 3, 15, 12}; rhs = {4, 2, 7, 1}; ref = {4, 15, 3, 1}; res_p = lhs.srem(4, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } lhs = {3, 6, 3, 1}; rhs = {3, 1, 2, 1}; ref = {3, 7, 1, 1}; res_p = lhs.srem(3, rhs); res = *(static_cast<StridedInterval *>(res_p.get())); if (res != ref) { errs() << "[testSrem] failed with operands " << lhs << ", " << rhs << ": got " << res << ", expected " << ref << "\n"; } ```python n = 4 lhs, rhs = MSI(n, 10, 13, 3), MSI(n, 10, 13, 3) print(f'{lhs}, {rhs}: {set(map(lambda k: as_signed_int(n, k), gamma(lhs)))}, {set(map(lambda k: as_signed_int(n, k), gamma(rhs)))}') res = srem(lhs, rhs, debug=True) print(f'{res}: {set(map(lambda k: as_signed_int(n, k), gamma(res)))}') ``` 3[10, 13]_{4}, 3[10, 13]_{4}: {-6, -3}, {-6, -3} a: -6, b: -3, c: -6, d: -3, s: 3, t: 3 all negative a: -6, b: -3, c: 3, d: 6, s: 3, t: 3 a: -6, b: -3, c: 3, d: 6, s: 3, t: 3 case 5 u: 3, e: -3, f: 0, -4, 0 13[0, 13]_{4}: {0, -3} ```python bin_op_test(srem, lambda n, a, b: rem(as_signed_int(n, a), as_signed_int(n, b)) % 2**n, big=False, non_zero=True) ```

5cf8125e795f1a3c3209d5cdf11cb261a1b1c334

ipynb

Jupyter Notebook

spec/msi.ipynb

peterrum/po-lab-2018

e4547288c582f36bd73d94157ea157b0a631c4ae

2018-06-05T08:07:52.000Z

2018-11-04T19:18:40.000Z

spec/msi.ipynb

peterrum/po-lab-2018

e4547288c582f36bd73d94157ea157b0a631c4ae

2018-06-05T15:14:39.000Z

2018-11-24T07:47:28.000Z

spec/msi.ipynb

peterrum/po-lab-2018

e4547288c582f36bd73d94157ea157b0a631c4ae

2018-11-05T10:04:30.000Z

2019-04-16T14:26:24.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

## Exploring reference frame ```python import sympy as sp import sympy.physics.mechanics as me ``` ```python psi = me.dynamicsymbols('psi') x0,y0 = me.dynamicsymbols('x0 y0') x01d,y01d = me.dynamicsymbols('x0 y0',1) u,v = me.dynamicsymbols('u v') ``` ```python N = me.ReferenceFrame('N') B = N.orientnew('B','Axis',[psi,N.z]) ``` ```python B.dcm(N) ``` $\displaystyle \left[\begin{matrix}\cos{\left(\psi{\left(t \right)} \right)} & \sin{\left(\psi{\left(t \right)} \right)} & 0\\- \sin{\left(\psi{\left(t \right)} \right)} & \cos{\left(\psi{\left(t \right)} \right)} & 0\\0 & 0 & 1\end{matrix}\right]$ ### V2pt_theory ```python O = me.Point('O') P = O.locatenew('P',10*B.x) ``` ```python O.set_vel(N,x0*N.x + y0*N.y) ``` ```python P.v2pt_theory(O,N,B) ``` $\displaystyle 10 \dot{\psi}\mathbf{\hat{b}_y} + x_{0}\mathbf{\hat{n}_x} + y_{0}\mathbf{\hat{n}_y}$ ```python P.vel(N).to_matrix(N) ``` $\displaystyle \left[\begin{matrix}\operatorname{x_{0}}{\left(t \right)} - 10 \sin{\left(\psi{\left(t \right)} \right)} \frac{d}{d t} \psi{\left(t \right)}\\\operatorname{y_{0}}{\left(t \right)} + 10 \cos{\left(\psi{\left(t \right)} \right)} \frac{d}{d t} \psi{\left(t \right)}\\0\end{matrix}\right]$ ### V1pt_theory ```python O = me.Point('O') P = O.locatenew('P',0) ``` ```python O.set_vel(N,0) P.set_vel(B,u*B.x + v*B.y) ``` ```python P.v1pt_theory(O,N,B) ``` $\displaystyle u\mathbf{\hat{b}_x} + v\mathbf{\hat{b}_y}$ ```python P.vel(N).to_matrix(N) ``` $\displaystyle \left[\begin{matrix}u{\left(t \right)} \cos{\left(\psi{\left(t \right)} \right)} - v{\left(t \right)} \sin{\left(\psi{\left(t \right)} \right)}\\u{\left(t \right)} \sin{\left(\psi{\left(t \right)} \right)} + v{\left(t \right)} \cos{\left(\psi{\left(t \right)} \right)}\\0\end{matrix}\right]$ ## Bludder ```python O = me.Point('O') O.set_vel(N,0) P = me.Point('P') P.set_pos(O,x0*N.x + y0*N.y) P.set_vel(B,u*B.x + v*B.y) P.v1pt_theory(O,N,B) ``` $\displaystyle u\mathbf{\hat{b}_x} + v\mathbf{\hat{b}_y} - y_{0} \dot{\psi}\mathbf{\hat{n}_x} + x_{0} \dot{\psi}\mathbf{\hat{n}_y}$ ```python P.vel(N).to_matrix(N) ``` $\displaystyle \left[\begin{matrix}u{\left(t \right)} \cos{\left(\psi{\left(t \right)} \right)} - v{\left(t \right)} \sin{\left(\psi{\left(t \right)} \right)} - \operatorname{y_{0}}{\left(t \right)} \frac{d}{d t} \psi{\left(t \right)}\\u{\left(t \right)} \sin{\left(\psi{\left(t \right)} \right)} + v{\left(t \right)} \cos{\left(\psi{\left(t \right)} \right)} + \operatorname{x_{0}}{\left(t \right)} \frac{d}{d t} \psi{\left(t \right)}\\0\end{matrix}\right]$ ```python ```

08136f05095ce02f5cb2d8e95aac43bc854248e5

ipynb

Jupyter Notebook

reference_frame.ipynb

axelande/rigidbodysimulator

a87c3eb3b7978ef01efca15e66a6de6518870cd8

reference_frame.ipynb

axelande/rigidbodysimulator

a87c3eb3b7978ef01efca15e66a6de6518870cd8

2020-10-26T19:47:02.000Z

2020-10-26T19:47:02.000Z

reference_frame.ipynb

axelande/rigidbodysimulator

a87c3eb3b7978ef01efca15e66a6de6518870cd8

2020-10-26T09:17:00.000Z

2020-10-26T09:17:00.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__yue_Hant

# Lecture 18: Numerical Solutions to the Diffusion Equation ## (Implicit Methods) ### Sections * [Introduction](#Introduction) * [Learning Goals](#Learning-Goals) * [On Your Own](#On-Your-Own) * [In Class](#In-Class) * [Revisiting the Discrete Version of Fick's Law](#Revisiting-the-Discrete-Version-of-Fick's-Law) * [A Linear System for Diffusion](#A-Linear-System-for-Diffusion) * [An Implicit Numerical Solution](#An-Implicit-Numerical-Solution) * [Deconstruction of the Solution Scheme](#Deconstruction-of-the-Solution-Scheme) * [Homework](#Homework) * [Summary](#Summary) * [Looking Ahead](#Looking-Ahead) * [Reading Assignments and Practice](#Reading-Assignments-and-Practice) Possible future improvement: Crank-Nicholson. ### Introduction ---- This lecture introduces the implicit scheme for solving the diffusion equation. Examine the descritization for our explicit scheme that we covered in the previous lecture: $$ \frac{u_{i,\, j+1} - u_{i,\, j}}{\Delta t} = D \frac{u_{i - 1,\, j} - 2 u_{i,\, j} + u_{i + 1,\, j}}{\Delta x^2} $$ This expression uses a _forward difference_ in time where we are subtracting the value of our dependent variable at time index $j$ from the value of our dependent variable at time-index $j+1$. If, instead, we perform a backward difference (replace $j$ with $j-1$) we will be subtracting our dependent variable at $j-1$ from the value at the index $j$. For example: $$ \frac{u_{i,\, j} - u_{i,\, j-1}}{\Delta t} = D \frac{u_{i - 1,\, j} - 2 u_{i,\, j} + u_{i + 1,\, j}}{\Delta x^2} $$ Attempting to repeat our previous algebraic manipulations we find that the solution to this equation is in terms of three unknown quantities at the index $j$. These quantities depend on indices $i-1$, $i$ and $i+1$ and our solution is only known to the index $j-1$. This seems like a complication that cannot be resolved however, examination of all the resulting equations in our grid will revel that this is a linear system that can be solved with the inclusion of the boundary conditions. The point of this lecture is to develop your understanding for how the use of matrices and linear algebra can be used to solve this problem. The system of equations and the method for solving the equations is known as an "implicit method". There is a good discussion in Numerical Recipes by Teukolsky, et al. to provide a foundation for these methods. [Top of Page](#Sections) ### Learning Goals ---- * Re-develop the descretizaton of Fick's law such that the solution scheme is implicit * Write the method as a linear system * Incorporate boundary conditions * Develop a solution strategy using linear algebra and Numpy or SciPy as appropriate. [Top of Page](#Sections) ### On Your Own ---- Suggestions for improvement of this section: * Develop numpy methods for linear algebra (e.g. creating matrices efficiently) * Matrix operations relevant to LA. * Solve a simple linear system. [Top of Page](#Sections) ### In Class ---- * Re-derive the discrete form of Fick's law. * Examine the structure of the resulting matrix. * Write a solver. ### Revisiting the Discrete Version of Fick's Law We start with a re-statement of Fick's second law in finite difference form that uses a FORWARD difference in time: $$ \frac{u_{i,\, j+1} - u_{i,\, j}}{\Delta t} = D \frac{u_{i - 1,\, j} - 2 u_{i,\, j} + u_{i + 1,\, j}}{\Delta x^2} $$ This choice of time differencing led to the EXPLICIT scheme. This time, we choose a BACKWARD difference in time as follows: $$ \frac{u_{i,\, j} - u_{i,\, j-1}}{\Delta t} = D \frac{u_{i - 1,\, j} - 2 u_{i,\, j} + u_{i + 1,\, j}}{\Delta x^2} $$ This choice leads to a set of linear equations. To illustrate how this develops we will write the equation above for a grid of eight points that represent the quantity of diffusing substance. See the next figure. In the above figure we represent a grid of two dimensions - this grid is identical to the explicit finite difference grid. The main difference between the explicit and implicit method is the way we fill the grid to arrive at our solution. In the spatial dimension we have 8 columns (the "$i$" index) and in the time dimension we show only three rows (the "$j$" index). The sizes of the grid in the two dimensions are arbitrary. Keep the following in mind: * The solution is known to the $j-1$ index. * The unknowns are the $j$ indcies. Algebraiclly rearranging this differencing scheme, we can write down: $$ u_{i,\, j-1} = \frac{\Delta t D}{\Delta x^2} \left( - u_{i - 1,\, j} + 2 u_{i,\, j} - u_{i + 1,\, j} \right) + u_{i,\, j} $$ one additional re-arrangment (substitute $\beta$ for the factor containing the diffusion coefficient) and we get: $$ - \beta u_{i - 1,\, j} + (1 + 2 \beta) u_{i,\, j} - \beta u_{i + 1,\, j} = u_{i,\, j-1} $$ We include "ghost cells" in grey above to enforce the boundary conditions. We can use fixed value (setting the ghost cells to a particular number) or fixed flux (setting the value of the ghost cell based on a pair of interior cells) to produce a linear system with an equal number of unknowns and equations. ### A Linear System for Diffusion We begin as usual by importing SymPy into the namespace and using `init_session` to define some helpful symbols. We also define a pair of symbols $U_{LHS}$ and $U_{RHS}$ that will be used to define values in the ghost cells. ```python import sympy as sp sp.init_session(quiet=True) var('U_LHS U_RHS') ``` We define the symbols we want to use in our linear system. For this demonstration, I don't add the time index but I keep my subscripts consistent with the figure above. ```python var('dt dx beta u1:7 b1:7') ``` In this cell we create the square matrix holding the coefficients that multiply the unknown quantities. Note the structure of the matrix. It is a _tridiagonal_ matrix. The function in NumPy is very compact, in SymPy not so much. So I apologize for the syntax in the SymPy/Python code below, but the more compact version can be difficult to read: ```python hpad = ones(0, 1); vpad = ones(1, 0) mainDiag = 2*beta+1; offDiag = -beta M = (sp.diag(vpad, offDiag, offDiag, offDiag, offDiag, offDiag, hpad)+ \ sp.diag(hpad, offDiag, offDiag, offDiag, offDiag, offDiag, vpad)+ \ sp.diag(mainDiag,mainDiag,mainDiag,mainDiag,mainDiag,mainDiag)) M ``` Here is our vector of unknown quantities. We know the solution to the $j-1$ time step. All of these symbols represent the value of our field (e.g. concentration, temperature, etc.) at the $j$'th time step. ```python xmatrix = sp.Matrix([u1,u2,u3,u4,u5,u6]) xmatrix ``` If we've got everything correct, this matrix product will reproduce the discrete diffusion equation outlined above. You'll note that the boundary equations are not formed correctly. For reference, here is the discrete form: $$ - \beta u_{i - 1,\, j} + (1 + 2 \beta) u_{i,\, j} - \beta u_{i + 1,\, j} = u_{i,\, j-1} $$ ```python M*xmatrix ``` It should start to become clear that we can write this linear system (of a tridiagonal matrix and a column vector of unknowns) as a matrix equation: $$ M \cdot \overline{x} = \overline{b} $$ Where M is the square matrix, x is the vector of unknown quantities and b is the last known value of the system variables (the $u_{i,j}$ are the unknowns, the $j-1$ are the last known values). There is still some work to be done before we can use linear algebra to get the solution. We need to implement the boundary conditions. ### Fixed Value Boundary Conditions Start with the form at the interior of the grid: $$ - \beta u_{i - 1,\, j} + (1 + 2 \beta) u_{i,\, j} - \beta u_{i + 1,\, j} = u_{i,\, j-1} $$ To get the form correct at the top and bottom of this solution vector we need to imagine adding "ghost cells" to the boundaries of our domain at $i=0$ and $i=7$. Using the above expression, let $i = 1$: $$ - \beta u_{0,\, j} + (1 + 2 \beta) u_{1,\, j} - \beta u_{2,\, j} = u_{1,\, j-1} $$ If we have fixed value boundary conditions, we then know the value of $u_0$. This is the boundary condition of our simulation. We will call this value $U_{LHS}$, substitute $U_{LHS} = u_0$ and move the known quantities to the RHS of the equation: $$ (1 + 2 \beta) u_{1,\, j} - \beta u_{2,\, j} = u_{1,\, j-1} + \beta U_{LHS} $$ ### Fixed Flux Boundary Conditions If we have fixed flux boundary conditions we can write the flux as a central difference on the cell $u_1$ that uses the "ghost" point at $u_0$: $$ \frac{u_{2,\, j} - u_{0,\, j}}{2 \Delta x} = F $$ Proceeding as before with $i=1$: $$ - \beta u_{0,\, j} + (1 + 2 \beta) u_{1,\, j} - \beta u_{2,\, j} = u_{1,\, j-1} $$ This time we know the relationship of $u_0$ to the other unknowns due to the specification of the defined flux boundary condition. Solving for $u_0$ we get: $$ u_{0,\, j} = u_{2,\, j} - {2 \Delta x} F $$ Substituting this into our expression that includes the ghost cell gives us: $$ - \beta (u_{2,\, j} - {2 \Delta x} F) + (1 + 2 \beta) u_{1,\, j} - \beta u_{2,\, j} = u_{1,\, j-1} $$ Simplifying: $$ (1 + 2 \beta) u_{1,\, j} - 2 \beta u_{2,\, j} = u_{1,\, j-1} - \beta 2 \Delta x F $$ So in this case we have to modify the matrix $M$ entries AND the solution vector $b$ recalling that the $j-1$ index is the known solution. We have now recovered the form of the equation in the dot product $M \cdot x$ and the form of this equation is telling us that we need to modify the solution vector $b$ with information about the boundary conditions before we find the inverse of the matrix and compute the new solution vector. Modifying the $b$ matrix with the known ghost cell values for the fixed value boundary conditions we get: ```python bmatrix = sp.Matrix([(b1+beta*U_LHS),b2,b3,b4,b5,(b6+beta*U_RHS)]) bmatrix ``` So the full form of our system is therefore: $$ \left[\begin{matrix}2 \beta + 1 & - \beta & 0 & 0 & 0 & 0\\- \beta & 2 \beta + 1 & - \beta & 0 & 0 & 0\\0 & - \beta & 2 \beta + 1 & - \beta & 0 & 0\\0 & 0 & - \beta & 2 \beta + 1 & - \beta & 0\\0 & 0 & 0 & - \beta & 2 \beta + 1 & - \beta\\0 & 0 & 0 & 0 & - \beta & 2 \beta + 1\end{matrix}\right] \cdot \left[\begin{matrix}u_{1}\\u_{2}\\u_{3}\\u_{4}\\u_{5}\\u_{6}\end{matrix}\right] = \left[\begin{matrix}U_{LHS} \beta + b_{1}\\b_{2}\\b_{3}\\b_{4}\\b_{5}\\U_{RHS} \beta + b_{6}\end{matrix}\right] $$ `SymPy` can evaluate the LHS for us. ```python sp.Eq(M*xmatrix,bmatrix) ``` All that remains is to solve the above linear system. Instead of using `SymPy`, we will use some tools in a different Python library. [Top of Page](#Sections) ### An Implicit Numerical Solution General setup in this section: ```python %matplotlib inline import numpy as np import matplotlib.pyplot as plt ``` Simulation parameters: ```python numberOfPoints = 100 lengthOfDomain = 1.0 dx = lengthOfDomain/numberOfPoints xPoints = np.linspace(0.0, lengthOfDomain, numberOfPoints) initialCondition = np.sin(xPoints*np.pi/lengthOfDomain) ``` A simple function to plot the initial condition: ```python def plotIC(): fig = plt.figure() axes = fig.add_axes([0.1, 0.1, 0.8, 0.8]) axes.plot(xPoints, initialCondition, 'ro') axes.set_xlabel('Distance $x$') axes.set_ylabel('Concentration of Stuff $c(x,t)$') axes.set_title('Initial Conditions'); ``` ```python plotIC() ``` It is worth noting that these schemes are unconditionally stable - so any choice of time step will produce a solution. The accuracy of the solution does depend on this choice, though. ```python diffusionCoefficient = 10.0 dt = dx**2/(diffusionCoefficient) numberOfIterations = 1000 ``` We create two solution vectors rather than one whole array to hold all of our solution. This is not particular to the implicit method, but it demonstrates another technique for saving memory and speeding up the calculation. We will fill these matrices and swap them (move data from `new` into `old` and overwrite `new`) at each time step. ```python newConcentration = np.zeros((numberOfPoints), dtype='float32') oldConcentration = np.zeros((numberOfPoints), dtype='float32') ``` First, some syntax: ```python ['h','h','h']*3 ``` The matrix has to be square. It should have the same dimensions as the nubmer of points in the system. The following code snippet was inspired by [this](http://stackoverflow.com/questions/5842903/block-tridiagonal-matrix-python) post. ```python def tridiag(a, b, c, k1=-1, k2=0, k3=1): # Here we use Numpy addition to make the job easier. return np.diag(a, k1) + np.diag(b, k2) + np.diag(c, k3) a = [-dt*diffusionCoefficient/dx/dx]*(numberOfPoints-1) b = [2*dt*diffusionCoefficient/dx/dx+1]*(numberOfPoints) c = [-dt*diffusionCoefficient/dx/dx]*(numberOfPoints-1) A = tridiag(a, b, c) ``` ```python A ``` We first need to prime the arrays by copying the initial condition into `oldConcentration`. Afterwards it will be enough to swap pointers (a variable that points to a memory location). ```python np.copyto(oldConcentration,initialCondition) ``` [Top of Page](#Sections) ### Deconstruction of the Solution Scheme In spite of the small chunk of code a few cells below, there is a lot going on. Let us dissect it. In bullet points: * Before the first solution step we enforce the boundary conditions. Our choice of matrix means that we are using "fixed value" boundary conditions. So we need to modify the `b` vector accordingly. The indexing notation of Numpy that permits us to find the first (`[0]`) and last cell (`[-1]`) of an array is very helpful here. ```python oldConcentration[0] = oldConcentration[0] + uLHS*dt*diffusionCoefficient/dx/dx oldConcentration[-1] = oldConcentration[-1] + uRHS*dt*diffusionCoefficient/dx/dx ``` Recall: $$ \left[\begin{matrix}2 \beta + 1 & - \beta & 0 & 0 & 0 & 0\\- \beta & 2 \beta + 1 & - \beta & 0 & 0 & 0\\0 & - \beta & 2 \beta + 1 & - \beta & 0 & 0\\0 & 0 & - \beta & 2 \beta + 1 & - \beta & 0\\0 & 0 & 0 & - \beta & 2 \beta + 1 & - \beta\\0 & 0 & 0 & 0 & - \beta & 2 \beta + 1\end{matrix}\right] \cdot \left[\begin{matrix}u_{1}\\u_{2}\\u_{3}\\u_{4}\\u_{5}\\u_{6}\end{matrix}\right] = \left[\begin{matrix}U_{LHS} \beta + b_{1}\\b_{2}\\b_{3}\\b_{4}\\b_{5}\\U_{RHS} \beta + b_{6}\end{matrix}\right] $$ * Solving the system involves using the built in `NumPy` functions to invert the matrix. What is returned is the solution vector. Please note that I'm using an internal `Numpy` (an optimized function!) function to COPY the results of the linear algebra solution into the `newConcentration` vector. ```python np.copyto(newConcentration,np.linalg.solve(A,oldConcentration)) ``` * Rather than storing ALL the data, we instead store just the current and the old concentrations. There are efficiencies in doing this, but if we want the older values, we need to store them on disk or in memory. * Tuple unpacking in Python leads to the `A,B=B,A` syntax below. This switches the references to the arrays. This is important for efficiency - you don't want to move any data if you don't have to. If you are running big calculations then moving that data around is a waste of time/resources. Better to just swap references. ```python oldConcentration, newConcentration = newConcentration, oldConcentration ``` * Repeat the process and after a specified number of iterations, plot the results. ```python uLHS = 0.0 uRHS = 0.0 numIterations = 200 for i in range(numIterations): # enforce boundary conditions oldConcentration[0] = oldConcentration[0] + uLHS*dt*diffusionCoefficient/dx/dx oldConcentration[-1] = oldConcentration[-1] + uRHS*dt*diffusionCoefficient/dx/dx # solve the system np.copyto(newConcentration,np.linalg.solve(A,oldConcentration)) # swap pointers oldConcentration, newConcentration = newConcentration, oldConcentration # plot the results fig2 = plt.figure() axes = fig2.add_axes([0.1, 0.1, 0.8, 0.8]) axes.plot(xPoints, newConcentration, 'ro') axes.set_ylim(0,1) axes.set_xlabel('Distance $x$') axes.set_ylabel('Concentration of Stuff $c(x,t)$') axes.set_title('Solution'); ``` [Top of Page](#Sections) ### Homework ---- * Solve the diffusion couple problem * Compare to the analytical solution * Describe the differences between them (in words and with some plots, maybe) * Examine the error in terms of truncation versus roundoff error. [Top of Page](#Sections) ### Looking Ahead ---- TBA [Top of Page](#Sections) ### Reading Assignments and Practice ---- TBA [Top of Page](#Sections)

e0c317b67f4d4b5e2bf4a31fd806e0157559a533

ipynb

Jupyter Notebook

Lecture-18-Implicit-Finite-Difference.ipynb

juhimgupta/MTLE-4720

41797715111636067dd4e2b305a782835c05619f

2017-07-19T04:04:38.000Z

2022-02-18T19:33:43.000Z

Lecture-18-Implicit-Finite-Difference.ipynb

juhimgupta/MTLE-4720

41797715111636067dd4e2b305a782835c05619f

2019-04-08T15:21:45.000Z

2020-03-03T20:19:00.000Z

Lecture-18-Implicit-Finite-Difference.ipynb

juhimgupta/MTLE-4720

41797715111636067dd4e2b305a782835c05619f

2017-07-27T02:27:49.000Z

2022-01-27T08:16:40.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

```python from sympy import * init_printing() ``` ```python eye(3) ``` ```python Matrix([[1, 2], [3, 4]]) * Matrix([[1, 2], [3, 4]]) ``` ```python x = symbols('x') (2 * x**2 + x + 10).as_poly().all_coeffs() ```

55300d0dbd13a5a801b603fb6e5b9b40e4132888

ipynb

Jupyter Notebook

notebooks/sympy_examples.ipynb

joebentley/simba

dd1b7bc6d22ad96566898dd1851cfa210462cb00

2020-03-19T10:59:25.000Z

2022-01-22T22:33:07.000Z

notebooks/sympy_examples.ipynb

joebentley/simba

dd1b7bc6d22ad96566898dd1851cfa210462cb00

2022-01-22T11:24:45.000Z

2022-01-22T11:24:45.000Z

notebooks/sympy_examples.ipynb

joebentley/simba

dd1b7bc6d22ad96566898dd1851cfa210462cb00

2020-03-19T13:27:41.000Z

2020-03-19T13:27:41.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__yue_Hant

# 4. Gyakorlat - Vasúti ütközőbak 2021.03.01 ## Feladat: ```python from IPython.display import Image Image(filename='gyak4_1.png',width=900) ``` A mellékelt ábrán látható módon egy $m$ tömegű vasúti szerlvény egy ütközőbakba csapódik $v_0$ kezdősebességgel. Feltételezzük, hogy a folyamat során a bak mozdulatlan marad. Modellezvén a bak elaszticitását és energia disszipációját, a fenti ábrán látható mechanikai modellt használjuk. Miközben a szerelvény ütközője érintezik a bak ütközőjével, kettejük rugómerevségét és csillapítási tényezőjét kombinálhatjuk egy $k$ eredő rugómerevséggé, valamint egy $2c$ nagyságú eredő csillapítási tényezővé. ### Adatok: | | | |:-----------------------|-----------------------| | $m$ = 5$\cdot$10$^4$ kg | $v_0$ = 1 m/s | | $k$ = 10$^6$ N/m | $c$ = 10$^5$ Ns/m | ### Részfeladatok: 1. Számítsa ki az ütközés során a rugóban ébredő maximális erőt! 2. Határozza meg az ütközés során elnyelt energiát! ## Megoldás: ### 1. Feladat További részletezés nélkül a mozgásegyenlet: $$m\ddot{x} + 2c\dot{x} + kx = 0.$$ ```python import sympy as sp from IPython.display import Math # hogy tudjunk LaTeX szöveget kiírni sp.init_printing() m,c,k,ζ,ω_n,ω_d,v_0,t = sp.symbols('m,c,k,ζ,ω_n,ω_d,v_0,t') x = sp.Function('x')(t) # Készítsünk behelyettesítési listát az adatok alapján, SI-ben adatok = [(m, 5*10**4), (v_0, 1), (k, 10**6), (c, 10**5)] mozgasegy = m*sp.diff(x,t,2) + 2*c*sp.diff(x,t,1) + k*x # Osszunk le a főegyütthatóval: foegyutthato = mozgasegy.coeff(sp.diff(x,t,2)) mozgasegy = (mozgasegy/foegyutthato).expand() mozgasegy ``` ```python mozgasegy = mozgasegy.subs([(2*c/m,2*ζ*ω_n),(k/m,ω_n**2)]) mozgasegy ``` ```python ω_n_num = sp.sqrt(k/m).subs(adatok) display(Math('\omega_n = {}'.format(sp.latex(ω_n_num)))) # rad/s ``` $\displaystyle \omega_n = 2 \sqrt{5}$ ```python ζ_num = (c/m/ω_n).subs(adatok).subs(ω_n,ω_n_num) display(Math('\zeta = {}'.format(sp.latex(ζ_num)))) # 1 ``` $\displaystyle \zeta = \frac{\sqrt{5}}{5}$ ```python ω_d_num = (ω_n*sp.sqrt(1-ζ**2)).subs(adatok).subs(ω_n,ω_n_num).subs(ζ,ζ_num) display(Math('\omega_d = {}'.format(sp.latex(ω_d_num)))) # rad/s ``` $\displaystyle \omega_d = 4$ ```python T_d_num = ((2*sp.pi)/ω_d).subs(adatok).subs(ω_d,ω_d_num) display(Math('T_d = {}'.format(sp.latex(T_d_num)))) # s ``` $\displaystyle T_d = \frac{\pi}{2}$ ```python mozgasegy_num = mozgasegy.subs([(ζ,ζ_num),(ω_n,ω_n_num)]) mozgasegy_num # természetesen ez a bal oldal, amennyiben a jobb oldal 0 ``` ```python # Oldjuk meg a mozgásegyenletet előszőr # az integrálási konstansok kézi meghatározásával. # általános megoldás: alt_meg = sp.dsolve(mozgasegy_num,x).rhs # right hand side alt_meg # figyelem, itt az eredeti kidolgozásban pont fordítva van C1 és C2! ``` ```python # Általános megoldás deriváltja: d_alt_meg = sp.diff(alt_meg,t) d_alt_meg ``` ```python # Kezedit értékek: x(0) = 0, v(0) = v0. # C1, C2 konstansok kifejezése: v0, C1, C2 = sp.symbols("v0, C1, C2") # Oldjuk meg az egyenletrendszert C1 és C2-re. konst = sp.solve([alt_meg.subs(t,0),d_alt_meg.subs(t,0)-v0],C1, C2) C1_num = konst[C1] C2_num = konst[C2] display(Math('C_1 = {},'.format(sp.latex(konst[C1])))) display(Math('C_2 = {}.'.format(sp.latex(konst[C2])))) ``` $\displaystyle C_1 = \frac{v_{0}}{4},$ $\displaystyle C_2 = 0.$ ```python alt_meg.subs([(C1,C1_num),(C2,C2_num)]) ``` ```python # Most pedig értékeljük, hogy a sympy a fentieket # automatikusan is képes elvégezni: kezdeti_ert = {x.subs(t,0): 0, x.diff(t).subs(t,0): v_0} display(kezdeti_ert) mozg_torv = sp.dsolve(mozgasegy_num,x,ics=kezdeti_ert) mozg_torv ``` Maximális rugóerő a maximális kitérésnél: keressük a maximális kitéréshez tartozó $t^*$ időt: ```python # A maximumban a derivált értéke zérus. # Itt már felhasználhatjuk azt, hogy C2 = 0 d_alt_meg.subs(C2,0) ``` ```python # Megoldva az egyenletet t-re: meg = sp.solve(d_alt_meg.subs(C2,0),t) t_csillag = meg[0] display(Math('t^* = {}'.format(t_csillag.evalf(4)))) # s ``` $\displaystyle t^* = 0.2768$ ```python # Visszahelyettesítve a mozgástörvénybe: x_max = mozg_torv.rhs.subs(t,t_csillag).subs(v_0,1) display(Math('x_{{max}} = {}'.format(x_max.evalf(4)))) # m ``` $\displaystyle x_{max} = 0.1285$ ```python # Amiből a maximális rugóerő: F_max = (k*x_max).subs(adatok) display(Math('F_{{r,max}} = {}'.format(F_max.evalf(5)/1000))) # kN ``` $\displaystyle F_{r,max} = 128.55$ ## Második feladat ```python # Newton II-ből a mozdony által az ütközőre ható erő kontakt_egy = sp.Eq(k*alt_meg+2*c*d_alt_meg,0) kontakt_egy = kontakt_egy.subs(C2,0).simplify() kontakt_egy ``` ```python # Oldjuk meg t-re, felhasználva, hogy C2 = 0 és C1 ≠ 0: kontakt_megold = sp.solve(kontakt_egy.subs(adatok),t) display(kontakt_megold) # a 2 megoldás közül a legkisebb kell, ami még pozitív. # Módszer: `ternary operator`, ami könnyen olvasható és értelmezhető. t_cscs = kontakt_megold[0] if 0 < kontakt_megold[0] < kontakt_megold[1] else kontakt_megold[1] display(Math('t^{{**}} = {}'.format(t_cscs.evalf(4)))) # s ``` ```python # A mozdony sebessége az elválás pillanatában (t** időpontban) v_t = mozg_torv.rhs.diff(t) # mozgástörvény deriváltja -> sebesség v_tcscs = v_t.subs(t,t_cscs).subs(adatok).evalf(4) display(Math('v_{{t^{{**}}}} = {}'.format(v_tcscs.evalf(4)))) # m/s ``` $\displaystyle v_{t^{**}} = -0.3305$ ```python # A kinetikus energia megváltozása a munkavégzéssel egyenlő: W_diss = (1/2*m*v_tcscs**2-1/2*m*v_0**2).subs(adatok) # A disszipált energia ennek mínusz egyszerese display(Math('E^\mathrm{{diss}} = {}'.format(-W_diss.evalf(4)/1000))) # kJ ``` $\displaystyle E^\mathrm{diss} = 22.27$ Készítette: Juhos-Kiss Álmos (Alkalmazott Mechanika Szakosztály) és Csuzdi Domonkos (Alkalmazott Mechanika Szakosztály) Takács Dénes (BME MM) ábrái és Vörös Illés (BME MM) kidolgozása alapján. Hibák, javaslatok: [email protected] [email protected] [email protected] 2021.03.01

aff05d70289b1d6df3dcedced641e30205e27bff

ipynb

Jupyter Notebook

negyedik_het/gyak_4.ipynb

barnabaspiri/RezgestanPython

3fcc4374c90d041436c816d26ded63af95b44103

negyedik_het/gyak_4.ipynb

barnabaspiri/RezgestanPython

3fcc4374c90d041436c816d26ded63af95b44103

2021-03-29T19:12:39.000Z

2021-04-26T18:06:02.000Z

negyedik_het/gyak_4.ipynb

barnabaspiri/RezgestanPython

3fcc4374c90d041436c816d26ded63af95b44103

2021-03-29T19:29:08.000Z

2021-04-10T20:58:06.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__hun_Latn

# 微積分 ## 積分 ### 不定積分 微分すると $f(x)$ になるような関数を $f(x)$ の **不定積分**（または**原始関数**）と呼び、以下のような記号で表す $$ \int{f(x)dx} $$ $f(x)$ の不定積分の1つを $F(x)$ とすると、定数の微分が 0 であることから、任意定数 $C$ について $F(x)+C$ も $f(x)$ の不定積分になる そのため、一般に次のように表される $$ \int{f(x)dx} = F(x) + C $$ このような $C$ は **積分定数** と呼ばれる 微分の性質から、不定積分について以下が成り立つ $$ \begin{align} \int(f(x) + g(x))dx &= \int f(x)dx + \int g(x)dx \\ \int(kf(x))dx &= k\int f(x)dx \end{align} $$ ここで、不定積分は積分定数分の不確実性があるため、上式 $\int(f(x) + g(x))dx &= \int f(x)dx + \int g(x)dx$ は「$f(x)$ の不定積分の1つを $F(x)$、$g(x)$ の不定積分の1つを $G(x)$ とすると、$(f(x) + g(x))$ の不定積分は $F(x)+G(x)+(定数)$ で表される」という意味になるため、要注意である これは $\int(kf(x))dx &= k\int f(x)dx$ についても同様である 具体的な例として、多項式関数の不定積分を考えてみると、例えば次の式が成り立つ $$ \int(x^3 + 2x)dx = \frac{1}{4}x^4 + x^2 + C \quad ただしCは積分定数 $$ 実際に $\frac{1}{4}x^4 + x^2$ を微分すると $x^3 + 2x$ になる また、微分の公式より、次の公式が成り立つ $$ \begin{align} \int x^pdx &= \frac{1}{p+1}x^{p+1} + C \\ \int\frac{1}{x}dx &= \ln|x| + C \\ \int e^xdx &= e^x + C \end{align} $$ #### 演習1 次の不定積分を求めよ 1. $$ \int(x^3 + 2x^2 + 1)dx $$ 2. $$ \int(x^2 + \frac{1}{x})dx $$ 3. $$ \int(\frac{1}{\sqrt x} + e^x)dx $$ #### 演習2 次の式が成り立つことを確かめよ 1. $$ \int(x^2 + 3x + 1)e^xdx = (x^2 + x)e^x + C $$ 2. $$ \int\frac{1}{1-x^2}dx = \frac{1}{2}(\ln|1+x| - \ln|1-x|) + C $$ #### 解答1 1. $$ \begin{align} \int(x^3 + 2x^2 + 1)dx &= \int x^3dx + 2\int x^2dx + \int1dx \\ &= \frac{1}{4}x^4 + \frac{2}{3}x^3 + x + C \end{align} $$ 2. $$ \begin{align} \int(x^2 + \frac{1}{x})dx &= \int x^2dx + \int\frac{1}{x}dx \\ &= \frac{1}{3}x^3 + \ln|x| + C \end{align} $$ 3. $$ \begin{align} \int(\frac{1}{\sqrt x} + e^x)dx &= \int x^{-\frac{1}{2}}dx + \int e^xdx \\ &= 2x^\frac{1}{2} + e^x + C \\ &= 2\sqrt{x} + e^x + C \end{align} $$ #### 解答2 それぞれの右辺を微分して確かめる 1. $$ \begin{align} \frac{d}{dx}\{(x^2 + x)e^x + C\} &= (x^2 + x)'\cdot e^x + (x^2 + x)\cdot(e^x)' \\ &= (2x + 1)e^x + (x^2 + x)e^x \\ &= (x^2 + 3x + 1)e^x \end{align} $$ 2. $$ \begin{align} \frac{d}{dx}\left\{\frac{1}{2}(\ln|1+x| - \ln|1-x|) + C\right\} &= \frac{1}{2}\{(\ln|1+x|)' - (\ln|1-x|)'\} \\ &= \frac{1}{2}\left(\frac{1}{1+x} - \left(-\frac{1}{1-x}\right)\right) \\ &= \frac{1}{1-x^2} \end{align} $$ ```julia using SymPy @vars x f(x) = x^3 + 2x^2 + 1 # 不定積分 integrate(f(x), x) ``` $\begin{equation*}\frac{x^{4}}{4} + \frac{2 x^{3}}{3} + x\end{equation*}$ ```julia f(x) = x^2 + 1/x integrate(f(x), x) ``` $\begin{equation*}\frac{x^{3}}{3} + \log{\left(x \right)}\end{equation*}$ ```julia f(x) = 1/sqrt(x) + exp(x) integrate(f(x), x) ``` $\begin{equation*}2 \sqrt{x} + e^{x}\end{equation*}$ ### 定積分 関数 $f(x)$ の不定積分の1つを $F(x)$ とすると、与えられた定数 $a$, $b$ の区間における $f(x)$ の **定積分** は次の式で定義される $$ \begin{align} \int_a^bf(x)dx &= F(b) - F(a) \\ &= \left[F(x)\right]_a^b \end{align} $$ 特に区間 $[a, b]$ において $f(x)\geq0$ ならば、定積分 $\int_a^bf(x)dx = F(b) - F(a)$ は、$a\leq x\leq b$, $0\leq y\leq f(x)$ 部分における面積になることが知られている 不定積分の性質から、次のことが分かる $$ \begin{align} \int_a^b(f(x) + g(x))dx &= \int_a^bf(x)dx + \int_a^bg(x)dx \\ \int_a^bkf(x)dx &= k\int_a^bf(x)dx \end{align} $$ #### 演習 次の計算を行え 1. $$ \int_0^2(x^3 + x) dx $$ 2. $$ \int_1^4(x + \sqrt x)dx $$ #### 解答 1. $$ \begin{align} \int_0^2(x^3 + x)dx &= \left[\frac{1}{4}x^4 + \frac{1}{2}x^2\right]_0^2 \\ &= \frac{1}{4}\times2^4 + \frac{1}{2}\times2^2 \\ &= 6 \end{align} $$ 2. $$ \begin{align} \int_1^4(x + \sqrt x)dx &= \left[\frac{1}{2}x^2 + \frac{2}{3}x^\frac{3}{2}\right]_1^4 \\ &= (\frac{1}{2}\times4^2 + \frac{2}{3}\times4^\frac{3}{2}) - (\frac{1}{2}\times1^2 + \frac{2}{3}\times1^\frac{3}{2}) \\ &= \frac{73}{6} \end{align} $$ ```julia f(x) = x^3 + x integrate(f(x), (x, 0, 2)) ``` $\begin{equation*}6\end{equation*}$ ```julia f(x) = x + sqrt(x) integrate(f(x), (x, 1, 4)) ``` $\begin{equation*}\frac{73}{6}\end{equation*}$ ## 偏微分と勾配 2変数関数 $z=f(x,y)$ を考える これは $(x,y)$ の値の組に対して、$z$ の値を1つ対応付ける写像である $z=f(x,y)$ を満たすような $(x,y,z)$ の集合は、3次元空間上の曲面と考えることが出来る 次のような具体例を考える $$ f(x,y) = x^2 + xy + y^2 + x $$ このとき $f(x,y)$ を $x$ の関数とみなして（$y$ を定数とみなして）微分すると、 $$ 2x + y + 1 $$ となる これを $f(x,y)$ の $x$ についての **偏導関数** と呼び、$\frac\partial{\partial x}f(x,y)$ や $f_x(x,y)$ などと記述する 偏導関数を求めることを **偏微分** する、という 偏導関数は、注目している変数を固定したときの導関数を意味している 上記の例でいうと、例えば $y=0$ に固定した関数 $f(x,0)=x^2+x$ を考えてみると、これを $x$ で微分した導関数 $2x+1$ は、偏導関数で $y=0$ としたもの $\frac\partial{\partial x}f(x,0) = 2x + 1$ に一致する 全ての $y$ についてこのような関係が成り立つため、$y=y_0$ における導関数は偏導関数 $\frac\partial{\partial x}f(x,y)$ で $y=y_0$ とおいたものであり、 $$ \frac{\partial y}{\partial x}(x,y_0) = 2x + y_0 + 1 $$ となる $xyz$ 空間では $z=f(x,y)$ は曲面を表し、これを平面 $y=y_0$ で切り取った曲線が $z=f(x,y_0)$ となる その切り口の曲線の導関数が、偏導関数で $y=y_0$ とおいたものであり $z=\frac\partial{\partial x}f(x,y_0)$ となる 2変数関数 $z=f(x,y)$ についても極値を考えることが出来る もし2変数関数 $z=f(x,y)$ が $(x,y)=(x_0,y_0)$ という点で極値をとるとすると、$z=f(x,y)$ の平面 $x=x_0$ による切り口が $y=y_0$ で極値をとり、$y=y_0$ による切り口が $x=x_0$ で極値をとらなければならない つまり必要条件は次のようになる $$ \frac{\partial f}{\partial x}(x_0, y_0) = 0,\ \frac{\partial f}{\partial y}(x_0, y_0) = 0 $$ ここで、 $$ \nabla f = \begin{pmatrix}\frac{\partial f}{\partial x} \\ \frac{\partial f}{\partial y}\end{pmatrix} $$ とおくと、この $\nabla f$ (ナブラf) は $\mathbb R^2$ から $\mathbb R^2$ への写像だと考えることが出来る つまりベクトル $\begin{pmatrix}x \\ y\end{pmatrix} \in \mathbb R^2$ を1つ考えると、それに対応してベクトル $\nabla f(x,y)$ が1つ決まる よって $f(x,y)$ の極値を求めるためには、 $$ \nabla f(x,y) = 0 $$ となる $x$, $y$ を求めれば良いことになる 具体例をもとに計算すると、 $$ \nabla f(x,y) = \begin{pmatrix}2x+y+1 \\ x+2y\end{pmatrix} = 0 $$ を解けばよいため、 $$ x=-\frac{2}{3},\ y=\frac{1}{3} $$ となる ```julia using Plots @vars x y f(x, y) = x^2 + x*y + y^2 + x # 2変数関数の3Dグラフをプロット ## ref: https://github.com/JuliaPy/SymPy.jl/blob/master/src/plot_recipes.jl surface(-10:10, -10:10, f(x, y)) ``` ```julia # (x,y)->z の増減表をプロット plot(VectorField(f)) ``` 以上の話を一般の$n$次変数関数について拡張する $n$次変数関数は次式で表される $$ y=f(x_1, x_2, \cdots, x_n) $$ または、変数をカンマ区切りの集合で表さず、ベクトル $\vec{x}=\begin{pmatrix}x_1 \\ x_2 \\ \vdots \\ x_n\end{pmatrix}$ で表し、 $$ y=f(\vec{x}) $$ と書くこともある ここで「$f$ が偏微分可能である」とは、全ての $x_i$ について $f$ が $x_i$ で偏微分可能であることを言う 特に全ての $x_i$ について無限回偏微分可能である場合、$f$ は **滑らか** であると言う ### 滑らかな$n$次変数関数の性質 滑らかな$n$次変数関数 $f$ の **勾配** $\nabla f$ は次で定義される $$ \nabla f = \begin{pmatrix}\frac{\partial f}{\partial x_1} \\ \frac{\partial f}{\partial x_2} \\ vdots \\ \frac{\partial f}{\partial x_n} \end{pmatrix} $$ これは$n$次元ベクトル $\vec{x}\in\mathbb{R}^n$ が1つ決まると、それに$n$次元ベクトルを1つ対応付けることが出来るため、$\mathbb{R}^2$ から $\mathbb{R}^2$ への写像になっている 関数 $f$ が $\vec{x}$ で極値をとるためには、次の条件が必要である $$ \nabla f(x) = \boldsymbol0 $$ これは必要条件に過ぎず、この条件を満たしても極値をとらないことがあるため要注意である 極値をとるための必要十分条件について考えるには、2階偏微分まで考える必要がある まず、その前に関数を複数回偏微分することを考える $f(\vec{x})$ を $x_i$ で偏微分した後に $x_j$ で偏微分したものを $\frac{\partial^2f}{\partial x_j\partial x_i}(\vec x)$ または $f_{x_ix_j}(\vec x)$ と書くことにする $f(\vec x)$ が滑らかなときは $f_{x_ix_j}(\vec x) = f_{x_jx_i}(\vec x)$ であることが知られているため、偏微分する順序を気にする必要はない このとき $f$ の **ヘッセ行列** は次で定義される $$ \nabla^2f = \begin{pmatrix} \frac{\partial^2f}{\partial x_1 \partial x_1} & \frac{\partial^2f}{\partial x_1 \partial x_2} & \ldots & \frac{\partial^2f}{\partial x_1 \partial x_n} \\ \frac{\partial^2f}{\partial x_2 \partial x_1} & \frac{\partial^2f}{\partial x_2 \partial x_2} & \ldots & \frac{\partial^2f}{\partial x_2 \partial x_n} \\ \vdots & \vdots & \ddots & \vdots \\ \frac{\partial^2f}{\partial x_n \partial x_1} & \frac{\partial^2f}{\partial x_n \partial x_2} & \ldots & \frac{\partial^2f}{\partial x_n \partial x_n} \end{pmatrix} $$ 関数 $f$ のヘッセ行列は $\nabla^2f$ や $\boldsymbol H_f$ と記述する $\frac{\partial^2}{\partial x_i\partial x_j}(\vec x) = \frac{\partial^2}{\partial x_j\partial x_i}(\vec x)$ であるため、ヘッセ行列は対称行列である 多変数関数 $f$ が $\nabla f(\vec x) = \boldsymbol$ となる点で極値をとるかどうかはヘッセ行列を調べれば分かる - 極大となる条件: ヘッセ行列が負定値 - 極小となる条件: ヘッセ行列が正定値 計算例として二次形式の勾配について考えてみる ここで **二次形式** とは$n$次対称対称行列 $\boldsymbol A$ に対して、 $$ f(\vec x) = \vec x^T \boldsymbol A \vec x $$ で定義されるものである この勾配を考えてみる $\boldsymbol A = (a_{ij})$ とすると、 $$ f(\vec x) = \sum_{i=1}^n\sum_{j=1}^n a_{ij}x_ix_j $$ となる 1つの添字 $k$ に注目して $x_k$ がこの右辺でいつ現れるかを考えると、$i=k$ のときと $j=k$ のときがあり、特に $i=j=k$ のときは $a_{kk}x_k^2$ という項がある $f$ を $x_k$ で偏微分すると、$x_k$ が現れる項だけを考えればよく、他は 0 になる $x_k$ が現れる項を、$i=j=k$ の場合、$i=k かつ j\neq k$ の場合、$i\neq k かつ j=k$ の場合、の3通りに分けて計算すると以下のようになる $$ \begin{align} \frac{\partial f}{\partial x_k}(\vec x) &= \frac{\partial}{\partial x_k}\left[a_{kk}x_k^2 + \sum_{j\neq k}a_{kj}x_kx_j + \sum_{i\neq k}a_{ik}x_ix_k\right] \\ &= 2a_{kk}x_k + \sum_{j\neq k}a_{kj}x_j + \sum_{i\neq k}a_{ik}x_i \\ &= 2a_{kk}x_k + 2\sum_{j\neq k}a_{kj}x_j \\ &= 2\sum_{j=1}^n a_{kj}x_j \end{align} $$ ただし、ここで $\sum_{i\neq k}$ という記号は「$i$を 1 から $n$ まで増やすが、$i=k$ の場合のみスキップして和をとる」という意味である また、$\boldsymbol A$ が対称行列であることから $a_{ik} = a_{kj}$ である性質を利用して計算している 以上より、勾配は次の式で表される $$ \nabla f(\vec x) = \begin{pmatrix}2\sum_{j=1}^na_{1j}x_j \\ 2\sum_{j=1}^na_{2j}x_j \\ vdots \\ 2\sum_{j=1}^na_{nj}x_j\end{pmatrix} = 2\boldsymbol A \vec x $$ この二次形式の勾配は、二次関数 $y=ax^2$ の導関数が $y'=2ax$ であることと形式が似ているため、比較的覚えやすい 次にこの $f$ のヘッセ行列を求める ヘッセ行列の $(k,l)$ 成分を $h_{kl}$ とすると、$h_{kl}$ は $\nabla f$ の第$k$成分を $x_l$ で偏微分したものになるため、 $$ h_{kl} = \frac{\partial}{\partial x_l}\left(2\sum_{j=1}^n a_{kj}x_j\right) = 2a_{kl} $$ となる 従ってヘッセ行列は、 $$ \nabla^2f(\vec x) = 2\boldsymbol A $$ である 以上より、$f$ が極値をとる条件は以下の通りである - $\vec x$ で極小となる条件: $\boldsymbol A\vec x = \boldsymbol0 かつ \boldsymbol A が正定値$ - $\vec x$ で極大となる条件: $\boldsymbol A\vec x = \boldsymbol0 かつ \boldsymbol A が負定値$ #### 演習 次の2変数関数の極値と、極値をとるときの $x$, $y$ を求めよ $$ f(x,y) = x^3 + 2xy + y^2 - x $$ #### 解答 まず $x$ と $y$ で偏微分する $$ \begin{align} \frac{\partial}{\partial x}f(x,y) &= 3x^2 + 2y - 1 \\ \frac{\partial}{\partial y}f(x,y) &= 2xy + 2y \\ \end{align} $$ これらを 0 とおいた方程式、つまり、 $$ \left\{ 3x^2 + 2y - 1 = 0 \\ 2xy + 2y = 0 \right. $$ を解くと、 $$ (x,y) = \left(-\frac{1}{3}, \frac{1}{3}\right),\ \left(1, -1\right) $$ を得る これらが極値をとる $(x,y)$ の候補であるが、実際に極値になるかを調べるために2階偏導関数を計算する $$ \begin{align} \frac{\partial^2}{\partial x \partial x}f(x,y) &= 6x \\ \frac{\partial^2}{\partial x \partial y}f(x,y) &= 2 \\ \frac{\partial^2}{\partial y \partial y}f(x,y) &= 2 \end{align} $$ 以上より、 $$ \nabla^2f(x,y) = \begin{pmatrix}6x & 2 \\ 2 & 2\end{pmatrix} $$ となる ここで、$(x,y) = \left(-\frac{1}{3}, \frac{1}{3}\right)$ の時は $\nabla^2f\left(-\frac{1}{3}, \frac{1}{3}\right) = \begin{pmatrix}-2 & 2 \\ 2 & 2\end{pmatrix}$ より、正定値にも負定値にもならないため、この点では極値をとらない 一方、$(x,y) = (1,-1)$ の時は $\nabla^2f(1,-1) = \begin{pmatrix}6 & 2 \\ 2 & 2\end{pmatrix}$ で正定値となるため、 $$ (x,y) = (1,-1) の時、極小値 -1 をとる $$ ```julia ```

ddc0d26c1cdccbf08fbcbead5c040d912ddcfe07

ipynb

Jupyter Notebook

02_machine-learning/02-03_calculus.ipynb

amenoyoya/julia_ml-tuto

9c0be0923ea00ca4d1d51c0c6f61f6f2748232be

02_machine-learning/02-03_calculus.ipynb

amenoyoya/julia_ml-tuto

9c0be0923ea00ca4d1d51c0c6f61f6f2748232be

02_machine-learning/02-03_calculus.ipynb

amenoyoya/julia_ml-tuto

9c0be0923ea00ca4d1d51c0c6f61f6f2748232be

Qwen/Qwen-72B

1. YES 2. YES

__label__yue_Hant

# Playing with Sets and Probability In this chapter, we’ll start by learning how we can make our programs understand and manipulate sets of numbers. We’ll then see how sets can help us understand basic concepts in prob- ability. Finally, we’ll learn about generating random numbers to simulate random events. Let’s get started! --- ## Set Construction In mathematical notation, you represent a set by writing the set members enclosed in curly brackets. For example, {2, 4, 6} represents a set with 2, 4, and 6 as its members. To create a set in Python, we can use the FiniteSet class from the sympy package, as follows: ```python from sympy import FiniteSet s = FiniteSet(2,4,6) s ``` $\displaystyle \left\{2, 4, 6\right\}$ ```python from sympy import FiniteSet from fractions import Fraction s = FiniteSet(1, 1.5, Fraction(1, 5)) print("Set is:" + str(s) + " and its length is:" + str(len(s))) ``` Set is:FiniteSet(1/5, 1, 1.5) and its length is:3

e9761c6f7297eff294a8e5dafea90f8bb395933e

ipynb

Jupyter Notebook

2021/Python-Maths/chapter5.ipynb

Muramatsu2602/python-study

c81eb5d2c343817bc29b2763dcdcabed0f6a42c6

2021/Python-Maths/chapter5.ipynb

Muramatsu2602/python-study

c81eb5d2c343817bc29b2763dcdcabed0f6a42c6

2021/Python-Maths/chapter5.ipynb

Muramatsu2602/python-study

c81eb5d2c343817bc29b2763dcdcabed0f6a42c6

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Matrix Formalism of the Equations of Movement > Renato Naville Watanabe > [Laboratory of Biomechanics and Motor Control](http://pesquisa.ufabc.edu.br/bmclab) > Federal University of ABC, Brazil <h1>Table of Contents<span class="tocSkip"></span></h1> <div class="toc"><ul class="toc-item"><li><span><a href="#Forward-Dynamics" data-toc-modified-id="Forward-Dynamics-1"><span class="toc-item-num">1&nbsp;&nbsp;</span>Forward Dynamics</a></span></li><li><span><a href="#Problems" data-toc-modified-id="Problems-2"><span class="toc-item-num">2&nbsp;&nbsp;</span>Problems</a></span></li><li><span><a href="#References" data-toc-modified-id="References-3"><span class="toc-item-num">3&nbsp;&nbsp;</span>References</a></span></li></ul></div> In this notebook will be shown two examples of how to use a matrix formalism to perform forward dynamics. It does not consist a comprehensive treatise about the subject. It is rather an introduction based on examples. Nevertheless, the reader of this notebook will have sufficient knowledge to read recent texts on biomechanics and other multibody dynamic analysis. ## Forward Dynamics For the forward dynamics analysis, we will consider that we know the torques and find the angular accelerations. Naturally, we could begin our analysis from the muscle forces, from the muscle activations or even from the neural commands from the motor cortex. <figure> <figcaption><i><center>Adapted from Erdemir et al. (2007) </center></i></figcaption> As an introduction to the matrix formalism used in multibody analysis, we will consider the double-pendulum system. This system could be used as a model from the arm and forearm of a subject, for example, and is an example of chaotic system. In the notebook about [free-body diagram](FreeBodyDiagramForRigidBodies.ipynb#doublependulum), we found the following equations of motion to the double-pendulum with actuators. <span class="notranslate"> \begin{align} \begin{split} \left(\frac{m_1l_1^2}{3} +m_2l_1^2\right)\frac{d^2\theta_1}{dt^2} + \frac{m_2l_1l_2}{2} \cos{(\theta_1-\theta_2)\frac{d^2\theta_2}{dt^2}} &= -\frac{m_1gl_1}{2}\sin(\theta_1)- m_2l_1g \sin(\theta_1) - \frac{m_2l_1l_2}{2}\left(\frac{d\theta_2}{dt}\right)^2 \sin(\theta_1-\theta_2) + M_1 - M_{12} \\ \frac{m_2l_1l_2}{2}\cos(\theta_1-\theta_2)\frac{d^2\theta_1}{dt^2} + \frac{m_2l_2^2}{3}\frac{d^2\theta_2}{dt^2} &= -\frac{m_2gl_2}{2}\sin(\theta_2) + \frac{m_2l_1l_2}{2}\left(\frac{d\theta_1}{dt}\right)^2 \sin(\theta_1-\theta_2)+ M_{12} \end{split} \end{align} </span> If we wanted to simulate this double pendulum we still need to isolate the angular accelerations of each of the bars. As can be easily noted, this would be too laborious to do by hand. Luckily, numerical integration is performed by computers. The easiest way to isolate these angular accelerations is to note that we can write the angular accelerations and the numbers multiplying them as a matrix and a vector. <span class="notranslate"> \begin{equation} \left[\begin{array}{cc}\frac{m_1l_1^2}{3} +m_2l_1^2&\frac{m_2l_1l_2}{2} \cos(\theta_1-\theta_2)\\\frac{m_2l_1l_2}{2}\cos(\theta_1-\theta_2)&\frac{m_2l_2^2}{3}\end{array}\right]\cdot\left[\begin{array}{c}\frac{d^2\theta_1}{dt^2}\\\frac{d^2\theta_2}{dt^2} \end{array}\right] = \left[\begin{array}{c}- \frac{m_2l_1l_2}{2}\left(\frac{d\theta_2}{dt}\right)^2 \sin(\theta_1-\theta_2)-\frac{m_1gl_1}{2}\sin(\theta_1)- m_2l_1g \sin(\theta_1) + M_1 - M_{12}\\ \frac{m_2l_1l_2}{2}\left(\frac{d\theta_1}{dt}\right)^2 \sin(\theta_1-\theta_2)-\frac{m_2gl_2}{2}\sin(\theta_2) + M_{12} \end{array}\right] \end{equation} </span> Typically the equations of motion are divided into a matrix corresponding to the terms involving the angular velocities (centrifugal and Coriolis forces), a matrix corresponding to gravitational force and another matrix corresponding to the forces and torques being applied to the system. <span class="notranslate"> \begin{equation} M(q)\ddot{q} = C(q,\dot{q}) + G(q) + Q + E \end{equation} </span> where - <span class="notranslate">$q$</span> is the vector of the generalized coordinates, like angles and positions; - <span class="notranslate">$M(q)$</span> is the matrix containing the inertia elements like mass and moments of inertia; - <span class="notranslate">$C(q,\dot{q})$</span> is the vector with the forces and moments dependent from the velocities and angular velocities, like centrifugal and Coriolis forces; - <span class="notranslate">$G(q)$</span> is the vector with the forces and torques caused by the gravitational force; - <span class="notranslate">$Q$</span> is the vector with forces and torques being applied to the body, like muscular torques and forces due to the constraints. - <span class="notranslate">$E$</span> is the vector with the forces and torques due to some external element, like springs or the Ground reaction Force. We can divide the equation describing the behavior of the double-pendulum in the matrices above: <span class="notranslate"> \begin{equation} \underbrace{\left[\begin{array}{cc}\frac{m_1l_1^2}{3} +m_2l_1^2&\frac{m_2l_1l_2}{2} \cos(\theta_1-\theta_2)\\\frac{m_2l_1l_2}{2}\cos(\theta_1-\theta_2)&\frac{m_2l_2^2}{3}\end{array}\right]}_{M}\cdot\underbrace{\left[\begin{array}{c}\frac{d^2\theta_1}{dt^2}\\\frac{d^2\theta_2}{dt^2} \end{array}\right]}_{\ddot{q}} = \underbrace{\left[\begin{array}{c}- \frac{m_2l_1l_2}{2}\left(\frac{d\theta_2}{dt}\right)^2 \sin(\theta_1-\theta_2)\\ \frac{m_2l_1l_2}{2}\left(\frac{d\theta_1}{dt}\right)^2 \sin(\theta_1-\theta_2)\end{array}\right]}_{C} + \underbrace{\left[\begin{array}{c}-\frac{m_1gl_1}{2}\sin(\theta_1)- m_2l_1g \sin(\theta_1)\\ -\frac{m_2gl_2}{2}\sin(\theta_2) \end{array}\right]}_{G} + \underbrace{\left[\begin{array}{c} M_1 - M_{12}\\M_{12} \end{array}\right]}_{Q} \end{equation} </span> To solve this differential equation numerically, we must obtain the expression of the angular accelerations. We can perform this by multiplying both sides by the inverse of the matrix $M$. <span class="notranslate"> \begin{equation} \left[\begin{array}{c}\frac{d^2\theta_1}{dt^2}\\\frac{d^2\theta_2}{dt^2} \end{array}\right] = \left[\begin{array}{cc}\frac{m_1l_1^2}{3} +m_2l_1^2&\frac{m_2l_1l_2}{2} \cos(\theta_1-\theta_2)\\\frac{m_2l_1l_2}{2}\cos(\theta_1-\theta_2)&\frac{m_2l_2^2}{3}\end{array}\right]^{-1}\cdot\left(\left[\begin{array}{c}- \frac{m_2l_1l_2}{2}\left(\frac{d\theta_2}{dt}\right)^2 \sin(\theta_1-\theta_2)\\ \frac{m_2l_1l_2}{2}\left(\frac{d\theta_1}{dt}\right)^2 \sin(\theta_1-\theta_2)\end{array}\right] + \left[\begin{array}{c}-\frac{m_1gl_1}{2}\sin(\theta_1)- m_2l_1g \sin(\theta_1)\\ -\frac{m_2gl_2}{2}\sin(\theta_2) \end{array}\right] + \left[\begin{array}{c} M_1 - M_{12}\\M_{12} \end{array}\right]\right) \end{equation} </span> Generically, having the differential equations in the format: <span class="notranslate"> \begin{equation} M(q)\ddot{q} = C(q,\dot{q}) + G(q) + Q + E \end{equation} </span> we can obtain the equation to perform the forward dynamics by: <span class="notranslate"> \begin{equation} \ddot{q} = M(q)^{-1}\left[C(q,\dot{q}) + G(q) + Q + E\right] \end{equation} </span> Now that we have the angular accelerations, to solve the equation numerically we must transform the second-order differential equations in first-order differential equations: <span class="notranslate"> \begin{equation} \left[\begin{array}{c}\frac{d\omega_1}{dt}\\\frac{d\omega_2}{dt}\\\frac{d\theta_1}{dt}\\\frac{d\theta_2}{dt} \end{array}\right] = \left[\begin{array}{c}\left[\begin{array}{cc}\frac{m_1l_1^2}{3} +m_2l_1^2&\frac{m_2l_1l_2}{2} \cos(\theta_1-\theta_2)\\\frac{m_2l_1l_2}{2}\cos(\theta_1-\theta_2)&\frac{m_2l_2^2}{3}\end{array}\right]^{-1}\left(\left[\begin{array}{c}- \frac{m_2l_1l_2}{2}\omega_2^2 \sin(\theta_1-\theta_2)\\ \frac{m_2l_1l_2}{2}\omega_1^2 \sin(\theta_1-\theta_2)\end{array}\right]+\left[\begin{array}{c} -\frac{m_1gl_1}{2}\sin(\theta_1)- m_2l_1g \sin(\theta_1) \\-\frac{m_2gl_2}{2}\sin(\theta_2) \end{array}\right] + \left[ \begin{array}{c}M_1 - M_{12}\\M_{12}\end{array}\right]\right)\\ \omega_1\\ \omega_2\end{array}\right] \end{equation} </span> Below is the numerical solution of a double-pendulum with each bar having length equal to 1 m and mass equal to 1 kg. ```python import numpy as np g = 9.81 m1 = 1 m2 = 1 l1 = 1 l2 = 0.5 theta10 = np.pi/10 theta20 = np.pi/3 omega10 = 2*np.pi omega20 = -6*np.pi dt = 0.0001 t = np.arange(0, 20, dt) state = np.zeros((4, len(t))) state[:,0] = np.array([omega10, omega20, theta10, theta20]) #print(state[0,0]) M1 = 0 M12 = 0 for i in range(1,len(t)): thetaDiff = state[2,i-1] - state[3,i-1] M = np.array([[m1*l1**2/3 + m2*l1**2, m2*l1*l2*np.cos(thetaDiff)/2], [m2*l1*l2*np.cos(thetaDiff)/2, m2*l2**2/3]]) C = np.array([[-m2*l1*l2*np.sin(thetaDiff)*state[1,i-1]**2/2], [m2*l1*l2*np.sin(thetaDiff)*state[0,i-1]**2/2]]) G = np.array([[-m1*g*l1/2*np.sin(state[2,i-1]) - m2*g*l2*np.sin(state[2,i-1])], [-m2*g*l2/2*np.sin(state[3,i-1])]]) #PID control #r = np.pi/3 #M12 = 30*(r-state[3,i-1])- 2*state[1,i-1] + 3*np.trapz(r-state[3,0:i])*dt Q = np.array([[M1 - M12],[M12]]) dstatedt = np.vstack((np.linalg.inv(M)@(C+G+Q),state[0,[i-1]],state[1,[i-1]])) state[:,[i]] = state[:,[i-1]] + dt*dstatedt ``` ```python import matplotlib.pyplot as plt %matplotlib notebook plt.figure() plt.plot(t[0::10], state[3,0::10].T) #plt.plot(t[0::10], r*np.ones_like(t[0::10])) plt.show() ``` <IPython.core.display.Javascript object> ```python plt.figure() step = 3000 for i in range(len(state[2,0::step])): plt.plot([0, l1*np.sin(state[2,i*step])], [0, -l1*np.cos(state[2,i*step])]) plt.plot([l1*np.sin(state[2,i*step]), l1*np.sin(state[2,i*step])+l2*np.sin(state[3,i*step])], [-l1*np.cos(state[2,i*step]), -l1*np.cos(state[2,i*step])-l2*np.cos(state[3,i*step])]) plt.show() ``` <IPython.core.display.Javascript object> ## Problems 1) Solve the problems 19.3.20 and 19.3.24 of the Ruina and Rudra's book by using the Lagrangian formalism (it is much easier than use the Newton-Euler formalism) and then use the matrix formalism to obtain the expressions of the angular accelerations. ## References - YAMAGUCHI, G. T. Dynamic modeling of musculoskeletal motion: a vectorized approach for biomechanical analysis in three dimensions., 2001 - CRAIG, J. Introduction to robotics. , 1989 - JAIN, A. Robot and multibody dynamics. , 2011 - SPONG, M. W.; HUTCHINSON, S.; VIDYASAGAR, M. Robot modeling and control., 2006 - ERDEMIR, A. et al. Model-based estimation of muscle forces exerted during movements. Clinical Biomechanics, v. 22, n. 2, p. 131–154, 2007. - STANEV, D.; MOUSTAKAS, K. Simulation of constrained musculoskeletal systems in task space. IEEE Transactions on Biomedical Engineering, v. 65, n. 2, p. 307–318, 2018. - ZAJAC FE, GORDON ME , [Determining muscle's force and action in multi-articular movement](https://drive.google.com/open?id=0BxbW72zV7WmUcC1zSGpEOUxhWXM&authuser=0). Exercise and Sport Sciences Reviews, 17, 187-230. , 1989 - RUINA A, RUDRA P. [Introduction to Statics and Dynamics](http://ruina.tam.cornell.edu/Book/index.html). Oxford University Press. , 2015

e372f94fd3bec4363e13e0683e19ffe883378854

ipynb

Jupyter Notebook

notebooks/MatrixFormalism.ipynb

rnwatanabe/BMC

545c4c28125684a707641fd97f5d92f303020c47

2021-03-15T20:07:52.000Z

2021-03-15T20:07:52.000Z

notebooks/.ipynb_checkpoints/MatrixFormalism-checkpoint.ipynb

guinetn/BMC

ae2d187a5fb9da0a2711a1ed56b87a3e1da0961f

notebooks/.ipynb_checkpoints/MatrixFormalism-checkpoint.ipynb

guinetn/BMC

ae2d187a5fb9da0a2711a1ed56b87a3e1da0961f

2018-10-13T17:35:16.000Z

2018-10-13T17:35:16.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

$$ \LaTeX \text{ command declarations here.} \newcommand{\N}{\mathcal{N}} \newcommand{\R}{\mathbb{R}} \renewcommand{\vec}[1]{\mathbf{#1}} \newcommand{\norm}[1]{\|#1\|_2} \newcommand{\d}{\mathop{}\!\mathrm{d}} \newcommand{\qed}{\qquad \mathbf{Q.E.D.}} \newcommand{\vx}{\mathbf{x}} \newcommand{\vy}{\mathbf{y}} \newcommand{\vt}{\mathbf{t}} \newcommand{\vb}{\mathbf{b}} \newcommand{\vw}{\mathbf{w}} $$ ```python %matplotlib inline from Lec07 import * ``` # EECS 445: Introduction to Machine Learning ## Lecture 06: Logistic Regression * Instructor: **Jacob Abernethy** and **Jia Deng** * Date: September 26, 2016 *Lecture Exposition Credit:* Benjamin Bray, Saket Dewangan ## Outline - Concept of Classification - Logistic Regression - Intuition, Motivation - Newton's Method ## Reading List - Suggested: - **[MLAPP]**, Chapter 8: Logistic Regression > In this lecture, we will move from regression to classification.Unlike of predicting some value for data in regression, we predict what category data belongs to in classification. And we will introduce logistic regression. In logistic regression, we will show how to find the optimal coefficients $\vw$ using Newton's method. ## Review: Supervised Learning - Goal - Given data $X$ in feature sapce and the labels $Y$ - Learn to predict $Y$ from $X$ - Labels could be discrete or continuous - Discrete-valued labels: Classification - Continuous-valued labels: Regression <center> </center> ## Classification Problem ### Classification Problem: Basics - Given an input vector $\vx$, assign it to one of $K$ distinct classes $C_k$, where $k = 1,\dots,K$. - The case $K=2$ is **Binary Classification** - Label $t=1$ means $x \in C_1$ - Label $t=0$ means $x \in C_2$ (or sometimes $t=-1$) - **Training:** Learn a classifier $y(\vx)$ from data, $$ \text{Training Data} \quad \{ (\vx_1, t_1), \dots, (\vx_N, t_N) \} \implies \text{Classifier} \ y(\vx) $$ - **Prediction:** Predict labels of new data, $$ \text{New Data} \quad \{ (\vx^{new}_1, t^{new}_1), \dots, (\vx^{new}_m, t^{new}_m) \} \stackrel{h}{\implies} \{ y(\vx^{new}_1), \dots, y(x^{new}_m) \} $$ - **Performance Evaluation:** Evaluate learned classifier on test data, $$ \text{Test Data} \quad \{ (\vx^{test}_1, t^{test}_1), \dots, (\vx^{test}_m, t^{test}_m) \} \stackrel{y}{\implies} \{ y(\vx^{test}_1), \dots, y(\vx^{test}_m) \} \implies \text{Error Estimate} $$ - To estimate **classification error**, we could use e.g. *zero-one loss*: $$ E = \frac{1}{m} \sum_{j=1}^m \mathbb{1} [ y(\vx^{test}_j) \neq t^{test}_j) ] $$ i.e. number of misclassified data. ### Classification Problems: Strategies - **Nearest-Neighbors:** Given query data $\vx$, find closest training points and do a majority vote. - **Discriminant Functions:** Learn a function $y(\vx)$ mapping $\vx$ to some class $C_k$. - **Probabilistic Model:** Learn the distributions $P(C_k | \vx)$ - *Discriminative Models* directly model $P(C_k | \vx)$ and learn parameters from the training set. - *Generative Models* learn class-conditional densities $P(\vx | C_k)$ and priors $P(C_k)$ ## Logistic Regression > - Logistic Regression is a technique for **classification**! > - We will focus on *binary* classification ### Logistic Regression: Preliminary—Logistic Sigmoid Function - The **logistic sigmoid function** is $$ \sigma(a) = \frac{1}{1 + \exp(-a)} = \frac{\exp(a)}{1 + \exp(a)} $$ - Sigmoid function $\sigma(a)$ maps $(-\infty, +\infty) \to (0,1)$ <center> </center> ### Logistic Regression: Why use Logistic Sigmoid Function? - Prediction is picking the larger one of $P(y=1 | \vx)$ and $P(y=0 | \vx)$. - This can be implemented by evaluating **log odds** $$ a = \ln \frac{P(y=1 | \vx)}{P(y=0 | \vx)} $$ - So the prediction is $$ y = \left\{\begin{matrix} 1& a\geq 0\\ 0& a< 0 \end{matrix}\right. $$ - Since $P(y=1 | \vx) + P(y=0 | \vx)=1$, we could solve for $$ P(y=1 | \vx) = \frac{\exp(a)}{1+\exp(a)} = \sigma(a) $$ *Logistic Function* appears! - A heuristic choice for log odds is a separating **hyper plane** $a = \vw^T \phi(\vx)$. So the criterion becomes $$ \boxed{ y = \left\{\begin{matrix} 1& \vw^T \phi(\vx)\geq 0, \quad \text{i.e.} \quad \sigma(\vw^T\phi(\vx)\geq 0) \geq 0.5\\ 0& \vw^T \phi(\vx)< 0 , \quad \text{i.e.} \quad \sigma(\vw^T\phi(\vx)\geq 0) < 0.5 \end{matrix}\right.} $$ - In this case, $P(y=1 | \vx) = \sigma(\vw^T \phi(\vx))$ and $P(y=0 | \vx) = 1-\sigma(\vw^T \phi(\vx))$. ### Logistic Regression: Underlying Model - We already have $$ \begin{align} P(y=1 | \vx, \vw) &= \sigma(\vw^T \phi(\vx)) \\ P(y=0 | \vx, \vw) &= 1-\sigma(\vw^T \phi(\vx)) \end{align} $$ - So we could model **class posterior** using Bernoulli random variable $$ y | \vx ,\vw \sim \mathrm{Bernoulli}( \sigma(\vw^T \phi(\vx)) ) $$ - We can obtain the best paramter $\vw$ by maximizing the likelihood of the training data.(Later) - Logistic regression is simpest discriminative model that is **linear** in the parameters. ### Logistic Regression: Example ```python plt.figure(figsize=(10,6)); plot_linear_boundary(); ``` - We could clearly see the linear boundary corresponding to $\vw^T \phi(\vx)$ ### Logistic Regression: Likelihood - We saw before that the **likelihood** for each binary label is: $$ \begin{align} P(y = 1 | \vx,\vw) &= \sigma(\vw^T \phi(\vx)) \\ P(y = 0 | \vx,\vw) &= 1 - \sigma(\vw^T \phi(\vx)) \end{align} $$ - With a clever trick, this $$ P(y | x,w) = \sigma(\vw^T \phi(\vx))^y \cdot (1 - \sigma(\vw^T \phi(\vx)))^{1-y} $$ - For a data set $\{(\vx_n, t_n) \}_{n=1}^N$ where $t_n \in \{ 0,1 \}$, the **likelihood function** is $$ P(\vy = \vt| \mathcal{X}, \vw) = \prod_{n=1}^N P(y=t_n | \vx_n, \vw) =\prod_{n=1}^N \sigma(\vw^T \phi(\vx_n))^{t_n} [1 - \sigma(\vw^T \phi(\vx_n))] ^{1-t_n} $$ - where $\mathcal{X} = \{\vx_n \}_{n=1}^N$ - The optimal $\vw$ can be obtained by maximizing this likelihood. - Maximum likelihood estimate $\vw_{ML}$ makse sense because $\vw_{ML}$ is the coefficient that are most likely to produce $\{t_n \}_{n=1}^N$ given $\mathcal{X}$. - Define **negative log-likelihood** as the **loss** $$ E(\vw) \triangleq -\ln P(\vy = \vt| \mathcal{X}, \vw) $$ - Maximizing **likelihood** is equivalent to minimizing **loss** $E(\vw)$ ### Logistic Regression: Gradient of Loss - Loss function $E(\vw)$ can be transformed: $$ \begin{align} E(\vw) &= -\ln P(\vy = \vt| \mathcal{X}, \vw) \\ &= -\ln \prod \nolimits_{n=1}^N \sigma(\vw^T \phi(\vx_n))^{t_n} [1 - \sigma(\vw^T \phi(\vx_n))] ^{1-t_n} \\ &= -\sum \nolimits_{n=1}^N \left[ t_n \ln \sigma(\vw^T \phi(\vx_n)) + (1-t_n) \ln(1-\sigma(\vw^T \phi(\vx_n))) \right] \\ &= -\sum \nolimits_{n=1}^N \left[ t_n \ln \frac{\exp(\vw^T\phi(\vx_n))}{1+\exp(\vw^T\phi(\vx_n))} + (1-t_n) \ln(\frac{1}{1+\exp(\vw^T\phi(\vx_n))}) \right] \\ &= -\sum \nolimits_{n=1}^N \left[ t_n \ln \frac{1}{1+\exp(-\vw^T\phi(\vx_n))} + (1-t_n) \ln(\frac{1}{1+\exp(\vw^T\phi(\vx_n))}) \right] \\ &= \boxed{\sum \nolimits_{n=1}^N \left[ t_n \ln (1+\exp(-\vw^T\phi(\vx_n))) + (1-t_n) \ln(1+\exp(\vw^T\phi(\vx_n))) \right] }\\ \end{align} $$ - Gradient of loss $\nabla_\vw E(\vw)$ $$ \begin{align} \nabla_\vw E(\vw) &= \nabla_\vw \sum \nolimits_{n=1}^N \left[ t_n \ln (1+\exp(-\vw^T\phi(\vx_n))) + (1-t_n) \ln(1+\exp(\vw^T\phi(\vx_n))) \right] \\ &= \sum \nolimits_{n=1}^N \left[-t_n \frac{\exp(-\vw^T\phi(\vx_n))}{1+\exp(-\vw^T\phi(\vx_n))} \phi(\vx_n)+ (1-t_n) \frac{\exp(\vw^T\phi(\vx_n))}{1+\exp(\vw^T\phi(\vx_n))} \phi(\vx_n) \right] \\ &= \sum \nolimits_{n=1}^N \left[-t_n (1-\sigma(\vw^T\phi(\vx_n)))+ (1-t_n) \sigma(\vw^T\phi(\vx_n)) \right] \phi(\vx_n) \\ &= \sum \nolimits_{n=1}^N \left[\sigma(\vw^T\phi(\vx_n)) - t_n \right] \phi(\vx_n) \\ &= \boxed{ \Phi^T \left( \sigma(\Phi \vw) - \vt \right) } \end{align} $$ of which $$ \Phi = \begin{bmatrix} - & \phi(\vx_1)^T & -\\ & \vdots & \\ - & \phi(\vx_N)^T & - \end{bmatrix}_{N \times M} \qquad \sigma(\Phi \vw)=\begin{bmatrix} \sigma(\vw^T\phi(\vx_1))\\ \vdots\\ \sigma(\vw^T\phi(\vx_N)) \end{bmatrix}_{N \times 1} \qquad \vt = \begin{bmatrix} t_1\\ \vdots\\ t_N \end{bmatrix}_{N \times 1} $$ - With the gradient of loss, we could perform *gradient descent* to find $\vw_{ML}$. - But we will use a new method by finding roots of first order derivative! > Remark > - Note that this gradient resembles the gradient in linear regression with least squares (Check Lecture 4) $$ \begin{align} \text{Logistic Regression} \quad & \nabla_\vw E(\vw) = \Phi^T \left( \sigma(\Phi \vw) - \vt \right) \\ \text{Linear Regression} \quad & \nabla_\vw E(\vw) = \Phi^T \left( \Phi \vw - \vt \right) \end{align} $$ ### Newton's Method: Overview - First let's consider one dimension case. - **Goal:** Finding *root* of a general function $f(x)$, i.e. solve for $x$ such that $$f(x)=0$$ - **Newton's Method:** Repeat until convergence: $$ x_{n+1} = x_n - \frac{f(x_n)}{f'(x_n)} $$ ### Newton's Method: Geometric Intuition - Find the roots of $f(x)$ by following its **tangent lines**. The tangent line of $f(x)$ at $x_n$ has equation $$ \ell(x) = f(x_n) + (x-x_n) f'(x_n) $$ - Set next iterate $x_{n+1}$ to be **root** of tangent line: $$ \begin{gather} f(x_n) + (x-x_n) f'(x_n) = 0 \\ \implies \boxed{ x_{n+1}= x_n - \frac{f(x_n)}{f'(x_n)} } \end{gather} $$ <center> </center> ### Newton's Method: Example ```python def fn(x): return (x-2)**3; def d1(x): return 3*(x-2)**2; newton_example(fn,d1) ``` > Remark > - Here is how Newton's method works > - Given some initial point $x_1$, we first find the tangent line $\ell_1(x)$ of $f(x)$ at $x_1$. > - Let $x_2$ denote the root of $\ell_1(x)$, i.e. $\ell_1(x_2)=0$ > - Find the tangent line $\ell_2(x)$ of $f(x)$ at $x_2$. > - Let $x_3$ denote the root of $\ell_2(x)$, i.e. $\ell_1(x_3)=0$ ### Newton's Method: Finding Stationary Point - We have shown how to use Newton's method to find the root for $f(x)$ $$ x_{n+1}= x_n - \frac{f(x_n)}{f'(x_n)} $$ - **Note** that Stationary point of $f(x)$ is equivalent to root of $f'(x)$ - So, we could find stationary point of $f(x)$ by finding root of $f'(x)$ using Newton's method. - The iteration steps becomes $$ x_{n+1}= x_n - \frac{f'(x_n)}{f''(x_n)} $$ - For *multi-dimension* case, this iteration turns into $$ \vx_{n+1}= \vx_n - \left(\nabla^2 f(\vx_n)\right)^{-1} \nabla_\vx f(\vx_n) $$ of which $\nabla^2 f(\vx_n)$ is **Hessian matrix** which is the *second order derivative* $$ \nabla^2 f = \begin{bmatrix} \frac{\partial f}{\partial x_1\partial x_1} & \cdots & \frac{\partial f}{\partial x_1\partial x_n}\\ \vdots & \ddots & \vdots\\ \frac{\partial f}{\partial x_n\partial x_1} & \cdots & \frac{\partial f}{\partial x_n\partial x_n} \end{bmatrix} $$ ### Logistic Regression: Applying Newton's Method - Back to logistic regression! - Recall our goal to minimize $E(\vw)$ and we already have its gradient $$ \nabla_\vw E(\vw) = \sum \nolimits_{n=1}^N \left[\sigma(\vw^T\phi(\vx_n)) - t_n \right] \phi(\vx_n) = \Phi^T \left( \sigma(\Phi \vw) - \vt \right) $$ - To minimize of $E(\vw)$, we could use Newton's method to find its *stationary point*! - To use Newton's method, we need the *Hessian matrix*. ### Logistic Regression: Hessian Matrix $$ \begin{align} \nabla^2 E(\vw) &= \nabla_\vw \nabla_\vw E(\vw) \\ &= \nabla_\vw \sum \nolimits_{n=1}^N \left[\sigma(\vw^T\phi(\vx_n)) - t_n \right] \phi(\vx_n) \\ &= \sum \nolimits_{n=1}^N \nabla_\vw \sigma(\vw^T\phi(\vx_n)) \phi(\vx_n) \\ &= \sum \nolimits_{n=1}^N \nabla_\vw \frac{1}{1 + \exp(-\vw^T \phi(\vx_n))} \phi(\vx_n) \\ &= \sum \nolimits_{n=1}^N \phi(\vx_n) \frac{\exp(-\vw^T \phi(\vx_n))}{(1 + \exp(-\vw^T \phi(\vx_n)))^2} \phi(\vx_n)^T \\ &= \sum \nolimits_{n=1}^N \phi(\vx_n) \frac{1}{1 + \exp(-\vw^T \phi(\vx_n))} \frac{\exp(-\vw^T \phi(\vx_n))}{1 + \exp(-\vw^T \phi(\vx_n))} \phi(\vx_n)^T \\ &= \sum \nolimits_{n=1}^N \phi(\vx_n) [\sigma(\vw^T \phi(\vx_n)) \cdot ( 1 - \sigma(\vw^T \phi(\vx_n)) )] \phi(\vx_n)^T \\ &= \sum \nolimits_{n=1}^N \phi(\vx_n) r_n(\vw) \phi(\vx_n)^T \end{align} $$ - of which $r_n(\vw) = \sigma(\vw^T \phi(\vx_n)) \cdot ( 1 - \sigma(\vw^T \phi(\vx_n)) )$ $$ \begin{align} H_\vw E(\vw) &= \sum \nolimits_{n=1}^N \phi(\vx_n) r_n(\vw) \phi(\vx_n)^T \\ &= \begin{bmatrix} | & & | \\ \phi(\vx_1) & \cdots & \phi(\vx_N)\\ | & & | \end{bmatrix} \begin{bmatrix} r_1(\vw) & & \\ & \ddots & \\ & & r_N(\vw) \end{bmatrix} \begin{bmatrix} - & \phi(\vx_1)^T & -\\ & \vdots & \\ - & \phi(\vx_N)^T & - \end{bmatrix} \\ &= \boxed{\Phi^T R(\vw) \Phi} \end{align} $$ - of which $$ R(\vw) = \begin{bmatrix} r_1(\vw) & & & \\ & r_2(\vw) & & \\ & & \ddots & \\ & & & r_N(\vw) \end{bmatrix} $$ ### Logistic Regression: Applying Newton's Method - We already have $$ \begin{gather} \nabla_\vw E(\vw) = \Phi^T \left( \sigma(\Phi \vw) - \vt \right) \\ H_\vw E(\vw) = \Phi^T R(\vw) \Phi \end{gather} $$ - So the iteration step is $$ \begin{align} \vw_{n+1} &= \vw_n - \left(H_\vw E(\vw_n)\right)^{-1} \nabla_\vw f(\vw_n) \\ &= \boxed{\vw_n - \left(\Phi^T R(\vw_n) \Phi \right)^{-1} \Phi^T \left( \sigma(\Phi \vw_n) - \vt \right)} \end{align} $$ - Repeat until convergence and we could get maximum likelihood estimate $\vw_{ML}$ which minimizes the loss function $E(\vw)$ and maximizes likelihood function $ P(\vy = \vt| \mathcal{X}, \vw)$ ### Logistic Regression: Do we have closed-form solution? - Recall for **ordinary least squares** and **regularized least squares**, we have closed-form solution: | | Ordinary Least Squares | Regularized Least Squares | | ------------- | :-------------: | :-------------: | | **Derivate of Loss Function** | $\Phi^T\Phi \vec{w} - \Phi^T \vec{t}$ | $(\Phi^T \Phi + \lambda I)\vec{w} - \Phi^T \vec{t}$ | | **Closed-form Solution** | $(\Phi^T \Phi)^{-1} \Phi^T \vec{t}$ | $(\Phi^T \Phi + \lambda I)^{-1} \Phi^T \vec{t}$ | - They are obtained by finding the closed-form root of derivative of loss function。 - For logistic regression, we have $$ \begin{gather} \nabla_\vw E(\vw) = 0 \\ \Downarrow \\ \Phi^T \left( \sigma(\Phi \vw) - \vt \right) = 0 \end{gather} $$ - Existence of sigmoid function makes $\nabla_\vw E(\vw)$ **nonlinear** and no closed-form solution exists. - So we must **iterate**! ### Appendix: Multi-class Classification using Logistic Regression - We have seen sigmoid function enables us to do binary classification with logistic regression. - What if we want have multiple classes? - We will resort to **softmax** aka **normalized exponential** function - **Softmax Function** $$ p_k = \frac{\exp(q_k)}{\sum_j \exp(q_j)} $$ Given any real numbers $q_1, \ldots, q_n$, we can generate a distribution on them using softmax function. - Recall in binary case, we have $$ P(y = 1 | \vx,\vw) = \sigma(\vw^T \phi(\vx)) $$ - For K-class classification, we define $\mathcal{W} = {\vw}_{k=1}^K$. - The probablity data $\vx$ belongs to class $j$ is $$ P(y = j | \vx,\mathcal{W}) = \frac{\exp(\vw_j^T \phi(\vw))}{\sum_{k=1}^{K} \exp(\vw_k^T \phi(\vw))} $$ - We classify using $$ y = \underset{j \in \{1,\dots, K\}}{\arg \max} P(y = j | \vx,\mathcal{W}) $$ - Similarly, $\mathcal{W} = {\vw}_{k=1}^K$ is learned by maximizing likelihood function. - For details, please refer to [this](http://ufldl.stanford.edu/wiki/index.php/Softmax_Regression)

408856fd3539ddb6830f7c690986f3888070e954

ipynb

Jupyter Notebook

lecture06_logistic_regression/lecture06_logistic-regression.ipynb

xipengwang/umich-eecs445-f16

298407af9fd417c1b6daa6127b17cb2c34c2c772

2016-09-11T23:15:35.000Z

2022-02-22T08:03:24.000Z

lecture06_logistic_regression/lecture06_logistic-regression.ipynb

eecs445-f16/umich-eecs445-f16

298407af9fd417c1b6daa6127b17cb2c34c2c772

lecture06_logistic_regression/lecture06_logistic-regression.ipynb

eecs445-f16/umich-eecs445-f16

298407af9fd417c1b6daa6127b17cb2c34c2c772

2016-09-12T20:50:46.000Z

2022-01-03T14:41:23.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

## Week 3 MA544 --- **Objectives and Plan** 1. Pseudo-inverse (Perron-Frobenius inverse) Properties 1. Linear Systems of Equations and Gaussian Elimination with pivoting 1. LU Decomposition of A 1. QR Decomposition of a matrix 1. Iterative solution of Linear Systems ```python #IMPORT import numpy as np import matplotlib.pyplot as plt import matplotlib.image as mpimg %matplotlib inline from ipywidgets import interact, interactive, fixed, interact_manual import ipywidgets as widgets ## Set a seed for the random number generator np.random.seed(100) ``` ## Linear System of Equations --- Consider the following system of $m$ linear equations in $n$ variables. \begin{align} a_{11} x_1 + a_{12} x_2 + \cdots + a_{1n} x_n &= b_1 \\ a_{21} x_1 + a_{22} x_2 + \cdots + a_{2n} x_n &= b_2 \\ \vdots \qquad \qquad & \ \\ a_{m1} x_1 + a_{m2} x_2 + \cdots + a_{mn} x_n &= b_ m, \end{align} - The solution of a linear system represents the **point of intersection of hyperplanes** $$ x_1 \begin{pmatrix}a_{11}\\a_{21}\\ \vdots \\a_{m1}\end{pmatrix} + x_2 \begin{pmatrix}a_{12}\\a_{22}\\ \vdots \\a_{m2}\end{pmatrix} + \cdots + x_n \begin{pmatrix}a_{1n}\\a_{2n}\\ \vdots \\a_{mn}\end{pmatrix} = \begin{pmatrix}b_1\\b_2\\ \vdots \\b_m\end{pmatrix} $$ - The solution also represents the **linear coding of the columns** of a matrix $A$ to get a vector $b$ in the column space ($\mathcal{R}(A)$). - The system could be represented in a compact form as $Ax = b$, where $$ A= \begin{pmatrix} a_{11} & a_{12} & \cdots & a_{1n} \\ a_{21} & a_{22} & \cdots & a_{2n} \\ \vdots & \vdots & \ddots & \vdots \\ a_{m1} & a_{m2} & \cdots & a_{mn} \end{pmatrix},\quad \mathbf{x}= \begin{pmatrix} x_1 \\ x_2 \\ \vdots \\ x_n \end{pmatrix},\quad \mathbf{b}= \begin{pmatrix} b_1 \\ b_2 \\ \vdots \\ b_m \end{pmatrix} $$ >- The system is called... >>- overdetermined when $m > n$. >>- underdetermined when $ m < n$. ## Gaussian elimination with scaled-row partial pivoting --- >- What is the need for pivoting? >- How can you find a factorization of the matrix by using the followign code. >- How can you modify the code to find the determinant of a matrix? >- How can you modify the following code to solve a linear system? >- How can you modify the code to find the inverse of a matrix? ```python ## Gaussian Elimination: Scaled Row Pivoting ## This function is based on the pseudo-code on page-148 in the Text by Kincaid and Cheney def GE_rsp(A): ''' This function returns the P'LU factorization of a square matrix A by scaled row partial pivoting. In place of returning L and U, elements of modified A are used to hold values of L and U. ''' m,n = A.shape L = np.eye(n) # Not being used U = np.zeros_like(A) # Not being used if m !=n: sys.exit("This function needs a square matrix as an input.") # The initial ordering of rows p = list(range(n)) # Scaling vector: absolute maximum elements of each row s = np.max(np.abs(A), axis=1) print("Scaling Vector: ",s) # Start the k-1 passes of Guassian Elimination on A for k in range(n-1): print("\n PASS {}: \n".format(k+1), A) # Find the pivot element and interchange the rows pivot_index = k + np.argmax(np.abs(A[p[k:], k])/s[p[k:]]) # Interchange element in the permutation vector if pivot_index !=k: temp = p[k] p[k]=p[pivot_index] p[pivot_index] = temp print("permutation vector: ",p) print("\n Pivot Element: {0:.2f} \n".format(A[p[k],k])) if np.abs(A[p[k],k]) < 10**(-20): sys.exit("ERROR!! Provided matrix is singular.") # For the k-th pivot row Perform the Gaussian elimination on the following rows for i in range(k+1, n): # Find the multiplier z = A[p[i],k]/A[p[k],k] #Save z in A itself. You can save this in L also A[p[i],k] = z #Elimination operation: Changes all elements in a row simultaneously ## A[p[i],k+1:] -= z*A[p[k],k+1:] return A, p ``` ```python ## Example on page number 146 (Kincaid Cheney). ## Example solved manually in class A = np.array([[2, 3, -6], [1,-6,8], [3, -2, 1]], dtype=float) print("\n Given A: \n ",A) A,p =GE_rsp(A) print("\n After Gaussian Elimination with RSPP: \n", A) print("\n The permutation Vector is: \n", p) ``` Given A: [[ 2. 3. -6.] [ 1. -6. 8.] [ 3. -2. 1.]] Scaling Vector: [6. 8. 3.] PASS 1: [[ 2. 3. -6.] [ 1. -6. 8.] [ 3. -2. 1.]] permutation vector: [2, 1, 0] Pivot Element: 3.00 PASS 2: [[ 0.66666667 4.33333333 -6.66666667] [ 0.33333333 -5.33333333 7.66666667] [ 3. -2. 1. ]] permutation vector: [2, 0, 1] Pivot Element: 4.33 After Gaussian Elimination with RSPP: [[ 0.66666667 4.33333333 -6.66666667] [ 0.33333333 -1.23076923 -0.53846154] [ 3. -2. 1. ]] The permutation Vector is: [2, 0, 1] ### LU Factorization --- One can use the Gaussian elimination to decompose the matrix A as follows $$ P A = L U,\text{ or }\ A = P^T L U; $$ where $P$ is a permutation matrix, $L$ is a unit lower-triangular matrix and $U$ is an upper triangular matrix. ```python print("\n Upper triangular, U:\n ", np.triu(A[p,:])) print("\n Lower triangular, L:\n", np.tril(A[p,:], -1)+np.eye(3)) print("The Permutation Matrix, P:\n",np.eye(3)[p,:]) ``` Upper triangular, U: [[ 3. -2. 1. ] [ 0. 4.33333333 -6.66666667] [ 0. 0. -0.53846154]] Lower triangular, L: [[ 1. 0. 0. ] [ 0.66666667 1. 0. ] [ 0.33333333 -1.23076923 1. ]] The Permutation Matrix, P: [[ 0. 0. 1.] [ 1. 0. 0.] [ 0. 1. 0.]] ## Iterative Methods for Linear Systems --- ### Jacobi Method ```python # You can modify this code to answer the following ''' Jacobi's iteration method for solving the system of equations Ax=b. p0 is the initialization for the iteration. ''' def jacobi(A, b, p0, tol, maxIter=100): n=len(A) p = p0 for k in range(maxIter): p_old = p.copy() # In python assignment is not the same as copy # Update every component of iterant p for i in range(n): sumi = b[i]; for j in range(n): if i==j: # Diagonal elements are not included in Jacobi continue; sumi = sumi - A[i,j] * p_old[j] p[i] = sumi/A[i,i] rel_error = np.linalg.norm(p-p_old)/n # print("Relative error in iteration", k+1,":",rel_error) if rel_error<tol: print("TOLERANCE MET BEFORE MAX-ITERATION") break return p; ``` ```python # Example System A = np.array([[10, -1, 2, 0], [-1, 11, -1, 3], [2, -1, 10, -1], [0, 3, -1, 8]],dtype=float) b = np.array([6, 25, -11, 15],dtype=float) ``` ```python ```

cfa70841a5d6f982f2bdcad37ec67c89733d9e1d

ipynb

Jupyter Notebook

course_notes/MA544 Share/NB3 MA544.ipynb

jschmidtnj/ma544-final-project

61fb57d344ad4f693eb697015ed926988402186f

2021-03-23T01:48:51.000Z

2022-02-01T22:49:47.000Z

course_notes/MA544 Share/NB3 MA544.ipynb

jschmidtnj/ma544-final-project

61fb57d344ad4f693eb697015ed926988402186f

course_notes/MA544 Share/NB3 MA544.ipynb

jschmidtnj/ma544-final-project

61fb57d344ad4f693eb697015ed926988402186f

2021-05-05T01:35:11.000Z

2021-05-05T01:35:11.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

```python from preamble import * %matplotlib notebook import matplotlib as mpl mpl.rcParams['legend.numpoints'] = 1 ``` ## Evaluation Metrics and scoring ### Metrics for binary classification ```python from sklearn.model_selection import train_test_split data = pd.read_csv("data/bank-campaign.csv") X = data.drop("target", axis=1).values y = data.target.values X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0) ``` ```python from sklearn.dummy import DummyClassifier dummy_majority = DummyClassifier(strategy='most_frequent').fit(X_train, y_train) pred_most_frequent = dummy_majority.predict(X_test) print("predicted labels: %s" % np.unique(pred_most_frequent)) print("score: %f" % dummy_majority.score(X_test, y_test)) ``` predicted labels: ['no'] score: 0.887540 ```python from sklearn.tree import DecisionTreeClassifier tree = DecisionTreeClassifier(max_depth=2).fit(X_train, y_train) pred_tree = tree.predict(X_test) tree.score(X_test, y_test) ``` 0.90278721957851804 ```python from sklearn.linear_model import LogisticRegression dummy = DummyClassifier().fit(X_train, y_train) pred_dummy = dummy.predict(X_test) print("dummy score: %f" % dummy.score(X_test, y_test)) logreg = LogisticRegression(C=0.1).fit(X_train, y_train) pred_logreg = logreg.predict(X_test) print("logreg score: %f" % logreg.score(X_test, y_test)) ``` dummy score: 0.803729 logreg score: 0.912013 #### Confusion matrices ```python from sklearn.metrics import confusion_matrix confusion = confusion_matrix(y_test, pred_logreg) print(confusion) ``` [[8911 228] [ 678 480]] ```python mglearn.plots.plot_binary_confusion_matrix() ``` <IPython.core.display.Javascript object> ```python print("Most frequent class:") print(confusion_matrix(y_test, pred_most_frequent)) print("\nDummy model:") print(confusion_matrix(y_test, pred_dummy)) print("\nDecision tree:") print(confusion_matrix(y_test, pred_tree)) print("\nLogistic Regression") print(confusion_matrix(y_test, pred_logreg)) ``` Most frequent class: [[9139 0] [1158 0]] Dummy model: [[8111 1028] [1024 134]] Decision tree: [[8809 330] [ 671 487]] Logistic Regression [[8911 228] [ 678 480]] ##### Relation to accuracy \begin{equation} \text{Accuracy} = \frac{\text{TP} + \text{TN}}{\text{TP} + \text{TN} + \text{FP} + \text{FN}} \end{equation} #### Precision, recall and f-score \begin{equation} \text{Precision} = \frac{\text{TP}}{\text{TP} + \text{FP}} \end{equation} \begin{equation} \text{Recall} = \frac{\text{TP}}{\text{TP} + \text{FN}} \end{equation} \begin{equation} \text{F} = 2 \cdot \frac{\text{precision} \cdot \text{recall}}{\text{precision} + \text{recall}} \end{equation} ```python from sklearn.metrics import f1_score print("f1 score most frequent: %.2f" % f1_score(y_test, pred_most_frequent, pos_label="yes")) print("f1 score dummy: %.2f" % f1_score(y_test, pred_dummy, pos_label="yes")) print("f1 score tree: %.2f" % f1_score(y_test, pred_tree, pos_label="yes")) print("f1 score: %.2f" % f1_score(y_test, pred_logreg, pos_label="yes")) ``` f1 score most frequent: 0.00 f1 score dummy: 0.12 f1 score tree: 0.49 f1 score: 0.51 /home/andy/checkout/scikit-learn/sklearn/metrics/classification.py:1117: UndefinedMetricWarning: F-score is ill-defined and being set to 0.0 due to no predicted samples. 'precision', 'predicted', average, warn_for) ```python from sklearn.metrics import classification_report print(classification_report(y_test, pred_most_frequent, target_names=["no", "yes"])) ``` precision recall f1-score support no 0.89 1.00 0.94 9139 yes 0.00 0.00 0.00 1158 avg / total 0.79 0.89 0.83 10297 /home/andy/checkout/scikit-learn/sklearn/metrics/classification.py:1117: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. 'precision', 'predicted', average, warn_for) ```python print(classification_report(y_test, pred_tree, target_names=["no", "yes"])) ``` precision recall f1-score support no 0.93 0.96 0.95 9139 yes 0.60 0.42 0.49 1158 avg / total 0.89 0.90 0.90 10297 ```python print(classification_report(y_test, pred_logreg, target_names=["no", "yes"])) ``` precision recall f1-score support no 0.93 0.98 0.95 9139 yes 0.68 0.41 0.51 1158 avg / total 0.90 0.91 0.90 10297 # Taking uncertainty into account ```python from mglearn.datasets import make_blobs from sklearn.svm import SVC X, y = make_blobs(n_samples=(400, 50), centers=2, cluster_std=[7.0, 2], random_state=22) X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0) svc = SVC(gamma=.05).fit(X_train, y_train) ``` ```python mglearn.plots.plot_decision_threshold() ``` <IPython.core.display.Javascript object> ```python print(classification_report(y_test, svc.predict(X_test))) ``` precision recall f1-score support 0 0.97 0.89 0.93 104 1 0.35 0.67 0.46 9 avg / total 0.92 0.88 0.89 113 ```python y_pred_lower_threshold = svc.decision_function(X_test) > -.8 ``` ```python print(classification_report(y_test, y_pred_lower_threshold)) ``` precision recall f1-score support 0 1.00 0.82 0.90 104 1 0.32 1.00 0.49 9 avg / total 0.95 0.83 0.87 113 ## Precision-Recall curves and ROC curves ```python from sklearn.metrics import precision_recall_curve precision, recall, thresholds = precision_recall_curve(y_test, svc.decision_function(X_test)) ``` ```python # create a similar dataset as before, but with more samples to get a smoother curve X, y = make_blobs(n_samples=(4000, 500), centers=2, cluster_std=[7.0, 2], random_state=22) X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0) svc = SVC(gamma=.05).fit(X_train, y_train) precision, recall, thresholds = precision_recall_curve( y_test, svc.decision_function(X_test)) # find threshold closest to zero: close_zero = np.argmin(np.abs(thresholds)) plt.figure() plt.plot(precision[close_zero], recall[close_zero], 'o', markersize=10, label="threshold zero", fillstyle="none", c='k', mew=2) plt.plot(precision, recall, label="precision recall curve") plt.xlabel("precision") plt.ylabel("recall") plt.title("precision_recall_curve"); plt.legend(loc="best") ``` <IPython.core.display.Javascript object> <matplotlib.legend.Legend at 0x7fe27528b940> ```python from sklearn.ensemble import RandomForestClassifier rf = RandomForestClassifier(n_estimators=100, random_state=0, max_features=2) rf.fit(X_train, y_train) # RandomForestClassifier has predict_proba, but not decision_function precision_rf, recall_rf, thresholds_rf = precision_recall_curve( y_test, rf.predict_proba(X_test)[:, 1]) plt.figure() plt.plot(precision, recall, label="svc") plt.plot(precision[close_zero], recall[close_zero], 'o', markersize=10, label="threshold zero svc", fillstyle="none", c='k', mew=2) plt.plot(precision_rf, recall_rf, label="rf") close_default_rf = np.argmin(np.abs(thresholds_rf - 0.5)) plt.plot(precision_rf[close_default_rf], recall_rf[close_default_rf], '^', markersize=10, label="threshold 0.5 rf", fillstyle="none", c='k', mew=2) plt.xlabel("precision") plt.ylabel("recall") plt.legend(loc="best") plt.title("precision_recall_comparison"); ``` <IPython.core.display.Javascript object> ```python print("f1_score of random forest: %f" % f1_score(y_test, rf.predict(X_test))) print("f1_score of svc: %f" % f1_score(y_test, svc.predict(X_test))) ``` f1_score of random forest: 0.609756 f1_score of svc: 0.655870 ```python from sklearn.metrics import average_precision_score ap_rf = average_precision_score(y_test, rf.predict_proba(X_test)[:, 1]) ap_svc = average_precision_score(y_test, svc.decision_function(X_test)) print("average precision of random forest: %f" % ap_rf) print("average precision of svc: %f" % ap_svc) ``` average precision of random forest: 0.665737 average precision of svc: 0.662636 #### Receiver Operating Characteristics (ROC) and AUC \begin{equation} \text{FPR} = \frac{\text{FP}}{\text{FP} + \text{TN}} \end{equation} ```python from sklearn.metrics import roc_curve fpr, tpr, thresholds = roc_curve(y_test, svc.decision_function(X_test)) plt.figure() plt.plot(fpr, tpr, label="ROC Curve") plt.xlabel("FPR") plt.ylabel("TPR (recall)") plt.title("roc_curve"); # find threshold closest to zero: close_zero = np.argmin(np.abs(thresholds)) plt.plot(fpr[close_zero], tpr[close_zero], 'o', markersize=10, label="threshold zero", fillstyle="none", c='k', mew=2) plt.legend(loc=4) ``` <IPython.core.display.Javascript object> <matplotlib.legend.Legend at 0x7fe273a24be0> ```python from sklearn.metrics import roc_curve fpr_rf, tpr_rf, thresholds_rf = roc_curve(y_test, rf.predict_proba(X_test)[:, 1]) plt.figure() plt.plot(fpr, tpr, label="ROC Curve SVC") plt.plot(fpr_rf, tpr_rf, label="ROC Curve RF") plt.xlabel("FPR") plt.ylabel("TPR (recall)") plt.title("roc_curve_comparison"); plt.plot(fpr[close_zero], tpr[close_zero], 'o', markersize=10, label="threshold zero SVC", fillstyle="none", c='k', mew=2) close_default_rf = np.argmin(np.abs(thresholds_rf - 0.5)) plt.plot(fpr_rf[close_default_rf], tpr[close_default_rf], '^', markersize=10, label="threshold 0.5 RF", fillstyle="none", c='k', mew=2) plt.legend(loc=4) ``` <IPython.core.display.Javascript object> <matplotlib.legend.Legend at 0x7fe27399a5f8> ```python from sklearn.metrics import roc_auc_score rf_auc = roc_auc_score(y_test, rf.predict_proba(X_test)[:, 1]) svc_auc = roc_auc_score(y_test, svc.decision_function(X_test)) print("AUC for Random Forest: %f" % rf_auc) print("AUC for SVC: %f" % svc_auc) ``` AUC for Random Forest: 0.936695 AUC for SVC: 0.916294 ```python X = data.drop("target", axis=1).values y = data.target.values X.shape ``` (41188, 63) ```python X_train, X_test, y_train, y_test = train_test_split( X, y, random_state=0, train_size=.1, test_size=.1) plt.figure() for gamma in [1, 0.01, 0.001]: svc = SVC(gamma=gamma).fit(X_train, y_train) accuracy = svc.score(X_test, y_test) auc = roc_auc_score(y_test == "yes", svc.decision_function(X_test)) fpr, tpr, _ = roc_curve(y_test , svc.decision_function(X_test), pos_label="yes") print("gamma = %.03f accuracy = %.02f AUC = %.02f" % (gamma, accuracy, auc)) plt.plot(fpr, tpr, label="gamma=%.03f" % gamma, linewidth=4) plt.xlabel("FPR") plt.ylabel("TPR") plt.xlim(-0.01, 1) plt.ylim(0, 1.02) plt.legend(loc="best") ``` <IPython.core.display.Javascript object> gamma = 1.000 accuracy = 0.89 AUC = 0.62 gamma = 0.010 accuracy = 0.89 AUC = 0.89 gamma = 0.001 accuracy = 0.91 AUC = 0.88 <matplotlib.legend.Legend at 0x7ff697fe0208> ### Multi-class classification ```python from sklearn.metrics import accuracy_score from sklearn.datasets import load_digits digits = load_digits() X_train, X_test, y_train, y_test = train_test_split( digits.data, digits.target, random_state=0) lr = LogisticRegression().fit(X_train, y_train) pred = lr.predict(X_test) print("accuracy: %0.3f" % accuracy_score(y_test, pred)) print("confusion matrix:") print(confusion_matrix(y_test, pred)) ``` accuracy: 0.953 confusion matrix: [[37 0 0 0 0 0 0 0 0 0] [ 0 39 0 0 0 0 2 0 2 0] [ 0 0 41 3 0 0 0 0 0 0] [ 0 0 1 43 0 0 0 0 0 1] [ 0 0 0 0 38 0 0 0 0 0] [ 0 1 0 0 0 47 0 0 0 0] [ 0 0 0 0 0 0 52 0 0 0] [ 0 1 0 1 1 0 0 45 0 0] [ 0 3 1 0 0 0 0 0 43 1] [ 0 0 0 1 0 1 0 0 1 44]] ```python plt.figure() scores_image = mglearn.tools.heatmap(confusion_matrix(y_test, pred), xlabel='Predicted label', ylabel='True label', xticklabels=digits.target_names, yticklabels=digits.target_names, cmap=plt.cm.gray_r, fmt="%d") plt.title("Confusion matrix") plt.gca().invert_yaxis() ``` <IPython.core.display.Javascript object> ```python print(classification_report(y_test, pred)) ``` precision recall f1-score support 0 1.00 1.00 1.00 37 1 0.89 0.91 0.90 43 2 0.95 0.93 0.94 44 3 0.90 0.96 0.92 45 4 0.97 1.00 0.99 38 5 0.98 0.98 0.98 48 6 0.96 1.00 0.98 52 7 1.00 0.94 0.97 48 8 0.93 0.90 0.91 48 9 0.96 0.94 0.95 47 avg / total 0.95 0.95 0.95 450 ```python print("micro average f1 score: %f" % f1_score(y_test, pred, average="micro")) print("macro average f1 score: %f" % f1_score(y_test, pred, average="macro")) ``` micro average f1 score: 0.953333 macro average f1 score: 0.954000 ## Using evaluation metrics in model selection ```python from sklearn.cross_validation import cross_val_score # default scoring for classification is accuracy print("default scoring ", cross_val_score(SVC(), X, y)) # providing scoring="accuracy" doesn't change the results explicit_accuracy = cross_val_score(SVC(), digits.data, digits.target == 9, scoring="accuracy") print("explicit accuracy scoring ", explicit_accuracy) roc_auc = cross_val_score(SVC(), digits.data, digits.target == 9, scoring="roc_auc") print("AUC scoring ", roc_auc) ``` default scoring [ 0.9 0.9 0.9] explicit accuracy scoring [ 0.9 0.9 0.9] AUC scoring [ 0.994 0.99 0.996] ```python from sklearn.model_selection import GridSearchCV # back to the bank campaign X = data.drop("target", axis=1).values y = data.target.values X_train, X_test, y_train, y_test = train_test_split( X, y, train_size=.1, test_size=.1, random_state=0) # we provide a somewhat bad grid to illustrate the point: param_grid = {'gamma': [0.0001, 0.01, 0.1, 1, 10]} # using the default scoring of accuracy: grid = GridSearchCV(SVC(), param_grid=param_grid) grid.fit(X_train, y_train) print("Grid-Search with accuracy") print("Best parameters:", grid.best_params_) print("Best cross-validation score (accuracy)):", grid.best_score_) print("Test set AUC: %.3f" % roc_auc_score(y_test, grid.decision_function(X_test))) print("Test set accuracy %.3f: " % grid.score(X_test, y_test)) # using AUC scoring instead: grid = GridSearchCV(SVC(), param_grid=param_grid, scoring="roc_auc") grid.fit(X_train, y_train) print("\nGrid-Search with AUC") print("Best parameters:", grid.best_params_) print("Best cross-validation score (AUC):", grid.best_score_) print("Test set AUC: %.3f" % roc_auc_score(y_test, grid.decision_function(X_test))) print("Test set accuracy %.3f: " % grid.score(X_test, y_test)) ``` Grid-Search with accuracy Best parameters: {'gamma': 0.0001} Best cross-validation score (accuracy)): 0.970304380104 Test set AUC: 0.992 Test set accuracy 0.973: Grid-Search with AUC Best parameters: {'gamma': 0.01} Best cross-validation score (AUC): 0.997467845028 Test set AUC: 1.000 Test set accuracy 1.000: /home/andy/anaconda3/lib/python3.5/site-packages/sklearn/grid_search.py:418: ChangedBehaviorWarning: The long-standing behavior to use the estimator's score function in GridSearchCV.score has changed. The scoring parameter is now used. ChangedBehaviorWarning) ```python from sklearn.metrics.scorer import SCORERS print(sorted(SCORERS.keys())) ``` ['accuracy', 'adjusted_rand_score', 'average_precision', 'f1', 'f1_macro', 'f1_micro', 'f1_samples', 'f1_weighted', 'log_loss', 'mean_absolute_error', 'mean_squared_error', 'median_absolute_error', 'precision', 'precision_macro', 'precision_micro', 'precision_samples', 'precision_weighted', 'r2', 'recall', 'recall_macro', 'recall_micro', 'recall_samples', 'recall_weighted', 'roc_auc'] ```python def my_scoring(fitted_estimator, X_test, y_test): return (fitted_estimator.predict(X_test) == y_test).mean() GridSearchCV(SVC(), param_grid, scoring=my_scoring) ``` # Exercises Load the adult dataset from ``data/adult.csv``, and split it into training and test set. Apply grid-search to the training set, searching for the best C for Logistic Regression, also search over L1 penalty vs L2 penalty. Plot the ROC curve of the best model on the test set. ```python # get dummy variables, needed for scikit-learn models on categorical data: X = pd.get_dummies(data.drop("income", axis=1)) y = data.income == " >50K" ```

de83b15b3fe4b129cb368659f73239a39a9d2d9b

ipynb

Jupyter Notebook

03.2 Evaluation Metrics.ipynb

bagustris/advanced_training

9b96ecc0bb6c913d12cd33b51cfe6ba80a5a58b0

2016-06-06T17:30:23.000Z

2021-11-16T13:51:36.000Z

03.2 Evaluation Metrics.ipynb

afcarl/advanced_training

1ef9246e2f70b82295bb3c4dc9a283e32fd427fb

2017-03-08T19:49:13.000Z

2017-03-08T19:55:03.000Z

03.2 Evaluation Metrics.ipynb

afcarl/advanced_training

1ef9246e2f70b82295bb3c4dc9a283e32fd427fb

2016-06-07T09:39:22.000Z

2021-09-01T01:45:44.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Numerical Integration #### Preliminaries We have to import the array library `numpy` and the plotting library `matplotlib.pyplot`, note that we define shorter aliases for these. Next we import from `numpy` some of the functions that we will use more frequently and from an utility library functions to format conveniently our results. Eventually we tell to the plotting library how we want to format our plots (`fivethirtyeight` is a predefined style that mimics a popular site of statistical analysis and yes, statistical analysis and popular apply both to a single item... while `00_mplrc` refers to some tweaks I prefer to use) ```python %matplotlib inline import numpy as np import matplotlib.pyplot as plt from numpy import cos, exp, pi, sin, sqrt from IPython.display import Latex, display plt.style.use(['fivethirtyeight', './00_mplrc']) ``` ## Plot of the load We start analyzing the loading process. Substituting $t_1=1.2$s in the expression of $p(t)$ we have $$p(t) = \left({15625 \over 27} {t^3 \over s^3} - {8750 \over 9} {t^2 \over s^2} + {1100 \over 3} {t \over s} + 400 \right)\text{N}$$ ```python N = 6000 def it(t): return int((t+1)*N/3) t = np.linspace(-1,2,N+1) p = np.where(t<0, 0, np.where( t<=1.2, 15625./27*t**3 - 8750./9*t**2 + 1100./3*t + 400, 0)) ``` We will use the above expression everywhere in the following. Let's visualize this loading with the help of a plot: ```python plt.plot(t,p) plt.ylim((-20,520)) plt.xticks((-1,0,1,1.2,2)) plt.xlabel('t [second]') plt.ylabel('p(t) [Newton]') plt.title(r'The load $p(t)$') plt.show() ``` From the plot it is apparent that the loading can be approximated by a constant rectangle plus a sine, of relatively small amplitude, with a period of about 1 second. I expect that the forced response will be a damped oscillation about the static displacement $400/k$, followed by a free response in which we will observe a damped oscillation about the zero displacement. ## The Particular Integral Writing the particuar integral as $$\xi(t) = \left(A {t^3 \over s^3} + B {t^2 \over s^2} + C {t \over s} + D \right)$$ where $A, B, C, D$ all have the dimension of a length, deriving with respect to time and substituting in the equation of motion we have $$\left( 6A\frac{t}{s} + 2 B\right)\frac{m}{s^2} + \left( 3A\frac{t^2}{s^2} + 2B\frac{t}{s} + C \right) \frac{c}{s} + \left( A\frac{t^3}{s^3} + B\frac{t^2}{s^2} + C\frac{t}{s} + D \right) k=\left({15625 \over 27} {t^3 \over s^3} - {8750 \over 9} {t^2 \over s^2} + {1100 \over 3} {t \over s} + 400 \right)\text{N}$$ Collecting the powers of $t/s$ in the left member we have $$A k \frac{t^3}{s^3} + \left( B k + \frac{3 A c}{s} \right) \frac{t^2}{s^2} + \left( C k + \frac{2 B c}{s} + \frac{6 A m}{s^2} \right) \frac{t}{s} + \left(D k + \frac{C c}{s} + \frac{2 B m}{s^2}\right)=\left({15625 \over 27} {t^3 \over s^3} - {8750 \over 9} {t^2 \over s^2} + {1100 \over 3} {t \over s} + 400 \right)\text{N}$$ and equating the coefficients of the different powers, starting from the higher to the lower ones, we have a sequence of equations of a single unknown, solving this sequence of equations gives, upon substitution of the numerical values of the system parameters, \begin{align*} A& = \frac{625}{14256}\text{m}=0.0438411896745 \text{m}\\ B& = \left(\frac{-175}{2376} - \frac{19}{209088} \sqrt{11}\right)\text{m}=-0.0739545830991 \text{m}\\ C& = \left(\frac{133}{1306800} \sqrt{11} + \frac{218117}{7920000}\right)\text{m}=0.0278775758319\text{m}\\ D& = \left(\frac{3013181}{99000000} - \frac{135571859}{7187400000000} \sqrt{11}\right)\text{m}=0.0303736121006\text{m}\\ \end{align*} Substituting in $\xi(t)$ and taking the time derivative we have \begin{align*} \xi(t) &= \frac{625}{14256} t^3 - \left( \frac{19}{209088} \sqrt{11} + \frac{175}{2376} \right) t^2 + \left( \frac{133}{1306800} \sqrt{11} + \frac{218117}{7920000} \right) t - \frac{135571859}{7187400000000} \sqrt{11} + \frac{3013181}{99000000},\\ \dot\xi(t) &= \frac{625}{4752} t^2 - 2 \left( \frac{19}{209088} \sqrt{11} + \frac{175}{2376} \right) t + \frac{133}{1306800} \sqrt{11} + \frac{218117}{7920000} \end{align*} ```python xi = np.where(t<0, 0, np.where(t<=1.2001, 625./14256*t**3 - (19./209088*sqrt(11) + 175./2376)*t**2 + t*(133./1306800*sqrt(11) + 218117./7920000) - 135571859./7187400000000*sqrt(11) + 3013181./99000000, 0)) dot_xi = np.where(t<0, 0, np.where(t<=1.2001, 625./4752*t**2 - 2*(t*(19./209088*sqrt(11) + 175./2376)) + 133./1306800*sqrt(11) + 218117./7920000, 0)) xi_0 = - 135571859./7187400000000*sqrt(11) + 3013181./99000000 dot_xi_0 = + 133./1306800*sqrt(11) + 218117./7920000 ``` ### Plot of the particular integral ```python plt.plot(t,xi) plt.title('Particular integral') plt.xlabel('s') plt.ylabel('m') plt.show() plt.plot(t, dot_xi) plt.title('Time derivative of particular integral') plt.xlabel('s') plt.ylabel('m/s') plt.show() ``` ## System Response ### Forced Response $0\le t\le t_1$ The response in terms of displacement and velocity is \begin{align} x(t) &= \exp(-\zeta\omega_nt) \left( R\cos(\omega_Dt) + S\sin(\omega_Dt)\right) + \xi(t),\\ v(t) &= \exp(-\zeta\omega_nt) \left( \left(S\cos(\omega_Dt)-R\sin(\omega_Dt)\right)\omega_D - \left(R\cos(\omega_Dt)+S\sin(\omega_Dt)\right)\zeta\omega_n \right) + \dot\xi(t) \end{align} and we can write the following initial conditions, taking into account that at time $t=0$ the system is at rest, \begin{align} x(0) &= 1 \cdot \left( R\cdot1 + S\cdot0\right) + \xi_0\\&=R+\xi_0=0,\\ \dot x(0) &= 1 \cdot \left( \left(S\cdot1-R\cdot0\right)\omega_D - \left(R\cdot1+S\cdot0\right)\zeta\omega_n \right) + \dot\xi_0\\&=S\omega_D-R\zeta\omega_n+\dot\xi_0=0 \end{align} The constants of integration are \begin{align} R &= -\xi_0,\\ S &= \frac{R\zeta\omega_n-\dot\xi_0}{\omega_D} \end{align} ```python mass = 12.0 stif = 13200.0 zeta = 0.038 w2_n = stif/mass w1_n = sqrt(w2_n) w1_D = w1_n*sqrt(1-zeta**2) damp = 2*zeta*w1_n*mass R = -xi_0 S = (R*zeta*w1_n-dot_xi_0)/w1_D display(HTML("<center><h3>Forced Displacements</h3></center>")) display(Latex(r""" $x(t) = \exp(-%g\cdot%g\,t) \left( %+g\cos(%g\,t)%+g\sin(%g\,t) \right)+\xi(t)$ """%(zeta,w1_n,R,w1_D,S,w1_D))) t1 = 1.2 it1 = it(t1) x_t1 = exp(-zeta*w1_n*t1)*(R*cos(w1_D*t1)+S*sin(w1_D*t1))+xi[it1] v_t1 =(exp(-zeta*w1_n*t1)*(R*cos(w1_D*t1)+S*sin(w1_D*t1))*(-zeta)*w1_n +exp(-zeta*w1_n*t1)*(S*cos(w1_D*t1)-R*sin(w1_D*t1))*w1_D +dot_xi[it1]) display(Latex( r'$$x(t_1)=x_1=%+g\,\text{m},\qquad v(t_1)=v_1=%+g\,\text{m/s}$$'% (x_t1,v_t1))) ``` <center><h3>Forced Displacements</h3></center> $x(t) = \exp(-0.038\cdot33.1662\,t) \left( -0.0303736\cos(33.1423\,t)-0.00199618\sin(33.1423\,t) \right)+\xi(t)$ $$x(t_1)=x_1=+0.035918\,\text{m},\qquad v(t_1)=v_1=+0.237819\,\text{m/s}$$ ### Free Response For $t\ge t_1$ the response (no external force) is given by \begin{align} x^*(t) &= \exp(-\zeta\omega_nt) \left(R^*\cos(\omega_Dt) + S^*\sin(\omega_Dt)\right),\\ v^*(t) &= \exp(-\zeta\omega_nt) \left( \left(S^*\cos(\omega_Dt)-R^*\sin(\omega_Dt)\right)\omega_D - \left(R^*\cos(\omega_Dt)+S^*\sin(\omega_Dt)\right)\zeta\omega_n \right). \end{align} By the new initial conditions, $$x^*(t_1) = x(t_1) = x_1, \qquad v^*(t_1) = v(t_1) = v_1,$$ we have, with $e_1 = \exp(-\zeta\omega_{n}t_1)$, $c_1 = \cos(\omega_Dt_1)$ and $s_1 = \sin(\omega_Dt_1)$ $$ e_1 \begin{bmatrix} c_1 & s_1 \\ -\omega_D s_1 - \zeta\omega_n c_1 & \omega_D c_1 - \zeta\omega_n s_1 \end{bmatrix} \, \begin{Bmatrix}R^*\\S^*\end{Bmatrix} = \begin{Bmatrix}x_1\\v_1\end{Bmatrix} $$ that gives $$ \begin{Bmatrix}R^*\\S^*\end{Bmatrix} = \frac{1}{\omega_D\,e_1}\, \begin{bmatrix} \omega_D c_1 - \zeta\omega_n s_1 & -s_1 \\ \zeta\omega_n c_1 + \omega_D s_1 & c_1 \end{bmatrix}\, \begin{Bmatrix}x_1\\v_1\end{Bmatrix}. $$ ```python e_t1 = exp(-zeta*w1_n*t1) c_t1 = cos(w1_D*t1) s_t1 = sin(w1_D*t1) Rs = (w1_D*c_t1*x_t1 - zeta*w1_n*s_t1*x_t1 - s_t1*v_t1) /w1_D /e_t1 Ss = (w1_D*s_t1*x_t1 + zeta*w1_n*c_t1*x_t1 + c_t1*v_t1) /w1_D /e_t1 display(HTML("<center><h3>Free Displacements</h3></center>")) display(Latex(r""" $$x^*(t) = \exp(-%g\cdot%g\,t) \left( %+g\cos(%g\,t)%+g\sin(%g\,t) \right)$$ """%(zeta,w1_n,Rs,w1_D,Ss,w1_D))) xs_t1 = exp(-zeta*w1_n*t1)*(Rs*cos(w1_D*t1)+Ss*sin(w1_D*t1)) vs_t1 = ((exp(-zeta*w1_n*t1)*(Rs*cos(w1_D*t1)+Ss*sin(w1_D*t1))*(-zeta)*w1_n +exp(-zeta*w1_n*t1)*(Ss*cos(w1_D*t1)-Rs*sin(w1_D*t1))*w1_D)) display(Latex(r'$$x^*(t_1)=%+g\,\text{m},\qquad v^*(t_1) = %+g\,\text{m/s}$$'% (xs_t1,vs_t1))) ``` <center><h3>Free Displacements</h3></center> $$x^*(t) = \exp(-0.038\cdot33.1662\,t) \left( -0.112254\cos(33.1423\,t)+0.124351\sin(33.1423\,t) \right)$$ $$x^*(t_1)=+0.035918\,\text{m},\qquad v^*(t_1) = +0.237819\,\text{m/s}$$ #### Putting it all together First, the homogeneous response ```python x_hom = np.where(t<0, 0, np.where(t<1.2001, exp(-zeta*w1_n*t) * (R *cos(w1_D*t) + S *sin(w1_D*t)), exp(-zeta*w1_n*t) * (Rs*cos(w1_D*t) + Ss*sin(w1_D*t)))) v_hom = np.where(t<0, 0, np.where(t<1.2001, exp(-t*zeta*w1_n) * ( ( S*w1_D- R*zeta*w1_n)*cos(t*w1_D) - ( S*zeta*w1_n+ R*w1_D)*sin(t*w1_D)), exp(-t*zeta*w1_n) * ( (Ss*w1_D-Rs*zeta*w1_n)*cos(t*w1_D) - (Ss*zeta*w1_n+Rs*w1_D)*sin(t*w1_D)))) ``` then, we put together the homogeneous response and the particular integral, in the different intervals ```python x = x_hom+xi v = v_hom+dot_xi ``` ### Plot of the response ```python plt.plot(t,x) plt.title('Displacement') plt.show() plt.plot(t,v) plt.title('Velocity') plt.show() plt.plot(t,x) plt.title('Displacement, zoom around t_1') plt.xlim((1.16,1.24)) plt.show() plt.plot(t,v) plt.title('Velocity, zoom around t_1') plt.xlim((1.16,1.24)) plt.show() ``` ## Numerical Integration The time step we are going to use is specified in terms of the natural period of vibration, $h=T_n/12$: ```python t_n = 2*pi/w1_n h = t_n/12.0 ``` We need a function that returns the value of the load, ```python def load(t): return 0 if t > 1.20001 else ( + 578.703703703703705*t**3 - 972.22222222222222*t**2 + 366.666666666666667*t + 400.) ``` ### Initialization The final time for the computation, the factors that modify the increment of the load to take into account the initial conditions, the modified stiffness, the containers for the results, the initial values of the results. ```python stop = 2.0 + h/2 a0fac = 3.0*mass + damp*h/2.0 v0fac = 6.0*mass/h + 3.0*damp ks = stif + 3.0*damp/h + 6.0*mass/h**2 T, X, V, A = [], [], [], [] x0 = 0 v0 = 0 t0 = 0 p0 = load(t0) ``` ### Computational Loop ```python while t0 < stop: a0 = (p0-stif*x0-damp*v0)/mass for current, vec in zip((t0,x0,v0,a0),(T,X,V,A)): vec.append(current) t1 = t0+h p1 = load(t1) dp = p1-p0 dx = (dp+a0fac*a0+v0fac*v0)/ks dv = 3*dx/h -a0*h/2 -3*v0 t0 = t1 ; p0 = p1 ; x0 = x0+dx ; v0 = v0+dv ``` ### The Plot ```python plt.plot(T,X,label='numerical') plt.plot(t,x,label='analytical') plt.xlim((0,2)) plt.legend(loc=3); ``` ```python plt.plot(T,X,'-o',label='numerical') plt.plot(t,x,'-x',label='analytical') plt.title('Displacement, zoom around t_1') plt.xlim((1.16,1.24)) plt.ylim((0,0.04)) plt.legend(loc=3) plt.show() ``` ```python # an IPython incantation that properly formats this notebook from IPython.display import HTML HTML(open("00_custom.sav.css", "r").read()) ``` <style> @font-face { font-family: 'Charis SIL'; src: url('fonts/CharisSILEur-R.woff') format('woff'); } @font-face { font-family: 'Architects Daughter'; font-style: normal; src: url(https://fonts.gstatic.com/s/architectsdaughter/v6/RXTgOOQ9AAtaVOHxx0IUBM3t7GjCYufj5TXV5VnA2p8.woff2) format('woff2'); 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; } .prompt{display: None;} div.cell{margin: auto;width:900px;} div #notebook { /* centre the content */ background: #fffaf0; margin: auto; padding: 0em; padding-top: 1em; } div #notebook_container {width: 960px!important;} #notebook li { /* More space between bullet points */ margin-top:0.2em; } div.text_cell_render{ font-family: "Charis SIL", Cambria, serif; line-height: 155%; font-size: 130%; } .CodeMirror{ font-family: Consolas, monospace; font-size: 140%; background-color:#fcffff!important; } .output_area { font-family: Consolas,monospace;font-size: 120%; background-color:#fcffff!important; margin-top:0.8em; } div.output_latex{overflow:hidden} h1 { font-family: 'Architects Daughter', serif; font-size: 48pt!important; text-align: center; text-shadow: 4px 4px 4px #aaa; padding-bottom: 48pt; } .warning{color: rgb( 240, 20, 20 )} </style>

cff4c799de5df2b5a1c2d3fdbed691ac91776afd

ipynb

Jupyter Notebook

dati_2015/ha03/03_Numerical_Integration.ipynb

shishitao/boffi_dynamics

365f16d047fb2dbfc21a2874790f8bef563e0947

dati_2015/ha03/03_Numerical_Integration.ipynb

shishitao/boffi_dynamics

365f16d047fb2dbfc21a2874790f8bef563e0947

dati_2015/ha03/03_Numerical_Integration.ipynb

shishitao/boffi_dynamics

365f16d047fb2dbfc21a2874790f8bef563e0947

2019-06-23T12:32:39.000Z

2021-08-15T18:33:55.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

$\newcommand{\Normal}{\mathcal{N}} \newcommand{\lp}{\left(} \newcommand{\rp}{\right)} \newcommand{\lf}{\left\{} \newcommand{\rf}{\right\}} \newcommand{\ls}{\left[} \newcommand{\rs}{\right]} \newcommand{\lv}{\left|} \newcommand{\rv}{\right|} \newcommand{\state}{x} \newcommand{\State}{\boldx} \newcommand{\StateR}{\boldX} \newcommand{\Covariance}{\Sigma} \newcommand{\CovX}{\Covariance_{\boldX}} \newcommand{\CovY}{\Covariance_{\boldY}} \newcommand{\CovZ}{\Covariance_{\boldZ}} \newcommand{\CovXY}{\Covariance_{\boldX\boldY}} \newcommand{\hatState}{\hat{\State}} \newcommand{\StateNum}{N} \newcommand{\StateDim}{K} \newcommand{\NumStates}{N} \newcommand{\StateToState}{A} \newcommand{\stateToState}{A} \newcommand{\StateCov}{\Sigma} \newcommand{\StateJac}{A} \newcommand{\hatStateCov}{\hat{\StateCov}} \newcommand{\StateMean}{\boldmu} \newcommand{\hatStateMean}{\hat{\StateMean}} \newcommand{\StateToStateHistory}{\boldA} \newcommand{\StateNoise}{\boldr} \newcommand{\StateNoiseCov}{R} \newcommand{\StateHistory}{\boldX} \newcommand{\StatesHistory}{\StateHistory} \newcommand{\StateToObserv}{C} \newcommand{\StateToobserv}{\boldc} \newcommand{\StateToObservHistory}{\boldC} \newcommand{\DState}{\bolddelta} \newcommand{\hatDState}{\hat{\DState}} \newcommand{\DStateMean}{\boldlambda} \newcommand{\hatDStateMean}{\hat{\DStateMean}} \newcommand{\DStateCov}{\Lambda} \newcommand{\hatDStateCov}{\hat{\DStateCov}} \newcommand{\DObserv}{\boldgamma} \newcommand{\hatDObserv}{\hat{\DObserv}} \newcommand{\observ}{z} \newcommand{\Observ}{\boldsymbol{\observ}} \newcommand{\ObservCov}{\Lambda} \newcommand{\observMean}{\lambda} \newcommand{\ObservMean}{\boldlambda} \newcommand{\hatobserv}{\hat{\observ}} \newcommand{\hatObserv}{\hat{\Observ}} \newcommand{\hatObservCov}{\hat{\ObservCov}} \newcommand{\hatobservMean}{\hat{\observMean}} \newcommand{\hatObservMean}{\hat{\ObservMean}} \newcommand{\ObservSet}{\ZZ} \newcommand{\ObservNum}{N} \newcommand{\ObservDim}{D} \newcommand{\ObservSourceNum}{M} \newcommand{\ObservHistory}{\boldZ} \newcommand{\ObservsHistory}{\ObservHistory} \newcommand{\Timestamps}{\boldT} \newcommand{\ObservJac}{H} \newcommand{\observNoise}{q} \newcommand{\ObservNoise}{\boldq} \newcommand{\ObservNoiseCov}{Q} \newcommand{\ObservNoiseCovHistory}{\boldQ} \newcommand{\Jacobian}{\boldJ} \newcommand{\Kalman}{K} \newcommand{\kalman}{\boldk} \newcommand{\CC}{\mathbb{C}} \newcommand{\NN}{\mathbb{N}} \newcommand{\RR}{\mathbb{R}} \newcommand{\XX}{\mathbb{X}} \newcommand{\ZZ}{\mathbb{Z}} \renewcommand{\AA}{\mathbb{A}} \newcommand{\boldzero}{\boldsymbol{0}} \newcommand{\boldone}{\boldsymbol{1}} \newcommand{\bolda}{\boldsymbol{a}} \newcommand{\boldb}{\boldsymbol{b}} \newcommand{\boldc}{\boldsymbol{c}} \newcommand{\boldd}{\boldsymbol{d}} \newcommand{\bolde}{\boldsymbol{e}} \newcommand{\boldf}{\boldsymbol{f}} \newcommand{\boldg}{\boldsymbol{g}} \newcommand{\boldh}{\boldsymbol{h}} \newcommand{\boldi}{\boldsymbol{i}} \newcommand{\boldj}{\boldsymbol{j}} \newcommand{\boldk}{\boldsymbol{k}} \newcommand{\boldl}{\boldsymbol{l}} \newcommand{\boldm}{\boldsymbol{m}} \newcommand{\boldn}{\boldsymbol{n}} \newcommand{\boldo}{\boldsymbol{o}} \newcommand{\boldp}{\boldsymbol{p}} \newcommand{\boldq}{\boldsymbol{q}} \newcommand{\boldr}{\boldsymbol{r}} \newcommand{\bolds}{\boldsymbol{s}} \newcommand{\boldt}{\boldsymbol{t}} \newcommand{\boldu}{\boldsymbol{u}} \newcommand{\boldv}{\boldsymbol{v}} \newcommand{\boldw}{\boldsymbol{w}} \newcommand{\boldx}{\boldsymbol{x}} \newcommand{\boldy}{\boldsymbol{y}} \newcommand{\boldz}{\boldsymbol{z}} \newcommand{\boldA}{\boldsymbol{A}} \newcommand{\boldB}{\boldsymbol{B}} \newcommand{\boldC}{\boldsymbol{C}} \newcommand{\boldD}{\boldsymbol{D}} \newcommand{\boldE}{\boldsymbol{E}} \newcommand{\boldF}{\boldsymbol{F}} \newcommand{\boldH}{\boldsymbol{H}} \newcommand{\boldJ}{\boldsymbol{J}} \newcommand{\boldK}{\boldsymbol{K}} \newcommand{\boldL}{\boldsymbol{L}} \newcommand{\boldM}{\boldsymbol{M}} \newcommand{\boldI}{\boldsymbol{I}} \newcommand{\boldP}{\boldsymbol{P}} \newcommand{\boldQ}{\boldsymbol{Q}} \newcommand{\boldR}{\boldsymbol{R}} \newcommand{\boldS}{\boldsymbol{S}} \newcommand{\boldT}{\boldsymbol{T}} \newcommand{\boldO}{\boldsymbol{O}} \newcommand{\boldU}{\boldsymbol{U}} \newcommand{\boldV}{\boldsymbol{V}} \newcommand{\boldW}{\boldsymbol{W}} \newcommand{\boldX}{\boldsymbol{X}} \newcommand{\boldY}{\boldsymbol{Y}} \newcommand{\boldZ}{\boldsymbol{Z}} \newcommand{\boldXY}{\boldsymbol{XY}} \newcommand{\boldmu}{\boldsymbol{\mu}}$ ### Состояние системы Теперь рассмотрим чуть более близкую к реальности модель движения материальной точки. В данной модели состояние движущейся описывается следующим вектором: $$ \State = \begin{pmatrix} x\\ y\\ \gamma\\ v\\ \omega\\ \end{pmatrix}, $$ где * $x$ &mdash; координата точки по оси $X$; * $y$ &mdash; координата точки по оси $Y$; * $\gamma$ &mdash; угол рыскания; далее просто yaw; * $v$ &mdash; проекция скорости на ось $X$; * $\omega$ &mdash; угловая скорость материальной точки. ### Модель эволюции системы #### Переход из момента времени $t$ к моменту $t + \Delta t$^[toc](#toc) $$ \State(t + \Delta t) = \boldf(\State(t)) \Rightarrow \begin{pmatrix} x(t + \Delta t)\\ y(t + \Delta t)\\ \gamma(t + \Delta t)\\ v(t + \Delta t)\\ \omega(t + \Delta t) \end{pmatrix} \approx \begin{pmatrix} x(t) + v(t)\cos(\gamma(t))\Delta t\\ y(t) + v(t)\sin(\gamma(t))\Delta t\\ \gamma(t) + \omega(t) \Delta t\\ v(t)\\ \omega(t)\\ \end{pmatrix}. $$ Заметим, что зависимость между состояниям нелинейная. Т.е. уже нельзя представить переход из момента $t$ в момент $t + \Delta t$ в виде: $$ \State(t + \Delta t) \approx A(\Delta t) \State(t) $$ Поэтому в данном случае мы будем использовать **EKF-фильтр**. #### Якобиан функции перехода $f(x(t))$^[toc](#toc) Итак, мы знаем, что $\State(t) \sim \Normal(\mu(t), \Sigma(t))$. Также мы знаем, что состояние в момент $\State(t + \Delta t)$ выражается через состояние в момент $\State(t)$ через некоторую нелинейную функцию $f(\cdot)$: $$ \State(t + \Delta t) \approx f(\State(t), \Delta t) = \begin{pmatrix} x(t) + v(t)\cos(\gamma(t))\Delta t\\ y(t) + v(t)\sin(\gamma(t))\Delta t\\ \gamma(t) + \omega(t) \Delta t\\ v(t)\\ \omega(t)\\ \end{pmatrix} $$ Поэтому $$ \State(t + \Delta t) \approx f(\mu(t)) + J_f(\mu(t)) (\State(t) - \mu(t)) + \text{H.O.D.}, $$ где * $f(\mu(t), \Delta t)$ &mdash; состояние в момент времени $t + \Delta t$, при условии, что в момент $t$ мы детерминированно находились в состоянии $\State(t) = \mu(t)$. * $J_f(\mu(t))$ &mdash; значение Якобиана $f(\State)$ по $\State$ в точке $\mu(t)$. * $\State(t) - \mu(t)$ &mdash; отклонение истинного значения состояния $\State(t)$ от ожидаемого $\mu(t)$; имеет распределение $\Normal(\boldzero, \Sigma(t))$, чем и обуславливает нормальное распределение для $\State(t + \Delta t)$. * H.O.D. &mdash; компоненты разложения высшего порядка, которыми пренебрегаем (Higher Order Degress). Якобиан имеет вид: $$ J_f(\State(t)) = \begin{pmatrix} 1 &0 &-v(t)\sin(\gamma(t))\Delta t &\cos(\gamma(t))\Delta t &0\\ 0 &1 &v(t)\cos(\gamma(t))\Delta t &\sin(\gamma(t))\Delta t &0\\ 0 &0 &1 &0 &\Delta t\\ 0 &0 &0 &1 &0\\ 0 &0 &0 &0 &1\\ \end{pmatrix} $$ #### Модель эволюции системы^[toc](#toc) В результате получаем \begin{align} &\mu(t + \Delta t) = f(\mu(t), \Delta t),\\ &\Sigma(t + \Delta t) = J_f(\mu(t)) \Sigma(t)J_f(\mu(t))^T + R(t) \Delta t, \end{align} где * $\mu(t)$ &mdash; текущее среднее состояния; * $\Sigma(t)$ &mdash; текущая дисперсия состояния; * $\Delta t$ &mdash; шаг по времени; * $R(t)$ &mdash; матрица плотности шума (показывает, как быстро дисперсия состояния наростает со временем). ### Модель наблюдений системы По сути достаточно лишь указать матрицы наблюдений. Так как в них нет нелинейностей, то тут можно применять обычную обработку показаний (без появления Якобианов и т.п.). #### GPS $$ C_{gps} = \begin{pmatrix} 1 &0 &0 &0 &0\\ 0 &1 &0 &0 &0\\ \end{pmatrix} $$ #### CAN $$ C_{can} = \begin{pmatrix} 0 &0 &0 &1 &0\\ \end{pmatrix} $$ #### IMU $$ C_{imu} = \begin{pmatrix} 0 &0 &0 &0 &1\\ \end{pmatrix} $$ ```python import numpy as np from matplotlib import pyplot as plt from matplotlib.patches import Ellipse, Rectangle from IPython import display import time from matplotlib.lines import Line2D %matplotlib inline from sdc.timestamp import Timestamp from sdc.car import Car from sdc.linear_movement_model import LinearMovementModel from sdc.cycloid_movement_model import CycloidMovementModel from sdc.can_sensor import CanSensor from sdc.gps_sensor import GpsSensor from sdc.imu_sensor import ImuSensor ``` <a id='program_car_model_create'></a> ### Создание автомобиля, настрока движения и установка необходимых датчиков^[toc](#toc) Функция для удобного создания полностью настроенной модели машины: ```python def create_car( initial_position=[5, 5], initial_velocity=5, initial_omega=0.0, initial_yaw=np.pi / 4, can_noise_variances=[0.25], # Стандартное отклонение - 0.5м gps_noise_variances=[1, 1], # Стандартное отклонение - 1м imu_noise_variances=None, # По умолчанию IMU не используется random_state=0, ): # Начальное состояние автомобиля car = Car( initial_position=initial_position, initial_velocity=initial_velocity, initial_yaw=initial_yaw, initial_omega=initial_omega) # Создание сенсоров if can_noise_variances is not None: car.add_sensor(CanSensor(noise_variances=can_noise_variances, random_state=random_state)) random_state += 1 if gps_noise_variances is not None: car.add_sensor(GpsSensor(noise_variances=gps_noise_variances, random_state=random_state)) random_state += 1 if imu_noise_variances is not None: car.add_sensor(ImuSensor(noise_variances=imu_noise_variances, random_state=random_state)) random_state += 1 # Последовательное движение movement_model = LinearMovementModel() car.set_movement_model(movement_model) return car ``` ```python # Калмановская локализация from sdc.car_plotter import CarPlotter from sdc.kalman_car import KalmanCar from sdc.kalman_can_sensor import KalmanCanSensor from sdc.kalman_gps_sensor import KalmanGpsSensor from sdc.kalman_imu_sensor import KalmanImuSensor from sdc.kalman_movement_model import KalmanMovementModel from sdc.kalman_filter import ( kalman_transit_covariance, kalman_process_observation, ) ``` <a id='program_model_kalman_car_from_car'></a> ### Создание калмановской модели машины из обычной модели^[toc](#toc) ```python def create_kalman_car(car, gps_variances=None, can_variances=None, imu_variances=None): """Создает калмановскую модель движения автомобиля на основе уже настроенной модели самого автомобиля""" # Скорость нарастания дисперсии в секунду noise_covariance_density = np.diag([ 0.1, 0.1, 0.1, # Дисперсия yaw 0.1, # Дисперсия скорости 0.1 # Дисперсия угловой скорости ]) # Формирование состояние калмановской локализации kalman_car = KalmanCar( initial_position=car.initial_position, initial_velocity=car.initial_velocity, initial_yaw=car.initial_yaw, initial_omega=car.initial_omega) # Начальная матрица ковариации kalman_car.covariance_matrix = noise_covariance_density # Модель движения kalman_movement_model = KalmanMovementModel(noise_covariance_density=noise_covariance_density) kalman_car.set_movement_model(kalman_movement_model) for sensor in car.sensors: noise_variances = sensor._noise_variances if isinstance(sensor, GpsSensor): noise_variances = noise_variances if gps_variances is None else gps_variances kalman_sensor = KalmanGpsSensor(noise_variances=noise_variances) elif isinstance(sensor, CanSensor): noise_variances = noise_variances if can_variances is None else can_variances kalman_sensor = KalmanCanSensor(noise_variances=noise_variances) elif isinstance(sensor, ImuSensor): noise_variances = noise_variances if imu_variances is None else imu_variances kalman_sensor = KalmanImuSensor(noise_variances=noise_variances) else: assert False kalman_car.add_sensor(kalman_sensor) return kalman_car ``` <a id='visualization_trajectory'></a> ### Визуализация траектории автомобиля^[toc](#toc) ```python initial_position = [20, 20] initial_velocity = 10 initial_yaw = 0.5 initial_omega = 0.02 car = Car(initial_position=initial_position, initial_velocity=initial_velocity, initial_yaw=initial_yaw, initial_omega=initial_omega) print(car) # Тестирование последовательного движения movement_model = LinearMovementModel() car.set_movement_model(movement_model) dt = Timestamp.seconds(0.1) duration = Timestamp.seconds(40) final_time = car.time + duration while car.time < final_time: car.move(dt) print(car) # Отрисовка траектории fig = plt.figure(figsize=(15, 15)) ax = plt.subplot(111, aspect='equal') ax.grid(which='both', linestyle='--', alpha=0.5) car_plotter = CarPlotter(car_width=3, car_height=1.5) car_plotter.plot_car(ax, car) car_plotter.plot_trajectory(ax, car, traj_color='k') # Установка корректных пределов x_limits, y_limits = car_plotter.get_limits(car) ax.set_xlim(x_limits) ax.set_ylim(y_limits); ``` <a id='test_kalman_localization'></a> ## Тестирование калмановской фильтрации^[toc](#toc) ```python car = create_car(initial_omega=0.05) kalman_car = create_kalman_car(car) # Создаем полотно fig = plt.figure(figsize=(15, 15)) ax = plt.subplot(111, aspect='equal') # ax.grid(which='both', linestyle='--', alpha=0.5) real_color = 'green' obs_color = 'blue' est_color = 'red' legend_lines = {'Kalman estimate': Line2D([0], [0], color=est_color, lw=4), 'Measurement': Line2D([0], [0], color=obs_color, lw=4), 'Real position': Line2D([0], [0], color=real_color, lw=4)} # Шаг интегрирования dt = Timestamp.seconds(0.1) # Длительность проезда duration = Timestamp.seconds(40) final_time = car.time + duration # Отрисовщик автомобиля и траектории car_plotter = CarPlotter( car_width=3, car_height=1.5, real_color=real_color, obs_color=obs_color, pred_color=est_color) car_plotter.plot_car(ax, car) # Отрисовка начальной позиции car_plotter.plot_car(ax, car) display.clear_output(wait=True) time.sleep(0.25) ax.set_xlim(-10, 100) ax.set_ylim(-10, 100) while car.time < final_time: ax.clear() ax.legend([legend_lines['Kalman estimate'], legend_lines['Measurement'], legend_lines['Real position']], ['Kalman estimate', 'Measurement', 'Real position']) # Делаем реальный переход к моменту времени t + dt car.move(dt) # Делаем предсказание на момент времени t + dt kalman_car.move(dt) # Теперь обработаем наблюдения в момент t + dt for sensor, kalman_sensor in zip(car.sensors, kalman_car.sensors): observation = sensor.observe() kalman_sensor.process_observation(observation) car_plotter.plot_car(ax, car) car_plotter.plot_kalman_car(ax, kalman_car) car_plotter.plot_trajectory(ax, car, traj_color=real_color) car_plotter.plot_trajectory(ax, kalman_car, traj_color=est_color) car_plotter.plot_observations(ax, car.gps_sensor.history[:, 0], car.gps_sensor.history[:, 1], color=obs_color) ax.set_xlim(-5, 100) ax.set_ylim(-5, 100) display.clear_output(wait=True) display.display(plt.gcf()) time.sleep(0.05) display.clear_output(wait=True) ```

b94019c1d35568539fa92dbab7366c090f599ab9

ipynb

Jupyter Notebook

road situation analysis/research/road/state estimation/kalman_filter_demo.ipynb

MikhailKitikov/DrivingMonitor

0b698d1ba644ce74e1c7d88c3e18a1ef997aabc0

road situation analysis/research/road/state estimation/kalman_filter_demo.ipynb

MikhailKitikov/DrivingMonitor

0b698d1ba644ce74e1c7d88c3e18a1ef997aabc0

road situation analysis/research/road/state estimation/kalman_filter_demo.ipynb

MikhailKitikov/DrivingMonitor

0b698d1ba644ce74e1c7d88c3e18a1ef997aabc0

Qwen/Qwen-72B

1. YES 2. YES

__label__kor_Hang

# Tarea 1 _Tarea 1_ de _Benjamín Rivera_ para el curso de __Métodos Numéricos__ impartido por _Joaquín Peña Acevedo_. Fecha limite de entrega __6 de Septiembre de 2020__. ## Como ejecutar #### Requerimientos Este programa se ejecuto en mi computadora con la version de __Python 3.8.2__ y con estos [requerimientos](https://github.com/BenchHPZ/UG-Compu/blob/master/MN/requerimientos.txt) ### Jupyter En caso de tener acceso a un _servidor jupyter_ ,con los requerimientos antes mencionados, unicamente basta con ejecutar todas las celdas de este _notebook_. Probablemente no todas las celdas de _markdown_ produzcan el mismo resultado por las [_Nbextensions_](jupyter-contrib-nbextensions.readthedocs.io). ### Consola Habrá archivos e instrucciones para poder ejecutar cada uno de los ejercicios desde la consola. ### Si todo sale mal En caso de que todo salga mal, tratare de dejar una copia disponible en __GoogleColab__ que se pueda ejecutar con la versión de __Python__ de _GoogleColab_ ## Ejercicio 1 Supongamos que una computadora tiene 8 dígitos para representar la parte fraccionaria de un número de punto flotante. ### Calcular el valor del épsilon de la máquina En clase vimos que si conocemos la cantidad de bits $p$ para representar la parte fraccionaria de la mantisa, entonces \begin{equation} \epsilon_m = (1.0)_2 \times 2^{-p} \label{eq:epsilon}\end{equation} Dado que sabemos que la máquina de este ejercicio usara $8bits$ para representar la parte fraccionaria entonces, por \ref{eq:epsilon}, el $\epsilon_m$ para este ejercicio es \begin{equation*} \epsilon_m = (1.0)_2 \times 2^{-8} = 3.90625 \times 10^{-3} \label{eq:epsilon maquina} \end{equation*} ```python print(2**(-8)) ``` 0.00390625 ### Dar la representación en notación cientifica (mantisa base 2, multiplicada por 2 elevda al exponente correspondiente) del número 5. Sabemos que el número $5$ se representa en binario como $(101)_2$. Como los números se prefieren normalizados entonces debemos representar $(1.01)_2$ en la notación solicitada. Por lo que \begin{equation*} 5 = (101)_2 \times 2^0 = (1.01)_2 \times 2^2 = 1.25 \times 2^2 \end{equation*} ### Dar la representación científica del número consecutico a 5 en la computadora. Escribir la distancia $d_c$ entre 5 y su consecutivo. Expresar $d_c$ en términos del épslon de la máquina. Sabemos que el número consecutivo $(5_c)$ a $5$ en esta computadora es $5+\epsilon_m$. Si extendemos toda la mantisa de $5$ este se ve $(1.01000000)$. Y sumar $\epsilon_m$ implica sumar $1$ a la mantisa, enspecificamente en esta computadora, al $bit 8$ de la mantisa. De manera que \begin{eqnarray*} 5_c &=& 5 + \epsilon_m = (1.01)_2 \times 2^2 + (1.0)_2 \times 2^{2-8} \\ &=& ((1.01000000)_2 + (0.00000001)_2) \times 2^2 \\ &=& (1.01000001)_2 \times 2^2 \\ &=& 5.015625 \end{eqnarray*} por lo que la distancia entre $5$ y su consecutivo $5+\epsilon_m$ es \begin{equation*} d_c = (5+\epsilon_m)-5 = \epsilon_m \times 2^2 = (0.00000001)_2 \times 2^2 = 0.015625 \end{equation*} ### Tenemos que el consecutivo de $5$ es expresable como $5 + d_c$. Si tenemos un $x$ real tal que $x \in (5, 5+d_c)$ entonces la computadora representara a $x$ como $fl(x)=5$ o $fl(x)=5+d_c$. Escribir una cota para el error relativo para las dos posibles represetnaciones de x > Error relativo \begin{equation*} \left| \frac{fl(x) - x}{x} \right| \end{equation*} Sabemos que las dos posibles representaciones son el _truncamiento_ y el _redondeo_ ,para dar la cota se deben calcular los valores minimos y maximos del error relativo. En general trabajaremos con \begin{equation} \label{eq:error relativo} \left| \frac{fl(x) - x}{x} \right| = \left| \frac{fl(x)}{x} - 1 \right| \end{equation} Antes de continuar es importante notar lo siguiente. Sabemos que, para ambos casos, el dominio de la función sera $[5, 5+d_c]$. Además, notemos que el rango de $\frac{fl(x)}{x}$, para nuestro dominio y los dos valores que puede tomar $fl(x)$, es $\left[ \frac{5}{5+d_c}, \frac{5+d_c}{5} \right]$. Por ultimo, sabemos que $\frac{fl(x)}{x}$ es descendente para $x>0$. __Truncamiento__ Para el truncamiento $fl(x) = 5$ por lo que debemos calcular la cota para \begin{equation*} Er_\_ = \left| \frac{5}{x} - 1 \right| \end{equation*} En este caso, el rango de $\frac{fl(x)}{x} = \frac{5}{x}$ es $\left[ \frac{5}{5+d_c}, \frac{5}{5}=1 \right]$ por lo que el rango de $Er_\_$ es $\left[ 0, |\frac{5}{5+d_c}-1| \right]$. Por iluminación divina, suponemos que esta función es ascendente, y por lo tanto $Er_\_(5) < Er_\_(5+dc)$. Primero evaluamos la función en estos puntos \begin{equation*} Er_\_(5) = \left|\frac{5}{5} -1\right| = 0 \quad\quad Er_\_(5+d_c) = \left|\frac{5}{5+d_c} -1 \right| \sim 0.00311 \end{equation*} Por lo que, usando el truncamiento, esta __<ins>función esta acotada</ins>__ por $\left[ Er_\_(5), Er_\_(5+d_c) \right]$ __Redondeo__ Procedemos de manera similar al anterior. Para el redondeo tenemos que $fl(x) = 5+d_c$, esto nos da la expresion \begin{equation*} Er_+ = \left| \frac{5+d_c}{x} - 1 \right| \end{equation*} Y de manera similar al anterior podemos ver que esta función es descendente, por lo que $Er_+(5+d_c) < Er_+(d_c)$ \begin{equation*} Er_+(5+d_c) = \left| \frac{5+d_c}{5+d_c} -1 \right| = 0 \quad\quad Er_+(5) = \left| \frac{5+d_c}{5} -1 \right| \sim 0.00312 \end{equation*} De manera que esta función queda acotada por $\left[ Er_+(5+d_c),Er_+(5) \right]$ ### Explique si los siguientes números tienen respresentación exacta en la computadora, es decir, si $fl(a_i)=a_i$ - $a_1 = \epsilon/2$ \par Sabemos que en el sistema de este ejercicio ($8bits$ parte flotante) $\epsilon_m = (1.0)_2 \times 2^{-8}$, de manera que, \begin{equation*} \epsilon_m/2 = \frac{(1.0)_2 \times 2^{-8}}{2} = (1.0)_2 \times 2^{-9} \end{equation*} por lo que, mientras que el rango del exponente sea suficiente (dado que el ejercicio solo da información del tamaño de la \textit{matisa}), este número __es representable__ en el sistema. - $a_2 = 1+ \epsilon/2$ \par De manera que $a_2$ se expresa como \begin{equation*} a_2 = (1.0)_2 + \epsilon/2 = (1.0)_2 + (1.0)_2 \times 2^{-9} = (1.000000001)_2 \end{equation*} pero como este sistema solo usa $8bits$ para la mantisa entonces, para este sistema \begin{equation*} a_2 = (1.0)_2 + \epsilon/2 = (1.000000001)_2 = (1.0)_2 \end{equation*} por lo que este número __no tiene representación__ en este sistema. - $a_3 = 1- \epsilon$ \par Este número se escribe como \begin{eqnarray*} a_3 = 1- \epsilon &=& (1.0)_2 - (1.0)_2 \times 2^{-8} \\ &=& (1.00000000)_2 - (0.00000001)_2 \\ &=& (0.11111111)_2 \\ &=& (1.1111111)_2 \times 2^{-1} \end{eqnarray*} por lo que este número __si tiene una representación__ en este sistema. - $a_4 = 1- \epsilon/2$ \par Como con los anteriores, esta operación se expresa como \begin{eqnarray*} a_4 = 1- \epsilon/2 &=& (1.0)_2 - (1.0)_2 \times 2^{-9} \\ &=& (1.00000000)_2 - (0.000000001)_2 \\ &=& (0.111111111)_2 \\ &=& (1.11111111)_2 \times 2^{-1} \end{eqnarray*} el cual __si tiene respresentación__ en el sistema de este ejercicio. - $a_5 = 1- \epsilon/4$ \par En este inciso primero calcularemos $\epsilon/4$, para el cual expandimos lo siguiente \begin{equation*} \epsilon/4 = \frac{(1.0)_2 \times 2^{-8}}{2^2} = (1.0)_2 \times 2^{-10} \end{equation*} el cual, mientras el exponente alcance, _si es representable_ en el sistema. Por otro lado, el numero de este inciso nos da \begin{eqnarray*} a_5 = 1 - \epsilon/4 &=& (1.0)_2 - (1.0)_2 \times 2^{-10} \\ &=& (1.00000000)_2 - (0.0000000001)_2 \\ &=& (0.1111111111)_2 \\ &=& (1.111111111)_2 \times 2^{-1} \end{eqnarray*} pero este número tiene una mantisa de $9bits$, por lo cual, __no tiene representación__ en el sistema. - $a_6 = \epsilon^2$ \par Para este inciso \begin{equation} a_6 = \epsilon^2 = ((1.0)_2 \times 2^{-8})_2^2 = (1.0)_2 \times 2^{-16} \end{equation} el cual __si tiene represetación__ en el sistema. - $a_7 = 0.125$ \par Primero pasamos de el número de decimal a binario, de manera que $(0.125)_{10} = (0.001)_{2}$. Luego hay que normalizarlo, por lo que $(0.001)_{2} = (1.0)_{2} \times 2^{-3}$. Por lo que este numero __si tiene respresentacion__ en el sistema. - $a_8 = 2^{-10}$ \par Y por \'ultimo, tenemos que \begin{equation*} a_8 = 2^{-10} = ((10.0)_2)^{-10} = ((1.0)_2 \times 2^{1})^{-10} = (1.0)_2 \times 2^{-10} \end{equation*} ### De una cota para el error relativo de las restas \ref{eq:resta 1} y \ref{eq:resta 2} respecto al verdader valor. Suponga que $fl(x)$ se obtiene por redondeo hacia abajo _(truncamiento)_ \begin{equation} fl(0.9) - fl(0.5) \label{eq:resta 1} \end{equation} \begin{equation} fl(0.9) - fl(0.895) \label{eq:resta 2} \end{equation} Para este ejercicio, dado que nos pide usar el \textit{truncamiento}, definimos a la \textbf{unidad de redondeo} como $u = \epsilon_m/2$. Esto tambien nos define a $fl(x)=x(1+\delta)$ y $|\delta| \leq u$. Adem\'as, siguiendo las notas, podemos usar la cota que ah\'i se proporciona y sustituir $u$. \begin{equation} |\delta_{x-y}| \leq \frac{\epsilon}{2}\frac{|x|+|y|}{|x-y|} \label{eq:cota} \end{equation} Y antes de continuar calculamos $\epsilon_m/2$ para poder usarlo mas adelante. De manera que \begin{equation*} \epsilon_m/2 = \frac{(1.0)_2 \times 2^{-8}}{2} = (1.0)_2 \times 2^{-9} \end{equation*} Y, como tambien lo usaremos, es bueno tener en cuenta. \begin{equation*} \delta_{x-y} = \frac{fl(x)-fl(y) - (x-y)}{x-y} \end{equation*} Empezamos por la operaci\'on \ref{eq:resta 1}, de donde obtenemos $x=0.9$ y $y=0.5$. Primero calculamos los valores de maquina de estos. \begin{eqnarray*} fl(x) = fl(0.9) &=& (1.1100(1100))_2\times 2^{-1} \\ &=& (1.11001100)_2\times 2^{-1} \quad\quad\quad \text{(Truncamiento (no cabe))} \\ &\sim& 0.8984375 &&\\&&\\ fl(y) = fl(0.5) &=& (1.0)_2\times 2^{-1} \\ &=& (1.00000000)_2\times 2^{-1} \quad\quad\quad \text{(Truncamiento (si cabe))} \\ &=& 0.5 \end{eqnarray*} De manera que, como ya conocemos $\epsilon_m$, los valores de la operaci\'on y sus representaciones en el sistema, procedemos a encontrar la cota. Dado que usamos la cota de las notas, unicamente queda sustituir, de esto obtenemos que: \begin{eqnarray*} \delta_{x-y} \sim -0.00390625 \\ \frac{\epsilon}{2}\frac{|x|+|y|}{|x-y|} = 0.00683593 \end{eqnarray*} Por lo que, siguiendo la cota de la ecuaci\'on \ref{eq:cota}, podemos decir que esta operaci\'on esta acotada por \begin{equation*} |\delta_{x-y}| \sim 0.00390625 \leq 0.00683593 \sim \frac{\epsilon}{2}\frac{|x|+|y|}{|x-y|} \end{equation*} De manera similar, para la operaci\'on \ref{eq:resta 2}, tenemos que $x=0.9$ y $y=0.895$. Calculamos los redondondeos de la computadora. \begin{eqnarray*} fl(x) = fl(0.9) &=& (1.1100(1100))_2\times 2^{-1} \\ &=& (1.11001100)_2\times 2^{-1} \quad\quad\quad \text{(Truncamiento (no cabe))} \\ &\sim& 0.8984375 &&\\&&\\ fl(y) = fl(0.895) &=& (1.1100101000111101)_2\times 2^{-1} \\ &=& (1.11001010)_2\times 2^{-1} \quad\quad\quad \text{(Truncamiento (no cabe))} \\ &=& 0.89453125 \end{eqnarray*} Ahora procedemos a calcular los limites de la cota, por lo que \begin{eqnarray*} \delta_{x-y} \sim -0.21875\\ \frac{\epsilon}{2}\frac{|x|+|y|}{|x-y|} = 0.70117187 \end{eqnarray*} Y por \'ultimo, seg\'un la cota \ref{eq:cota}, acotamos esta operaci\'on por \begin{equation*} |\delta_{x-y}| \sim -0.21875 \leq 0.70117187 \sim \frac{\epsilon}{2}\frac{|x|+|y|}{|x-y|} \end{equation*} ```python # Funciones auxiliares para el Ejercicio 2.3 def deltaXY(fx, fy, x, y): return ((fx-fy)-(x-y))/(x-y) def cotaSup(x, y): ep2 = 0.001953125 return ep2*(abs(x) + abs(y))/abs(x - y) #print(deltaXY(0.8984375, 0.89453125, 0.9, 0.895)) #print(cotaSup(0.9, 0.895)) ``` ## Ejercicio 2 Programe la función `epsilonFloat` que devuelve el épsilon de la máquina $\epsilon_m$ para números de simple precisión y la función `epsilonDouble` para números de doble precisión. ``` epsilon = 1.0 unidad = 1.0 valor = unidad + epsilon while valor > unidad epsilon = epsilon/2 valor = end + epsilon end while epsilon = epsilon*2 ``` Usar el algoritmo visto en clase. ```python # Primera parte del ejercicio 1 import numpy as np def epsilonMaquina(tipoDato): """ Funcion que trata de calcular el epsilon de la maquina mediante el algoritmo antes pre_ sentado. Input: tipoDato := esta pensado para ser uno de los tipos proporcionados por la li_ breria numpy. Output: Regresa el epsilon de la maquina calcula_ do con el tipo de dato especificado. """ epsilon = tipoDato(1.0) unidad = tipoDato(1.0) valor = unidad + epsilon while valor > unidad: epsilon = epsilon/tipoDato(2.0) valor = unidad + epsilon return epsilon*2 def epsilonFloat(): """ Calculamos el epsilon de la maquina con precision de 32bits """ return epsilonMaquina(np.float32) def epsilonDouble(): """ Calculamos el epsilon de la maquina con precision de 64 bits A pesar de que el flotante de python ya tiene esta precision, creo que es convenien_ te especificarlo. """ return epsilonMaquina(np.float64) # Epsilons calculados eF = np.float32(epsilonFloat()) eD = np.float64(epsilonDouble()) # Imprimir en pantalla print(f'Se calculalron los epsilons \n\t{eF=} y \n\t{eD=} \n' 'para 32 y 64 bits correspondientemente.\n') ``` Se calculalron los epsilons eF=1.1920929e-07 y eD=2.220446049250313e-16 para 32 y 64 bits correspondientemente. ```python # Segunda parte del ejercicio 1 def respuesta(res): """ Funcion para formatear la respuesta. """ return "iguales" if res else "diferentes" def comparacion(epsilon): """ Esta funcion resivira el epsilon a eva_ luar y el tipo de dato al que este correspon_ de para hacer las comparaciones solicitadas en el ejercicio. Input: En caso de que Output: Las respuestas son procesadas por la funcion respuesta para obtener el for_ mato solicitado True implica que son iguales False implica que son diferentes """ tD = type(epsilon) # Para escribir menos print(f'Con {epsilon=} y tipo de dato = {str(tD)} se da que') # Comprobaciones print(f'{respuesta( tD(1 + epsilon ) == 1 ) =}') print(f'{respuesta( tD( epsilon/2 ) == 0 ) =}') print(f'{respuesta( tD(1 + epsilon/2 ) == 1 ) =}') print(f'{respuesta( tD(1 - epsilon/2 ) == 1 ) =}') print(f'{respuesta( tD(1 - epsilon/4 ) == 1 ) =}') print(f'{respuesta( tD( epsilon**2 ) == 0 ) =}') print(f'{respuesta(epsilon + tD(epsilon**2) == epsilon) =}') print(f'{respuesta(epsilon - tD(epsilon**2) == epsilon) =}') print('...\n') # Hacemos la comparacion para 32bits comparacion(eF) # y para 64 comparacion(eD) ``` Con epsilon=1.1920929e-07 y tipo de dato = <class 'numpy.float32'> se da que respuesta( tD(1 + epsilon ) == 1 ) ='diferentes' respuesta( tD( epsilon/2 ) == 0 ) ='diferentes' respuesta( tD(1 + epsilon/2 ) == 1 ) ='iguales' respuesta( tD(1 - epsilon/2 ) == 1 ) ='diferentes' respuesta( tD(1 - epsilon/4 ) == 1 ) ='iguales' respuesta( tD( epsilon**2 ) == 0 ) ='diferentes' respuesta(epsilon + tD(epsilon**2) == epsilon) ='diferentes' respuesta(epsilon - tD(epsilon**2) == epsilon) ='diferentes' ... Con epsilon=2.220446049250313e-16 y tipo de dato = <class 'numpy.float64'> se da que respuesta( tD(1 + epsilon ) == 1 ) ='diferentes' respuesta( tD( epsilon/2 ) == 0 ) ='diferentes' respuesta( tD(1 + epsilon/2 ) == 1 ) ='iguales' respuesta( tD(1 - epsilon/2 ) == 1 ) ='diferentes' respuesta( tD(1 - epsilon/4 ) == 1 ) ='iguales' respuesta( tD( epsilon**2 ) == 0 ) ='diferentes' respuesta(epsilon + tD(epsilon**2) == epsilon) ='diferentes' respuesta(epsilon - tD(epsilon**2) == epsilon) ='diferentes' ... De manera que el programa calculo que el _epsilon de la maquina_ es {{eF}} y {{eD}} para las precisiones de _32_ y _64 bits_ correspondientemente, y repecto a las comparaciones unicamente se encontraron __dos igualdades__ cuando se uso preciosion de _64bits_. #### Como ejecutar [GoogleColab](https://colab.research.google.com/gist/BenchHPZ/cd5bc176f3e3841fa1e84924feca9ec2/tarea1-benjamin_rivera-metodos_numericos.ipynb) <a href="https://colab.research.google.com/gist/BenchHPZ/cd5bc176f3e3841fa1e84924feca9ec2/tarea1-benjamin_rivera-metodos_numericos.ipynb"> </a> Para ejecutar este ejercicio en __consola__ es importante ubicarse en la misma carpeta del [archivo `T1.py`](https://github.com/BenchHPZ/UG-Compu/blob/master/MN/Tareas/T1/T1.py) y ejecutar el siguiente comando en consola ```console python3 T1.py ``` Este programa no espera recibir argumento alguno. La salida debe ser similar a la siguiente imagen ```python ```

a028084c370652fc96246bfbb566de2081d01990

ipynb

Jupyter Notebook

MN/Tareas/T1/Tarea1.ipynb

BenchHPZ/UG-Compu

fa3551a862ee04b59a5ba97a791f39a77ce2df60

MN/Tareas/T1/Tarea1.ipynb

BenchHPZ/UG-Compu

fa3551a862ee04b59a5ba97a791f39a77ce2df60

MN/Tareas/T1/Tarea1.ipynb

BenchHPZ/UG-Compu

fa3551a862ee04b59a5ba97a791f39a77ce2df60

Qwen/Qwen-72B

1. YES 2. YES

__label__spa_Latn

# Demo - LISA Horizon Distance This demo shows how to use ``LEGWORK`` to compute the horizon distance for a collection of sources. ```python %matplotlib inline ``` ```python import legwork as lw import numpy as np import astropy.units as u import matplotlib.pyplot as plt ``` ```python %config InlineBackend.figure_format = 'retina' plt.rc('font', family='serif') plt.rcParams['text.usetex'] = False fs = 24 # update various fontsizes to match params = {'figure.figsize': (12, 8), 'legend.fontsize': fs, 'axes.labelsize': fs, 'xtick.labelsize': 0.9 * fs, 'ytick.labelsize': 0.9 * fs, 'axes.linewidth': 1.1, 'xtick.major.size': 7, 'xtick.minor.size': 4, 'ytick.major.size': 7, 'ytick.minor.size': 4} plt.rcParams.update(params) ``` ## Horizon distance of circular binaries The horizon distance for a source is the maximum distance at which the SNR of a source is still above some detectable threshold. The horizon distance can be computed from the SNR as follows since it is inversely proportional to the distance. \begin{equation} D_{\rm hor} = \frac{\rho(D)}{\rho_{\rm detect}} \cdot D, \label{eq:snr_to_hor_dist} \end{equation} Where $\rho(D)$ is the SNR at some distance $D$ and $\rho_{\rm detect}$ is the SNR above which we consider a source detectable. Let's start doing this by creating a grid of chirp masses and orbital frequencies and creating a Source class from them. ```python # create a list of masses and frequencies m_c_grid = np.logspace(-1, np.log10(50), 500) * u.Msun f_orb_grid = np.logspace(np.log10(4e-5), np.log10(3e-1), 400) * u.Hz # turn the two lists into grids MC, FORB = np.meshgrid(m_c_grid, f_orb_grid) # flatten grids m_c, f_orb = MC.flatten(), FORB.flatten() # convert chirp mass to individual masses for source class q = 1.0 m_1 = m_c / q**(3/5) * (1 + q)**(1/5) m_2 = m_1 * q # use a fixed distance and circular binaries dist = np.repeat(1, len(m_c)) * u.kpc ecc = np.zeros(len(m_c)) # create the source class sources = lw.source.Source(m_1=m_1, m_2=m_2, dist=dist, f_orb=f_orb, ecc=ecc, gw_lum_tol=1e-3) ``` Next, we can use `LEGWORK` to compute their merger times and SNRs for the contours. ```python # calculate merger times and then SNR sources.get_merger_time() sources.get_snr(verbose=True) ``` Calculating SNR for 200000 sources 0 sources have already merged 125169 sources are stationary 125169 sources are stationary and circular 74831 sources are evolving 74831 sources are evolving and circular array([5.37039831e-04, 5.48303595e-04, 5.59803603e-04, ..., 1.06420933e+04, 1.07531750e+04, 1.08654183e+04]) We flattened the grid to fit into the Source class but now we can reshape the output to match the original grid. ```python # reshape the output into grids t_merge_grid = sources.t_merge.reshape(MC.shape) snr_grid = sources.snr.reshape(MC.shape) ``` Now we can define a couple of functions for formatting the time, distance and galaxy name contours. ```python def fmt_time(x): if x == 4: return r"$t_{\rm merge} = T_{\rm obs}$" elif x >= 1e9: return "{0:1.0f} Gyr".format(x / 1e9) elif x >= 1e6: return "{0:1.0f} Myr".format(x / 1e6) elif x >= 1e3: return "{0:1.0f} kyr".format(x / 1e3) elif x >= 1: return "{0:1.0f} yr".format(x) elif x >= 1/12: return "{0:1.0f} month".format(x * 12) else: return "{0:1.0f} week".format(x * 52) def fmt_dist(x): if x >= 1e9: return "{0:1.0f} Gpc".format(x / 1e9) elif x >= 1e6: return "{0:1.0f} Mpc".format(x / 1e6) elif x >= 1e3: return "{0:1.0f} kpc".format(x / 1e3) else: return "{0:1.0f} pc".format(x) def fmt_name(x): if x == np.log10(8): return "MW Centre" elif x == np.log10(50): return "SMC/LMC" elif x == np.log10(800): return "Andromeda" elif x == np.log10(40000): return "GW170817" ``` Finally, we put it all together to create a contour plot with all of the information. ```python # create a square figure plus some space for a colourbar size = 12 cbar_space = 2 fig, ax = plt.subplots(figsize=(size + cbar_space, size)) # set up scales early so contour labels show up nicely ax.set_xscale("log") ax.set_yscale("log") # set axes labels and lims ax.set_xlabel(r"Orbital Frequency, $f_{\rm orb} \, [\rm Hz]$") ax.set_ylabel(r"Chirp Mass, $\mathcal{M}_c \, [\rm M_{\odot}]$") ax.set_xlim(4e-5, 3e-1) # calculate the horizon distance snr_threshold = 7 horizon_distance = (snr_grid / snr_threshold * 1 * u.kpc).to(u.kpc) # set up the contour levels distance_levels = np.arange(-3, 6 + 0.5, 0.5) distance_tick_levels = distance_levels[::2] # plot the contours for horizon distance distance_cont = ax.contourf(FORB, MC, np.log10(horizon_distance.value), levels=distance_levels) # hide edges that show up in rendered PDFs for c in distance_cont.collections: c.set_edgecolor("face") # create a colour with custom formatted labels cbar = fig.colorbar(distance_cont, ax=ax, pad=0.02, ticks=distance_tick_levels, fraction=cbar_space / (size + cbar_space)) cbar.ax.set_yticklabels([fmt_dist(np.power(10, distance_tick_levels + 3)[i]) for i in range(len(distance_tick_levels))]) cbar.set_label(r"Horizon Distance", fontsize=fs) cbar.ax.tick_params(axis="both", which="major", labelsize=0.7 * fs) # annotate the colourbar with some named distances named_distances = np.log10([8, 50, 800, 40000]) for name in named_distances: cbar.ax.axhline(name, color="white", linestyle="dotted") # plot the same names as contours named_cont = ax.contour(FORB, MC, np.log10(horizon_distance.value), levels=named_distances, colors="white", alpha=0.8, linestyles="dotted") ax.clabel(named_cont, named_cont.levels, fmt=fmt_name, use_clabeltext=True, fontsize=0.7*fs, manual=[(1.1e-3, 2e-1), (4e-3, 2.2e-1), (4e-3,1e0), (3e-3, 1.2e1)]) # add a line for when the merger time becomes less than the inspiral time time_cont = ax.contour(FORB, MC, t_merge_grid.to(u.yr).value, levels=[4], colors="black", linewidths=2, linestyles="dotted") #[1/52, 1/12, 4, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10] ax.clabel(time_cont, time_cont.levels, fmt=fmt_time, fontsize=0.7*fs, use_clabeltext=True, manual=[(2.5e-2, 5e0)]) # plot a series of lines and annotations for average DCO masses for m_1, m_2, dco in [(0.6, 0.6, "WDWD"), (1.4, 1.4, "NSNS"), (10, 1.4, "BHNS"), (10, 10, "BHBH"), (30, 30, "BHBH")]: # find chirp mass m_c_val = lw.utils.chirp_mass(m_1, m_2) # plot lines before and after bbox ax.plot([4e-5, 4.7e-5], [m_c_val, m_c_val], color="black", lw=0.75, zorder=1, linestyle="--") ax.plot([1.2e-4, 1e0], [m_c_val, m_c_val], color="black", lw=0.75, zorder=1, linestyle="--") # plot name and bbox, then masses below in smaller font ax.annotate(dco + "\n", xy=(7.5e-5, m_c_val), ha="center", va="center", fontsize=0.7*fs, bbox=dict(boxstyle="round", fc="white", ec="white", alpha=0.25)) ax.annotate(r"${{{}}} + {{{}}}$".format(m_1, m_2), xy=(7.5e-5, m_c_val * 0.95), ha="center", va="top", fontsize=0.5*fs) # ensure that everyone knows this only applies for circular sources ax.annotate(r"$e = 0.0$", xy=(0.03, 0.04), xycoords="axes fraction", fontsize=0.8*fs, bbox=dict(boxstyle="round", fc="white", ec="white", alpha=0.25)) ax.set_facecolor(plt.get_cmap("viridis")(0.0)) plt.show() ```

81209efd8039bee79ea9424a0e98810a5ee18235

ipynb

Jupyter Notebook

docs/demos/HorizonDistance.ipynb

arfon/LEGWORK

91ca299d00ed6892acdf5980f33826421fa348ef

2021-09-28T21:53:24.000Z

2022-02-05T14:29:44.000Z

docs/demos/HorizonDistance.ipynb

arfon/LEGWORK

91ca299d00ed6892acdf5980f33826421fa348ef

2021-10-31T15:04:26.000Z

2022-03-15T19:01:40.000Z

docs/demos/HorizonDistance.ipynb

arfon/LEGWORK

91ca299d00ed6892acdf5980f33826421fa348ef

2021-11-18T09:20:53.000Z

2022-03-16T11:30:44.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Week 5 worksheet 1: Introduction to numerical integration This notebook is modified from one created by Charlotte Desvages. This week, we investigate numerical methods to estimate integrals. The 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 🚩 ***Exercise $x$:***. #### Displaying solutions Solutions 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. ```python %run scripts/create_widgets.py W05-W1 ``` ## Numerical integration 🚩 *Recommended reading:* Section 3.3 in **ASC** Numerical integration is the process of computing an approximation of a definite integral, using a particular *scheme*. There are many different ways we could go about this, but in general, we want to approximate an integral using a **weighted sum** which is easy to compute: $$ \int_a^b f(x) \ dx \approx \sum_{k=0}^{N-1} w_k f(x_k), $$ where - $x_k \in [a, b]$ are **nodes**, i.e. a finite number of points chosen in the integration interval, - $w_k \in \mathbb{R}$ are **weights** (coefficients) chosen appropriately. The choice of nodes and weights differentiates one numerical integration method from another, and different choices lead to different *degrees of precision*. We will see more about this next week. ### Riemann sums You probably already know a numerical integration method -- the Riemann sum. Run the code cell below to display a figure (it uses [`matplotlib.patches.Rectangle()`](https://matplotlib.org/api/_as_gen/matplotlib.patches.Rectangle.html)): *Remark:* The first command `%matplotlib notebook` is a notebook-wide setting, which allows to generate **dynamic plots** inside the Jupyter notebook, which we can e.g. zoom into or further modify. (We can toggle back to the default behaviour using the command `%matplotlib inline`, where all plots are "printed" for good when they are created, and cannot be further modified.) Once you are finished with the plot you, you should click on the 'Stop interaction' blue button in the plot above. ```python %matplotlib notebook import matplotlib.pyplot as plt import matplotlib.patches as patches import numpy as np def f(x): return np.exp(-x**2) # Create an x-axis with 100 points and estimate the function a, b = 0, 3 x_plot = np.linspace(a, b, 100) f_plot = f(x_plot) # Create the nodes N = 10 x_node = np.linspace(a, b, N+1) f_node = f(x_node) # Plot the function fig, ax = plt.subplots(1, 2, figsize=(9, 3)) ax[0].plot(x_plot, f_plot, 'k-') ax[1].plot(x_plot, f_plot, 'k-') # Plot the rectangles for left and right sums h = (b - a) / N for k in range(N): rect = patches.Rectangle((x_node[k], 0), h, f_node[k], edgecolor='k') ax[0].add_patch(rect) rect = patches.Rectangle((x_node[k], 0), h, f_node[k+1], edgecolor='k') ax[1].add_patch(rect) # Plot the nodes ax[0].plot(x_node[:-1], f_node[:-1], 'rx') ax[1].plot(x_node[1:], f_node[1:], 'rx') # Label the plots ax[0].set_xlabel(r'$x$') ax[1].set_xlabel(r'$x$') ax[0].set_ylabel(r'$f(x)$') ax[0].set_title('Left Riemann sum') ax[1].set_title('Right Riemann sum') plt.show() ``` We can estimate the integral of $f(x)$ by calculating the area shaded in blue. Here, we subdivide the interval $[a, b]$ into $N$ partitions of equal width $h$: $$ h = \frac{b-a}{N} $$ The **nodes** are the end points of these sub-intervals, and here the **weights** are simply $h$, the width of each interval. The integral of $f(x)$ between $a$ and $b$ can then be estimated as: $$ \begin{align} \int_a^b f(x) \ dx &\approx \sum_{k=0}^{N-1} h \ f(x_k), \quad & \text{left Riemann sum} \\ \int_a^b f(x) \ dx &\approx \sum_{k=1}^N h \ f(x_k), \quad & \text{right Riemann sum} \end{align} $$ where the $N+1$ nodes $x_k$ are given by $x_k = a + kh$, with $k = 0, 1, \dots, N$. With this choice of nodes and weights, each element of the sum is simply the area of one blue rectangle. ```python from math import erf import numpy as np # Estimate the integral left_I = np.sum(h * f_node[:-1]) right_I = np.sum(h * f_node[1:]) # Exact value I_exact = np.sqrt(np.pi) / 2 * (erf(b) - erf(a)) print(f'The exact integral is {I_exact:.3f}.\n') print(f'The left Riemann sum is {left_I:.3f}.\n') print(f'The right Riemann sum is {right_I:.3f}.\n') ``` --- 🚩 ***Exercise 1:*** Using the Riemann sum methods above, estimate the value of the integral using different values of $N$. How does the accuracy change with $N$? *Hint:* plot $\log(N)$ vs. $\log(\text{error})$. You may wish to use e.g. [`np.polyfit()`](https://numpy.org/doc/stable/reference/generated/numpy.polyfit.html) or [`scipy.stats.linregress()`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.linregress.html). ```python ``` ```python %run scripts/show_solutions.py W05-W1_ex1 ``` --- ### The midpoint rule The midpoint rule is similar to the Riemann sums, but the nodes are taken as the **midpoint** of each partition instead of one of the extremities: $$ \int_a^b f(x) \ dx \approx \sum_{k=0}^{N-1} h \ f(x_k), $$ where the nodes $x_k$ are given by $x_k = a + \left(k + \frac{1}{2}\right)h$, with $k = 0, 1, \dots, N-1$. ```python def f(x): return np.exp(-x**2) # Create an x-axis with 100 points and estimate the function a, b = 0, 3 x_plot = np.linspace(a, b, 100) f_plot = f(x_plot) # Create the nodes N = 10 h = (b - a) / N x_node = np.linspace(a + 0.5*h, b, N) f_node = f(x_node) # Plot the function fig, ax = plt.subplots(figsize=(5, 3)) ax.plot(x_plot, f_plot, 'k-') # Plot the rectangles for k in range(N): rect = patches.Rectangle((x_node[k] - 0.5*h, 0), h, f_node[k], edgecolor='k') ax.add_patch(rect) # Plot the nodes ax.plot(x_node, f_node, 'rx') # Label the plots ax.set_xlabel(r'$x$') ax.set_ylabel(r'$f(x)$') ax.set_title('Midpoint rule') plt.show() # Estimate the integral midpoint_I = np.sum(h * f_node) # Exact value I_exact = np.sqrt(np.pi) / 2 * (erf(b) - erf(a)) print(f'The exact integral is {I_exact:.3f}.\n') print(f'The estimated integral using the midpoint rule is {midpoint_I:.3f}.\n') ``` --- 🚩 ***Exercise 2:*** Using the midpoint rule method above, estimate the value of the integral using different values of $N$. How does the accuracy change with $N$? ```python ``` ```python %run scripts/show_solutions.py W05-W1_ex2 ``` --- ### The trapezoid rule The trapezoid rule also uses partitions of equal width, but instead of approximating the integral as the area of rectangles, it uses trapezoids -- the function is interpolated linearly between the nodes. $$ \int_a^b f(x) \ dx \approx \sum_{k=0}^{N-1} h\frac{\left(f(x_k) + f(x_{k+1})\right)}{2} , $$ where the nodes $x_k$ are given by $x_k = a +kh$, with $k = 0, 1, \dots, N$. ```python def f(x): return np.exp(-x**2) # Create an x-axis with 100 points and estimate the function a, b = 0, 3 x_plot = np.linspace(a, b, 100) f_plot = f(x_plot) # Create the nodes N = 6 h = (b - a) / N x_node = np.linspace(a, b, N + 1) f_node = f(x_node) # Plot the function fig, ax = plt.subplots(figsize=(5, 3)) ax.plot(x_plot, f_plot, 'k-') # Plot the trapezoids for k in range(N): verts = [[x_node[k], 0], [x_node[k+1], 0], [x_node[k+1], f_node[k+1]], [x_node[k], f_node[k]]] trapz = patches.Polygon(verts, h, edgecolor='k') ax.add_patch(trapz) # Plot the nodes ax.plot(x_node, f_node, 'rx') # Label the plots ax.set_xlabel(r'$x$') ax.set_ylabel(r'$f(x)$') ax.set_title('Trapezoid rule') plt.show() # Estimate the integral midpoint_I = np.sum(0.5 * h * (f_node[:-1] + f_node[1:])) # Exact value I_exact = np.sqrt(np.pi) / 2 * (erf(b) - erf(a)) print(f'The exact integral is {I_exact:.3f}.\n') print(f'The estimated integral using the midpoint rule is {midpoint_I:.3f}.\n') ``` --- 🚩 ***Exercise 3:*** Using the trapezoid rule method above, estimate the value of the integral using different values of $N$. How does the accuracy change with $N$? ```python ``` ```python %run scripts/show_solutions.py W05-W1_ex3 ``` ```python ```

63449f7a6ab230cb1d6d7c60bf9fe3fa6c9897cb

ipynb

Jupyter Notebook

Workshops/W05-W1_NMfCE_Numerical_integration.ipynb

DrFriedrich/nmfce-2021-22

2ccee5a97b24bd5c1e80e531957240ffb7163897

Workshops/W05-W1_NMfCE_Numerical_integration.ipynb

DrFriedrich/nmfce-2021-22

2ccee5a97b24bd5c1e80e531957240ffb7163897

Workshops/W05-W1_NMfCE_Numerical_integration.ipynb

DrFriedrich/nmfce-2021-22

2ccee5a97b24bd5c1e80e531957240ffb7163897

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# A demonstration of SuSiE's motivations This document explains with toy example illustration the unique type of inference SuSiE is interested in. ## The inference problem We assume our audience are familiar or interested in large scale regression. Similar to eg LASSO, SuSiE is a method for variable selection in large scale regression. Yet the type of inference SuSiE attempts to accomplish is different from other large scale regression methods, and is worth motivating in this document for those not familiar with this particular type of inference. The type of inference is motivated by the so-called "genetic fine-mapping" study. Consider fitting the regression model $$y = \sum_{j=1}^p x_j\beta_j + \epsilon \quad \epsilon \sim N(0, \sigma^2I_n)$$ where $x_1 = x_2, x_3 = x_4$ and $\beta_1 \ne 0, \beta_4 \ne 0, \beta_{j \notin \{1,4\}} = 0$. Our goal is to make a statement that $$\beta_1 \ne 0 \text{ or } \beta_2 \ne 0, \text{ and } \beta_3 \ne 0 \text{ or } \beta_4 \ne 0,$$ that is, in SuSiE variable selection we want to capture the fact that variables $x_1$ and $x_2$ (likewise $x_3$ and $x_4$) are too similar to distinguish. This is an inference that to our knowledge few other large scale regression can make; at least not in an intuitive and interpretable fashion. To illustrate here I set $p=1000$ and simulate a data-set: ```sos set.seed(1) n = 500 p = 1000 b = rep(0,p) b[200] = 1 b[800] = 1 X = matrix(rnorm(n*p),nrow=n,ncol=p) X[,200] = X[,400] X[,600] = X[,800] y = X %*% b + rnorm(n) ``` The "true" effects are: ```sos pdf('truth.pdf', width =5, height = 5, pointsize=16) plot(b, col="black", pch=16, main = 'True effect size') pos = 1:length(b) points(pos[b!=0],b[b!=0],col=2,pch=16) dev.off() ``` <strong>png:</strong> 2 ```sos %preview truth.pdf -s png --dpi 100 ``` ## LASSO inference LASSO will simply choose one of: - $x_1, x_3$ - $x_1, x_4$ - $x_2, x_3$ - $x_2, x_4$ This is not what we want. For instance on the simulated data, ```sos alpha = 1 y.fit = glmnet::glmnet(X,y,alpha = alpha,intercept = FALSE) y.cv = glmnet::cv.glmnet(X,y,alpha = alpha,intercept = FALSE, lambda = y.fit$lambda) bhat = glmnet::predict.glmnet(y.fit,type ="coefficients", s = y.cv$lambda.min)[-1,1] ``` ```sos pdf('lasso.pdf', width =5, height = 5, pointsize=16) plot(bhat, col="black", pch=16, main = 'Lasso') pos = 1:length(bhat) points(pos[b!=0],bhat[b!=0],col=2,pch=16) dev.off() ``` <strong>png:</strong> 2 ```sos %preview lasso.pdf -s png --dpi 100 ``` LASSO randomly picked $x_1$ and $x_3$ even though the true non-zero effects are $\beta_1$ and $\beta_4$. ## Existing Bayesian methods for sparse regression For sparse enough problems, most other Bayesian methods provide posterior probabilities on "models" by enumerating (CAVIAR), schochastic search (FINEMAP) or sampling (BIMBAM) from all possible combinations of variables. In our motivating example, the "true" posterior for models are \begin{align} p(\beta_1 \ne 0, \beta_2 = 0, \beta_3 \ne 0, \beta_4 = 0, \beta_{5:p} = 0) &= 0.25 \\ p(\beta_1 = 0, \beta_2 \ne 0, \beta_3 \ne 0, \beta_4 = 0, \beta_{5:p} = 0) &= 0.25 \\ p(\beta_1 \ne 0, \beta_2 = 0, \beta_3 = 0, \beta_4 \ne 0, \beta_{5:p} = 0) &= 0.25 \\ p(\beta_1 = 0, \beta_2 \ne 0, \beta_3 = 0, \beta_4 \ne 0, \beta_{5:p} = 0) &= 0.25. \end{align} Although compared to LASSO the model posterior contains the information to make statements about $\beta_1 \ne 0 \text{ or } \beta_2 \ne 0, \text{ and } \beta_3 \ne 0 \text{ or } \beta_4 \ne 0$, it is not explicitly provided. One has to post-process these posteriors in order to make the statement. Such pre-processing is non-trivial, see eg Stephens and Balding 2009 for an example in the context of genetic fine-mapping. In addition, marginalized probabilities are often provided by these Bayesian methods, calcualted as \begin{align} p(\beta_1) &= p(\beta_1 \ne 0, \beta_2 = 0, \beta_3 \ne 0, \beta_4 = 0, \beta_{5:p} = 0) \\ & + p(\beta_1 \ne 0, \beta_2 = 0, \beta_3 = 0, \beta_4 \ne 0, \beta_{5:p} = 0) \\ & = 0.5, \end{align} but this does not provide the type of inference we are interested in. We illustrate Bayesian variable selection using `FINEMAP`. First we compute "summary statistics" that `FINEMAP` requires, ```sos library(abind) mm_regression = function(X, Y, Z=NULL) { if (!is.null(Z)) { Z = as.matrix(Z) } reg = lapply(seq_len(ncol(Y)), function (i) simplify2array(susieR:::univariate_regression(X, Y[,i], Z))) reg = do.call(abind, c(reg, list(along=0))) # return array: out[1,,] is betahat, out[2,,] is shat return(aperm(reg, c(3,2,1))) } sumstats = mm_regression(as.matrix(X), as.matrix(y)) dat = list(X=X,Y=as.matrix(y)) saveRDS(list(data=dat, sumstats=sumstats), '/tmp/Toy.with_sumstats.rds') ``` we then set up the path containing the `finemap` executable (here set to `~/GIT/github/mvarbvs/dsc/modules/linux`) and run a wrapper script provided in the `susieR` package under `inst/code` folder (the package source can be [downloaded here](https://github.com/stephenslab/susieR)). ```sos export PATH=~/GIT/github/mvarbvs/dsc/modules/linux:$PATH Rscript ~/GIT/susieR/inst/code/finemap.R input=\"/tmp/Toy.with_sumstats.rds\" output=\"N2finemapping.FINEMAP\" args=\"--n-causal-max\ 2\" 2> /dev/null ``` |---------------------------------| | Welcome to FINEMAP v1.1 | | | | (c) 2015 University of Helsinki | | | | Help / Documentation: | | - ./finemap --help | | - www.christianbenner.com | | | | Contact: | | - [email protected] | | - [email protected] | |---------------------------------| -------- SETTINGS -------- - regions : 1 - n-causal-max : 2 - n-configs-top : 50000 - n-iterations : 100000 - n-convergence : 1000 - prob-tol : 0.001 - corr-config : 0.95 - prior-std : 0.05 - prior-k0 : 0 --------------- RUNNING FINEMAP (1/1) --------------- - GWAS z-scores : /tmp/RtmpRHQEch/file7d275e5895af.finemap_condition_1.z - SNP correlations : /tmp/RtmpRHQEch/file7d272073d9a6.ld - Causal SNP configurations : /tmp/RtmpRHQEch/file7d275e5895af.finemap_condition_1.config - Single-SNP statistics : /tmp/RtmpRHQEch/file7d275e5895af.finemap_condition_1.snp - Log file : /tmp/RtmpRHQEch/file7d275e5895af.finemap_condition_1.log - Reading input : done! - Number of SNPs in region : 1000 - Number of individuals in GWAS : 500 - Prior-Pr(# of causal SNPs is k) : (0 -> 0) 1 -> 0.666667 2 -> 0.333333 - 6979 configurations evaluated (1.004/100%) : converged after 1004 iterations - log10(Evidence of at least 1 causal SNP) : 60.0667 - Post-Pr(# of causal SNPs is k) : 0 -> 0 1 -> 8.6199e-22 2 -> 1 - Writing output : done! - Run time : 0 hours, 0 minutes, 4 seconds Posterior probabilities for "models" are: ```sos finemap = readRDS("N2finemapping.FINEMAP.rds")[[1]] head(finemap$set) ``` <table> <thead><tr><th scope=col>rank</th><th scope=col>config</th><th scope=col>config_prob</th><th scope=col>config_log10bf</th></tr></thead> <tbody> <tr><td>1 </td><td>400,800 </td><td>0.25 </td><td>65.64032</td></tr> <tr><td>2 </td><td>400,600 </td><td>0.25 </td><td>65.64032</td></tr> <tr><td>3 </td><td>200,800 </td><td>0.25 </td><td>65.64032</td></tr> <tr><td>4 </td><td>200,600 </td><td>0.25 </td><td>65.64032</td></tr> <tr><td>5 </td><td>200 </td><td>0.00 </td><td>41.57626</td></tr> <tr><td>6 </td><td>400 </td><td>0.00 </td><td>41.57626</td></tr> </tbody> </table> `FINEMAP` correctly determined 4 "model configurations" as expected, each with probability 0.25. Simply marginalizing across all models we obtain posterior inclusion probability per feature, ```sos snp = finemap$snp pip = snp[order(as.numeric(snp$snp)),]$snp_prob ``` ```sos pdf('finemap.pdf', width =5, height = 5, pointsize=16) susieR::susie_plot(pip, y='PIP', b=b, main = 'Bayesian sparse regression') dev.off() ``` <strong>png:</strong> 2 ```sos %preview finemap.pdf -s png --dpi 100 ``` From these marginalized posterior we can only make a statement that each of the 4 identified variables have 0.5 probability of being non-zero. That is, they all have equal contributions. It does not reflect the fact that the result comes from identical feature pairs $x_1, x_2$ and $x_3, x_4$. Existing variational inference methods (`varbvs`) do not provide accurate calculation of marginal posterior probabilities, although like LASSO, existing variational methods are good for prediction purposes. ## SuSiE SuSiE uses a variational inference algorithm which is not only computational convenient, but also directly obtains posterior statements of the desired form. ```sos fitted = susieR::susie(X, y, L=5, estimate_residual_variance=TRUE, scaled_prior_variance=0.2, tol=1e-3, track_fit=TRUE, min_abs_corr=0.1) ``` ```sos pdf('susie.pdf', width =5, height = 5, pointsize=16) susieR::susie_plot(fitted, y='PIP', b=b, max_cs=0.4, main = paste('SuSiE, ', length(fitted$sets$cs), 'CS identified')) dev.off() ``` <strong>png:</strong> 2 ```sos %preview susie.pdf -s png --dpi 100 ``` Here SuSiE identifies 2 sets of variables -- 2 confidence sets each containing one causal variable (blue and green circles). The marginal posterior is the same as from existing Bayesian methods (FINEMAP result), but with the two sets identified one can easily state that the causal variables are ($x_1$ or $x_2$), and ($x_3$ or $x_4$). Within each set, the contributions of variables are equal because there is no information to distinguish between them. Notice that SuSiE does not directly provide posterior of model configuration, that is, inference on ($x_1$ and $x_3$), or ($x_1$ and $x_4$), or ($x_2$ and $x_3$), or ($x_2$ and $x_4$). Effect size estimate by SuSiE, ```sos bhat = coef(fitted)[-1] pdf('susie_eff.pdf', width =5, height = 5, pointsize=16) susieR::susie_plot(bhat, y='bhat', b=b, main = 'SuSiE, effect size estimate') dev.off() ``` <strong>png:</strong> 2 ```sos %preview susie_eff.pdf -s png --dpi 100 ``` ```sos convert -density 120 \( truth.pdf lasso.pdf +append \) \( finemap.pdf susie.pdf +append \) -append Motivating_Example.png ```

688d3f536259d7265d26318da7a5622644bb2bb7

ipynb

Jupyter Notebook

manuscript_results/motivating_example.ipynb

llgai508/susie-paper

7633d734b5c02ae9f102d7d7c0e4d249a007afd9

manuscript_results/motivating_example.ipynb

llgai508/susie-paper

7633d734b5c02ae9f102d7d7c0e4d249a007afd9

manuscript_results/motivating_example.ipynb

llgai508/susie-paper

7633d734b5c02ae9f102d7d7c0e4d249a007afd9

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

<p> <div align="right"> Massimo Nocentini<br> <small> <br>March and April 2018: cleanup <br>November 2016: splitting from "big" notebook </small> </div> </p> <br> <br> <div align="center"> <b>Abstract</b><br> Theory of matrix functions, with applications to Pascal array $\mathcal{P}$. </div> ```python from sympy import * from sympy.abc import n, i, N, x, lamda, phi, z, j, r, k, a, alpha, beta init_printing() ``` ```python import functions_catalog ``` ```python from matrix_functions import * from commons import * from sequences import * ``` ```python %run ../../src/commons.py %run ../../src/matrix_functions.py %run ../../src/functions_catalog.py ``` # Pascal array $\mathcal{P}$ ```python m=8 ``` ```python P_ = Matrix(m,m, lambda n,k: binomial(n, k, evaluate=k >= n or not k)) P_ # not usable in the framework because not a definition in equality style ``` ```python P = define(Symbol(r'\mathcal{{P}}_{{ {} }}'.format(m)), Matrix(m,m,binomial)) P ``` ```python eigendata = spectrum(P) eigendata ``` ```python data, eigenvals, multiplicities = eigendata.rhs # unpacking to use `eigenvals` in `subs` ``` ```python Phi_polynomials = component_polynomials(eigendata, early_eigenvals_subs=True) Phi_polynomials ``` ```python cmatrices = component_matrices(P, Phi_polynomials) list(cmatrices.values()) ``` ## `power` function ```python f_power, g_power = functions_catalog.power(eigendata, Phi_polynomials) ``` ```python P_power = g_power(P) P_power ``` ```python production_matrix(P_power.rhs) ``` ```python assert P_power.rhs == (P.rhs**r).applyfunc(simplify) ``` ## `inverse` function ```python f_inverse, g_inverse = functions_catalog.inverse(eigendata, Phi_polynomials) ``` ```python P_inverse = g_inverse(P) P_inverse, g_inverse(P_inverse) ``` ```python production_matrix(P_inverse.rhs) ``` ```python assert (P_inverse.rhs * P.rhs) == Matrix(m, m, identity_matrix()) assert P_inverse.rhs == P.rhs**(-1) assert P_inverse.rhs == P_power.rhs.subs({r:-1}) ``` ## `sqrt` function ```python f_sqrt, g_sqrt = functions_catalog.square_root(eigendata, Phi_polynomials) ``` ```python P_sqrt = g_sqrt(P) P_sqrt ``` ```python production_matrix(P_sqrt.rhs) ``` ```python assert P_sqrt.rhs == P.rhs**(S(1)/2) assert P_sqrt.rhs * P_sqrt.rhs == P.rhs assert P_sqrt.rhs == P_power.rhs.subs({r:S(1)/2}) ``` ```python P_power.rhs.subs({r:S(1)/3}) ``` ```python P_power.rhs.subs({r:2}) ``` ```python inspect(_) ``` nature(is_ordinary=True, is_exponential=True) ## `expt` function ```python f_exp, g_exp = functions_catalog.exp(eigendata, Phi_polynomials) ``` ```python P_exp = g_exp(P) P_exp ``` ```python inspect(P_exp.rhs) ``` nature(is_ordinary=False, is_exponential=True) ```python production_matrix(P_exp.rhs.subs({alpha:1})) # faster than `production_matrix(P_exp.rhs).subs({alpha:1})` ``` ```python simp_P_expt = define(P_exp.lhs, Mul(exp(alpha), P_exp.rhs.applyfunc(lambda c: (c/exp(alpha)).expand()), evaluate=False)) simp_P_expt ``` ```python from sympy.functions.combinatorial.numbers import stirling ``` ```python S = Matrix(m, m, lambda n,k: stirling(n,k, kind=2)) define(Symbol('S'), S), production_matrix(S), production_matrix(S, exp=True) ``` ```python S*P.rhs*S**(-1), S**(-1)*P.rhs*S ``` ## `log` function ```python f_log, g_log, = functions_catalog.log(eigendata, Phi_polynomials) ``` ```python P_log = g_log(P) P_log ``` ```python inspect(P_log.rhs[1:,:-1]) ``` nature(is_ordinary=False, is_exponential=True) ```python production_matrix(P_log.rhs[1:,:-1]) ``` ```python P_exp_dirty = define(P_exp.lhs, P_exp.rhs.subs({alpha:1})) P_exp_dirty ``` ```python P_exp_eigendata = spectrum(P_exp_dirty) P_exp_eigendata ``` ```python P_exp_Phi_polynomials = component_polynomials(P_exp_eigendata, early_eigenvals_subs=True) P_exp_Phi_polynomials ``` ```python f_log_dirty, g_log_dirty, = functions_catalog.log(P_exp_eigendata, P_exp_Phi_polynomials) ``` ```python g_log_dirty ``` ```python g_log_dirty(P_exp_dirty) ``` ```python P_log_eigendata = spectrum(P_log) P_log_eigendata ``` ```python P_log_Phi_polynomials = component_polynomials(P_log_eigendata, early_eigenvals_subs=True) P_log_Phi_polynomials ``` ```python f_exp_dirty, g_exp_dirty, = functions_catalog.exp(P_log_eigendata, P_log_Phi_polynomials) ``` ```python g_exp_dirty ``` ```python g_exp_dirty(P_log) ``` ```python _.rhs.subs({alpha:1}) ``` ## `sin` function ```python f_sin, g_sin, G_sin = functions_catalog.sin(eigendata, Phi_polynomials) ``` ```python P_sin = G_sin(P) P_sin ``` ```python production_matrix(P_sin.rhs).applyfunc(simplify) # takes long to evaluate ``` ## `cos` function ```python f_cos, g_cos, G_cos = functions_catalog.cos(eigendata, Phi_polynomials) ``` ```python P_cos = G_cos(P) P_cos ``` ```python production_matrix(P_sin).applyfunc(simplify) # takes long to evaluate ``` ```python assert (P_sin.rhs**2 + P_cos.rhs**2).applyfunc(trigsimp) == Matrix(m,m, identity_matrix()) # sin^2 + cos^2 = 1 ``` ## `sin` function ```python P2 = define(Symbol(r'2\,\mathcal{P}'), 2*P.rhs) P2 ``` ```python eigendata_P2 = spectrum(P2) Phi_polynomials_P2 = component_polynomials(eigendata_P2, early_eigenvals_subs=True) ``` ```python f_sin2, g_sin2, G_sin2 = functions_catalog.sin(eigendata_P2, Phi_polynomials_P2) ``` ```python g_sin2 ``` ```python P_sin2 = G_sin2(P2) P_sin2 ``` ```python PP = P_sin2.rhs.applyfunc(lambda i: i.subs({alpha:1})) assert PP == (2*P_sin.rhs*P_cos.rhs).applyfunc(trigsimp) ``` ```python PP ``` --- <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"></a><br />This work is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License</a>.

078383e36e9b9326334bfa1553e6ef758e140bfb

ipynb

Jupyter Notebook

notes/matrices-functions/pascal-riordan-array.ipynb

massimo-nocentini/simulation-methods

f7578a9719b1a22e5a25a8de85cc229aef4c259d

notes/matrices-functions/pascal-riordan-array.ipynb

massimo-nocentini/simulation-methods

f7578a9719b1a22e5a25a8de85cc229aef4c259d

notes/matrices-functions/pascal-riordan-array.ipynb

massimo-nocentini/simulation-methods

f7578a9719b1a22e5a25a8de85cc229aef4c259d

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

.. meta:: :description: A guide which introduces the most important steps to get started with pymoo, an open-source multi-objective optimization framework in Python. .. meta:: :keywords: Multi-Criteria Decision Making, Multi-objective Optimization, Python, Evolutionary Computation, Optimization Test Problem ```python %%capture %run ./part_2.ipynb ``` # Part III: Multi-Criteria Decision Making Having now obtained a set of non-dominated solutions, one can ask how a decision-maker can nail down the set to only a few or even a single solution. This decision-making process for multi-objective problems is also known as Multi-Criteria Decision Making (MCDM). You should know that the main focus of *pymoo* lies in the optimization, not the MCDM part. However, the framework offers some rudimentary tools to find an appropriate solution. The Pareto-optimal solutions obtained from the optimization procedure are given by: ```python F = res.F xl, xu = problem.bounds() plt.figure(figsize=(7, 5)) plt.scatter(F[:, 0], F[:, 1], s=30, facecolors='none', edgecolors='blue') plt.title("Objective Space") plt.show() ``` Before we start using any technique, we should note that the objectives have a different scale. What has not been a problem for single-objective optimization because not more than one dimension existed now becomes fundamentally important to consider. ```python fl = F.min(axis=0) fu = F.max(axis=0) print(f"Scale f1: [{fl[0]}, {fu[0]}]") print(f"Scale f2: [{fl[1]}, {fu[1]}]") ``` Scale f1: [1.3377795039158837, 74.97223429467643] Scale f2: [0.01809179532919018, 0.7831767823138299] As one can observe, the lower and upper bounds of the objectives $f_1$ and $f_2$ are very different, and such normalization is required. A common way is normalizing using the so-called ideal and nadir point. However, for the decision-making purpose here and the sake of generalization, we assume the ideal and nadir points (also referred to as boundary points) and the Pareto-front) are not known. Thus the points can be approximated by: ```python approx_ideal = F.min(axis=0) approx_nadir = F.max(axis=0) ``` ```python plt.figure(figsize=(7, 5)) plt.scatter(F[:, 0], F[:, 1], s=30, facecolors='none', edgecolors='blue') plt.scatter(approx_ideal[0], approx_ideal[1], facecolors='none', edgecolors='red', marker="*", s=100, label="Ideal Point (Approx)") plt.scatter(approx_nadir[0], approx_nadir[1], facecolors='none', edgecolors='black', marker="p", s=100, label="Nadir Point (Approx)") plt.title("Objective Space") plt.legend() plt.show() ``` Normalizing the obtained objective values regarding the boundary points is relatively simple by: ```python nF = (F - approx_ideal) / (approx_nadir - approx_ideal) fl = nF.min(axis=0) fu = nF.max(axis=0) print(f"Scale f1: [{fl[0]}, {fu[0]}]") print(f"Scale f2: [{fl[1]}, {fu[1]}]") plt.figure(figsize=(7, 5)) plt.scatter(nF[:, 0], nF[:, 1], s=30, facecolors='none', edgecolors='blue') plt.title("Objective Space") plt.show() ``` ### Compromise Programming Without going into too much detail in this getting started guide, one way for decision-making is using decomposition functions. They require the definition of weights that reflect the user's wishes. A vector gives the weights with only positive float numbers summing up to one and a length equal to the number of objectives. Here for a bi-objective problem, let us assume the first objective is less a bit less important than the second objective by setting the weights to ```python weights = np.array([0.2, 0.8]) ``` Next, we choose the decomposition method called Augmented Scalarization Function (ASF), a well-known metric in the multi-objective optimization literature. ```python from pymoo.decomposition.asf import ASF decomp = ASF() ``` Now let us obtain the best solution regarding the ASF. Because ASF is supposed to be minimized, we choose the minimum ASF values calculated from all solutions. You might be wondering why the weights are not passed directly, but `1/weights`. For ASF, different formulations exist, one where the values are divided and one where they are multiplied. In *pymoo*, we divide, which does not reflect the idea of the user's criteria. Thus, the inverse needs to be applied. No worries if this is too much detail for now; however, decision-making about decomposition techniques is vital. ```python i = decomp.do(nF, 1/weights).argmin() ``` After having found a solution ($i$) we can operate on the original scale to represent the results: ```python print("Best regarding ASF: Point \ni = %s\nF = %s" % (i, F[i])) plt.figure(figsize=(7, 5)) plt.scatter(F[:, 0], F[:, 1], s=30, facecolors='none', edgecolors='blue') plt.scatter(F[i, 0], F[i, 1], marker="x", color="red", s=200) plt.title("Objective Space") plt.show() ``` ### Pseudo-Weights A simple way to chose a solution out of a solution set in the context of multi-objective optimization is the pseudo-weight vector approach proposed in <cite data-cite="multi_objective_book"></cite>. Respectively, the pseudo weight $w_i$ for the i-ith objective function can be calculated by: \begin{equation} w_i = \frac{(f_i^{max} - f_i {(x)}) \, /\, (f_i^{max} - f_i^{min})}{\sum_{m=1}^M (f_m^{max} - f_m (x)) \, /\, (f_m^{max} - f_m^{min})} \end{equation} This equation calculates the normalized distance to the worst solution regarding each objective $i$. Please note that for non-convex Pareto fronts, the pseudo weight does not correspond to the result of an optimization using the weighted sum. However, for convex Pareto-fronts, the pseudo weights indicate the location in the objective space. ```python from pymoo.mcdm.pseudo_weights import PseudoWeights i = PseudoWeights(weights).do(nF) ``` ```python print("Best regarding Pseudo Weights: Point \ni = %s\nF = %s" % (i, F[i])) plt.figure(figsize=(7, 5)) plt.scatter(F[:, 0], F[:, 1], s=30, facecolors='none', edgecolors='blue') plt.scatter(F[i, 0], F[i, 1], marker="x", color="red", s=200) plt.title("Objective Space") plt.show() ```

a05d8e43642e0f7dcb039450379f305c832f4e33

ipynb

Jupyter Notebook

source/getting_started/part_3.ipynb

SunTzunami/pymoo-doc

f82d8908fe60792d49a7684c4bfba4a6c1339daf

2021-09-11T06:43:49.000Z

2021-11-10T13:36:09.000Z

source/getting_started/part_3.ipynb

SunTzunami/pymoo-doc

f82d8908fe60792d49a7684c4bfba4a6c1339daf

2021-09-21T14:04:47.000Z

2022-03-07T13:46:09.000Z

source/getting_started/part_3.ipynb

SunTzunami/pymoo-doc

f82d8908fe60792d49a7684c4bfba4a6c1339daf

2021-10-09T02:47:26.000Z

2022-02-10T07:02:37.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# SIRD: A Epidemic Model with Social Distancing **Prof. Tony Saad (<a href='www.tsaad.net'>www.tsaad.net</a>) <br/>Department of Chemical Engineering <br/>University of Utah** <hr/> ```python #HIDDEN from routines import plot_sird_model import ipywidgets as widgets from ipywidgets import interact, interact_manual %matplotlib inline %config InlineBackend.figure_formats = ['svg'] continuousUpdate = False style = {'description_width': 'initial'} beta = widgets.BoundedFloatText(value=0.5,min=0,max=1,step=0.01,description='Infection rate ($\\beta$):',continuous_update=continuousUpdate, style=style) days = widgets.BoundedFloatText(value=14,min=1,max=20,step=1, description='Recovery (days):' ,style=style,continuous_update=continuousUpdate) δ1 = widgets.BoundedFloatText(value=0.1,min=0,max=20.0,step=0.01,description='D to S ($\delta_1$):',readout_format='.3f',style=style,continuous_update=continuousUpdate) δ2 = widgets.BoundedFloatText(value=0.15,min=0,max=20.0,step=0.01,description='S to D ($\delta_2$):',readout_format='.3f',style=style,continuous_update=continuousUpdate) months = widgets.BoundedFloatText(value=12,min=1,max=60,step=1, description='Simulation (months):',style=style,continuous_update=continuousUpdate) vaccinateAfter = widgets.BoundedFloatText(value=8,min=1,description='Vaccine found (months):',max=64,style=style,continuous_update=continuousUpdate) minI = widgets.BoundedFloatText(value=1.0,min=0.0,max=50.0,step=0.001,description='Min Infected (%):',readout_format='.3f',style=style,continuous_update=continuousUpdate, disabled=True) maxI = widgets.BoundedFloatText(value=10.0,min=0,max=50.0,step=0.001,description='Max Infected (%):',readout_format='.3f',style=style,continuous_update=continuousUpdate, disabled=True) semilogy = widgets.Checkbox(value=False,description='semilogy plot:',style=style) # widgets.link((maxI, 'value'), (minI, 'max')) def on_value_change(change): minI.max = maxI.value*0.99 maxI.observe(on_value_change) distanceModel = widgets.Dropdown(options=[('Constant'), ('Reactive')],description='Social Distancing Model:',style=style) def show_max_min(change): if distanceModel.value == 'Constant': maxI.disabled=True minI.disabled=True else: maxI.disabled=False minI.disabled=False distanceModel.observe(show_max_min) ui1 = widgets.HBox([beta,months]) ui2 = widgets.HBox([days,vaccinateAfter]) ui3 = widgets.HBox([δ1,δ2]) ui4 = widgets.HBox([minI,maxI]) ui5 = widgets.HBox([distanceModel, semilogy]) out = widgets.interactive_output(plot_sird_model, {'infection_rate': beta, 'incubation_period': days, 'D_to_S': δ1, 'S_to_D': δ2, 'tend_months':months, 'vaccinateAfter': vaccinateAfter,'minIpercent':minI, 'maxIpercent':maxI,'distanceModel':distanceModel,'semilogy':semilogy}) display(ui1,ui2,ui3,ui4, ui5, out) ``` HBox(children=(BoundedFloatText(value=0.5, description='Infection rate ($\\beta$):', max=1.0, step=0.01, style… HBox(children=(BoundedFloatText(value=14.0, description='Recovery (days):', max=20.0, min=1.0, step=1.0, style… HBox(children=(BoundedFloatText(value=0.1, description='D to S ($\\delta_1$):', max=20.0, step=0.01, style=Des… HBox(children=(BoundedFloatText(value=1.0, description='Min Infected (%):', disabled=True, max=50.0, step=0.00… HBox(children=(Dropdown(description='Social Distancing Model:', options=('Constant', 'Reactive'), style=Descri… Output() # Description SIRD is an epidemic model for infectious disease and is a variation of the SIR model with the addition of social distancing. A compartmental diagram is shown below: The governing equations are: \begin{equation} \frac{\text{d}S}{\text{d}t} = -\beta SI - \delta_1 S + \delta_2 D \end{equation} \begin{equation} \frac{\text{d}I}{\text{d}t} = \beta SI - \gamma I \end{equation} \begin{equation} \frac{\text{d}R}{\text{d}t} =\gamma I \end{equation} \begin{equation} \frac{\text{d}D}{\text{d}t} =\delta_1 S - \delta_2 D \end{equation} where: * $\beta$ is the average infection rate * $\gamma$ is the fraction of people recovering, and is equal to $1/d$ where $d$ is the average number of days for recovery * $\delta_1$ is the fraction at which people move from being socially distanced back to the general population * $\delta_2$ is the average fraction at which people become socially distant The goal of this model is to better understanding the effectiveness of social distancing on "flattening" the curve of an infectious disease. For example, is full lock-down better than a step-by-step implementation of social distancing? ## Social Distancing Models Two social distancing models are supported on this page, Constant and Reactive. ### Constant Social Distancing Assumes that both $\delta_1$ and $\delta_2$ are constant ### Reactive Social Distancing This Model triggers social distancing when the # of infected reaches a certain percentage of the population (designated as Max Infected in the GUI, $I_\text{max}$) and relaxes social distancing when it reaches a minimum # of infected (designated as Min Infected in the GUI, $I_\text{min}$). This produces very interesting dynamics especially as $I_\text{max} \to I_\text{min}$ ## Slides You can see a more detailed description in the following <a href='https://github.com/saadtony/SIRD/blob/master/SIRD.pdf'>slides</a>.

f0cb7e3eeb8df2424cb013c86eed846fec54f5e4

ipynb

Jupyter Notebook

SIRD.ipynb

saadtony/SIRD

87888445826aa9db0e386cf23f0f262bb4f9ab55

SIRD.ipynb

saadtony/SIRD

87888445826aa9db0e386cf23f0f262bb4f9ab55

SIRD.ipynb

saadtony/SIRD

87888445826aa9db0e386cf23f0f262bb4f9ab55

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn