I am working on the file "Modulo2/.ipynb_checkpoints/Clase17_Repaso1(Mod.2)-checkpoint.ipynb".
The first task is:
Ejemplo 2. Fractal aleatorio tipo Barnsley

En la clase de fractales aleatorios vimos que el fractal helecho de Barnsley se generaba a través de cuatro transformaciones afines que se elegían con cierta probabilidad.
Vimos que este helecho representaba de manera muy aproximada helechos reales.
Vimos que modificando parámetros de la tabla, se podían generar mutaciones de el helecho.

Pues bien, usando la misma idea de transformaciones afines que se escogen con cierta probabilidad, se pueden generar una infinidad inimaginable de fractales. Incluso, se pueden generar fractales aleatorios que poseen un atractor determinístico (¿Qué es esto?).
Como en la clase de fractales, repliquemos el fractal tipo Barnsley descrito por la siguiente tabla...
Referencia:
- Barnsley, Michael F. Fractals Everywhere: New Edition, ISBN: 9780486320342.
Can you write Python code for it?


I am working on the file "Modulo2/Clase11_SimulacionMontecarlo.ipynb".
The first task is:
Ahora, necesitamos crear un apostador. Empezaremos con uno extremadamente básico por ahora. Veremos, que aún con un apostador muy básico, veremos cosas muy reveladoras usando un simulador montecarlo.
Can you write Python code for it?

# Crearemos un apostador simple. Las caracterísitcas son: se empieza con un capital inicial, siempre se apuesta lo mismo,
# y se va a apostar un número determinado de veces.
def apostador(cap_inicial, apuesta, n_apuestas):
    capital = cap_inicial
    ccapital = [cap_inicial]

    for i in range(n_apuestas):
        if tirar_dado():
            capital += apuesta
            ccapital.append(capital)
        else:
            capital -= apuesta
            ccapital.append(capital)

    return ccapital

# Ver como evolucionan los fondos de nuestro apostador al jugar 100 veces
plt.plot(apostador(10000, 100, 100))
plt.show()


I am working on the file "Modulo2/Clase11_SimulacionMontecarlo.ipynb".
The first task is:
Vemos que al largo plazo la mayoría de los apostadores quebraron. Sin embargo, esta forma de visualizar los resultados no es adecuada. Utilicemos matplotlib.
Can you write Python code for it?

# Modificar la función para que no devuelva los fondos al final, sino que grafique los fondos a través del tiempo
def apostador(cap_inicial, apuesta, n_apuestas):
    capital = cap_inicial
    ccapital = [cap_inicial]

    for i in range(n_apuestas):
        if tirar_dado():
            capital += apuesta
            ccapital.append(capital)
        else:
            capital -= apuesta
            ccapital.append(capital)

    return ccapital

# (Montecarlo) Simular varios (100) escenarios en que se apuestan 50, 100, 1000 y 10000 veces. ¿Qué pasa?
N = 100
n = 10000
for i in range(N):
    plt.plot(apostador(10000, 100, n))

plt.show()


I am working on the file "Modulo2/Clase11_SimulacionMontecarlo.ipynb".
The first task is:
¿Qué es una simulación montecarlo?
Revisitamos el concepto de simulación montecarlo.

La idea de una simulación montecarlo es probar muchos resultados posibles. En la realidad, solo uno de esos resultados posibles se dará, pero, en términos de evaluación de riesgos, cualquiera de las posibilidades podría ocurrir.

Los simuladores montecarlo se usan usualmente para evaluar el riesgo de una estrategia de negocios dada con opciones y acciones.
Los simuladores montecarlo pueden ayudar a tomar decisiones exitosas, y que el resultado de una decisión no sea la única medida de si dicha decisión fue buena. Las decisiones no deben ser evaluadas después del resultado. Por el contrario, los riesgos y beneficios solo deben ser considerados en el momento en que se debe tomar la decisión, sin prejuicios retrospectivos. Un simulador montecarlo puede ayudar a visualizar muchos (o en algunos casos, todos) de los resultados potenciales para tener una mejor idea de los riesgos de una decisión.
Usamos montecarlo para evaluar el resultado de la caminata aleatoria

Describir, de nuevo, el proceso de la caminata aleatoria en el pizarrón y ver el valor esperado de la caminata después de N pasos.

Luego, evaluar el proceso utilizando montecarlo y comparar resultados.
Can you write Python code for it?

# Hacer código acá
import random
import numpy as np
import matplotlib.pyplot as plt

def caminata_aleatoria(N):
    s = 0
    ss = [s]
    for i in range(N):
        z = random.choice([-1,1])
        s += z
        ss.append(s)
    return ss, s

N = 100
n = 10000
ultimo = []
for i in range(n):
    ss, s = caminata_aleatoria(N)
    ultimo.append(s)
    #plt.plot(ss)

#plt.show()
print("La media muestral del ultimo valor de la caminata aleatoria es:", np.mean(ultimo))


I am working on the file "Modulo2/Clase12_IntegracionMontecarlo.ipynb".
The first task is:
Actividad. Utilizar la anterior función para aproximar el área de la región descrita por
$$4(2x-1)^4+8(2y-1)^8<1+2(2y-1)^3(3x-2)^2$$
Poner los resultados en una tabla cuyas filas correspondan a la cantidad de términos utilizados en la aproximación (usar 10, 100, 1000, 10000 y 100000 términos).
Can you write Python code for it?

N = 100
x = np.linspace(0, 1, N)
y = np.linspace(0, 1, N)

def region(x,y):
    return 4*(2*x-1)**4+8*(2*y-1)**8 < 1+2*(2*y-1)**3*(3*x-2)**2

X, Y = np.meshgrid(x,y)

plt.figure(figsize=(5,5))
plt.scatter(X,Y,c=~region(X,Y),cmap='bone')
plt.show()

# Resolver
a1, a2, b1, b2 = 0, 0, 1, 1
N = np.logspace(1,5,5)

df = pd.DataFrame(index=N,columns=['Valor_aproximacion'], dtype='float')
df.index.name = "Cantidad_terminos"

for n in N:
    df.loc[n,"Valor_aproximacion"] = int_montecarlo2(region, a1, b1, a2, b2, n)

df


I am working on the file "Modulo2/Clase12_IntegracionMontecarlo.ipynb".
The first task is:
De cálculo integral, sabemos que
$$A(\mathcal{D})=\int_{0}^{1}x-x^2\text{d}x.$$
Entonces...
Can you write Python code for it?

# Usar la funcion int_montecarlo1
def f(x):
    return x-x**2

A_Daprox = int_montecarlo1(f, 0, 1, 100000000)
A_Daprox


I am working on the file "Modulo2/Clase12_IntegracionMontecarlo.ipynb".
The first task is:
De modo que si la región se puede describir fácilmente, diría el ferras 'no hay pedo, lo pago' (podemos usar montecarlo tipo 1).
Can you write Python code for it?


I am working on the file "Modulo2/Clase12_IntegracionMontecarlo.ipynb".
The first task is:
En este caso, la integral se puede hacer fácilmente. Comparemos el resultado con el valor real:
$$A(\mathcal{D})=\int_{0}^{1}x^2\text{d}x=\left.\frac{x^3}{3}\right|_{x=0}^{x=1}=\frac{1}{3}$$
Hagamos una tabla viendo:
- cantidad de terminos
- valor de la aproximacion
- error relativo
Can you write Python code for it?

import pandas as pd

A_D = 1/3

N = np.logspace(1,7,7)

df = pd.DataFrame(index=N,columns=['Valor_aproximacion', 'Error_relativo'], dtype='float')
df.index.name = "Cantidad_terminos"

for n in N:
    x = np.random.uniform(0, 1, n.astype(int))
    df.loc[n,"Valor_aproximacion"] = np.sum(parab(x))/n
    df.loc[n,"Error_relativo"] = np.abs(df.loc[n,"Valor_aproximacion"]-A_D)/A_D

df


I am working on the file "Modulo2/Clase12_IntegracionMontecarlo.ipynb".
The first task is:
Escribamos una función que tenga como entradas:
- la función que describe la region $region$,
- los límites de la region $a_1$, $b_1$, $a_2$ y $b_2$, con $R=\left[a_1,b_1\right]\times\left[a_2,b_2\right]$ y
- el número de términos que se usará en la aproximación $N$,
y que devuelva la aproximación montecarlo tipo 2 del area de la region.
Can you write Python code for it?

# Escribir la función acá
def int_montecarlo2(region, a1, b1, a2, b2, N):
    A_R = (b1-a1)*(b2-a2)
    x = np.random.uniform(a1, b1, N.astype(int))
    y = np.random.uniform(a2, b2, N.astype(int))
    return A_R*np.sum(region(x,y))/N


I am working on the file "Modulo2/Clase12_IntegracionMontecarlo.ipynb".
The first task is:
Integración Montecarlo tipo 1
Se basa en la definición de valor promedio de una función y en el valor esperado de una variable aleatoria uniforme.
Presentamos esto mediante un ejemplo.
Ejemplo. Aproxime el área bajo la curva $y=x^2$ en el intervalo $\left[0,1\right]$.
Veamos primero cómo luce dicha área.
Can you write Python code for it?

import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline

def parab(x):
    return x**2

x = np.linspace(0,1)
y = parab(x)

plt.fill_between(x,y)
plt.text(0.8,0.2,'$\mathcal{D}$',fontsize=20)
plt.show()


I am working on the file "Modulo2/Clase12_IntegracionMontecarlo.ipynb".
The first task is:
La probabilidad de que el punto $(X,Y)$ esté en el círculo unitario $\mathcal{D}$ es
$$P((X,Y)\in\mathcal{D})=\frac{A(\mathcal{D})}{A(\mathcal{R})}=\frac{\pi}{4}.$$
Luego, definimos una variable aleatoria de Bernoulli $B$ de manera que
$$B=\left\lbrace\begin{array}{ccc}0 & \text{si} & (X,Y)\notin\mathcal{D}\1 & \text{si} & (X,Y)\in\mathcal{D} \end{array}\right.=\left\lbrace\begin{array}{ccc}0 & \text{si} & X^2+Y^2>1\1 & \text{si} & X^2+Y^2\leq 1 \end{array}\right..$$
Entonces, el valor esperado de la variable aleatoria $B$ es
$$E\left[B\right]=\theta=P((X,Y)\in\mathcal{D})=\frac{A(\mathcal{D})}{A(\mathcal{R})}.$$
De lo anterior, una estimación de theta se puede obtener como
$$\theta=\frac{A(\mathcal{D})}{A(\mathcal{R})}\approx \frac{1}{N}\sum_{i=1}^{N}b_i,$$
donde
$$b_i=\left\lbrace\begin{array}{ccc}0 & \text{si} & x_i^2+y_i^2>1\1 & \text{si} & x_i^2+y_i^2\leq 1 \end{array}\right.$$
son realizaciones de la variable aleatoria $B$, que a su vez es producto de las realizaciones $x_i$ e $y_i$ de las variables aleatorias $X$ e $Y$, respectivamente.
Finalmente, la aproximación montecarlo tipo 2 con $N$ términos es
$$A(\mathcal{D})\approx \frac{A(\mathcal{R})}{N}\sum_{i=1}^{N}b_i.$$
Can you write Python code for it?

def reg_circ(x,y):
    return x**2+y**2<=1

A_R = 4

A_Dapprox = A_R*np.sum(reg_circ(x,y))/N
A_Dapprox


I am working on the file "Modulo2/Clase12_IntegracionMontecarlo.ipynb".
The first task is:
Si aproximamos $A(\mathcal{D})$ aproximamos el valor de $\pi$, pues el área del círculo unitario es:
$$A(\mathcal{D})=\pi(1)^2=\pi.$$
Por otra parte es claro que el área de la región $\mathcal{R}=\left[-1,1\right]\times\left[-1,1\right]$ es
$$A(\mathcal{R})=4.$$
Ahora, haremos uso de nuestro generador de números aleatorios. Supongamos que escogemos un punto aleatorio en la región $\mathcal{R}=\left[-1,1\right]\times\left[-1,1\right]$. Describimos este punto como $(X,Y)$ para $X$ e $Y$ variables aleatorias uniformes sobre el intervalo $\left[-1,1\right]$.
¿Cómo generamos puntos aleatorios en un rectángulo?
Can you write Python code for it?

N = 1000000
x = np.random.uniform(-1, 1, N)
y = np.random.uniform(-1, 1, N)

X, Y = np.meshgrid(x,y)

plt.figure(figsize=(5,5))
plt.scatter(X,Y)
plt.show()


I am working on the file "Modulo2/Clase13_FractalesAleatorios.ipynb".
The first task is:
Actividad: jugando con los coeficientes de la transformación es posible crear mutaciones del helecho.
Un experimentador dió con una tabla de coeficientes que produce otro helecho que se ve muy parecido a la naturaleza. La tabla es la siguiente:
Can you write Python code for it?


I am working on the file "Modulo2/Clase14_ManejoDatosPandas.ipynb".
The first task is:
Actividad. Importen todos los archivos .csv como acabamos de hacerlo con el de apple. Además, crear un solo DataFrame que cuyos encabezados por columna sean los nombres respectivos (AAPL, AMZN,...) y contengan los datos de precio de cierre.
Can you write Python code for it?

file_amazon = 'precios/AMZN.csv'
file_microsoft = 'precios/MSFT.csv'
file_nvidia = 'precios/NVDA.csv'

df_amazon = pd.read_csv(file_amazon, index_col='Date', usecols=['Date', 'Adj_Close'])
df_microsoft = pd.read_csv(file_microsoft, index_col='Date', usecols=['Date', 'Adj_Close'])
df_nvidia = pd.read_csv(file_nvidia, index_col='Date', usecols=['Date', 'Adj_Close'])

closes = pd.DataFrame(index=df_amazon.index, columns=['AAPL', 'AMZN', 'MSFT', 'NVDA'])
closes.index.name = 'Date'
closes['AAPL'] = df_apple
closes['AMZN'] = df_amazon
closes['MSFT'] = df_microsoft
closes['NVDA'] = df_nvidia
closes

closes.plot(figsize=(8,6));


I am working on the file "Modulo2/Clase14_ManejoDatosPandas.ipynb".
The first task is:
Acá hay varias cosas por notar.

Quisieramos indizar por fecha.
Para nuestra aplicación solo nos interesan los precios de cierre de las acciones (columna Adj_Close).
Can you write Python code for it?

# Cargamos hoja de calculo en un dataframe
file_apple = 'precios/AAPL.csv'
df_apple = pd.read_csv(file_apple, index_col='Date', usecols=['Date', 'Adj_Close'])
df_apple


I am working on the file "Modulo2/Clase14_ManejoDatosPandas.ipynb".
The first task is:
Como antes, solo nos interesan los precios de cierre ajustados...
Can you write Python code for it?

# Notar que los índices se indican como Major_axis
closes = panel_data.ix['Adj Close']
closes


I am working on the file "Modulo2/Clase14_ManejoDatosPandas.ipynb".
The first task is:
Las fechas para las que no se tienen datos quedan marcadas con ǸaN
Can you write Python code for it?

# Se verán 'huecos' en la gráfica
closes.plot(figsize=(8,6));

# Llenamos los huecos con el precio de cierre del día anterior
closes = closes.fillna(method='ffill')
closes

# Gráfico limpio...
closes.plot(figsize=(8,6));


I am working on the file "Modulo2/Clase14_ManejoDatosPandas.ipynb".
The first task is:
Reordenamos las fechas...
Can you write Python code for it?

# Generamos todas los días entre las fechas dadas
all_weekdays = pd.date_range(start=start_date, end=end_date, freq='B')

# Reindizamos en este orden
closes = closes.reindex(all_weekdays)
closes


I am working on the file "Modulo2/Clase14_ManejoDatosPandas.ipynb".
The first task is:
Utilizaremos la función data.DataReader...
Can you write Python code for it?

help(data.DataReader)

# Definimos los instrumentos que vamos a descargar. Como antes tendremos Apple, Amazon, Microsoft y Nvidia.
tickers = ['AAPL', 'AMZN', 'MSFT', 'NVDA']

# Definimos que fuente online vamos a usar (yahoo finance)
data_source = 'yahoo'

# Queremos los datos desde 01/01/2011 hasta 31/12/2016.
start_date = '2011-01-01'
end_date = '2016-12-31'

# Usamos la función DataReader. Si, así de fácil...
panel_data = data.DataReader(tickers, data_source, start_date, end_date)


I am working on the file "Modulo2/Clase14_ManejoDatosPandas.ipynb".
The first task is:
¿Qué contiene esta variable?
Can you write Python code for it?


I am working on the file "Modulo2/Clase15_EvolucionPrecios.ipynb".
The first task is:
4. Simulación de varios escenarios
Habiendo caracterizado los rendimientos diarios como una variable aleatoria normal con la media y la varianza muestral obtenida de los datos del 2016, podemos generar números aleatorios con estas características para simular el comportamiento de los precios de las acciones en el 2017.
Sin embargo, cada simulación que hagamos nos conducirá a distintos resultados (los precios siguen evolucionando aleatoriamente). Entonces, lo que haremos es simular varios escenarios para así ver alguna tendencia y tomar decisiones (próxima clase).
Pero, ¿cómo generar vectores de números aleatorios que distribuyen normalmente con una media y varianza dadas?
Can you write Python code for it?


I am working on the file "Modulo2/Clase15_EvolucionPrecios.ipynb".
The first task is:
Con los rendimientos, calculamos los precios de cierre... (explicar en el tablero)
Can you write Python code for it?


I am working on the file "Modulo2/Clase16_ProbabilidadPrecio-Umbral.ipynb".
The first task is:
3. Proyección de precios de cierre
Por tanto, para calcular los precios, tenemos:
$$\begin{align}
p_i&=p_{i-1}\exp(r_i)\
p_{i+1}&=p_i\exp(r_{i+1})=p_{i-1}\exp(r_i)\exp(r_{i+1})=p_{i-1}\exp(r_i+r_{i+1})\
&\vdots\
p_{i+k}&=p_{i-1}\exp(r_i+\cdots+r_{i+k}).
\end{align}$$
Si hacemos $i=0$ en la última ecuación, tenemos que $p_{k}=p_{-1}\exp(r_0+\cdots+r_{k})$, donde $p_{-1}$ es el último precio reportado en el 2016.
Can you write Python code for it?

# Función de proyección de precios
def closes_proj(simret, closes):
    return (closes.iloc[-1,:].values[0])*np.exp(simret.cumsum())

# Proyección de precios y concatenación con precios de 2016
simdata = closes_proj(simret, closes)
simdata

# Gráfico
simdata.plot(figsize=(8,6),legend=False);


I am working on the file "Modulo2/Clase16_ProbabilidadPrecio-Umbral.ipynb".
The first task is:
4. Probabilidad Precio-Umbral
Ya que tenemos muchos escenarios de precios proyectados, podemos ver varias cosas. Por ejemplo, ¿cuál es la probabilidad de que el precio de cierre sobrepase algún valor umbral en algún momento?
Can you write Python code for it?

K = 200
dates = pd.date_range('20170101',periods=ndays)
strike = pd.DataFrame({'Strike':K*np.ones(ndays)},index=dates)
simul = pd.concat([closes.T,simdata.T,strike.T]).T
simul.plot(figsize=(8,6),legend=False);

strike = pd.DataFrame(K*np.ones(ndays*ntraj).reshape((ndays,ntraj)),index=dates)
count = simdata>strike
prob = count.T.sum()/ntraj
prob.plot(figsize=(8,6),legend=False);

((K-closes.iloc[-1,:])/closes.iloc[-1,:]).values

closes.iloc[-1,:]


I am working on the file "Modulo3/.ipynb_checkpoints/Clase18_OptimizacionSympy-checkpoint.ipynb".
The first task is:
Actividad
Determinar los valores extremos absolutos de $h(x)=x^3-3x$ en $\left[-2.2,1.8\right]$, usando sympy. Mostrar en una gráfica.
En varias variables...
El procedimiento es análogo.
Si una función $f:\mathbb{R}^n\to\mathbb{R}$ alcanza un máximo o mínimo local en $\boldsymbol{x}=\boldsymbol{c}\in\mathbb{R}^n$, y $f$ es diferenciable en el punto $\boldsymbol{x}=\boldsymbol{c}$, entonces $\left.\frac{\partial f}{\partial \boldsymbol{x}}\right|_{\boldsymbol{x}=\boldsymbol{c}}=\boldsymbol{0}$ (todas las derivadas parciales en el punto $\boldsymbol{x}=\boldsymbol{c}$ son cero).
Criterio de la segunda derivada: para ver si es máximo o mínimo, se toma la segunda derivada (matriz jacobiana) y se verifica definición negativa o positiva, respectivamente.
Si se restringe a cierta región, hay ciertas técnicas. La más general, pero también la más compleja es la de multiplicadores de Lagrange.
Can you write Python code for it?

sym.var('x y')
x, y

def f(x, y):
    return x**2 + y**2

dfx = sym.diff(f(x,y), x)
dfy = sym.diff(f(x,y), y)
dfx, dfy

xy_c = sym.solve([dfx, dfy], [x, y])
xy_c

x_c, y_c = xy_c[x], xy_c[y]

d2fx = sym.diff(f(x,y), x, 2)
d2fy = sym.diff(f(x,y), y, 2)
dfxy = sym.diff(f(x,y), x, y)

Jf = sym.Matrix([[d2fx, dfxy], [dfxy, d2fy]])
Jf.eigenvals()

import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

x = np.linspace(-2, 2, 100)
y = x
X, Y = np.meshgrid(x, y)

ax.plot_surface(X, Y, f(X, Y))
ax.plot([0], [0], [0], '*r')


I am working on the file "Modulo3/.ipynb_checkpoints/Clase18_OptimizacionSympy-checkpoint.ipynb".
The first task is:
Concluimos que el máximo absoluto de $f$ en $\left[0,5\right]$ es $0$ y se alcanza en $x=0$, y que el mínimo absoluto es $-9$ y se alcanza en $x=3$.
Can you write Python code for it?

f_num = sym.lambdify([x], f, 'numpy')
x_vec = np.linspace(0, 5, 100)

plt.figure(figsize=(8,6))
plt.plot(x_vec, f_num(x_vec), 'k', label = '$y=f(x)$')
plt.plot([0], [0], '*r', label = '$(0,0=\max_{0\leq x\leq 5} f(x))$')
plt.plot([3], [-9], '*b', label = '$(3,-9=\min_{0\leq x\leq 5} f(x))$')
plt.legend(loc='best')
plt.xlabel('x')
plt.show()


I am working on the file "Modulo3/.ipynb_checkpoints/Clase18_OptimizacionSympy-checkpoint.ipynb".
The first task is:
El converso del teorema anterior no es cierto.
Actividad
Considere $g(x)=x^3$.
- Usando sympy, muestre que $g'(0)=0$.
- Sin embargo, descartar que $x=0$ es un extremo de $g(x)$ viendo su gráfica.
2. Criterio de la segunda derivada
Sea $f(x)$ una función tal que $f’(c)=0$ y cuya segunda derivada existe en un intervalo abierto que contiene a $c$.
- Si $f’’(c)>0$, entonces $f(c)$ es un mínimo relativo.
- Si $f’’(c)<0$, entonces $f(c)$ es un máximo relativo.
- Si $f’’(c)=0$, entonces el criterio no decide.
Ejemplo
Mostrar, usando sympy, que la función $f(x)=x^2$ tiene un mínimo relativo en $x=0$.
Ya vimos que $f'(0)=0$. Notemos que:
Can you write Python code for it?

f = x**2
#d2f = sym.diff(f, x, x)
d2f = sym.diff(f, x, 2)
d2f

d2f>0


I am working on the file "Modulo3/.ipynb_checkpoints/Clase18_OptimizacionSympy-checkpoint.ipynb".
The first task is:
Otra manera de hacer lo anterior
Can you write Python code for it?

def f(x):
    return x**2

f_sym = f(x)
f_sym

df = sym.diff(f(x), x)
df

x_c = sym.solve(df, x)
x_c[0]


I am working on the file "Modulo3/.ipynb_checkpoints/Clase18_OptimizacionSympy-checkpoint.ipynb".
The first task is:
Veamos la gráfica...
Can you write Python code for it?

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

f_num = sym.lambdify([x], f, 'numpy')
x_vec = np.linspace(-5, 5, 100)

plt.plot(x_vec, f_num(x_vec))
plt.xlabel('$x$')
plt.ylabel('$x^2$')
plt.show()


I am working on the file "Modulo3/.ipynb_checkpoints/Clase21_AjusteCurvas-checkpoint.ipynb".
The first task is:
Creo que no. Pero, ¿Y una parábola?
Can you write Python code for it?

beta2 = pyomo_utilities.curve_polyfit(x, y, 2)
yhat2 = beta2[0]+beta2[1]*x+beta2[2]*x**2

plt.figure(figsize=(8,6))
plt.plot(x, y, '*b', label = 'datos')
plt.plot(x, yhat1, '-r', label = 'ajuste 1')
plt.plot(x, yhat2, '-g', label = 'ajuste 2')
plt.legend(loc = 'best')
plt.xlabel('$x$')
plt.ylabel('$y$')
plt.grid()
plt.show()


I am working on the file "Modulo3/.ipynb_checkpoints/Clase21_AjusteCurvas-checkpoint.ipynb".
The first task is:
De nuevo, veamos $\beta$
Can you write Python code for it?


I am working on the file "Modulo3/.ipynb_checkpoints/Clase21_AjusteCurvas-checkpoint.ipynb".
The first task is:
Mejor...
5. Actividad

Ajustar polinomios de grado 1 hasta grado 10 a los siguientes datos.
Graficar el error cuadrático acumulado contra el número de términos, y elegir un polinomio que ajuste bien y su grado no sea muy alto.
Para el grado de polinomio elegido, realizar el ajuste con ridge con coeficiente de 0.001.
Comparar los beta.

Abrir un nuevo notebook, llamado Tarea7_ApellidoNombre y subirlo a moodle en el espacio habilitado. Si no terminan esto en clase, tienen hasta mañana a las 23:00.
Can you write Python code for it?

def f(x):
    return np.exp(-x**2/2)/np.sqrt(2*np.pi)

x = np.linspace(-3, 3)
y = f(x)

plt.figure(figsize=(8,6))
plt.plot(x, y, '*b', label = 'datos')
plt.legend(loc = 'best')
plt.xlabel('$x$')
plt.ylabel('$y$')
plt.grid()
plt.show()


I am working on the file "Modulo3/.ipynb_checkpoints/Clase21_AjusteCurvas-checkpoint.ipynb".
The first task is:
Mucho mejor. Entonces, ¿mientras más se suba el orden mejor la aproximación?
¡Cuidado! OVERFITTING...
Can you write Python code for it?

beta20 = pyomo_utilities.curve_polyfit(x, y, 20)
yhat20 = np.array([x**i for i in range(21)]).T.dot(beta20)

plt.figure(figsize=(8,6))
plt.plot(x, y, '*b', label = 'datos')
plt.plot(x, yhat1, '-r', label = 'ajuste 1')
plt.plot(x, yhat2, '-g', label = 'ajuste 2')
plt.plot(x, yhat3, '-k', label = 'ajuste 3')
plt.plot(x, yhat20, '-c', label = 'ajuste 20')
plt.legend(loc = 'best')
plt.xlabel('$x$')
plt.ylabel('$y$')
plt.grid()
plt.show()


I am working on the file "Modulo3/.ipynb_checkpoints/Clase21_AjusteCurvas-checkpoint.ipynb".
The first task is:
Si estos puntos que parecen ser atípicos, hacen parte de una 'mala medición', vemos que el ajuste que obtenemos a los otros puntos es muy pobre...
¿Cómo podemos evitar esto? La respuesta es ajuste robusto.
Can you write Python code for it?

beta = pyomo_utilities.curve_polyfit(x, y, 1, robust=True)
yhat = beta[0]+beta[1]*x

plt.figure(figsize=(8,6))
plt.plot(x, y, '*b', label = 'datos')
plt.plot(x, yhat, '-r', label = 'ajuste')
plt.legend(loc = 'best')
plt.xlabel('$x$')
plt.ylabel('$y$')
plt.grid()
plt.show()

beta


I am working on the file "Modulo3/.ipynb_checkpoints/Clase21_AjusteCurvas-checkpoint.ipynb".
The first task is:
Tampoco. Quizá un polinomio cúbico...
Can you write Python code for it?

beta3 = pyomo_utilities.curve_polyfit(x, y, 3)
yhat3 = beta3[0]+beta3[1]*x+beta3[2]*x**2+beta3[3]*x**3

plt.figure(figsize=(8,6))
plt.plot(x, y, '*b', label = 'datos')
plt.plot(x, yhat1, '-r', label = 'ajuste 1')
plt.plot(x, yhat2, '-g', label = 'ajuste 2')
plt.plot(x, yhat3, '-k', label = 'ajuste 3')
plt.legend(loc = 'best')
plt.xlabel('$x$')
plt.ylabel('$y$')
plt.grid()
plt.show()


I am working on the file "Modulo3/.ipynb_checkpoints/Clase21_AjusteCurvas-checkpoint.ipynb".
The first task is:
Veamos $\beta$ para el ajuste con cúbica
Can you write Python code for it?


I am working on the file "Modulo3/.ipynb_checkpoints/Clase21_AjusteCurvas-checkpoint.ipynb".
The first task is:
¡Cuidado! ver el tamaño de algunos coeficientes. Cuando los coeficientes son grandes, ¿qué pasa?
Es conveniente ver el error como función del orden del polinomio... selección de modelos
Can you write Python code for it?

e_ms = []
for i in range(10):
    beta = pyomo_utilities.curve_polyfit(x, y, i+1);
    yhat = np.array([x**j for j in range(i+2)]).T.dot(beta)
    e_ms.append(sum((y - yhat)**2))

plt.figure(figsize=(8,5))
plt.plot(np.arange(10)+1, e_ms, 'o')
plt.xlabel('orden')
plt.ylabel('error')
plt.show()


I am working on the file "Modulo3/.ipynb_checkpoints/Clase22_ClasificacionBinaria-checkpoint.ipynb".
The first task is:
Actividad
Considere los siguientes datos y diseñe un clasificador binario por regresión logística.
Mostrar el gráfico de la división del clasificador con los puntos de entrenamiento.
Abrir un nuevo notebook, llamado Tarea8_ApellidoNombre y subirlo a moodle en el espacio habilitado. Si no terminan esto en clase, tienen hasta el miércoles a las 23:00.
La tarea de la clase pasada es hasta el miercoles también (se me olvidó habilitar el espacio)
Can you write Python code for it?


I am working on the file "Modulo3/.ipynb_checkpoints/Clase22_ClasificacionBinaria-checkpoint.ipynb".
The first task is:
Los parámetros del clasificador son entonces:
Can you write Python code for it?

B

x = np.arange(20, 110, 0.5)
y = np.arange(20, 110, 0.5)
Xm, Ym = np.meshgrid(x, y)
m,n = np.shape(Xm)
Xmr = np.reshape(Xm,(m*n,1))
Ymr = np.reshape(Ym,(m*n,1))

Xa = np.append(np.ones((len(Ymr),1)), Xmr, axis=1)
Xa = np.append(Xa,Ymr,axis=1)

Yg = reg_log(B,Xa)
Z = np.reshape(Yg, (m,n))
Z = np.round(Z)

plt.figure(figsize=(10,10))
plt.contour(Xm, Ym, Z)
plt.scatter(X[:, 0],X[:, 1], c=Y, edgecolors='w')
plt.show()


I am working on the file "Modulo3/.ipynb_checkpoints/Clase22_ClasificacionBinaria-checkpoint.ipynb".
The first task is:
Notamos que:
- Si $z$ es grande, $\sigma(z)=1$.
- Si $-z$ es grande, $\sigma(z)=-1$.
- $\sigma(0)=0.5$.
Finalmente...
Regresor logístico: $\hat{y}=\sigma(\boldsymbol{x}_a^T\boldsymbol{\beta})$.
Para manejar todos los datos de entrenamiento, se define la matriz
$$\boldsymbol{X}a=\left[\boldsymbol{1}{m\times 1}\quad \boldsymbol{X}\right]=\left[\begin{array}{cc} 1 & {\boldsymbol{x}^1}^T \ 1 & {\boldsymbol{x}^2}^T \ \vdots & \vdots \ 1 & {\boldsymbol{x}^m}^T \end{array}\right]\in\mathbb{R}^{m\times (n+1)}.$$
Así,
$$\hat{\boldsymbol{Y}}=\left[\begin{array}{c} \hat{y}^1 \ \hat{y}^2 \ \vdots \ \hat{y}^m \end{array}\right]=\sigma(\boldsymbol{X}_a\boldsymbol{\beta})$$
Can you write Python code for it?

def reg_log(B,Xa):
    return fun_log(Xa.dot(B))


I am working on the file "Modulo3/.ipynb_checkpoints/Clase23_Repaso1(Mod.3)-checkpoint.ipynb".
The first task is:
1.2
Encontrar el ángulo $\theta$ que maximiza el área de un trapecio isósceles cuya base menor y segmentos laterales miden exactamente una unidad.
Graficar la función área respecto al ángulo $\theta$ en el intervalo donde tiene sentido, junto con el punto donde ocurre el máximo (en color rojo).

Declarar variable y función.
Can you write Python code for it?

def A(theta):
    return (1+sym.sin(theta))*sym.cos(theta)

sym.var('theta', real = True)

A(theta)


I am working on the file "Modulo3/.ipynb_checkpoints/Clase23_Repaso1(Mod.3)-checkpoint.ipynb".
The first task is:
2.2
Una dieta ideal debe satisfacer (o posiblemente, exceder) ciertos requerimientos nutricionales básicos al menor costo posible, ser variada y buena al paladar. ¿Cómo podemos formular dicha dieta?
Suponga que solo tenemos acceso a las siguientes comidas:
Can you write Python code for it?

import pandas as pd

df = pd.DataFrame(columns=['Energia', 'Proteina', 'Calcio', 'Precio', 'Limite_diario'], index=['Avena', 'Pollo', 'Huevos', 'Leche', 'Pastel', 'Frijoles_cerdo'])
df.loc[:,'Energia']=[110, 205, 160, 160, 420, 260]
df.loc[:,'Proteina']=[4, 32, 13, 8, 4, 14]
df.loc[:,'Calcio']=[2, 12, 54, 285, 22, 80]
df.loc[:,'Precio']=[3, 24, 13, 9, 20, 19]
df.loc[:,'Limite_diario']=[4, 3, 2, 8, 2, 2]

df


I am working on the file "Modulo3/.ipynb_checkpoints/Clase23_Repaso1(Mod.3)-checkpoint.ipynb".
The first task is:
Ejemplo 2. Programación lineal
En clase vimos cómo llevar los problemas de programación lineal a la forma
\begin{equation}
\begin{array}{ll}
\min_{\boldsymbol{x}} & \boldsymbol{f}^T\boldsymbol{x} \
\text{s. a. }        & \boldsymbol{A}{eq}\boldsymbol{x}=\boldsymbol{b}{eq} \
                     & \boldsymbol{A}\boldsymbol{x}\leq\boldsymbol{b}.
\end{array}
\end{equation}
Además, aprendimos a resolver los problemas en esta forma con la función linprog del paquete pyomo_utilities.py, proporcionando únicamente los parámetros $\boldsymbol{f}$, $\boldsymbol{A}$ y $\boldsymbol{b}$ ($\boldsymbol{A}{eq}$ y $\boldsymbol{b}{eq}$, de ser necesario).
2.1
Maximizar la función $x_1+2x_2+3x_3+4x_4+5$ sujeta a las restricciones $4x_1+3x_2+2x_3+x_4\leq10$, $x_1−x_3+2x_4=2$, $x_1+x_2+x_3+x_4\geq1$, $x_1\geq0$, $x_2\geq0$, $x_3\geq0$, $x_4\geq0$.
Can you write Python code for it?

f = -np.arange(1, 5)
A = np.array([[4, 3, 2, 1], [-1, -1, -1, -1]])
A = np.concatenate((A, -np.eye(4)), axis = 0)
b = np.array([10, -1, 0, 0, 0, 0])
Aeq = np.array([[1, 0, -1, 2]])
beq = np.array([2])

import pyomo_utilities

x, obj = pyomo_utilities.linprog(f, A, b, Aeq, beq)

x

obj = -obj + 5
obj


I am working on the file "Modulo3/.ipynb_checkpoints/Clase23_Repaso1(Mod.3)-checkpoint.ipynb".
The first task is:
Ejemplo 3. Ajuste de curvas
El archivo forest_mex.csv contiene información histórica anual del porcentaje de área forestal de México. La primer columna corresponde a los años y la segunda corresponde al porcentaje de área forestal.
Tomado de: https://data.worldbank.org/indicator/AG.LND.FRST.ZS?view=chart.
Usando los años como variable independiente $x$ y el porcentaje de área forestal como variable dependiente $y$, ajustar polinomios de grado 1 hasta grado 3.
Mostrar en un solo gráfico los datos de porcentaje de área forestal contra los años, y los polinomios ajustados.
Graficar el error cuadrático acumulado contra el número de términos. ¿Cuál es el polinomio que mejor se ajusta?
Con los polinomios ajustados en el punto anterior, estime el año en que México quedará sin area forestal (suponiendo que todo sigue igual).
Can you write Python code for it?

data_file = 'forest_mex.csv'
data = pd.read_csv(data_file, header = None)

x = data.iloc[:, 0].values
y = data.iloc[:, 1].values

plt.figure()
plt.plot(x, y)
plt.show()

beta1 = pyomo_utilities.curve_polyfit(x, y, 1)
beta2 = pyomo_utilities.curve_polyfit(x, y, 2)
beta3 = pyomo_utilities.curve_polyfit(x, y, 3)

yhat1 = beta1.dot(np.array([x**i for i in range(2)]))
yhat2 = beta2.dot(np.array([x**i for i in range(3)]))
yhat3 = beta3.dot(np.array([x**i for i in range(4)]))

plt.figure(figsize = (8,6))
plt.plot(x, y, '*b', label = 'datos reales')
plt.plot(x, yhat1, '-r', label = 'ajuste 1')
plt.plot(x, yhat2, '-g', label = 'ajuste 2')
plt.plot(x, yhat3, '-k', label = 'ajuste 3')
plt.legend(loc = 'best')
plt.xlabel('$x$')
plt.ylabel('$y$')
plt.show()

ems = []
ems.append(sum((y-yhat1)**2))
ems.append(sum((y-yhat2)**2))
ems.append(sum((y-yhat3)**2))

plt.figure(figsize = (8,6))
plt.plot(np.arange(3)+1, ems, '*b')
plt.xlabel('$n$')
plt.ylabel('$e_{ms}(n)$')
plt.show()


I am working on the file "Modulo3/.ipynb_checkpoints/Clase23_Repaso1(Mod.3)-checkpoint.ipynb".
The first task is:
Ejemplo 4. Clasificador binario
Hasta ahora hemos visto como diseñar clasificadores binarios dados un conjunto de entrenamiento. Sin embargo, no le hemos dado uso.
Después del diseño de un clasificador, lo que sigue es entregarle datos de entrada y que él los clasifique.
Para los datos de la tarea de clasificación binaria, diseñaremos un clasificador binario por regresión logística lineal utilizando únicamente los primeros 80 datos.
Luego, usaremos el clasificador diseñado para clasificar a los 20 datos restantes. ¿Cuántos datos se clasifican bien? ¿Cuántos mal?
Can you write Python code for it?

X = 10*np.random.random((100, 2))
Y = (X[:, 1] > X[:, 0]**2)*1

plt.figure(figsize = (8,6))
plt.scatter(X[:,0], X[:,1], c=Y)
plt.show()

Xe = X[0:80, :]
Ye = Y[0:80]

B = pyomo_utilities.logreg_clas(Xe, Ye)


I am working on the file "Modulo3/.ipynb_checkpoints/Clase23_Repaso1(Mod.3)-checkpoint.ipynb".
The first task is:
El más grande es el máximo absoluto y el más pequeño es el mínimo absoluto. Gráfico.
Can you write Python code for it?

xnum = np.linspace(-1, 4.5, 100)

plt.figure(figsize=(8,6))
plt.plot(xnum, f(xnum), 'k', lw = 2, label = '$y=f(x)$')
plt.plot([-1], [f(-1)], '*r', ms = 10, label = '$max_{-1\leq x\leq 4.5}f(x)=55$')
plt.plot([xc[0], xc[2]], [f(xc[0]), f(xc[2])], '*b', ms = 10, label = '$min_{-1\leq x\leq 4.5}f(x)=5$')
plt.legend(loc='best')
plt.xlabel('$x$')
plt.ylabel('$y$')
plt.show()


I am working on the file "Modulo3/.ipynb_checkpoints/Clase23_Repaso1(Mod.3)-checkpoint.ipynb".
The first task is:
El más grande es el máximo absoluto.
Can you write Python code for it?

thetanum = np.linspace(0, np.pi/2, 100)
Anum = sym.lambdify([theta], A(theta), 'numpy')

plt.figure(figsize=(8,6))
plt.plot(thetanum, Anum(thetanum), 'k', lw = 2, label = '$y=A(\theta)$')
plt.plot([thetac[1]], [A(thetac[1])], '*r', ms = 10, label = '$max_{0\leq x\leq \pi/2}A(\theta)$')
plt.legend(loc='best')
plt.xlabel('$\theta$')
plt.ylabel('$y$')
plt.show()


I am working on the file "Modulo3/.ipynb_checkpoints/Clase23_Repaso1(Mod.3)-checkpoint.ipynb".
The first task is:
El polinomio que mejor se ajusta es el cúbico.
Can you write Python code for it?

sym.var('a', real = True)

Af1 = beta1[0]+beta1[1]*a
Af2 = beta2[0]+beta2[1]*a+beta2[2]*a**2
Af3 = beta3[0]+beta3[1]*a+beta3[2]*a**2+beta3[3]*a**3

Af1, Af2, Af3

a1 = sym.solve(Af1, a)
a2 = sym.solve(Af2, a)
a3 = sym.solve(Af3, a)

a1

a2

a3


I am working on the file "Modulo3/.ipynb_checkpoints/Clase23_Repaso1(Mod.3)-checkpoint.ipynb".
The first task is:
Evaluar en los extremos y en los puntos críticos.
Can you write Python code for it?


I am working on the file "Modulo3/.ipynb_checkpoints/Clase23_Repaso1(Mod.3)-checkpoint.ipynb".
The first task is:
¿Qué más librerías necesitamos?
Can you write Python code for it?

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline


I am working on the file "Modulo3/Clase18_OptimizacionSympy.ipynb".
The first task is:
2. Criterio de la segunda derivada
Sea $f(x)$ una función tal que $f’(c)=0$ y cuya segunda derivada existe en un intervalo abierto que contiene a $c$.
- Si $f’’(c)>0$, entonces $f(c)$ es un mínimo relativo.
- Si $f’’(c)<0$, entonces $f(c)$ es un máximo relativo.
- Si $f’’(c)=0$, entonces el criterio no decide.
Ejemplo
Mostrar, usando sympy, que la función $f(x)=x^2$ tiene un mínimo relativo en $x=0$.
Ya vimos que $f'(0)=0$. Notemos que:
Can you write Python code for it?

f = x**2
#d2f = sym.diff(f, x, x)
d2f = sym.diff(f, x, 2)
d2f

d2f>0


I am working on the file "Modulo3/Clase18_OptimizacionSympy.ipynb".
The first task is:
Actividad
Determinar los valores extremos absolutos de $h(x)=x^3-3x$ en $\left[-2.2,1.8\right]$, usando sympy. Mostrar en una gráfica.
Can you write Python code for it?


I am working on the file "Modulo3/Clase18_OptimizacionSympy.ipynb".
The first task is:
El converso del teorema anterior no es cierto.
Actividad
Considere $g(x)=x^3$.
- Usando sympy, muestre que $g'(0)=0$.
- Sin embargo, descartar que $x=0$ es un extremo de $g(x)$ viendo su gráfica.
Can you write Python code for it?

def g(x):
    return x**3

dg = sym.diff(g(x), x)
x_c = sym.solve(dg, x)
x_c

x_vec = np.linspace(-2,2,100)
plt.figure(figsize=(8,6))
plt.plot(x_vec, g(x_vec))
plt.xlabel('$x$')
plt.ylabel('$x^3$')
plt.show()


I am working on the file "Modulo3/Clase18_OptimizacionSympy.ipynb".
The first task is:
En varias variables...
El procedimiento es análogo.
Si una función $f:\mathbb{R}^n\to\mathbb{R}$ alcanza un máximo o mínimo local en $\boldsymbol{x}=\boldsymbol{c}\in\mathbb{R}^n$, y $f$ es diferenciable en el punto $\boldsymbol{x}=\boldsymbol{c}$, entonces $\left.\frac{\partial f}{\partial \boldsymbol{x}}\right|_{\boldsymbol{x}=\boldsymbol{c}}=\boldsymbol{0}$ (todas las derivadas parciales en el punto $\boldsymbol{x}=\boldsymbol{c}$ son cero).
Criterio de la segunda derivada: para ver si es máximo o mínimo, se toma la segunda derivada (matriz jacobiana) y se verifica definición negativa o positiva, respectivamente.
Si se restringe a cierta región, hay ciertas técnicas. La más general, pero también la más compleja es la de multiplicadores de Lagrange.
Can you write Python code for it?

sym.var('x y')
x, y

def f(x, y):
    return x**2 + y**2

dfx = sym.diff(f(x,y), x)
dfy = sym.diff(f(x,y), y)
dfx, dfy

xy_c = sym.solve([dfx, dfy], [x, y])
xy_c

x_c, y_c = xy_c[x], xy_c[y]
x_c

d2fx = sym.diff(f(x,y), x, 2)
d2fy = sym.diff(f(x,y), y, 2)
dfxy = sym.diff(f(x,y), x, y)

Jf = sym.Matrix([[d2fx, dfxy], [dfxy, d2fy]])
Jf.eigenvals()

import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

x = np.linspace(-2, 2, 100)
y = x
X, Y = np.meshgrid(x, y)

ax.plot_surface(X, Y, f(X, Y))
ax.plot([x_c], [y_c], [f(x_c,y_c)], '*r')


I am working on the file "Modulo3/Clase18_OptimizacionSympy.ipynb".
The first task is:
Otra manera de hacer lo anterior
Can you write Python code for it?

def f(x):
    return x**2

df = sym.diff(f(x), x)
df

x_c = sym.solve(df, x)
x_c[0]


I am working on the file "Modulo3/Clase18_OptimizacionSympy.ipynb".
The first task is:
Por tanto, por el criterio de la segunda derivada, $f(0)=0$ es un mínimo relativo (en efecto, el mínimo global).
Actividad
¿Qué pasa con $g(x)=x^3$ al intentar utilizar el criterio de la segunda derivada? (usar sympy).
Can you write Python code for it?

g(x)

d2g = sym.diff(g(x), x, 2)
d2g

d2g.subs(x, 0)


I am working on the file "Modulo3/Clase18_OptimizacionSympy.ipynb".
The first task is:
Veamos la gráfica...
Can you write Python code for it?

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

f_num = sym.lambdify([x], f, 'numpy')
x_vec = np.linspace(-5, 5, 100)

plt.plot(x_vec, f_num(x_vec))
plt.xlabel('$x$')
plt.ylabel('$x^2$')
plt.show()


I am working on the file "Modulo3/Clase20_ProgramaciónLineal.ipynb".
The first task is:
4. Problema de transporte

Referencia: https://es.wikipedia.org/wiki/Programaci%C3%B3n_lineal

<img style="float: right; margin: 0px 0px 15px 15px;" src="https://upload.wikimedia.org/wikipedia/commons/a/a0/Progr_Lineal.PNG" width="400px" height="125px" />
Este es un caso curioso, con solo 6 variables (un caso real de problema de transporte puede tener fácilmente más de 1.000 variables) en el cual se aprecia la utilidad de este procedimiento de cálculo.
Existen tres minas de carbón cuya producción diaria es:
- la mina "a" produce 40 toneladas de carbón por día;
- la mina "b" produce 40 t/día; y,
- la mina "c" produce 20 t/día.
En la zona hay dos centrales termoeléctricas que consumen:
- la central "d" consume 40 t/día de carbón; y,
- la central "e" consume 60 t/día.
Los costos de mercado, de transporte por tonelada son:
- de "a" a "d" = 2 monedas;
- de "a" a "e" = 11 monedas;
- de "b" a "d" = 12 monedas;
- de "b" a "e" = 24 monedas;
- de "c" a "d" = 13 monedas; y,
- de "c" a "e" = 18 monedas.
Si se preguntase a los pobladores de la zona cómo organizar el transporte, tal vez la mayoría opinaría que debe aprovecharse el precio ofrecido por el transportista que va de "a" a "d", porque es más conveniente que los otros, debido a que es el de más bajo precio.
En este caso, el costo total del transporte es:
- transporte de 40 t de "a" a "d" = 80 monedas;
- transporte de 20 t de "c" a "e" = 360 monedas; y,
- transporte de 40 t de "b" a "e" = 960 monedas,
Para un total 1.400 monedas.
Sin embargo, formulando el problema para ser resuelto por la programación lineal con
- $x_1$ toneladas transportadas de la mina "a" a la central "d"
- $x_2$ toneladas transportadas de la mina "a" a la central "e"
- $x_3$ toneladas transportadas de la mina "b" a la central "d"
- $x_4$ toneladas transportadas de la mina "b" a la central "e"
- $x_5$ toneladas transportadas de la mina "c" a la central "d"
- $x_6$ toneladas transportadas de la mina "c" a la central "e"
se tienen las siguientes ecuaciones:
Restricciones de la producción:

$x_1 +...
Can you write Python code for it?


I am working on the file "Modulo3/Clase20_ProgramaciónLineal.ipynb".
The first task is:
Y por último, las restricciones del problema, van a estar dadas por las capacidades de oferta y demanda de cada cervecería (en cajas de cerveza) y cada bar, las cuales se detallan en el gráfico de más arriba.
Solución
Sean:
- $x_i$ cajas transportadas de la cervecería A al Bar $i$,
- $x_{i+5}$ cajas transportadas de la cervecería B al Bar $i$.
La actividad consiste en plantear el problema y resolverlo con linprog...
Can you write Python code for it?


I am working on the file "Modulo3/Clase21_AjusteCurvas.ipynb".
The first task is:
3.2. Lasso
$$\boldsymbol{\beta}^{lasso} = \arg \min_{\boldsymbol{\beta}} \left|\left|\boldsymbol{y}-\boldsymbol{X}\boldsymbol{\beta}\right|\right|^2 + \lambda\left|\left|\boldsymbol{\beta}\right|\right|_1$$
La norma 1 no es más que la suma de los valores absolutos de las componentes $\left|\left|\boldsymbol{\beta}\right|\right|1=\sum{j=0}^m\left|\beta_j\right|$.
Can you write Python code for it?

beta20_lasso = pyomo_utilities.curve_polyfit(x, y, 20, reg_mode = 'lasso', reg_coef = 0.0001)
yhat20_lasso = np.array([x**i for i in range(21)]).T.dot(beta20_lasso)

plt.figure(figsize=(8,6))
plt.plot(x, y, '*b', label = 'datos')
plt.plot(x, yhat20, '-c', label = 'ajuste 20')
plt.plot(x, yhat20_ridge, '--r', label = 'ajuste 20_ridge')
plt.plot(x, yhat20_lasso, '--k', label = 'ajuste 20_lasso')
plt.legend(loc = 'best')
plt.xlabel('$x$')
plt.ylabel('$y$')
plt.grid()
plt.show()

beta20_lasso


I am working on the file "Modulo3/Clase21_AjusteCurvas.ipynb".
The first task is:
4. Ajuste robusto
Ahora, consideremos de nuevo el caso de la línea recta con un par de puntos atípicos al inicio y al final...
Can you write Python code for it?

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 1, 30)
y = 10*x + 2 + np.random.randn(30)

y[0] = 16
y[-1] = 0

plt.figure(figsize=(8,6))
plt.plot(x, y, '*b')
plt.xlabel('$x$')
plt.ylabel('$y$')
plt.grid()
plt.show()

beta = pyomo_utilities.curve_polyfit(x, y, 1)
yhat = beta[0]+beta[1]*x

plt.figure(figsize=(8,6))
plt.plot(x, y, '*b', label = 'datos')
plt.plot(x, yhat, '-r', label = 'ajuste')
plt.legend(loc = 'best')
plt.xlabel('$x$')
plt.ylabel('$y$')
plt.grid()
plt.show()

beta


I am working on the file "Modulo3/Clase21_AjusteCurvas.ipynb".
The first task is:
Creo que no. Pero, ¿Y una parábola?
Can you write Python code for it?

beta2 = pyomo_utilities.curve_polyfit(x, y, 2)
yhat2 = beta2[0]+beta2[1]*x+beta2[2]*x**2

plt.figure(figsize=(8,6))
plt.plot(x, y, '*b', label = 'datos')
plt.plot(x, yhat1, '-r', label = 'ajuste 1')
plt.plot(x, yhat2, '-g', label = 'ajuste 2')
plt.legend(loc = 'best')
plt.xlabel('$x$')
plt.ylabel('$y$')
plt.grid()
plt.show()


I am working on the file "Modulo3/Clase21_AjusteCurvas.ipynb".
The first task is:
Mejor...
5. Actividad

Ajustar polinomios de grado 1 hasta grado 10 a los siguientes datos.
Graficar el error cuadrático acumulado contra el número de términos, y elegir un polinomio que ajuste bien y su grado no sea muy alto.
Para el grado de polinomio elegido, realizar el ajuste con ridge con coeficiente de 0.001.
Comparar los beta.

Abrir un nuevo notebook, llamado Tarea7_ApellidoNombre y subirlo a moodle en el espacio habilitado. Si no terminan esto en clase, tienen hasta mañana a las 23:00.
Can you write Python code for it?

def f(x):
    return np.exp(-x**2/2)/np.sqrt(2*np.pi)

x = np.linspace(-3, 3)
y = f(x)

plt.figure(figsize=(8,6))
plt.plot(x, y, '*b', label = 'datos')
plt.legend(loc = 'best')
plt.xlabel('$x$')
plt.ylabel('$y$')
plt.grid()
plt.show()


I am working on the file "Modulo3/Clase21_AjusteCurvas.ipynb".
The first task is:
Note que la pendiente es aproximadamente $10$ y el intercepto es aproximadamente $2$.
La anterior idea se puede extender a ajuste polinomial...
2. Ajuste polinomial
Ahora, considere el siguiente conjunto de datos...
Can you write Python code for it?

n = 100
x = np.linspace(np.pi/3, 5*np.pi/3, n)
y = 4*np.sin(x) + 0.5*np.random.randn(n)

plt.figure(figsize=(8,6))
plt.plot(x, y, '*b')
plt.xlabel('$x$')
plt.ylabel('$y$')
plt.grid()
plt.show()


I am working on the file "Modulo3/Clase21_AjusteCurvas.ipynb".
The first task is:
Tampoco. Quizá un polinomio cúbico...
Can you write Python code for it?

beta3 = pyomo_utilities.curve_polyfit(x, y, 3)
yhat3 = beta3[0]+beta3[1]*x+beta3[2]*x**2+beta3[3]*x**3

plt.figure(figsize=(8,6))
plt.plot(x, y, '*b', label = 'datos')
plt.plot(x, yhat1, '-r', label = 'ajuste 1')
plt.plot(x, yhat2, '-g', label = 'ajuste 2')
plt.plot(x, yhat3, '-k', label = 'ajuste 3')
plt.legend(loc = 'best')
plt.xlabel('$x$')
plt.ylabel('$y$')
plt.grid()
plt.show()


I am working on the file "Modulo3/Clase21_AjusteCurvas.ipynb".
The first task is:
Veamos $\beta$ para el ajuste con parábola
Can you write Python code for it?


I am working on the file "Modulo3/Clase21_AjusteCurvas.ipynb".
The first task is:
¡Cuidado! ver el tamaño de algunos coeficientes. Cuando los coeficientes son grandes, ¿qué pasa?
Es conveniente ver el error como función del orden del polinomio... selección de modelos
Can you write Python code for it?

e_ms = []
for i in range(10):
    beta = pyomo_utilities.curve_polyfit(x, y, i+1);
    yhat = np.array([x**j for j in range(i+2)]).T.dot(beta)
    e_ms.append(sum((y - yhat)**2))

plt.figure(figsize=(8,5))
plt.plot(np.arange(10)+1, e_ms, 'o')
plt.xlabel('orden')
plt.ylabel('error')
plt.show()


I am working on the file "Modulo3/Clase21_AjusteCurvas.ipynb".
The first task is:
¿Cómo ajustamos una curva a esto?
1. Problema básico
<img style="float: right; margin: 0px 0px 15px 15px;" src="https://upload.wikimedia.org/wikipedia/commons/3/3a/Linear_regression.svg" width="400px" height="125px" />
Consideramos que tenemos un conjunto de n pares ordenados de datos $(x_i,y_i)$, para $i=1,2,3,\dots,n$.
¿Cuál es la recta que mejor se ajusta a estos datos?
Consideramos entonces ajustes de la forma $\hat{f}(x) = \beta_0+\beta_1 x = \left[1 \quad x\right]\left[\begin{array}{c} \beta_0 \ \beta_1 \end{array}\right]=\left[1 \quad x\right]\boldsymbol{\beta}$ (lineas rectas).
Para decir 'mejor', tenemos que definir algún sentido en que una recta se ajuste mejor que otra.
Mínimos cuadrados: el objetivo es seleccionar los coeficientes $\boldsymbol{\beta}=\left[\beta_0 \quad \beta_1 \right]^T$, de forma que la función evaluada en los puntos $x_i$ ($\hat{f}(x_i)$) aproxime los valores correspondientes $y_i$.
La formulación por mínimos cuadrados, encuentra los $\boldsymbol{\beta}=\left[\beta_0 \quad \beta_1 \right]^T$ que minimiza
$$\sum_{i=1}^{n}(y_i-\hat{f}(x_i))^2=\sum_{i=1}^{n}(y_i-\left[1 \quad x_i\right]\boldsymbol{\beta})^2=\left|\left|\boldsymbol{y}-\boldsymbol{X}\boldsymbol{\beta}\right|\right|^2,$$
donde $\boldsymbol{y}=\left[y_1\quad\dots\quad y_n\right]$, y $\boldsymbol{X}=\left[\begin{array}{ccc}1 & x_1\ \vdots & \vdots \ 1 & x_n\end{array}\right].$ Esto es,
$$\boldsymbol{\beta}^{ls} = \arg \min_{\boldsymbol{\beta}} \left|\left|\boldsymbol{y}-\boldsymbol{X}\boldsymbol{\beta}\right|\right|^2$$
Para llevar a cabo la anterior minimización, el módulo pyomo_utilities.py ha sido actualizado con la función curve_polyfit(x, y, order, reg = None, robust = False). Esta función recibe:
- x: datos de variable independiente
- y: datos de variable dependiente
- order: orden del polinomio con el que se quiere ajustar
- reg_mode: modo de regularización
- robust: ajuste robusto o no.
Para los datos anteriores queríamos ajustar una recta (order = 1)...
Can you write Python code for it?

import pyomo_utilities

beta = pyomo_utilities.curve_polyfit(x, y, 1)

beta

yhat = beta[0]+beta[1]*x

plt.figure(figsize=(8,6))
plt.plot(x, y, '*b', label = 'datos')
plt.plot(x, yhat, '-r', label = 'ajuste')
plt.legend(loc = 'best')
plt.xlabel('$x$')
plt.ylabel('$y$')
plt.grid()
plt.show()

beta


I am working on the file "Modulo3/Clase21_AjusteCurvas.ipynb".
The first task is:
¿Qué tienen en común los anteriores problemas?
Las curvas están completamente determinadas por los puntos (datos limpios, suficientes y necesarios).
Esto se traduce en que, al llevar el problema a un sistema de ecuaciones lineales, existe una única solución: no hay necesidad, ni se puede optimizar nada.
¿Tendremos datos así de 'bonitos' en la vida real?
La realidad es que los datos que encontraremos en nuestra vida profesional se parecen más a esto...
Can you write Python code for it?

x = np.linspace(0, 1, 30)
y = 10*x + 2 + np.random.randn(30)

plt.figure(figsize=(8,6))
plt.plot(x, y, '*b')
plt.xlabel('$x$')
plt.ylabel('$y$')
plt.grid()
plt.show()


I am working on the file "Modulo3/Clase21_AjusteCurvas.ipynb".
The first task is:
¿Se ajustará bien una recta?
Can you write Python code for it?

beta1 = pyomo_utilities.curve_polyfit(x, y, 1)
yhat1 = beta1[0]+beta1[1]*x

plt.figure(figsize=(8,6))
plt.plot(x, y, '*b', label = 'datos')
plt.plot(x, yhat1, '-r', label = 'ajuste 1')
plt.legend(loc = 'best')
plt.xlabel('$x$')
plt.ylabel('$y$')
plt.grid()
plt.show()


I am working on the file "Modulo3/Clase22_ClasificacionBinaria.ipynb".
The first task is:
Actividad
Considere los siguientes datos y diseñe un clasificador binario por regresión logística.
Mostrar el gráfico de la división del clasificador con los puntos de entrenamiento.
Abrir un nuevo notebook, llamado Tarea8_ApellidoNombre y subirlo a moodle en el espacio habilitado. Si no terminan esto en clase, tienen hasta el miércoles a las 23:00.
La tarea de la clase pasada es hasta el miercoles también (se me olvidó habilitar el espacio)
Can you write Python code for it?


I am working on the file "Modulo3/Clase22_ClasificacionBinaria.ipynb".
The first task is:
Diseñar un clasificador binario con regresión logística.
El paquete pyomo_utilities.py fue actualizado y contiene ahora la función logreg_clas(X, Y).
Can you write Python code for it?

import pyomo_utilities

B = pyomo_utilities.logreg_clas(X, Y)


I am working on the file "Modulo3/Clase22_ClasificacionBinaria.ipynb".
The first task is:
Los parámetros del clasificador son entonces:
Can you write Python code for it?

B

x = np.arange(20, 110, 0.5)
y = np.arange(20, 110, 0.5)
Xm, Ym = np.meshgrid(x, y)
m,n = np.shape(Xm)
Xmr = np.reshape(Xm,(m*n,1))
Ymr = np.reshape(Ym,(m*n,1))

Xa = np.append(np.ones((len(Ymr),1)), Xmr, axis=1)
Xa = np.append(Xa,Ymr,axis=1)

Yg = reg_log(B,Xa)
Z = np.reshape(Yg, (m,n))
Z = np.round(Z)

plt.figure(figsize=(10,10))
plt.contour(Xm, Ym, Z)
plt.scatter(X[:, 0],X[:, 1], c=Y, edgecolors='w')
plt.show()


I am working on the file "Modulo3/Clase23_Repaso1(Mod.3).ipynb".
The first task is:
Ejemplo 2. Programación lineal
En clase vimos cómo llevar los problemas de programación lineal a la forma
\begin{equation}
\begin{array}{ll}
\min_{\boldsymbol{x}} & \boldsymbol{f}^T\boldsymbol{x} \
\text{s. a. }        & \boldsymbol{A}{eq}\boldsymbol{x}=\boldsymbol{b}{eq} \
                     & \boldsymbol{A}\boldsymbol{x}\leq\boldsymbol{b}.
\end{array}
\end{equation}
Además, aprendimos a resolver los problemas en esta forma con la función linprog del paquete pyomo_utilities.py, proporcionando únicamente los parámetros $\boldsymbol{f}$, $\boldsymbol{A}$ y $\boldsymbol{b}$ ($\boldsymbol{A}{eq}$ y $\boldsymbol{b}{eq}$, de ser necesario).
2.1
Maximizar la función $x_1+2x_2+3x_3+4x_4+5$ sujeta a las restricciones $4x_1+3x_2+2x_3+x_4\leq10$, $x_1−x_3+2x_4=2$, $x_1+x_2+x_3+x_4\geq1$, $x_1\geq0$, $x_2\geq0$, $x_3\geq0$, $x_4\geq0$.
Can you write Python code for it?

f = -np.arange(1, 5)
A = np.array([[4, 3, 2, 1], [-1, -1, -1, -1]])
A = np.concatenate((A, -np.eye(4)), axis = 0)
b = np.array([10, -1, 0, 0, 0, 0])
Aeq = np.array([[1, 0, -1, 2]])
beq = np.array([2])

import pyomo_utilities

x, obj = pyomo_utilities.linprog(f, A, b, Aeq, beq)

x

obj = -obj + 5
obj


I am working on the file "Modulo3/Clase23_Repaso1(Mod.3).ipynb".
The first task is:
Ejemplo 3. Ajuste de curvas
El archivo forest_mex.csv contiene información histórica anual del porcentaje de área forestal de México. La primer columna corresponde a los años y la segunda corresponde al porcentaje de área forestal.
Tomado de: https://data.worldbank.org/indicator/AG.LND.FRST.ZS?view=chart.
Usando los años como variable independiente $x$ y el porcentaje de área forestal como variable dependiente $y$, ajustar polinomios de grado 1 hasta grado 3.
Mostrar en un solo gráfico los datos de porcentaje de área forestal contra los años, y los polinomios ajustados.
Graficar el error cuadrático acumulado contra el número de términos. ¿Cuál es el polinomio que mejor se ajusta?
Con los polinomios ajustados en el punto anterior, estime el año en que México quedará sin area forestal (suponiendo que todo sigue igual).
Can you write Python code for it?

data_file = 'forest_mex.csv'
data = pd.read_csv(data_file, header = None)

x = data.iloc[:, 0].values
y = data.iloc[:, 1].values

plt.figure()
plt.plot(x, y)
plt.show()

beta1 = pyomo_utilities.curve_polyfit(x, y, 1)
beta2 = pyomo_utilities.curve_polyfit(x, y, 2)
beta3 = pyomo_utilities.curve_polyfit(x, y, 3)

yhat1 = beta1.dot(np.array([x**i for i in range(2)]))
yhat2 = beta2.dot(np.array([x**i for i in range(3)]))
yhat3 = beta3.dot(np.array([x**i for i in range(4)]))

plt.figure(figsize = (8,6))
plt.plot(x, y, '*b', label = 'datos reales')
plt.plot(x, yhat1, '-r', label = 'ajuste 1')
plt.plot(x, yhat2, '-g', label = 'ajuste 2')
plt.plot(x, yhat3, '-k', label = 'ajuste 3')
plt.legend(loc = 'best')
plt.xlabel('$x$')
plt.ylabel('$y$')
plt.show()

ems = []
ems.append(sum((y-yhat1)**2))
ems.append(sum((y-yhat2)**2))
ems.append(sum((y-yhat3)**2))

plt.figure(figsize = (8,6))
plt.plot(np.arange(3)+1, ems, '*b')
plt.xlabel('$n$')
plt.ylabel('$e_{ms}(n)$')
plt.show()


I am working on the file "Modulo3/Clase23_Repaso1(Mod.3).ipynb".
The first task is:
Ejemplo 4. Clasificador binario
Hasta ahora hemos visto como diseñar clasificadores binarios dados un conjunto de entrenamiento. Sin embargo, no le hemos dado uso.
Después del diseño de un clasificador, lo que sigue es entregarle datos de entrada y que él los clasifique.
Para los datos de la tarea de clasificación binaria, diseñaremos un clasificador binario por regresión logística lineal utilizando únicamente los primeros 80 datos.
Luego, usaremos el clasificador diseñado para clasificar a los 20 datos restantes. ¿Cuántos datos se clasifican bien? ¿Cuántos mal?
Can you write Python code for it?

X = 10*np.random.random((100, 2))
Y = (X[:, 1] > X[:, 0]**2)*1

plt.figure(figsize = (8,6))
plt.scatter(X[:,0], X[:,1], c=Y)
plt.show()

Xe = X[0:80, :]
Ye = Y[0:80]

B = pyomo_utilities.logreg_clas(Xe, Ye)

B

x = np.arange(0, 10, 0.01)
y = np.arange(0, 10, 0.01)
Xm, Ym = np.meshgrid(x, y)
m,n = np.shape(Xm)
Xmr = np.reshape(Xm,(m*n,1))
Ymr = np.reshape(Ym,(m*n,1))

Xa = np.append(np.ones((len(Ymr),1)), Xmr, axis=1)
Xa = np.append(Xa,Ymr,axis=1)

def fun_log(z):
    return 1/(1+np.exp(-z))
def reg_log(B,Xa):
    return fun_log(Xa.dot(B))

Yg = reg_log(B,Xa)
Z = np.reshape(Yg, (m,n))
Z = np.round(Z)

plt.figure(figsize=(10,10))
plt.contour(Xm, Ym, Z)
plt.scatter(Xe[:, 0], Xe[:, 1], c=Ye, edgecolors='w')
plt.show()

Xp = X[80:, :]
Yp = Y[80:]

Xpa = np.append(np.ones((len(Yp),1)), Xp, axis=1)
Yhat = np.round(reg_log(B,Xpa))

Yhat

Yp

malos = sum(np.abs(Yhat-Yp))

malos


I am working on the file "Modulo3/Clase23_Repaso1(Mod.3).ipynb".
The first task is:
Evaluar en los extremos y en los puntos críticos.
Can you write Python code for it?


I am working on the file "Modulo3/Clase23_Repaso1(Mod.3).ipynb".
The first task is:
Luego de consultar expertos en nutrición tenemos que una dieta satisfactoria tiene por lo menos $2000$ kcal de energía, $55$ g de proteina, y $800$ mg de calcio.
Para imponer la variedad se ha decidido limitar el número de porciones diarias de cada una de las comidas como se indica en la tabla.
Can you write Python code for it?

f = np.array(df.loc[:,'Precio'])
A = -np.array([df.loc[:,'Energia'], df.loc[:,'Proteina'], df.loc[:,'Calcio']])
A = np.concatenate((A, np.eye(6)), axis = 0)
A = np.concatenate((A, -np.eye(6)), axis = 0)
b = np.array([-2000, -55, -800])
b = np.concatenate((b, df.loc[:,'Limite_diario']))
b = np.concatenate((b, np.zeros((6,))))

x, obj = pyomo_utilities.linprog(f, A, b)

x

obj


I am working on the file "Modulo3/Clase23_Repaso1(Mod.3).ipynb".
The first task is:
Sacar derivada e igualar a cero.
Can you write Python code for it?

df = sym.diff(f(x), x)
xc = sym.solve(df, x)
xc


I am working on the file "Modulo3/Clase23_Repaso1(Mod.3).ipynb".
The first task is:
¿Qué más librerías necesitamos?
Can you write Python code for it?

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline


I am working on the file "Moebius-Normals.ipynb".
The first task is:

Can you write Python code for it?

from IPython.core.display import HTML
def  css_styling():
    styles = open("./custom.css", "r").read()
    return HTML(styles)
css_styling()


I am working on the file "Moebius-Normals.ipynb".
The first task is:
A 3d arrow is designed as a right cone and a disk as its base. We define the standard cone, as  the cone of vertex, Vert(0,0, headsize), and angle theta between the symmetry axis, Oz, and any generatrice:
Can you write Python code for it?

def arrow3d(headsize, theta):
    r = headsize*np.tan(theta)
    u = np.linspace(0,2*np.pi, 60)
    v = np.linspace(0, 1, 15)
    U,V = np.meshgrid(u,v)
    #parameterization of the standard cone
    x = r*V*np.cos(U)
    y = r*V*np.sin(U)
    z = headsize*(1-V)
    cone = np.stack((x,y,z)) #shape(3, m, n)
    w = np.linspace(0, r, 10)
    u, w = np.meshgrid(u,w)
    #parameterization of the base disk
    xx = w*np.cos(u)
    yy = w*np.sin(u)
    zz = np.zeros(w.shape)
    disk = np.stack((xx,yy,zz))
    return cone, disk


I am working on the file "Moebius-Normals.ipynb".
The first task is:
Define a unicolor colorscale, to plot the cones and disks defining the 3d arrows:
Can you write Python code for it?


I am working on the file "Moebius-Normals.ipynb".
The first task is:
Parameterize the Moebius strip and define it as a Plotly surface:
Can you write Python code for it?

u = np.linspace(0, 2*np.pi, 36)
v = np.linspace(-0.5, 0.5, 10)
u, v = np.meshgrid(u,v)
tp = 1+v*np.cos(u/2.)
x = tp*np.cos(u)
y = tp*np.sin(u)
z = v*np.sin(u/2.)
fig= go.Figure(go.Surface(
                    x=x,
                    y=y,
                    z=z,
                    colorscale="balance",
                    colorbar=dict(thickness=20, len=0.6)))


I am working on the file "Moebius-Normals.ipynb".
The first task is:
The following function returns the Plotly traces that represent a 3d arrow:
Can you write Python code for it?

def get_normals(start, origin, cone, disk, colorscale=pl_c):
    tr_cone=go.Surface(
                 x=cone[0, :, :],
                 y=cone[1, :, :],
                 z=cone[2, :, :],
                 colorscale=colorscale,
                 showscale=False)
    tr_disk=go.Surface(
                 x=disk[0, :, :],
                 y=disk[1, :, :],
                 z=disk[2, :, :],
                 colorscale=colorscale,
                 showscale=False)
    tr_line=go.Scatter3d(
                 x=[start[0], origin[0]],
                 y=[start[1], origin[1]],
                 z=[start[2], origin[2]],
                 mode='lines',
                 line=dict(width=3, color='rgb(60, 9, 17)')
                 )
    return [tr_line, tr_cone, tr_disk]  #return a list that is concatenated to data


I am working on the file "Mohr_circle.ipynb".
The first task is:
Mohr circle for 2D stresses
Can you write Python code for it?

def mohr2d(S11=10, S12=0, S22=-5):
    """Plot Mohr circle for a 2D tensor"""
    center = [(S11 + S22)/2.0, 0.0]
    radius = np.sqrt((S11 - S22)**2/4.0 + S12**2)
    Smin = center[0] - radius
    Smax = center[0] + radius

    print("Minimum Normal Stress: ", np.round(Smin,6))
    print("Maximum Normal Stress: ", np.round(Smax, 6))
    print("Average Normal Stress: ", np.round(center[0], 6))
    print("Minimum Shear Stress: ", np.round(-radius, 6))
    print("Maximum Shear Stress: ", np.round(radius, 6))

    plt.figure()
    circ = plt.Circle((center[0],0), radius, facecolor='#cce885', lw=3,
    edgecolor='#5c8037')
    plt.axis('image')
    ax = plt.gca()
    ax.add_artist(circ)
    ax.set_xlim(Smin - .1*radius, Smax + .1*radius)
    ax.set_ylim(-1.1*radius, 1.1*radius)
    plt.plot([S22, S11], [S12, -S12], 'ko')
    plt.plot([S22, S11], [S12, -S12], 'k')
    plt.plot(center[0], center[1], 'o', mfc='w')
    plt.text(S22 + 0.1*radius, S12, 'A')
    plt.text(S11 + 0.1*radius, -S12, 'B')
    plt.xlabel(r"$\sigma$", size=18)
    plt.ylabel(r"$\tau$", size=18)

w = interact(mohr2d,
             S11=(-100.,100.),
             S12=(-100.,100.),
             S22=(-100.,100.))


I am working on the file "Mohr_circle.ipynb".
The first task is:
Mohr circle for 3D stresses
Can you write Python code for it?

def mohr3d(S11=90, S12=0, S13=95, S22=96, S23=0, S33=-50):
    r"""Plot 3D Mohr circles."""

    S = np.array([[S11, S12, S13],
                  [S12, S22, S23],
                  [S13, S23, S33]])

    S3, S2, S1 = eigvalsh(S)

    R_maj = 0.5*(S1 - S3)
    cent_maj = 0.5*(S1+S3)

    R_min = 0.5*(S2 - S3)
    cent_min = 0.5*(S2 + S3)

    R_mid = 0.5*(S1 - S2)
    cent_mid = 0.5*(S1 + S2)

    plt.figure()
    circ1 = plt.Circle((cent_maj,0), R_maj, facecolor='#cce885', lw=3,
                       edgecolor='#5c8037')
    circ2 = plt.Circle((cent_min,0), R_min, facecolor='w', lw=3,
                       edgecolor='#15a1bd')
    circ3 = plt.Circle((cent_mid,0), R_mid, facecolor='w', lw=3,
                       edgecolor='#e4612d')
    plt.axis('image')
    ax = plt.gca()
    ax.add_artist(circ1)
    ax.add_artist(circ2)
    ax.add_artist(circ3)
    ax.set_xlim(S3 - .1*R_maj, S1 + .1*R_maj)
    ax.set_ylim(-1.1*R_maj, 1.1*R_maj)
    plt.xlabel(r"$\sigma$", size=18)
    plt.ylabel(r"$\tau$", size=18)

w = interact(mohr3d,
             S11=(-100.,100.),
             S12=(-100.,100.),
             S13=(-100.,100.),
             S22=(-100.,100.),
             S23=(-100.,100.),
             S33=(-100.,100.))

from IPython.core.display import HTML
def css_styling():
    styles = open('./styles/custom_barba.css', 'r').read()
    return HTML(styles)
css_styling()


I am working on the file "MoindresCarres.ipynb".
The first task is:
Cette fois, les résidus sont bien répartis aléatoirement autour de l'origine. Calculons le coefficient de détermination selon
\begin{equation}
    R^2 = \frac{\sum_k (y^{calc}_k - \overline{y})^2}{\sum_k (y_k - \overline{y})^2}
\end{equation}
où les $y_k$ sont les données, les $y^{calc}$ sont ceux calculés avec le polynômes et $\overline{y}$ est la moyenne des valeurs $y_k$.
Can you write Python code for it?


I am working on the file "MoindresCarres.ipynb".
The first task is:
D'après les équations présentées en introduction :
Can you write Python code for it?

a = (npoints * xy_sum - x_sum * y_sum) / (npoints * x2_sum - x_sum**2)
print("a = ", a)

b = (x2_sum * y_sum - x_sum * xy_sum) / (npoints * x2_sum - x_sum**2)
print("b = ", b)


I am working on the file "MoindresCarres.ipynb".
The first task is:
Il reste à calculer la somme des produits $x\times y$. Pour parcourir à la fois la liste des valeurs de $x$ et de $y$ on utilise la fonction zip qui joint les deux listes :
Can you write Python code for it?

for xi, yi in zip(x, y):
    print("xi = ", xi, "\tyi = ", yi)


I am working on the file "MoindresCarres.ipynb".
The first task is:
La nouvelle fonction renvoie évidemment les mêmes résultats :
Can you write Python code for it?

a, b = regLin_np(x, y)
print("a = {:8.3f}\nb = {:8.3f}".format(a, b)) # \n est le caractere de fin de ligne


I am working on the file "MoindresCarres.ipynb".
The first task is:
La somme des carrés ou des produits peut également être obtenue aisément.
Can you write Python code for it?


I am working on the file "MoindresCarres.ipynb".
The first task is:
La somme des valeurs d'un tableau peut être obtenue par la méthode sum().
Can you write Python code for it?


I am working on the file "MoindresCarres.ipynb".
The first task is:
Le tout peut être fait en une seul ligne :
Can you write Python code for it?

x, y = np.loadtxt("data/donnees.dat", unpack=True)
print(x)
print(y)


I am working on the file "MoindresCarres.ipynb".
The first task is:
Lecture du fichier ligne par ligne :
Can you write Python code for it?

with open("data/donnees.dat", "r") as inp:
    for line in inp:
        xi, yi = line.split()
        print(xi, yi)
print("type de xi : ", type(xi))


I am working on the file "MoindresCarres.ipynb".
The first task is:
Les paramètres sont bien les mêmes que ceux que nous avions déterminés à la main.
Can you write Python code for it?

a, b = parametres
print("a = {:8.3f}\nb = {:8.3f}".format(a, b))


I am working on the file "MoindresCarres.ipynb".
The first task is:
Les résidus sont un bon indicateur de la qualité du modèle. Ici, on dit que les résidus sont 'structurés'. Ils ne sont pas aléatoirement répartis autour de zéro, ils présentent une variation parabolique. Cette structure des résidus indique qu'une fonction affine n'est pas adaptée pour représenter les données.
Utilisons la méthode polyfit pour ajuster une parabolle :
Can you write Python code for it?


I am working on the file "MoindresCarres.ipynb".
The first task is:
Les valeurs de $y$ correspondent à la deuxième colonne.
Can you write Python code for it?


I am working on the file "MoindresCarres.ipynb".
The first task is:
Maintenant que nous disposons de toutes les valeurs nécessaires, il ne reste plus qu'à calculer $a$ et $b$. Nous avons encore besoin du nombre de points. La fonction len donne le nombre d'éléments d'une liste.
Can you write Python code for it?

npoints = len(x)
print("Nombre de points = ", npoints)


I am working on the file "MoindresCarres.ipynb".
The first task is:
Mettons cela à profit pour calculer la somme :
Can you write Python code for it?

xy_sum = 0.
for xi, yi in zip(x, y):
    xy_sum += xi * yi
print("somme des valeurs de x*y = ", xy_sum)


I am working on the file "MoindresCarres.ipynb".
The first task is:
Nous allons maintenant visualiser les points et la droite de régression dans un premier graphique, puis, les résidus dans un second graphique. Pour ce faire, nous utiliserons la méthode subplot de matplotlib qui place des graphiques sur une grille. Les trois arguments de subplot sont le nombre de lignes, le nombre de colonnes et le numéro du graphique.
Can you write Python code for it?

# graphique 1: les données et la droite de régression
plt.subplot(2, 1, 1)
plt.plot(x, y, "bo", label="data")
plt.plot(x, a * x + b, "r-", label="regression")
plt.xlabel("x")
plt.ylabel("y")
plt.title("Regression linéaire avec résidus")
plt.legend(loc="lower right")
# graphique 2: les résidus
plt.subplot(2, 1, 2)
plt.plot(x, y - (a * x + b), "g-", label="residus")
plt.xlabel("x")
plt.ylabel("Résidus")
plt.legend(loc="upper center")


I am working on the file "MoindresCarres.ipynb".
The first task is:
Nous pouvons maintenant simplifier la fonction regLin en utilisant les fonctions de numpy :
Can you write Python code for it?

def regLin_np(x, y):
    """
    Ajuste une droite d'équation a*x + b sur les points (x, y) par la méthode
    des moindres carrés.

    Args :
        * x (list): valeurs de x
        * y (list): valeurs de y

    Return:
        * a (float): pente de la droite
        * b (float): ordonnée à l'origine
    """
    # conversion en array numpy
    x = np.array(x)
    y = np.array(y)
    # nombre de points
    npoints = len(x)
    # calculs des parametres a et b
    a = (npoints * (x*y).sum() - x.sum()*y.sum()) / (npoints*(x**2).sum() - (x.sum())**2)
    b = ((x**2).sum()*y.sum() - x.sum() * (x*y).sum()) / (npoints * (x**2).sum() - (x.sum())**2)
    # renvoie des parametres
    return a, b


I am working on the file "MoindresCarres.ipynb".
The first task is:
On va maintenant enregistrer les valeurs xi et yi dans des listes. Par ailleurs, on peut remarquer que les valeurs sont lues comme des chaînes de caractères. Il faut les convertir en nombre flottants avec la fonction float().
Can you write Python code for it?

# création des listes
x = list()
y = list()

# lecture du fichier
with open("data/donnees.dat", "r") as inp:
    for line in inp:
        xi, yi = line.split()
        x.append(float(xi))
        y.append(float(yi))


I am working on the file "MoindresCarres.ipynb".
The first task is:
Pour afficher les nombres flotant, il est possible d'utiliser un format. Deux syntaxes existent suivant la version de python :
Can you write Python code for it?

# python 2.7 et superieur
print("a = {:8.3f}".format(a))
print("b = {:8.3f}".format(b))

# python 2.X
print("a = %8.3f" % a)
print("b = %8.3f" % b)


I am working on the file "MoindresCarres.ipynb".
The first task is:
Pour aller plus loin : les résidus
Nous allons maintenant utiliser les méthodes vues précédemment sur un échantillon plus large. De plus, nous représenterons les résidus qui correspondent à la différence entre les points issus des données et la droite obtenue par la régression linéaire.
Commençons par lire les données dans le fichier regLinData.dat
Can you write Python code for it?

x, y = np.loadtxt("data/regLinData.dat", unpack=True)


I am working on the file "MoindresCarres.ipynb".
The first task is:
Pour calculer les produits entre deux arrays numpy il suffit de les multiplier :
Can you write Python code for it?

b = np.array([3, 2, 1])
print("a : ", a)
print("b : ", b)
print("a * b :", a * b)


I am working on the file "MoindresCarres.ipynb".
The first task is:
Reprennons les lignes précédentes pour représenter les données graphiquement.
Can you write Python code for it?

# graphique 1: les données et la droite de régression
plt.subplot(2, 1, 1)
plt.plot(x, y, "bo", label="data")
plt.plot(x, p0*x**2 + p1*x + p2, "r-", label="parabolle")
plt.xlabel("x")
plt.ylabel("y")
plt.title("Regression linéaire avec résidus")
plt.legend(loc="lower right")
# graphique 2: les résidus
plt.subplot(2, 1, 2)
plt.plot(x, y - (p0*x**2 + p1*x + p2), "g-", label="residus")
plt.xlabel("x")
plt.ylabel("Résidus")
plt.legend(loc="upper center")


I am working on the file "MoindresCarres.ipynb".
The first task is:
Représentation graphique
Python offre la possibilité de réaliser une réprésentation graphique en utilisant le module matplotlib. Voici un exemple d'utilisation de ce module pour représenter les points $(x, y)$ et la droite de régression précédemment déterminée.
Pour une utilisation dans ipython il faut d'abord préparer l'environnement pour intégrer matplotlib.
Can you write Python code for it?


I am working on the file "MoindresCarres.ipynb".
The first task is:
Utilisation de la méthode polyfit
La méthode polytfit du module numpy prend comme argument les valeurs de $x$, de $y$ et le degré du polynome (1 ici puisqu'il s'agit d'une droite).
Can you write Python code for it?

parametres = np.polyfit(x, y, 1)
print(parametres)


I am working on the file "MoindresCarres.ipynb".
The first task is:
Utilisons maintenant la méthode linregress.
Can you write Python code for it?

a, b, r, p_value, std_err = linregress(x, y)
print("a   ={:8.3f}\nb   ={:8.3f}\nr^2 ={:8.5f}".format(a, b, r**2))


I am working on the file "MoindresCarres.ipynb".
The first task is:
Étape 2: Créer une fonction
Dans cette fonction nous allons regrouper les différentes étapes permettant de réaliser la régression linéaire. La fonction prend comme arguments les listes des valeurs de $x$ et $y$ et retourne les valeurs des paramètres $a$ et $b$. Les entrées et sorties de la fonction doivent être explicités dans la docstring située en dessous de la définition.
Can you write Python code for it?

def regLin(x, y):
    """
    Ajuste une droite d'équation a*x + b sur les points (x, y) par la méthode
    des moindres carrés.

    Args :
        * x (list): valeurs de x
        * y (list): valeurs de y

    Return:
        * a (float): pente de la droite
        * b (float): ordonnée à l'origine
    """
    # initialisation des sommes
    x_sum = 0.
    x2_sum = 0.
    y_sum = 0.
    xy_sum = 0.
    # calcul des sommes
    for xi, yi in zip(x, y):
        x_sum += xi
        x2_sum += xi**2
        y_sum += yi
        xy_sum += xi * yi
    # nombre de points
    npoints = len(x)
    # calcul des parametres
    a = (npoints * xy_sum - x_sum * y_sum) / (npoints * x2_sum - x_sum**2)
    b = (x2_sum * y_sum - x_sum * xy_sum) / (npoints * x2_sum - x_sum**2)
    # renvoie des parametres
    return a, b


I am working on the file "Monday_2017-04-24/02_Python_examples.ipynb".
The first task is:
Interactive and Batch possibilities - Munich temperatures
Can you write Python code for it?

# playing around with the data interactively

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np

data = np.loadtxt("data/munich_temperatures.txt")
day = data[:,0]
temp = data[:,1]

%load code/temperature.py


I am working on the file "Monday_2017-04-24/02_Python_examples.ipynb".
The first task is:
Manipulating arrays by vector operations is typically a factor of 10 faster than the visit each element strategy!
Can you write Python code for it?

%%timeit
import numpy as np

# fast vector operations
x = np.linspace(0.0, 2.0 * np.pi, 100)
y = np.sin(x)


I am working on the file "Monday_2017-04-24/06_Homework_1.ipynb".
The first task is:
We see that the asymptotic form is an excellent approximation for the Bessel function at large $x$-values.
Can you write Python code for it?

# Verification of scipys Bessel function implementation
# - recursion relation

import scipy.special as ss
import numpy as np
import matplotlib.pyplot as plt
import matplotlib

# for nicer plots, make fonts larger and lines thicker
matplotlib.rcParams['font.size'] = 12
matplotlib.rcParams['axes.linewidth'] = 2.0

# Now, let's verify numerically the recursion relation
# J(n+1,x) = (2n/x)J(n,x)-J(n-1,x), n = 5

# We choose here to consider x-values  between 0.1 and 50.
# We exclude 0 because the recursion relation contains a
# formal division by it.
x = np.linspace(0.1, 50, 500)

# construct both sides of the recursion relation, these should be equal
n = 5

# the scipy implementation of jn(5);
j_n = ss.jn(5, x)

# The recursion relation:
j_n_rec = (2.0 * (n - 1) / x) * ss.jn(n - 1, x) - ss.jn(n - 2, x)

# We now plot the difference between the two formulas
# (j_n and j_n_rec above).  Note that to
# properly display the errors, we want to use a logarithmic y scale.
plt.semilogy(x, abs(j_n - j_n_rec), 'r+-', linewidth=2.0)

plt.title('Error in recursion for $J_%s$' % n)
plt.xlabel('x')
plt.ylabel('$|J_n(5) - J_{n,rec}(5)|$')
plt.grid()

# Don't forget a show() call at the end of the script.
# Here we save the plot to a file
plt.savefig("bessel_error.png")


I am working on the file "Monday_2017-05-08/01_basic_types_in_python.ipynb".
The first task is:
Boolean Type
Python has an explicit boolean type which can only take the values True and False. It is used to test conditions in loops and if statements.
Can you write Python code for it?

f = False
t = True
a = 1

print(f or t)   # logical 'or'
print(f and t)  # logical 'and'
print(a == 1)   # test for equality
print(a == 2)
print(a < 5, a >= 5)


I am working on the file "Monday_2017-05-08/01_basic_types_in_python.ipynb".
The first task is:
By default Python uses Double Precision floating point numbers.
The example print(c / d) reminds us that most floating-point numbers do not have an exact representation in a computer (numerics!). See also Floating Point Arithmetic: Issues and Limitations and read especially What every computer scientist should know about Floating-Point Arithmetic if you have not yet done so!

Exercise:
Calculate the expressions: $2 + 4 \cdot 3$, $5^{5^{5}}$, $\mathrm{e}^{-1}$
and $\left({49 \atop 6}\right)=\frac{49!}{6! 43!}$
Hint: You can use the functions numpy.exp and numpy.math.factorial to obatin Eulers number and factorials respectively.
Can you write Python code for it?


I am working on the file "Monday_2017-05-08/01_basic_types_in_python.ipynb".
The first task is:
Exercises

Write down a Python expression which evaluates to True
if $1 < x \leq 10$ and to False otherwise.
Explain the results of the following cell! Can you modify the expressions such that the results meet your expectations?
Can you write Python code for it?


I am working on the file "Monday_2017-05-08/01_basic_types_in_python.ipynb".
The first task is:
String Type
The Python String type is a special case of a container which we will treat in detail in the coming weeks!
Can you write Python code for it?

first_name = "Thomas"
second_name = "Erben"

full_name = first_name + " " + second_name # concatenation of strings
print(full_name)

print(full_name[1], full_name[1:3])        # accessing parts of strings
                                           # (see containers)
print(len(full_name))                      # length of string
print(full_name.upper())                   # translate all chars to uppercase

print(full_name.find("Erben"))             # find substring


I am working on the file "Monday_2017-05-08/01_basic_types_in_python.ipynb".
The first task is:
The last example shows that Python provides aribtrary precise integer arithmetic! There is only one integer type in the Python core.
Can you write Python code for it?

a = 5
print(type(a))   # The type of the object a variable points to
                 # can explicitely be queried!
print(type(5))


I am working on the file "Monday_2017-05-08/02_basic_control_structures_in_python.ipynb".
The first task is:
Exercises:

$x$ and $y$ are integer numbers. Write a python program which determines whether $x<y$, $x>y$ or $x=y$ and prints out the result!

Hint: Nested if-statements
Can you write Python code for it?


I am working on the file "Monday_2017-05-08/02_basic_control_structures_in_python.ipynb".
The first task is:
Notes:

condition must be a boolean expression! The loop is executed while the condition evaluates to True.
Note the colon at the end of the condition!
Python has no special characters indicating the start and the end of
the while-loop execution block. The block is merely indicated by identation!
This is the case for all Python control structures! Blocks are always indicated
by code-identation. All lines belonging to a block must be idented by the same
amount of spaces. The usual ident is four spaces (never use tabs).

Exercises

What is the output of the print statements in the following code fragements? Answer the question before executing the codes!

a = 1
  i = 1
  while i < 5:
      i = i + 1
      a = a + 1
  print(i, a)
  and
  a = 1
  i = 1
  while i < 5:
      i = i + 1
  a = a + 1
  print(i, a)
Can you write Python code for it?


I am working on the file "Monday_2017-05-08/02_basic_control_structures_in_python.ipynb".
The first task is:
The square root $y=\sqrt{x}$ of a positive number $x$ can be estimated iteratively with $y_0>0$ (an arbitrary positive number) and $y_{n+1}=\frac 12\left(y_n+\frac{x}{y_n}\right)$.

Write a python program to estimate the square root with that recipe!
Hint: Construct a while-loop with the condition $|y_{n+1}-y_n|>\epsilon$ with $\epsilon=10^{-6}$ and update $y_n$ and $y_{n+1}$ within the loop. Consider the final $y_{n+1}$ as estimate for $\sqrt{x}$.
Can you write Python code for it?


I am working on the file "Monday_2017-05-08/02_basic_control_structures_in_python.ipynb".
The first task is:
Write a program to test whether a given positive integer $x$ is a prime number!

Hints:
  - You need a combination of a while-loop and an if-statement.
  - A very simple test for the prime-property is: A positive integer is prime if $x\bmod n \neq 0$ for all $2\leq n \leq \sqrt{x}$.
Can you write Python code for it?


I am working on the file "Monday_2017-05-08/03_Review_Questions.ipynb".
The first task is:
Exercise 2
Can you write Python code for it?

import numpy as np
stu1 = 80.0
stu2 = 90.0
stu3 = 66.5
ave = (stu1 + stu2 + stu3)/3
print("Student scores:")
print(stu1)
print(stu2)
print(stu3)
print("Average: %f" %ave)


I am working on the file "Monday_2017-05-08/03_Review_Questions.ipynb".
The first task is:
Exercise 3
Can you write Python code for it?

n1, lef1 = divmod(32,5)
n2, lef2 = divmod(45,7)
n3, lef3 = divmod(51,6)
n = [n1,n2,n3]
lef = [lef1,lef2,lef3]

print("Number of students in each group:")
for i in range(0,3):
    print('Class %d: %d' %(i+1,n[i]))
print("Number of students leftover:")
for i in range(0,3):
    print('Class %d: %d' %(i+1,lef[i]))


I am working on the file "Monday_2017-05-15/01_functions_in_python.ipynb".
The first task is:
Exercises:

Try to answer the following question without executing the codes:

What is the output of the print-statements in the follwing code:
    ```
    def triple(x):
        x = x * 3
        print(x)
x = 5
print(triple(x))
What did the programmer of the function probably intend to do?
  - What is the output of the following code:
a = print(5)
print(a)
```
Can you write Python code for it?


I am working on the file "Monday_2017-05-15/01_functions_in_python.ipynb".
The first task is:
printing vs. returning function results
Many students have difficulties to understand the difference between printing the result of a function and returning the result of a function. The confusion arises because, in some sitouations, they behave the same way
Can you write Python code for it?

def p(x):    # p(x) prints its result 'and' returns None!
    print(2 * x)

def r(x):    # r(x) returns its result!
    return 2 * x

# When interactively calling the two functions, they both seem to
# behave the same way:
p(10)
r(10)

# The results are however different, when 'assiging' the functions
# results to variables:
p_result = p(10)
r_result = r(10)

print(p_result, r_result)

# Note that you need to 'return' the result of a function if you
# want to use it later (assign it to a variable)! If in doubt, then
# return the result!


I am working on the file "MongoDB.ipynb".
The first task is:
Geolocation
Mongodb also has build in support for geolocation indexes
This allows for searching for example nearby shops for a given location
Can you write Python code for it?

scratch_db.zips.create_index([("loc", "2dsphere")])
flagstaff = scratch_db.zips.find_one({"city": "FLAGSTAFF"})
nearby = scratch_db.zips.find({"loc": {
    "$near": {
        "$geometry": {
            'type': 'Point',
            'coordinates': flagstaff['loc']
        },
        "$maxDistance": 50000
    }
}})

for city in nearby:
    print(city['city'])


I am working on the file "MongoDB.ipynb".
The first task is:
You can see with the index it's execution is a bit different.
Seeing the executionTimeMillis parameter shows that the second one is executed much faster.
This is because the index allow you to search the index instead of all the documents.
Some other information about the dataset
Can you write Python code for it?

print("Amount of cities per state:")
pipeline = [
    {"$unwind": "$state"},
    {"$group": {"_id": "$state", "count": {"$sum": 1}}},
    {"$sort": SON([("count", -1), ("_id", -1)])}
    ]
results = scratch_db.zips.aggregate(pipeline)
for result in results:
    print("State %s:   %d" % tuple(result.values()))

print("Amount of cities with fewer then 50 people")
lt = scratch_db.zips.find({"pop": {"$lt": 50}})
print("%d cities" % lt.count())
for city in lt.limit(10):
    print("%s: %d" % (city['city'], city['pop']))


I am working on the file "MongoDBTutorial.ipynb".
The first task is:
A practical example
At my job I have been working on a project to help make Commerce datasets easier to find. One of the barriers to searching for records is when the keywords return either too many or too few results. It can also be a problem if the keywords are too technical for lay users.
One solution is to use topic modeling to extract latent themes from the metadata records and then probabilistically assign each record a more sensical set of keywords based on its proximity (via kmeans) to the topics.
In order to get started, first I had to gather up a bunch of JSON metadata records and store them for analysis and modeling. Here's what I did:
```python
import requests
NOAA_URL = "https://data.noaa.gov/data.json"
def load_data(URL):
    """
    Loads the data from URL and returns data in JSON format.
    """
    r = requests.get(URL)
    data = r.json()
    return data
noaa = load_data(NOAA_URL)
```
But...this kinda takes a long time, so I've created a file for you that contains a small chunk of the records to use for today's workshop.
Can you write Python code for it?

with open("data_sample.json") as data_file:
    noaa = json.load(data_file)

len(noaa)


I am working on the file "MongoDBTutorial.ipynb".
The first task is:
Checking out the data
Now let's print out just one record to examine the structure.
Can you write Python code for it?


I am working on the file "MongoDBTutorial.ipynb".
The first task is:
Collections
A collection is a group of documents stored in MongoDB, and can be thought of as roughly the equivalent of a table in a relational database. Getting a collection in PyMongo works the same as getting a database:
Can you write Python code for it?

collection = db.my_collection

db.collection_names()


I am working on the file "MongoDBTutorial.ipynb".
The first task is:
Connect
Just as with the relational database example with sqlite, we need to begin by setting up a connection. With MongoDB, we will be using pymongo, though MongoDB also comes with a console API that uses Javascript.
To make our connection, we will use the PyMongo method MongoClient:
Can you write Python code for it?


I am working on the file "MongoDBTutorial.ipynb".
The first task is:
Create and access a database
Mongodb creates databases and collections automatically for you if they don't exist already. A single instance of MongoDB can support multiple independent databases. When working with PyMongo, we access databases using attribute style access, just like we did with sqlite:
Can you write Python code for it?


I am working on the file "MongoDBTutorial.ipynb".
The first task is:
Define the collection
Next we define the collection where we'll insert the NOAA metadata records:
Can you write Python code for it?


I am working on the file "MongoDBTutorial.ipynb".
The first task is:
Full text search with a text index
One of the things that makes MongoDB special is that it enables us to create search indexes. Indexes provide high performance read operations for frequently used queries.
In particular, a text index will enable us to search for string content in a collection. Keep in mind that a collection can have at most one text index.
We will create a text index on the description field so that we can search inside our NOAA records text:
Can you write Python code for it?


I am working on the file "MongoDBTutorial.ipynb".
The first task is:
If we want to create a new text index, we can do so by first dropping the first text index:
Can you write Python code for it?


I am working on the file "MongoDBTutorial.ipynb".
The first task is:
If you already know SQL...
The following table provides an overview of common SQL aggregation terms, functions, and concepts and the corresponding MongoDB aggregation operators:
| SQL Terms, Functions, and Concepts  | MongoDB Aggregation Operators  |
| ----------------------------------  |:-------------------------------|
| WHERE                               | \$match                        |
| GROUP BY                            | \$group                        |
| HAVING                              | \$match                        |
| SELECT                              | \$project                      |
| ORDER BY                            | \$sort                         |
| LIMIT                               | \$limit                        |
| SUM()                               | \$sum                          |
| COUNT()                             | \$sum                          |
| join                                | \$lookup                       |
But...thanks to MongoDB's nested data structures, we can also do a lot of things we can't do in a relational database.
Length
Let's look for some entries that have way too many keywords:
Can you write Python code for it?

cursor = db.records.find({"$where": "this.keywords.length > 100"}).limit(2);
for rec in cursor:
    pprint(rec)


I am working on the file "MongoDBTutorial.ipynb".
The first task is:
Insert data
Then we loop through each record in the NOAA dataset and insert just the target information for each into the collection.
Can you write Python code for it?

# What data fields seem important to you? Add them below following the examples:

def insert(metadata):
    for dataset in metadata:
        data ={}
        data["title"] = dataset["title"]
        data["description"] = dataset["description"]
        data["keywords"] = dataset["keyword"]
        data["accessLevel"] = dataset["accessLevel"]
        data["lang"] = dataset["language"]
        # choose your own
        # choose your own
        # choose your own
        # choose your own

        records.insert_one(data)

insert(noaa)

# Check to make sure they're all in there
records.count()


I am working on the file "MongoDBTutorial.ipynb".
The first task is:
Introduction to MongoDB with PyMongo and NOAA Data
This notebook provides a basic walkthrough of how to use MongoDB and is based on a tutorial originally by Alberto Negron.
What is MongoDB?
MongoDB is a cross-platform document-oriented NoSQL database. Rather than the traditional table-based relational database structure, MongoDB stores JSON-like documents with dynamic schemas (called BSON), making data integration easier and faster for certain types of applications.
Features
Some of the features include:
Document-orientation
Instead of taking a business subject and breaking it up into multiple relational structures, MongoDB can store the business subject in the minimal number of documents.
Ad hoc queries
MongoDB supports field, range queries, regular expression searches. Queries can return specific fields of documents and also include user-defined JavaScript functions.
Indexing
Any field in a MongoDB document can be indexed – including within arrays and embedded documents. Primary and secondary indices are available.
Aggregation
Aggregation operators can be strung together to form a pipeline – analogous to Unix pipes.
When it makes sense to use MongoDB
Metadata records are frequently stored as JSON, and almost anything you get from an API will be JSON. For example, check out the metadata records for the National Oceanic and Atmospheric Administration.
MongoDB is a great tool to use with JSON data because it stores structured data as JSON-like documents, using dynamic rather than predefined schemas.
In MongoDB, an element of data is called a document, and documents are stored in collections. One collection may have any number of documents. Collections are a bit like tables in a relational database, and documents are like records. But there is one big difference: every record in a table has the same fields (with, usually, differing values) in the same order, while each document in a collection can have completely different fields from the other documents.
Documents are Python dictionaries...
Can you write Python code for it?

import json
import pymongo
from pprint import pprint


I am working on the file "MongoDBTutorial.ipynb".
The first task is:
Now let's remove the earthwindfire database:
Can you write Python code for it?


I am working on the file "MongoDBTutorial.ipynb".
The first task is:
Projections
Projections allow you to pass along the documents with only the specified fields to the next stage in the pipeline. The specified fields can be existing fields from the input documents or newly computed fields.
For example, let's redo our fulltext Russia search, but project just the titles of the records:
Can you write Python code for it?

cursor = db.records.find({'$text': {'$search': "Russia"}}, {"title": 1,"_id":0 })
for rec in cursor:
    print rec


I am working on the file "MongoDBTutorial.ipynb".
The first task is:
Querying
Querying with .findOne( )
The find_one() method selects and returns a single document from a collection and returns that document (or None if there are no matches). It is useful when you know there is only one matching document, or are only interested in the first match
Can you write Python code for it?


I am working on the file "MongoDBTutorial.ipynb".
The first task is:
Querying with .find( )
To get more than a single document as the result of a query we use the find() method. find() returns a Cursor instance, which allows us to iterate over all matching documents.
python
records.find()
For example, we can iterate over the first 2 documents (there are a lot in the collection and this is just an example) in the records collection
Can you write Python code for it?

for rec in records.find()[:2]:
    pprint(rec)


I am working on the file "MongoDBTutorial.ipynb".
The first task is:
Searching
MongoDB queries are represented as JSON-like structures just like documents. To build a query, you just need to specify a dictionary with the properties you want the results to match. For example, let's say we were just interested in publically available satellite data from NESDIS.
This query will match all documents in the records collection with keywords code "NESDIS".
Can you write Python code for it?


I am working on the file "MongoDBTutorial.ipynb".
The first task is:
The aggregation pipeline
The aggregation pipeline allows MongoDB to provide native aggregation capabilities that corresponds to many common data aggregation operations in SQL.  Here's where you will put the pieces together to aggregate to get results that you can begin to analyze and perform machine learning on.
Here's an example of an aggregation pipeline:
Can you write Python code for it?

from IPython.display import Image
Image(filename='images/mongodb_pipeline.png', width=600, height=300)


I am working on the file "MongoDBTutorial.ipynb".
The first task is:
To test our newly created text index on the description field, we will search documents using the $text operator. Let's start by looking for all the documents that have the word 'precipitation' in their description field.
Can you write Python code for it?

cursor = db.records.find({'$text': {'$search': 'precipitation'}})
for rec in cursor:
    print rec

cursor = db.records.find({'$text': {'$search': 'fire'}})
cursor.count()


I am working on the file "MongoDBTutorial.ipynb".
The first task is:
We can also create a wildcard text index for scenarios where we want any text fields in the records to be searchable. In such scenarios you can index all the string fields of your document using the $** wildcard specifier.
The query would go something like this:
Can you write Python code for it?

db.records.create_index([("$**","text")])

cursor = db.records.find({'$text': {'$search': "Russia"}})
for rec in cursor:
    pprint(rec)


I am working on the file "MongoDBTutorial.ipynb".
The first task is:
We can also just drop a database. First let's determine what databases we have:
Can you write Python code for it?


I am working on the file "MongoDBTutorial.ipynb".
The first task is:
You can put anything in:
Can you write Python code for it?

doc = {"class":"xbus-502","date":"03-05-2016","teaching_assistant":"bilbro", "sauce": "awesome"}
collection.insert_one(doc)


I am working on the file "MongoDBTutorial.ipynb".
The first task is:
collStats returns a variety of storage statistics for a given collection. Let's try it out for our NOAA records collection:
Can you write Python code for it?

db.command({'collstats': 'my_collection', 'verbose': 'true' })


I am working on the file "Monte Carlo Integration.ipynb".
The first task is:
Clearly, as the number of points increase, the area becomres closer to the true value.
Let us further examine this change by starting with $10^3$ points and then going all the way till $10^6$ points.
Can you write Python code for it?

%%time
N_vals = 1000 + np.arange(1000)*1000
areas = np.zeros_like(N_vals, dtype="float")
for i, N in enumerate(N_vals):
    area = get_MC_area(x, y, f, N=N, plot=False)
    areas[i] = area

print "Mean area of last 100 points: %.3f" % np.mean(areas[-100:])
print "Areas of last 10 points: ", areas[-10:]

plt.plot(N_vals, areas, color="0.1", alpha=0.7)
plt.axhline(y=np.mean(areas[100:]), linestyle="--", lw=1., color="k")
plt.ylabel("Area")
plt.xlabel("Number of samples")
#plt.xscale("log")


I am working on the file "Monte Carlo Integration.ipynb".
The first task is:
The above figure, shows that for $N=10^7$, the region covered by the sampled points is almost as smooth as the shaded region. Furthermore, the area is closer to the true value of $81.38$.
Now, let us also analyze, how the value of the calculated area changes with the order of number of sampled points.
Can you write Python code for it?

for i in xrange(2,8):
    area = get_MC_area(x, y, f, N=10**i, plot=False)
    print i, area


I am working on the file "Monte Carlo Integration.ipynb".
The first task is:
What is Monte Carlo (MC) Integration?
Let us say that we want to approximate the area between the curve defined by $f(x) = x^2 + 3x + \ln{x}$ between $x\in (0,5]$ and the x-axis.
Can you write Python code for it?

def f(x):
    return x**2 + 3*x + np.log(x)

step= 0.001
x = np.arange(1,5+step*0.1,step)
y = f(x)
print x.min(), x.max()
print y.min(), y.max()
plt.plot(x, y, lw=2., color="r")
plt.fill_between(x, 0, y, color="r", alpha=0.5)
plt.axhline(y=0, lw=1., color="k", linestyle="--")
plt.axhline(y=y.max(), lw=1., color="k", linestyle="--")
plt.axvline(x=x.min(), lw=1., color="k", linestyle="--")
plt.axvline(x=x.max(), lw=1., color="k", linestyle="--")
plt.xlabel("x")
plt.ylabel("y")
plt.title("$f(x) = x^2 + 3x + \ln{x}, x\in[1,5]$")