markdown
stringlengths 0
37k
| code
stringlengths 1
33.3k
| path
stringlengths 8
215
| repo_name
stringlengths 6
77
| license
stringclasses 15
values |
|---|---|---|---|---|
Submit the pipeline for execution
Pipelines groups runs using experiments
So before you submit a pipeline you need to create an experiment or pick an existing experiment
Once you have compiled a pipeline, you can use the pipelines SDK to submit that pipeline
|
EXPERIMENT_NAME = 'MockupModel'
#Specify pipeline argument values
arguments = {}
# Get or create an experiment and submit a pipeline run
client = kfp.Client()
experiment = client.create_experiment(EXPERIMENT_NAME)
#Submit a pipeline run
run_name = pipeline_func.__name__ + ' run'
run_result = client.run_pipeline(experiment.id, run_name, pipeline_filename, arguments)
#vvvvvvvvv This link leads to the run information page. (Note: There is a bug in JupyterLab that modifies the URL and makes the link stop working)
|
xgboost_synthetic/build-train-deploy.ipynb
|
kubeflow/examples
|
apache-2.0
|
Training loop
|
epoch = 3
for e in range(epoch):
train_loss = 0.
acc = mx.gluon.metric.Accuracy()
for i, (data, label) in enumerate(train_data):
data = data.as_in_context(ctx)
label = label.as_in_context(ctx)
with mx.autograd.record():
output = net(data)
l = loss(output, label)
l.backward()
trainer.update(data.shape[0])
train_loss += l.mean().asscalar()
acc.update(label, output)
print("Train Accuracy: %.2f\t Train Loss: %.5f" % (acc.get()[1], train_loss/(i+1)))
|
example/adversary/adversary_generation.ipynb
|
leezu/mxnet
|
apache-2.0
|
Now we perturb the input
|
data_perturbated = data + 0.15 * mx.nd.sign(data.grad)
output = net(data_perturbated)
acc = mx.gluon.metric.Accuracy()
acc.update(label, output)
print("Validation batch accuracy after perturbation {}".format(acc.get()[1]))
|
example/adversary/adversary_generation.ipynb
|
leezu/mxnet
|
apache-2.0
|
En el último capítulo, usamos una combinación lineal de variables independientes para predecir la media de una variable dependiente. Asumimos que en general la variable dependiente se distribuía como una Gaussiana y también exploramos que sucedía al relajar esta condición y usar una distribución t de Student. En este capítulo veremos más ejemplos donde es aconsejable usar distribuciones distintas a las gaussianas. Como veremos pronto, hay un motivo general, o patrón, que se puede usar para generalizar el modelo lineal a muchos problemas.
En el presente capítulo veremos:
Regresión logística y funciones inversa de enlace
Regresión logística simple
Regresión logística múltiple
La función de softmax y la regresión logística multinomial
Regresión de Poisson
Regresión de Poisson cero-inflada
Modelos lineales generalizados
La principal idea de este capítulo es bastante simple, en lugar de usar una combinación lineal de variables de entrada para predecir la media de una variable de salida, vamos a aplicar una función a la combinación lineal de variables de entrada para predecir la media de la variable de salida:
$$\mu = f(\alpha + X \beta) \tag{4.1}$$
donde $f$ es lo que se conoce como función inversa de enlace. Hay una gran variedad de funciones inversas de enlace que podemos elegir, probablemente la más simple sea la función identidad. Esta es una función que devuelve el mismo valor utilizado como argumento. Todos los modelos del capítulo anterior usaron la función de identidad, y por simplicidad simplemente la omitimos. La función de identidad puede no ser muy útil en sí misma, pero nos permite pensar en varios modelos diferentes de una manera unificada.
¿Por qué llamamos a $f$ función inversa de enlace en lugar de llamarla simplemente función de enlace? La razón es histórica. Tradicionalmente las personas aplican funciones al otro lado de la ecuación $4.1$, y llaman a esas funciones funciones de enlace, por lo tanto, para evitar confusiones, nos apegaremos al término función de enlace inverso.
Una situación en la que resulta útil emplear una función inversa de enlace es cuando trabajamos con variables categóricas, como nombres de colores, género, especies biológicas, afiliación política. Ninguna de estas variables es modelada adecuadamente usando una distribución Gaussiana. Si cambiamos la distribución que usamos para modelar los datos, en general necesitaremos también cambiar la forma en que modelamos los valores plausibles para la media de esas distribuciones. Por ejemplo, si usamos una distribución binomial como en el primer y segundo capítulo, necesitaremos un modelo lineal que arroje un valor en el intervalo [0, 1], una forma de lograr esto es mantener el modelo lineal pero usar una función inversa de enlace para restringir la salida al intervalo deseado. Estos trucos no están restringidos a variables discretas, es posible que deseemos modelar datos que solo puedan tomar valores positivos y, por lo tanto, es posible que deseemos restringir el modelo lineal para que devuelva valores positivos para la media de una distribución como por ejemplo las distribuciones Gamma o exponencial.
Antes de continuar, observe que algunas variables pueden codificarse como cuantitativas o cualitativas, y esa es una decisión que debe tomar en función del contexto de su problema; por ejemplo, podemos hablar de las variables categóricas rojas y verdes si estamos hablando de nombres de colores o las cuantitativas de 650 nm y 510 nm si estamos hablando de longitudes de onda.
Regresión logística
Los problemas de regresión consisten en predecir un valor continuo para una variable de salida dados los valores de una o más variables de entrada. En cambio, la clasificación se trata de asignar un valor discreto (que representa una clase discreta) a una variable de salida dadas algunas variables de entrada. En ambos casos, la tarea es obtener un modelo que capture correctamente la asignación entre las variables de salida y de entrada, para ello tenemos a nuestra disposición una muestra con pares de variables de entrada-salida. Desde una perspectiva de aprendizaje automático, tanto las regresiones como las clasificaciones son ejemplos de algoritmos de aprendizaje supervisado.
Mi madre prepara una comida basada en fideos que es deliciosa y se llama sopa seca. El nombre del plato parece algo ridículo ya que las sopas tienen agua por definición. Sin embargo el nombre adquiere sentido al comprender como se prepara. Algo similar ocurre con la regresión logística cuando se utiliza como método de clasificación.
La regresión logistica es la generalización del modelo de regresión que vimos en el capítulo pasado para cuando la variable dependiente es binaria. Esta generalización se logra en dos pasos. Primero reemplazamos $f$ en $4.1$ por la función logística:
$$ \text{logística}(z) = \frac{1}{1 + e^{-z}} \tag{4.2}$$
Usamos esta función por que una de sus propiedades es que no importa el valor del argumento $z$, el resultado siempre será un valor en el intervalo [0-1]. La función logística es conocida también como función sigmoide, por su aspecto típico de S como se puede ver al ejecutar la siguiente celda:
|
z = np.linspace(-6, 6)
logística = 1 / (1 + np.exp(-z))
plt.plot(z, logística)
plt.xlabel('z')
plt.ylabel('logística(z)')
plt.title('Figure 4.1');
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
El segundo paso consiste en usar como likelihood una distribución binomial y no una Gaussiana. De esta forma el modelo queda expresado como:
$$
\theta = logistic(\alpha + x\beta) \
y = \text{Bern}(\theta) \tag{4.3}
$$
Esto modelo se puede motivar de la siguiente forma. Si nuestros datos son binarios $y \in {0, 1}$, como con el ejemplo de la moneda o el diagnóstico, vemos que tiene sentido usar una distribución bernoulli. Esta distribución está parametrizada por un único parámetro en el intervalo [0, 1], el cual puede ser generado desde un modelo lineal siempre y cuando los valores generados por el modelo lineal sean comprimidos al intervalo [0, 1], algo que puede ser obtenido al emplear una función logística.
Usando un diagrama de Kruschke una regresión logística con priors Gaussianos:
<img alt="regresión_logística" src="imagenes/logística.png" width=250>
El conjunto de datos del Iris
Vamos a aplicar una regresión logística al conjunto de datos Iris. Este es un conjunto de datos clásico que contiene información sobre flores de 3 especies estrechamente relacionadas: setosa, virginica y versicolor. Estas serán nuestras variables dependientes, las clases que queremos predecir. Tenemos 50 individuos de cada especie y para cada individuo el conjunto de datos contiene cuatro variables (o features) que vamos a usar como variables independientes. Estas son el largo del pétalo, el ancho del pétalo, el largo del sépalo y el ancho del sépalo. Por si se lo están preguntando, los sépalos son hojas modificadas, cuya función está generalmente relacionada con la protección de las flores en la yema.
Podemos cargar un DataFrame con el conjunto de datos del iris haciendo:
|
iris = pd.read_csv('datos/iris.csv')
iris.head()
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
Ahora graficaremos las 3 especies versus la longitud del sépalo usando la función stripplot de seaborn:
|
sns.stripplot(x="species", y="sepal_length", data=iris, jitter=True)
plt.title('Figure 4.2');
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
Observe en la figura 4.2 que en el eje y se representan una variable continua mientras que en el eje x la variable es categórica. La dispersión (o jitter) de los puntos a lo largo del eje x no tiene ningún significado, y es solo un truco para evitar que todos los puntos colapsen en una sola línea (pueden probar pasando el argumento jitter=False). Por lo tanto lo único que importa al leer el eje x es la pertenencia de los puntos a las clases setosa, versicolor o virginica.
Otra forma de inspeccionar los datos es haciendo una matriz de dispersión con la función pairplot. En la figura 4.3 podemos ver una matriz de $4 \times 4$, ya que tenemos 4 variables independientes (o features). La matriz es simétrica con los triángulos superior e inferior conteniendo la misma información. En la diagonal principal en vez de tener una gráfico de dispersión de una variable contra si misma (lo cual no es informativo) tenemos un KDE de cada feature para cada especie (o clase). Cada especie está representada usando un color particular.
|
sns.pairplot(iris, hue='species')
plt.title('Figure 4.3');
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
Antes de continuar, tómese un tiempo para estudiar las gráficas anteriores y familiarizarse con el conjunto de datos y cómo se relacionan las variables dependientes y las independientes.
El modelo logístico aplicado al conjunto de datos del iris.
Vamos a comenzar con la regresión logística más simple posible: dos clases, setosa y versicolor, y solo una variable independiente, la longitud del sépalo. Como se hace normalmente, vamos a codificar las variables categóricas setosa y versicolor con los números 0 y 1. Usando Pandas podemos hacer:
|
df = iris.query("species == ('setosa', 'versicolor')")
y_0 = pd.Categorical(df['species']).codes
x_n = 'sepal_length'
x_0 = df[x_n].values
x_c = x_0 - x_0.mean()
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
Al igual que con otros modelos lineales, centrar los datos puede ayudar con el muestreo. Ahora que tenemos los datos en el formato adecuado, finalmente podemos construir el modelo con PyMC3.
Observe cómo la primera parte del siguiente modelo se asemeja a un modelo de regresión lineal. Este modelo tiene dos variables deterministas: θ ybd. θ es la salida de la función logística aplicada a la variable μ y bd es límite de decisión (el cual explicaremos más adelante).Otro punto que vale la pena mencionar es que en lugar de escribir explícitamente la función logística estamos usando pm.math.sigmoid (esto es un alias para una función de Theano).
|
with pm.Model() as modelo_0:
α = pm.Normal('α', mu=0, sd=10)
β = pm.Normal('β', mu=0, sd=10)
μ = α + pm.math.dot(x_c, β)
θ = pm.Deterministic('θ', pm.math.sigmoid(μ))
bd = pm.Deterministic('bd', -α/β)
yl = pm.Bernoulli('yl', p=θ, observed=y_0)
trace_0 = pm.sample(1000)
varnames = ['α', 'β', 'bd']
az.plot_trace(trace_0, varnames);
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
Como es habitual, también mostramos el summary del posterior. Más adelante, compararemos el valor que obtengamos para el límite de decisión con un valor calculado utilizando otro método.
|
az.summary(trace_0, varnames)
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
Ahora vamos a graficar los datos junto con la curva sigmoide ajustada:
|
theta = trace_0['θ'].mean(axis=0)
idx = np.argsort(x_c)
plt.figure(figsize=(10, 6))
plt.plot(x_c[idx], theta[idx], color='C2', lw=3);
plt.vlines(trace_0['bd'].mean(), 0, 1, color='k')
bd_hpd = az.hpd(trace_0['bd'])
plt.fill_betweenx([0, 1], bd_hpd[0], bd_hpd[1], color='k', alpha=0.5)
plt.scatter(x_c, np.random.normal(y_0, 0.02), marker='.', color=[f'C{x}' for x in y_0])
theta_hpd = az.hpd(trace_0['θ'])[idx]
plt.fill_between(x_c[idx], theta_hpd[:,0], theta_hpd[:,1], color='C2', alpha=0.5)
plt.xlabel(x_n)
plt.ylabel('θ', rotation=0, labelpad=20)
# use original scale for xticks
locs, _ = plt.xticks()
plt.xticks(locs, np.round(locs + x_0.mean(), 1))
plt.title('Figure 4.4');
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
La figura 4.4 muestra la longitud del sépalo para las especies (setosa = 0, versicolor = 1). Para mitigar la superposición de los datos, hemos agregado ruido (jitter) a las variables-respuesta binarias. Una línea verde en forma de S representa el valor medio de $\theta$. Esta línea se puede interpretar como la probabilidad que una flor sea versicolor dado el valor de la longitud del sépalo. La banda verde semitransparente es el intervalo del 94% de HPD. De esta forma podemos interpretar a la regresión logística como una forma de combinar variables linealmente a fin de obtener una probabilidad para variables binarias.
Alternativamente podemos usar una regresión logística para clasificar, esto lo podemos hacer discretizando el valor de probabilidad obtenido. El caso más común es asignar la clase 1 si la probabilidad es mayor a 0.5 y asignar la clase 0 en caso contrario. En la figura 4.4 hemos graficado este límite de decisión usando una línea vertical negra junto con su 94% HPD (la banda gris). De acuerdo con el límite de decisión, los valores $x_i$ (longitud del sépalo en este caso) a la izquierda corresponden a la clase 0 (setosa) y los valores a la derecha a la clase 1 (versicolor).
El límite de decisión se define como el valor de $x_i$, para el cual $y = 0.5$. Y resulta ser $- \frac{\alpha}{\beta} $, como podemos comprobar a continuación:
A partir de la definición del modelo tenemos la relación:
$$\theta = logistic(\alpha + x \beta) \tag{4.4}$$
Y a partir de la definición de la función logística tenemos que $\theta = 0.5 $, cuando el argumento de la regresión logística es 0, es decir:
$$0.5 = logística(\alpha + x_i \beta) \Leftrightarrow 0 = \alpha + x_i \beta \tag{4.5}$$
Reordenando 4.5, encontramos que el valor de $x_i$, para el cual, $\theta = 0.5$ corresponde a la expresión:
$$x_i = - \frac{\alpha}{\beta} \tag{4.6}$$
Resumiendo los puntos más importantes hasta el momento:
El valor de $\theta$ es, en términos generales, $p(y= 1 \mid x) $. En este sentido, la regresión logística es en realidad una regresión, solo que estamos regresionando la probabilidad de que un punto de datos pertenezca a la clase 1, dada una combinación lineal de características.
Estamos modelando la media de una variable dicotómica, es decir, un número en el intervalo [0-1]. Luego, introducimos una regla para convertir esta probabilidad en una asignación de dos clases. En este caso, si $p(y = 1) >= 0.5 $ asignamos clase 1, de lo contrario clase 0.
No hay nada especial en el valor 0.5, aparte de que es el número en el medio entre 0 y 1. Podemos argumentar que este límite solo es razonable si estamos de acuerdo en cometer un error en una u otra dirección. En otras palabras, si es lo mismo para nosotros clasificar erróneamente una setosa como versicolor o una versicolor como setosa. Resulta que este no es siempre el caso, y el costo asociado a la clasificación errónea no tiene por qué ser simétrico, como recordarán del capítulo 2 cuando analizamos las funciones de pérdida.
Regresión logística múltiple
De manera similar a la regresión lineal múltiple, la regresión logística múltiple consiste en utilizar más de una variable independiente. Intentemos combinar la longitud del sépalo y el ancho del sépalo. Recuerda que necesitamos preprocesar un poco los datos.
|
df = iris.query("species == ('setosa', 'versicolor')")
y_1 = pd.Categorical(df['species']).codes
x_n = ['sepal_length', 'sepal_width']
#x_n = ['petal_length', 'petal_width']
x_1 = df[x_n].values
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
El límite de decisión
No dudes en omitir esta sección y pasar directamente a la implementación del modelo si no estás demasiado interesado en cómo podemos obtener el límite de decisión.
Desde el modelo, tenemos:
$$\theta = logística(\alpha + \beta_1 x_1 + \beta_2 x_2) \tag{4.7}$$
Y a partir de la definición de la función logística, tenemos que $\theta = 0.5$, cuando el argumento de la regresión logística es cero, es decir:
$$ 0.5 = logística(\alpha + \beta_1x_1 + \beta_2x_2) \Leftrightarrow 0 = \alpha + \beta_1x_1 + \beta_2x_2 \tag {4.8}$$
Reordenando, encontramos el valor de $x_2$ para el cual $\theta = 0.5$ el cual corresponde a la expresión:
$$ x_2 = -\frac{\alpha}{\beta_2} + \left (-\frac{\beta_1}{\beta_2} x_1 \right) \tag {4.9}$$
Esta expresión para el límite de decisión tiene la misma forma matemática que la ecuación de una línea, siendo el primer término el intercepto y el segundo la pendiente. Los paréntesis se utilizan para mayor claridad y podemos omitirlos si queremos. Que el límite sea una línea es totalmente razonable, ¿no es así? Si tenemos una sola variable, tenemos datos unidimensionales y podemos dividirla en dos grupos usando un punto; si tenemos dos variables, tenemos un espacio de datos bidimensional y podemos separarlo usando una línea; para las tres dimensiones, el límite será un plano y para dimensiones más altas hablaremos genéricamente acerca de los hiperplanos. Bueno, en realidad siempre podemos hablar de hyperplanos n-dimensionales.
Implementando el modelo
Para escribir el modelo de regresión logística múltiple utilizando PyMC3, aprovechamos sus capacidades de vectorización, lo que nos permite introducir solo modificaciones menores respecto del modelo logístico simple:
|
with pm.Model() as modelo_1:
α = pm.Normal('α', mu=0, sd=10)
β = pm.Normal('β', mu=0, sd=2, shape=len(x_n))
μ = α + pm.math.dot(x_1, β)
θ = pm.Deterministic('θ', pm.math.sigmoid(μ))
bd = pm.Deterministic('bd', -α/β[1] - β[0]/β[1] * x_1[:,0])
yl = pm.Bernoulli('yl', p=θ, observed=y_1)
trace_1 = pm.sample(2000)
varnames = ['α', 'β']
az.plot_forest(trace_1, var_names=varnames);
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
Como hicimos para una única variable predictiva, vamos a graficar los datos y el límite de decisión.
|
idx = np.argsort(x_1[:,0])
bd = trace_1['bd'].mean(0)[idx]
plt.scatter(x_1[:,0], x_1[:,1], c=[f'C{x}' for x in y_0])
plt.plot(x_1[:,0][idx], bd, color='k');
bd_hpd = az.hpd(trace_1['bd'])[idx]
plt.fill_between(x_1[:,0][idx], bd_hpd[:,0], bd_hpd[:,1], color='k', alpha=0.5);
plt.xlabel(x_n[0])
plt.ylabel(x_n[1])
plt.title('Figure 4.5');
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
El límite de decisión es una línea recta, como ya hemos visto. No se confunda con el aspecto curvo de la banda del 94% de HPD. La curvatura aparente es el resultado de tener múltiples líneas que giran alrededor de una región central (aproximadamente alrededor de la media de x y la media de y).
Interpretación de los coeficientes de una regresión logística
Debemos tener cuidado al interpretar los coeficientes $\beta$ de una regresión logística. La interpretación no es tan sencilla como con los modelos lineales en el capítulo anterior. La función logística introduce una no linearidad, que debemos tener en cuenta. Si $\beta$ es positivo, aumentar $x$ aumentará $p(y = 1)$ en cierta cantidad, pero la cantidad no es una función lineal de $x$, es en cambio una función no-lineal de $x$. Podemos visualizar este hecho en la figura 4.4, en lugar de una línea con una pendiente constante, tenemos una línea en forma de S con una pendiente que cambia en función de $x$. Un poco de álgebra nos puede dar una idea de cuánto cambia $p(y=1)$ con $\beta$:
El modelo logístico básico es:
$$\theta = logistic (\alpha + X \beta) \tag{4.11} $$
El inverso de la logística es la función logit, que es:
$$ logit(z) = log \left (\frac{z}{1-z} \right) \tag{4.12}$$
Por lo tanto, si tomamos la primera ecuación en esta sección y aplicamos la función logit a ambos términos, obtenemos:
$$ logit(\theta) = \alpha + X \beta \tag{4.13}$$
O equivalente:
$$ log \left (\frac{\theta} {1-\theta} \right) = \alpha + X \beta \tag {4.14}$$
Recuerden que $\theta$ en nuestro modelo era la probabilidad de $y = 1 $, por lo tanto:
$$ log \left(\frac {p(y = 1)} {1-p (y = 1)} \right) = \alpha + X \beta \tag {4.15} $$
La cantidad $$\frac{p (y = 1)} {1-p (y = 1)}$$ se conoce como odds. Los odds a favor se definen como la relación entre la probabilidad de éxito y la probabilidad de no éxito. Mientras que la probabilidad de obtener 2 tirando un dado es 1/6, los odds para el mismo evento son $\frac{1/6}{5/6} \simeq 0.2$ o dicho de otra forma 1 evento favorable frente a 5 eventos desfavorables. Los odds suelen ser utilizadas por los jugadores principalmente porque proporcionan una herramienta más intuitiva que las probabilidades en bruto cuando se piensa en la forma correcta de apostar.
En una regresión logística, el coeficiente $\beta$ codifica el aumento en unidades de log-odds por unidad de aumento de la variable $x$.
La transformación de probabilidad a odds es una transformación monotónica, lo que significa que las probabilidades aumentan a medida que aumenta la probabilidad. Mientras que las probabilidades están restringidas al intervalo $[0, 1]$, los odds viven en el intervalo $[0, \infty]$. El logaritmo es otra transformación monótonica y los log-odds están en el intervalo $[-\infty, \infty]$. La figura 4.6 muestra cómo la probabilidad está relacionada con los odds y los log-odds.
|
probability = np.linspace(0.01, 1, 100)
odds = probability / (1 - probability)
_, ax1 = plt.subplots()
ax2 = ax1.twinx()
ax1.plot(probability, odds, 'C0')
ax2.plot(probability, np.log(odds), 'C1')
ax1.set_xlabel('probability')
ax1.set_ylabel('odds', color='C0')
ax2.set_ylabel('log-odds', color='C1')
ax1.grid(False)
ax2.grid(False)
plt.title('Figure 4.6');
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
Por lo tanto, los valores de los coeficientes proporcionados por summary están en la escala log-odds.
|
df = az.summary(trace_1, varnames)
df
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
Una forma muy empírica de entender los modelos es cambiar los parámetros y ver qué sucede. En el siguiente bloque de código, calculamos las log-odds en favor de versicolor como $\text {log_odds_versicolor_i} = \alpha + beta_1 x1 + \beta_2 x2$, y luego la probabilidad de versicolor con la función logística. Luego repetimos el cálculo arreglando $x_2$ y aumentando $x_1$ en 1.
|
x_1 = 4.5 # sepal_length
x_2 = 3 # sepal_width
log_odds_versicolor_i = (df['mean'] * [1, x_1, x_2]).sum()
probability_versicolor_i = logistic(log_odds_versicolor_i)
log_odds_versicolor_f = (df['mean'] * [1, x_1 + 1, x_2]).sum()
probability_versicolor_f = logistic(log_odds_versicolor_f)
(f'{log_odds_versicolor_f - log_odds_versicolor_i:.2f}',
f'{probability_versicolor_f - probability_versicolor_i:.2f}')
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
Si ejecutas el código, encontrarás que el aumento en las log-odds es de $\approx 4.7$, que es exactamente el valor de $\beta_0$ (verifique el summary para trace_1). Esto está en línea con nuestro hallazgo anterior que muestra que los coeficientes $\beta$ indican el aumento en unidades log-odds por incremento unitario de la variable $x$. El aumento en la probabilidad es $\approx 0.70$.
Trabajando con variables correlacionadas
Sabemos por el capítulo anterior que trabajar con variables muy correlacionadas puede traernos problemas. Las variables correlacionadas se traducen en combinaciones más amplias de coeficientes que explican los datos o, desde el punto de vista complementario, variables correlacioadas tienen menos poder para restringir los modelos. Un problema similar ocurre cuando las clases se vuelven perfectamente separables, es decir, no hay superposición entre clases dada la combinación lineal de variables en nuestro modelo. Podemos visualizar un ejemplo de esto al usar el conjunto de datos iris con el modelo_1, pero esta vez utilizando las variables ancho de pétalo y largo de pétalo. Encontraras que los coeficientes $\beta$ son más amplios que antes y también el 94% HPD (banda gris en la figura 4.5) es mucho más amplia. La figura 4.7 muestra un heatmap para las variables sepal_length y sepal_width (usadas en el primer ejemplo) la correlación no es tan alta como la correlación entre las variables petal_length y petal_width (usada en el segundo ejemplo).
|
corr = iris[iris['species'] != 'virginica'].corr()
mask = np.tri(*corr.shape).T
sns.heatmap(corr.abs(), mask=mask, annot=True, cmap='viridis')
plt.title('Figure 4.7');
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
Para generar la figura 4.7, hemos utilizado una máscara que elimina el triángulo superior y los elementos diagonales del heatmap, ya que estos son poco informativos o redundantes. Observe también que hemos graficado el valor absoluto de la correlación, ya que en este momento no nos importa el signo de la correlación entre las variables, solo su fuerza.
Una solución cuando se trabaja con variables (altamente) correlacionadas, es simplemente eliminar una (o más de una) de las variables correlacionadas. Otra opción es poner más información en el a priori, esto se puede lograr con a prioris informativos si es que contamos con información previa útil, o más general utilizando a prioris ligeramente informativos. Andrew Gelman y el equipo de Stan recomiendan usar el siguiente a priori al realizar una regresión logística:
$$ \beta \sim Student t (0, \nu, sd) \tag {4.10}$$
donde sd se elije de forma que informe débilmente sobre los valores esperados para la escala. Se sugiere que el parámetro de normalidad $\nu$ sea alrededor de 3-7. Lo que dice este a priori es que esperamos que el coeficiente sea pequeño, pero ponemos colas pesadas porque esto nos lleva a un modelo más robusto que el uso de una distribución gaussiana.
Tratando con clases desequilibradas
El conjunto de datos del iris está completamente equilibrado; en el sentido de que cada categoría tiene exactamente el mismo número de observaciones. Tenemos 50 setosas, 50 versicolores, y 50 virgininas. Por el contrario, muchos conjuntos de datos constan de datos no balanceados, es decir, hay muchos más datos de una clase que de la otra. Cuando esto sucede, la regresión logística puede generar problemas, es decir, el límite no se puede determinar con la misma precisión que cuando el conjunto de datos está más equilibrado.
Para ver un ejemplo de este comportamiento, vamos a usar el conjunto de datos del iris y vamos a eliminar arbitrariamente algunos puntos de datos de la clase setosa:
|
df = iris.query("species == ('setosa', 'versicolor')")
df = df[45:]
y_3 = pd.Categorical(df['species']).codes
x_n = ['sepal_length', 'sepal_width']
x_3 = df[x_n].values
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
Y ahora ejecutamos una regresión logística múltiple, tal cual hicimos antes.
|
with pm.Model() as modelo_3:
α = pm.Normal('α', mu=0, sd=10)
β = pm.Normal('β', mu=0, sd=2, shape=len(x_n))
μ = α + pm.math.dot(x_3, β)
θ = pm.math.sigmoid(μ)
bd = pm.Deterministic('bd', -α/β[1] - β[0]/β[1] * x_3[:,0])
yl = pm.Bernoulli('yl', p=θ, observed=y_3)
trace_3 = pm.sample(1000)
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
El límite de decisión se desplaza hacia la clase menos abundante y la incertidumbre es más grande que antes. Este es el comportamiento típico de un modelo logístico para datos no balanceados. ¡Pero espera un minuto! Bien podrías argumentar que te estoy engañando ya que la mayor incertidumbre es en realidad el producto de tener menos datos y no solo menos setosas que versicolores. Este es un punto totalmente válido, pero si realizas el ejercicio 2 podrás verificar que lo que explica esta gráfica son los datos desequilibrados.
|
idx = np.argsort(x_3[:,0])
bd = trace_3['bd'].mean(0)[idx]
plt.scatter(x_3[:,0], x_3[:,1], c= [f'C{x}' for x in y_3])
plt.plot(x_3[:,0][idx], bd, color='k');
bd_hpd = pm.hpd(trace_3['bd'])[idx]
plt.fill_between(x_3[:,0][idx], bd_hpd[:,0], bd_hpd[:,1], color='k', alpha=0.5);
plt.xlabel(x_n[0])
plt.ylabel(x_n[1]);
plt.title('Figure 4.8')
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
¿Qué hacer si encontramos datos desequilibrados? Bueno, la solución obvia es obtener un conjunto de datos con aproximadamente la misma cantidad por clase. Este es un punto a tener en cuenta al recopilar o generar los datos. Si no tenés control sobre el conjunto de datos, debes tener cuidado al interpretar los resultados para datos no balanceados. Verifique la incertidumbre del modelo y ejecute algunas verificaciones predictivas posteriores para ver si los resultados son útiles para usted. Otra opción sería utilizar priors más informativos y/o ejecutar un modelo alternativo como se explica más adelante en este capítulo.
Regresión softmax (o multinomial)
Una forma de generalizar la regresión logística a más de dos clases es con la regresión softmax. Necesitamos introducir 2 cambios con respecto a la regresión logística, primero reemplazamos la función logística con la función softmax:
$$softmax (\mu_i) = \frac {exp (\mu_i)} {\sum exp (\mu_k)} \tag{4.16}$$
En palabras, para obtener la salida de la función softmax para el i-esimo elemento de un vector $\mu$, tomamos la exponencial del valor i-esimo dividido por la suma de todos los valores del vector $\mu$ exponenciados.
La función softmax garantiza que obtendremos valores positivos que suman 1. La función softmax se reduce a la función logística cuando $k=2$. Como nota al margen, la función softmax tiene la misma forma que la distribución de Boltzmann, distribución central en la mecánica estadística, una rama muy poderosa de la física que se ocupa de la descripción probabilística de los sistemas atómicos y moleculares. La distribución de Boltzmann (y a veces la función softmax) incluye un parámetro llamado temperatura (T) que divide $\mu$; cuando $ T \rightarrow \infty $ la distribución de probabilidad se vuelve plana y todos los estados son igualmente probables, y cuando $T \rightarrow 0$ solo se llena el estado más probable y, por lo tanto, el softmax se comporta como la función máximo.
El segundo cambio en la regresión softmax es que reemplazamos la distribución de Bernoulli por la distribución categórica. La distribución categórica es la generalización de Bernoulli a más de dos resultados. Además, como la distribución de Bernoulli (tirada de una sola moneda) es un caso especial de la Binomial (tiradas de $n$ monedas), la categórica (tirada de un dado de $k$ caras) es un caso especial de la distribución multinomial ($n$ tiradas de un dado de $k$ caras).
k-diagram
Para ejemplificar la regresión de softmax, continuaremos trabajando con el conjunto de datos iris, solo que esta vez usaremos sus 3 clases (setosa, versicolor y virginica) y sus cuatro características (largo sépalo, ancho sépalo, longitud del pétalo y ancho del pétalo). También vamos a estandarizar los datos, ya que esto ayudará a que el sampler se ejecute de manera más eficiente (también podríamos centrar los datos):
|
iris = sns.load_dataset('iris')
y_s = pd.Categorical(iris['species']).codes
x_n = iris.columns[:-1]
x_s = iris[x_n].values
x_s = (x_s - x_s.mean(axis=0)) / x_s.std(axis=0)
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
El código de PyMC3 refleja los pocos cambios entre el modelo logístico y el modelo softmax. Presta atención a los valores de shape para los coeficientes $\alpha $ y $\beta$. En el siguiente código usamos la función softmax de Theano. Hemos utilizado la expresión import theano.tensor as tt, que es la convención utilizada por los desarrolladores de PyMC3:
|
with pm.Model() as modelo_s:
α = pm.Normal('α', mu=0, sd=5, shape=3)
β = pm.Normal('β', mu=0, sd=5, shape=(4,3))
μ = pm.Deterministic('μ', α + pm.math.dot(x_s, β))
θ = tt.nnet.softmax(μ)
yl = pm.Categorical('yl', p=θ, observed=y_s)
trace_s = pm.sample(2000)
az.plot_forest(trace_s, var_names=['α', 'β']);
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
¿Qué tan bien funciona nuestro modelo? Averigüemos cuántos casos podemos predecir correctamente. En el siguiente código, solo usamos la media de los parámetros para calcular la probabilidad de que cada punto de datos pertenezca a cada una de las tres clases, luego asignamos la clase usando la función argmax. Y comparamos el resultado con los valores observados:
|
data_pred = trace_s['μ'].mean(0)
y_pred = [np.exp(point)/np.sum(np.exp(point), axis=0) for point in data_pred]
f'{np.sum(y_s == np.argmax(y_pred, axis=1)) / len(y_s):.2f}'
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
El resultado es que clasificamos correctamente $\approx 98 \%$ de los datos, es decir, clasificamos erroneamente solo tres casos. Ese es realmente un muy buen trabajo. Sin embargo, una verdadera prueba para evaluar el rendimiento de nuestro modelo sería verificarlo con un conjunto de datos no usado para ajustar al modelo. De lo contrario, es posible que estemos sobreestimando la capacidad real del modelo para generalizar a otros datos.
Es posible que hayas notado que las distribuciones marginales de cada parámetro son muy amplias. Este es el mismo problema de no identificabilidad que ya hemos encontrado para los datos correlacionados en otros modelos de regresión o con clases perfectamente separables. En este caso, el ancho posterior se debe a la condición de que todas las probabilidades deben sumar 1. Dada esta condición, estamos usando más parámetros de los que necesitamos para especificar completamente el modelo. En términos simples, si tenés 10 números que suman 1, solo necesitás darme 9 de ellos; el otro puedo calcularlo. Esto es precisamente lo que está pasando con este problema. Una solución es fijar los parámetros extra a algún valor, por ejemplo, cero. El siguiente código muestra cómo lograr esto usando PyMC3:
|
with pm.Model() as modelo_sf:
α = pm.Normal('α', mu=0, sd=2, shape=2)
β = pm.Normal('β', mu=0, sd=2, shape=(4,2))
α_f = tt.concatenate([[0] ,α])
β_f = tt.concatenate([np.zeros((4,1)) , β], axis=1)
μ = α_f + pm.math.dot(x_s, β_f)
θ = tt.nnet.softmax(μ)
yl = pm.Categorical('yl', p=θ, observed=y_s)
trace_sf = pm.sample(1000)
az.plot_forest(trace_sf, var_names=['α', 'β']);
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
Linear discriminant analysis (LDA)
Hasta ahora hemos discutido la regresión logística y algunas extensiones de la misma. En todos estos casos, calculamos $p(y \mid x) $, es decir, la probabilidad que una clase $y$ teniendo como dato una o más variables $x$, luego usamos un umbral o límite para convertir la probabilidad computada en un límite discreto lo que nos permite asignar clases.
Este enfoque no es único. Una alternativa es modelar primero $p(x \mid y)$. No vamos a entrar en mucho detalle aquí sobre este tipo de modelos para clasificación, pero vamos a ver un ejemplo que ilustra la idea central de este tipo de modelo. Lo haremos para dos clases y una sola variable, exactamente como el primer modelo que construimos en este capítulo, es más usaremos los mismos datos.
En el siguiente código se puede ver que ahora el límite de decisión se define como el promedio entre las medias de las Gaussianas. Este modelo es equivalente a lo que se conoce como análisis discriminante lineal (Linear Discriminar Analysis).
|
with pm.Model() as modelo_lda:
μ = pm.Normal('μ', mu=0, sd=10, shape=2)
σ = pm.HalfNormal('σ', 10)
setosa = pm.Normal('setosa', mu=μ[0], sd=σ, observed=x_0[:50])
versicolor = pm.Normal('versicolor', mu=μ[1], sd=σ, observed=x_0[50:])
bd = pm.Deterministic('bd', (μ[0] + μ[1]) / 2)
trace_lda = pm.sample(1000)
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
Ahora vamos a generar una figura que muestra las dos clases (setosa = 0 yversicolor = 1) contra los valores de la longitud del sépalo, y también el límite de decisión como una línea naranja y el intervalo del 94% de HPD como una banda naranja semitransparente.
|
plt.axvline(trace_lda['bd'].mean(), ymax=1, color='C1')
bd_hpd = pm.hpd(trace_lda['bd'])
plt.fill_betweenx([0, 1], bd_hpd[0], bd_hpd[1], color='C1', alpha=0.5)
plt.plot(x_0, np.random.normal(y_0, 0.02), '.', color='k')
plt.ylabel('θ', rotation=0)
plt.xlabel('sepal_length')
plt.title('Figure 4.9');
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
Como habrá notado, la figura 4.9 es bastante similar a la figura 4.4. Verifique también los valores de la decisión de límite en el siguiente summary:
|
az.summary(trace_lda)
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
Tanto el modelo LDA como la regresión logística proporcionan resultados similares. El modelo discriminante lineal puede extenderse a más de una característica al modelar las clases como Gaussianas multivariadas. Además, es posible relajar el supuesto de que las clases comparten una varianza común (o covarianza). Esto conduce a un modelo conocido como análisis discriminante cuadrático (QDA).
En general, los modelos LDA o QDA funcionarán mejor que una regresión logística cuando las características que estamos usando estén más o menos distribuidas como Gaussianas y la regresión logística funcionará mejor en el caso contrario. Una ventaja de modelos como LDA y QDA (o generalizaciones de esta idea) es que puede ser más fácil o más natural incorporar información previa.
Es importante tener en cuenta que los límites de decisión de LDA y QDA pueden ser calculados analíticamente y, por lo tanto, por lo general se calculan de esa manera. Para usar un LDA para dos clases y una característica, solo necesitamos calcular la media de cada distribución y promediar esos dos valores, y obtenemos la decisión de los límites. En el modelo anterior, lo hicimos, pero con un giro Bayesiano. Estimamos los parámetros de las dos Gaussianas y luego insertamos esas estimaciones en una fórmula predefinida.
Regresión de Poisson
Otro modelo lineal generalizado muy popular es la regresión de Poisson. Este modelo asume que los datos se distribuyen de acuerdo con la distribución de Poisson.
Un escenario en el que la distribución de Poisson es útil es cuando se analizan cosas, como la descomposición de un núcleo radioactivo, el número de hijos por pareja o el número de seguidores de Twitter. Lo que todos estos ejemplos tienen en común es que usualmente los modelamos usando números discretos no negativos {0, 1, 2, 3 ...}. Este tipo de variable recibe el nombre de datos de conteo (count data).
La distribución de Poisson
Imagina que estamos contando la cantidad de autos rojos que pasan por una avenida por hora. Podríamos usar la distribución de Poisson para describir estos datos. La distribución de Poisson se utiliza generalmente para describir la probabilidad que ocurra un número determinado de eventos independientes entre si en un intervalo de tiempo o espacio fijo. Esta distribución discreta se parametriza utilizando solo un valor, $\mu$ (la tasa, también comúnmente representada con la letra griega $\lambda$). $\mu$ corresponde a la media y también a la varianza de la distribución. La función de probabilidad de masa de la distribución de Poisson es:
$$ f(x \mid \mu) = \frac {e^{-\mu}\mu^x} {x!} \tag{4.17}$$
dónde:
* $\mu$ es el número promedio de eventos por unidad de tiempo / espacio
* $x$ es un valor entero positivo 0, 1, 2, ...
* $x!$ es el factorial de x, k! = k × (k - 1) × (k - 2) × ... × 2 × 1
En la siguiente gráfica, podemos ver algunos ejemplos de la familia de distribución de Poisson, para diferentes valores de $\mu$.
|
mu_params = [0.5, 1.5, 3, 8]
x = np.arange(0, max(mu_params) * 3)
for mu in mu_params:
y = stats.poisson(mu).pmf(x)
plt.plot(x, y, 'o-', label=f'μ = {mu:3.1f}')
plt.legend()
plt.xlabel('x')
plt.ylabel('f(x)')
plt.title('Figure 4.10')
plt.savefig('B11197_04_10.png', dpi=300);
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
Es importante notar que $\mu$ puede ser un flotante, pero la distribución modela probabilidad de un número discreto de eventos. En la figura 4.10, los puntos representan los valores de la distribución, mientras que las líneas continuas son una ayuda visual que nos ayuda a comprender fácilmente la forma de la distribución. Recuerde, la distribución de Poisson es una distribución discreta.
La distribución de Poisson puede verse como un caso especial de la distribución binomial cuando la cantidad de intentos $n$ es muy grande pero la probabilidad de éxito $p$ es muy baja. Sin entrar en detalles matemáticos, tratemos de aclarar la afirmación anterior. Siguiendo el ejemplo del auto, podemos afirmar que o vemos el auto rojo o no, por lo que podemos usar una distribución binomial. En ese caso tenemos:
$$ x \sim Bin(n, p) \tag{4.18}$$
Entonces, la media de la distribución binomial es:
$$\mathbf{E}[x] = np \tag{4.19} $$
Y la varianza viene dada por:
$$ \mathbf {V}[x] = np (1 - p) \tag{4.20}$$
Pero tenga en cuenta que incluso si se encuentra en una avenida muy transitada, la posibilidad de ver un auto rojo en comparación con el número total de automóviles en una ciudad es muy pequeño y, por lo tanto, tenemos:
$$n >> p \Rightarrow np \simeq np (1-p) \tag{4.21}$$
Entonces, podemos hacer la siguiente aproximación:
$$\mathbf {V}[x] = np \tag{4.22}$$
Ahora la media y la varianza están representadas por el mismo número y podemos
declarar con confianza que nuestra variable se distribuye como una distribución de Poisson:
$$x \sim Poisson(\mu = np) \tag{4.23}$$
El modelo de Poisson inflado de ceros
Al contar cosas, una posibilidad es no contar esas cosas, es decir obtener cero. El número cero puede ocurrir generalmente por muchas razones; obtuvimos un cero porque estábamos contando autos rojos y un auto rojo no pasó por la avenida o porque no logramos verlo (tal vez no vimos pasar un diminuto auto rojo detrás de un gran camión). Entonces, si usamos una distribución de Poisson, notaremos, por ejemplo, cuando realizamos una verificación predictiva posterior, que el modelo generó menos ceros en comparación con los datos.
¿Cómo arreglamos eso? Podemos tratar de abordar la causa exacta por la cual nuestro modelo predice menos ceros de los observados e incluir ese factor en el modelo. Sin embargo, suele ser el caso, que es suficiente y más fácil para nuestro propósito, asumir que simplemente tenemos una mezcla de dos procesos:
Uno modelado por una distribución de Poisson con probabilidad $\psi$
Otra persona que da ceros adicionales con probabilidad $1 - \psi$.
Esto se conoce como modelo Poisson inflado de ceros (ZeroInflatedPoisson). En algunos textos, encontrarás que $\psi$ se usa para representar los ceros extra y $1-\psi$ la probabilidad de Poisson.
Básicamente una distribución ZIP nos dice que:
$$p(y_j = 0) = 1 - \psi + (\psi) e^{-\mu} \tag{4.24}$$
$$p(y_j = k_i ) = \psi \frac{\mu^x_i e^{-\mu}}{x_i!} \tag{4.25}$$
Donde $1-\psi$ es la probabilidad de ceros adicionales. Podríamos implementar fácilmente estas ecuaciones en un modelo PyMC3. Sin embargo, podemos hacer algo aún más fácil y usar la distribución ZIP de PyMC3.
|
#np.random.seed(42)
n = 100
θ_real = 2.5
ψ = 0.1
# Simulate some data
counts = np.array([(np.random.random() > (1-ψ)) * np.random.poisson(θ_real)
for i in range(n)])
with pm.Model() as ZIP:
ψ = pm.Beta('ψ', 1., 1.)
θ = pm.Gamma('θ', 2., 0.1)
y = pm.ZeroInflatedPoisson('y', ψ, θ, observed=counts)
trace = pm.sample(1000)
az.plot_trace(trace)
plt.title('Figure 4.11');
az.summary(trace)
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
Regresión de Poisson y regresión ZIP
El modelo ZIP puede parecer un poco aburrido, pero a veces necesitamos estimar distribuciones simples como esta u otra como las distribuciones de Poisson o Gaussianas. Además, podemos usar las distribuciones Poisson o ZIP como parte de un modelo lineal. Como vimos con la regresión logística (y softmax) podemos usar una función de enlace inverso para transformar el resultado de un modelo lineal en una variable adecuada para ser utilizada con otra distribución que no sea la normal. En la siguiente figura, vemos una posible implementación de una regresión ZIP. La regresión de Poisson será similar, pero sin la necesidad de incluir $\phi$ ya que no modelaremos un exceso de ceros. Observe que ahora usamos la función exponencial como la función de enlace inverso. Esta elección garantiza que los valores devueltos por el modelo lineal sean positivos.
Para ejemplificar la implementación de un modelo de regresión ZIP, vamos a trabajar con un conjunto de datos tomado del Instituto de Investigación y Educación Digital.
El problema es el siguiente: trabajamos en la administración de un parque y queremos mejorar la experiencia de los visitantes. Por lo tanto, decidimos realizar una breve encuesta a 250 grupos que visitan el parque. Parte de los datos que recopilamos (a nivel de grupo) consiste en:
La cantidad de peces que capturaron (contar)
Cuántos niños había en el grupo (niño)
Ya sea que hayan traído o no una casa-rodante o "caravana" al parque (camper).
Usando estos datos, vamos a construir un modelo que predice el número de peces capturados en función de las variables niño y caravana. Podemos usar Pandas para cargar los datos:
|
fish_data = pd.read_csv('datos/fish.csv')
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
Lo dejo como un ejercicio para que explore el conjunto de datos utilizando gráficos y / o una función de Pandas, como describe(). Por ahora vamos a continuar traduciendo el diagrama de Kruschke anterior a PyMC3:
|
with pm.Model() as ZIP_reg:
ψ = pm.Beta('ψ', 1, 1)
α = pm.Normal('α', 0, 10)
β = pm.Normal('β', 0, 10, shape=2)
θ = pm.math.exp(α + β[0] * fish_data['child'] + β[1] * fish_data['camper'])
yl = pm.ZeroInflatedPoisson('yl', ψ, θ, observed=fish_data['count'])
trace_ZIP_reg = pm.sample(1000)
az.plot_trace(trace_ZIP_reg);
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
Para entender mejor los resultados de nuestra inferencia, hagamos una gráfica.
|
children = [0, 1, 2, 3, 4]
fish_count_pred_0 = []
fish_count_pred_1 = []
for n in children:
without_camper = trace_ZIP_reg['α'] + trace_ZIP_reg['β'][:,0] * n
with_camper = without_camper + trace_ZIP_reg['β'][:,1]
fish_count_pred_0.append(np.exp(without_camper))
fish_count_pred_1.append(np.exp(with_camper))
plt.plot(children, fish_count_pred_0, 'C0.', alpha=0.01)
plt.plot(children, fish_count_pred_1, 'C1.', alpha=0.01)
plt.xticks(children);
plt.xlabel('Number of children')
plt.ylabel('Fish caught')
plt.plot([], 'C0o', label='without camper')
plt.plot([], 'C1o', label='with camper')
plt.legend();
plt.title('Figure 4.12');
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
Regresión logística robusta
Acabamos de ver cómo corregir un exceso de ceros sin modelar directamente el factor que los genera. Se puede utilizar un enfoque similar, sugerido por Kruschke, para realizar una versión más robusta de la regresión logística. Recuerde que en la regresión logística modelamos los datos como binomiales, es decir, ceros y unos. Por lo tanto, puede suceder que encontremos un conjunto de datos con ceros y/o unos inusuales. Tomemos como ejemplo el conjunto de datos de iris que ya hemos visto, pero con algunos datos intrusos agregados de manera deliberada:
|
iris = sns.load_dataset("iris")
df = iris.query("species == ('setosa', 'versicolor')")
y_0 = pd.Categorical(df['species']).codes
x_n = 'sepal_length'
x_0 = df[x_n].values
y_0 = np.concatenate((y_0, np.ones(6, dtype=int)))
x_0 = np.concatenate((x_0, [4.2, 4.5, 4.0, 4.3, 4.2, 4.4]))
x_c = x_0 - x_0.mean()
plt.plot(x_c, y_0, 'o', color='k');
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
Aquí tenemos algunas versicolors (1s) con una longitud de sépalo inusualmente corta. Podemos arreglar esto con un modelo de mezcla. Vamos a decir que la variable de salida viene con probabilidad $\pi$ por adivinación aleatoria o con probabilidad $1-\pi$ de un modelo de regresión logística. Matemáticamente, tenemos:
$$p = \pi \ 0.5 + (1 - \pi) \: \text{logistic}(\alpha + X \beta) \tag{4.26} $$
Tenga en cuenta que cuando $\pi = 1$ obtenemos $p = 0.5 $, y para $\pi = 0 $ recuperamos la expresión para regresión logística.
La implementación de este modelo es una modificación directa del primer modelo de este capítulo.
|
with pm.Model() as modelo_rlg:
α = pm.Normal('α', mu=0, sd=10)
β = pm.Normal('β', mu=0, sd=10)
μ = α + x_c * β
θ = pm.Deterministic('θ', pm.math.sigmoid(μ))
bd = pm.Deterministic('bd', -α/β)
π = pm.Beta('π', 1, 1)
p = π * 0.5 + (1 - π) * θ
yl = pm.Bernoulli('yl', p=p, observed=y_0)
trace_rlg = pm.sample(1000)
az.summary(trace_rlg, varnames)
theta = trace_rlg['θ'].mean(axis=0)
idx = np.argsort(x_c)
plt.plot(x_c[idx], theta[idx], color='C2', lw=3);
plt.vlines(trace_rlg['bd'].mean(), 0, 1, color='k')
bd_hpd = pm.hpd(trace_rlg['bd'])
plt.fill_betweenx([0, 1], bd_hpd[0], bd_hpd[1], color='k', alpha=0.5)
plt.scatter(x_c, np.random.normal(y_0, 0.02), marker='.', color=[f'C{x}' for x in y_0])
theta_hpd = pm.hpd(trace_rlg['θ'])[idx]
plt.fill_between(x_c[idx], theta_hpd[:,0], theta_hpd[:,1], color='C2', alpha=0.5)
plt.xlabel(x_n)
plt.ylabel('θ', rotation=0)
# use original scale for xticks
locs, _ = plt.xticks()
plt.xticks(locs, np.round(locs + x_0.mean(), 1))
plt.title('Figure 4.13');
|
04_Generalizando_modelos_lineales.ipynb
|
aloctavodia/EBAD
|
gpl-3.0
|
2D trajectory interpolation
The file trajectory.npz contains 3 Numpy arrays that describe a 2d trajectory of a particle as a function of time:
t which has discrete values of time t[i].
x which has values of the x position at those times: x[i] = x(t[i]).
x which has values of the y position at those times: y[i] = y(t[i]).
Load those arrays into this notebook and save them as variables x, y and t:
|
f = np.load('trajectory.npz')
x = f['x']
y = f['y']
t = f['t']
assert isinstance(x, np.ndarray) and len(x)==40
assert isinstance(y, np.ndarray) and len(y)==40
assert isinstance(t, np.ndarray) and len(t)==40
|
assignments/assignment08/InterpolationEx01.ipynb
|
rsterbentz/phys202-2015-work
|
mit
|
Use these arrays to create interpolated functions $x(t)$ and $y(t)$. Then use those functions to create the following arrays:
newt which has 200 points between ${t_{min},t_{max}}$.
newx which has the interpolated values of $x(t)$ at those times.
newy which has the interpolated values of $y(t)$ at those times.
|
x_approx = interp1d(t, x, kind='cubic')
y_approx = interp1d(t, y, kind='cubic')
traj_approx = interp2d(x, y, t, kind='cubic')
newt = np.linspace(t.min(),max(t),200)
newx = x_approx(newt)
newy = y_approx(newt)
assert newt[0]==t.min()
assert newt[-1]==t.max()
assert len(newt)==200
assert len(newx)==200
assert len(newy)==200
|
assignments/assignment08/InterpolationEx01.ipynb
|
rsterbentz/phys202-2015-work
|
mit
|
Make a parametric plot of ${x(t),y(t)}$ that shows the interpolated values and the original points:
For the interpolated points, use a solid line.
For the original points, use circles of a different color and no line.
Customize you plot to make it effective and beautiful.
|
fig = plt.figure(figsize=(7,7))
plt.plot(newx, newy, marker='.')
plt.plot(x, y, 'ro')
plt.xticks([-1.0,-0.5,0.0,0.5,1.0])
plt.yticks([-1.0,-0.5,0.0,0.5,1.0])
plt.xlabel('x(t)')
plt.ylabel('y(t)')
assert True # leave this to grade the trajectory plot
|
assignments/assignment08/InterpolationEx01.ipynb
|
rsterbentz/phys202-2015-work
|
mit
|
value noise
We start with a function ${f_1}$ that takes an integer ${x}$ and produces a value ${v}$ so that $0 \le v \le 1$. First, we need a seeded table ${r}$ of random values between 0 and 1:
|
r = np.random.ranf(4)
|
value_noise.ipynb
|
basp/aya
|
mit
|
Actually, lets define a seed function that initializes this table with using a seed number and and sample size:
|
def seed(n, size=4):
global r
np.random.seed(n)
r = np.random.ranf(size)
|
value_noise.ipynb
|
basp/aya
|
mit
|
And now we can define ${f_1}$ using this table:
def f1(x):
x = int(x % len(r))
return r[x]
seed(0, 4)
x = np.linspace(0, 15, 16)
y = [f1(x) for x in x]
plt.plot(x, y, 'bo')
With a small ${r}$ table we also get a very small period. You can see that ${f_1}$ repeats every 4 units along the x-axis. Let's fix this by re-seeding ${r}$ with more samples.
|
seed(0, 8)
y = [f1(x) for x in x]
plt.plot(x, y, 'bo')
|
value_noise.ipynb
|
basp/aya
|
mit
|
Which already looks a lot more random. Now we repeat every 8 units along the x-axis. We will get back to the amount of samples later, for now well keep it small to make things more manageable.
We're also deliberately plotting the function as dots instead of a continuous line because we still haven't figured out how to, for example sample noise at position 0.5 along the x-axis. Up until now we have only been dealing with integers such as 0, 1, 3 etc.
linear interpolation
If we have two values ${v_0} = 2$ and ${v_1} = 5$ we can perform a linear interpolation between them. An easy way to start visualizing this is to start drawing a line between $(0, 2)$ and $(1, 5)$.
|
v0 = 2
v1 = 5
plt.plot([0,1], [v0,v1])
|
value_noise.ipynb
|
basp/aya
|
mit
|
Now let's say we want to find out what the ${y}$ value is for when ${x} = 1/3$. Let's consider this line for a moment, we notice it starts at ${y} = 2$ where ${x} = 0$. So let's start with a function ${f_1}$ that describes this:
${f_1}(x) = x + 2$
This will work for when ${x} = 0$ but not for when ${x} = 1$:
${f_1}(0) = 0 + 2 = 2$
${f_1}(1) = 1 + 2 = 3$
We need something else so that when we invoke ${f_1}(1)$ we get a result of 5. In order to find out how much, we need to find out the difference between ${v_0}$ and ${v_1}$ first. We do this by substracting ${v_0}$ from ${v_1}$ so $\delta{v} = {v_1} - {v_0}$ which is $5 - 2 = 3$. This means that when ${x} = 1$ we need to add 3. When ${x} = 0$ we need to add 0. So considering $0 \le x \le 1$ we can say that we need to add $\delta{v}{x}$ along the way to ${f_1}$ in order to get to our destination which leads us to ${f_1}(x) = 3x + 2$:
|
def f1(x): return 3 * x + 2
x = np.linspace(0, 1, 10)
y = [f1(x) for x in x]
plt.plot(x, y)
|
value_noise.ipynb
|
basp/aya
|
mit
|
It would be nice to have a more generic version of this function. This is pretty easy though:
${f_2}(v0, v1, vt) = v0 + (v1 - v0)t$
|
def f2(v0, v1, t):
return v0 + (v1 - v0) * t
y = [f2(v0, v1, t) for t in x]
plt.plot(x, y)
|
value_noise.ipynb
|
basp/aya
|
mit
|
In theory we now could use any ${v_0}$ and ${v_1}$ and interpolate between them. Let's try ${v_0} = -3$ and ${v_1} = 2$:
|
v0, v1 = -3, 2
y = [f2(v0, v1, t) for t in x]
plt.plot(x, y)
|
value_noise.ipynb
|
basp/aya
|
mit
|
Correlation Matrix
By calling df.corr() on a full pandas DataFrame will return a square matrix containing all pairs of correlations.
By plotting them as a heatmap, you can visualize many correlations more efficiently.
Correlation matrix with two perfectly correlated features
|
df = x_plus_noise(randomness=0)
sns.heatmap(df.corr(), vmin=0, vmax=1)
df.corr()
|
course/class1/correlation/examples/01 - correlation matrix and heatmap.ipynb
|
hershaw/data-science-101
|
mit
|
Correlation matrix with mildly-correlated features
|
df = x_plus_noise(randomness=0.5)
sns.heatmap(df.corr(), vmin=0, vmax=1)
df.corr()
|
course/class1/correlation/examples/01 - correlation matrix and heatmap.ipynb
|
hershaw/data-science-101
|
mit
|
Correlation matrix with not-very-correlated features
|
df = x_plus_noise(randomness=1)
sns.heatmap(df.corr(), vmin=0, vmax=1)
df.corr()
|
course/class1/correlation/examples/01 - correlation matrix and heatmap.ipynb
|
hershaw/data-science-101
|
mit
|
Inspired by the Classifier comparision from SciKit Example, we are trying to see which algorithm work better.
Due to heavyness of data, we are avoiding checking Linear, RBF, SVM
|
X, y, TEST_X = sam_pickle_load(prefix="tmp/Iteration2_vt_kb_")
df_check_stats(X, y, TEST_X)
clf = RandomForestClassifier(random_state=192)
scores = cross_val_score(clf, X, y, cv=5, n_jobs=-1)
print('AC Score:', scores.mean())
# preprocess dataset, split into training and test part
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.25, random_state=42)
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import RBF
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
names = ["Nearest Neighbors",
# "Linear SVM",
# "RBF SVM",
# "Gaussian Process",
"Decision Tree", "Random Forest", "Neural Net", "AdaBoost",
"Naive Bayes", "QDA", "GBT",]
classifiers = [
KNeighborsClassifier(3),
# SVC(kernel="linear", C=0.025),
# SVC(gamma=2, C=1),
# GaussianProcessClassifier(1.0 * RBF(1.0), warm_start=True),
DecisionTreeClassifier(),
RandomForestClassifier(),
MLPClassifier(),
AdaBoostClassifier(),
GaussianNB(),
QuadraticDiscriminantAnalysis(),
GradientBoostingClassifier()]
# iterate over classifiers
te_scores = []
tr_scores = []
for name, clf in zip(names, classifiers):
clf.fit(X_train, y_train)
tr_scores.append(clf.score(X_train, y_train))
te_scores.append(clf.score(X_test, y_test))
plt.figure(figsize=(12, 3))
plt.plot(range(len(names)), tr_scores)
plt.plot(range(len(names)), te_scores)
plt.xticks(range(len(names)), names, fontsize=8)
plt.yticks(fontsize=8)
plt.ylabel('Scores', fontsize=8)
# plt.xlabel('Alog', fontsize=8)
plt.title('Classifiers Performance on Pump it Data', fontsize=9)
lines_scores = te_scores.copy()
lines_scores.sort()
plt.plot((0, len(tr_scores) -1 ), (lines_scores[-1], lines_scores[-1]), '-.')
plt.plot((0, len(tr_scores) -1 ), (lines_scores[-2], lines_scores[-2]), '--')
plt.legend(['Train Score',
'Test Score',
'Top Test Score',
'2nd Top Test Score'], fontsize=8)
te_scores
|
pumpit/PumpIt-04.ipynb
|
msampathkumar/datadriven_pumpit
|
apache-2.0
|
Administrative Stuff
Connect to the Jupyter server that I have created on Amazon EC2. URL is:
https://54.172.168.134:8888/
Password is: "LifeIsGood!"
When in there, create a new notebook, and then click on the "Untitled" at the top, and rename it to your own name.
Learning Outcomes:
By the end of this section, you will be able to:
Use Python functions to visualize the Normal, Binomial, Hypergeometric, and Poisson distributions.
Describe the meaning of a p-value.
Describe the difference between the population and sample distribution.
Describe the Central Limit Theorem and its use in inferential statistics.
Inferential Statistics
In the first part, we learned about descriptive statistics, and common plots used to visualize the data.
In this section, we will learn about inferential statistics, which when boiled down to its core, is all about figuring out how probable our data (or more extreme) could have been under random chance.
The Logic of Inference
We observe some data. We want to know what probability we could have observed that data or something more extreme, purely by random chance.
To do so, we need a few ingredients:
A test statistic - a summary statistic of the data. Usually the mean or variance.
A null random model - essentially one of the distributions taught by Sean, and other non-parametric distributions.
Inspired by @jakevdp (Jake Vanderplas, UW eScience Institute), we will not be using analytical methods (i.e. algebra) in this segment, but instead we will use computational methods.
Example 1: The probability of getting that result or something more extreme
Here is a datapoint: We have flipped a coin 20 times, and it came out to be heads 16 times. Is this coin biased or not?
Firstly, let's define the test statistic as "the number of heads flipped".
Secondly, let's define the null random model as "20 coin flips where the probability of heads is 0.5".
|
null_flips = binom.rvs(n=20, p=0.5, size=10000)
plt.hist(null_flips)
plt.axvline(16)
alpha = 5 / 100
null_flips = binom.rvs(n=20, p=0.5, size=10000)
plt.hist(null_flips)
plt.axvline(16)
sum(null_flips >=16) / 10000
|
Inferential Statistics.ipynb
|
ericmjl/be-stats-iap2016
|
mit
|
Our test here tells us whether it is possible for us to see X number of heads or more under randomness. Let us count up the number of times we see 16 or more heads under the null model.
|
num_heads = sum(null_flips >= 16)
num_heads
|
Inferential Statistics.ipynb
|
ericmjl/be-stats-iap2016
|
mit
|
Finally, let's calculate the probability of seeing this number by random chance.
|
p_value = num_heads / len(null_flips)
p_value
|
Inferential Statistics.ipynb
|
ericmjl/be-stats-iap2016
|
mit
|
The probability of seeing this under a null model of p=0.5 is very low (approximately 1 in 200). Therefore, it is likely the case that the coin is biased.
Exercise 1
Epidemiologists have been longitudinally measuring the rate of cancer incidence in a population of humans. Over the first 10 years, cancer rates were 10 per 10000 by the age of 30. In the 11th and 12th years, cancer rates went up to 14 per 10000. Calculate the p-value of the 11th year and the 12th year separately.
Hint: Model this as a Poisson process.
What are you assuming about the null model?
|
null_poisson = poisson.rvs(10, size=100000)
sum(null_poisson >= 14) / 100000
|
Inferential Statistics.ipynb
|
ericmjl/be-stats-iap2016
|
mit
|
Visualize this using the plot below.
|
plt.hist(null_poisson)
plt.axvline(14)
|
Inferential Statistics.ipynb
|
ericmjl/be-stats-iap2016
|
mit
|
Exercise 2
In your average bag of M&Ms, there are on average 30 brown, 20 yellow, 20 red, 10 orange, 10 green, and 10 blue out of every 100 M&M candies. I draw out 50 candies, and find that I have 22 brown. Is this bag an "average" bag?
|
null_hypergeom = hypergeom.rvs(M=100, n=30, N=50, size=10000)
sum(null_hypergeom >= 22) / 10000
|
Inferential Statistics.ipynb
|
ericmjl/be-stats-iap2016
|
mit
|
Once again, plot this below.
|
plt.hist(null_hypergeom)
plt.axvline(22)
|
Inferential Statistics.ipynb
|
ericmjl/be-stats-iap2016
|
mit
|
Exercise 3
Systolic blood pressure in healthy patients is Normally distributed with mean 122 mmHg and std. deviation 9 mmHg. In hypertensive patients, it is Normally with mean 140 and std. deviation 6 mmHg. (I pulled out these numbers from a hat - http://www.cdc.gov/nchs/data/nhsr/nhsr035.pdf)
A patient comes in and measures 130 mmHg.
What is the p-value of this patient's blood pressure, under:
the hypothesis that this patient is healthy?
the hypothesis that this patient is hypertensive?
Plot the distributions and the patient's systolic blood pressure.
|
null_healthy = norm.rvs(122, 9, size=100000)
null_hyper = norm.rvs(140, 6, size=100000)
sns.kdeplot(null_healthy)
sns.kdeplot(null_hyper)
plt.axvline(130)
# P-value calculation under healthy hypothesis
np.sum(null_healthy >= 130) / len(null_healthy)
# P-value calculation under hypertension hypothesis
np.sum(null_hyper <= 130) / len(null_hyper)
|
Inferential Statistics.ipynb
|
ericmjl/be-stats-iap2016
|
mit
|
Example 2: Difference between two experimental groups.
You've measured enzyme activity under two inhibitors and a control without an inhibitor. Is the difference a true difference, or could we have observed this purely by random chance? Take a look at the data below.
|
# inhibitor1 = norm.rvs(70, 22, size=20)
# inhibitor2 = norm.rvs(72, 10, size=30)
# control = norm.rvs(75, 20, size=15)
# data = pd.DataFrame([inhibitor1, inhibitor2, control]).T
# data.columns = ['Inhibitor 1', 'Inhibitor 2', 'Control']
# data.to_csv('drug_inhibitor.csv')
data = pd.read_csv('drug_inhibitor.csv', index_col=0) #
data.mean().plot(kind='bar', yerr=data.std())
data.head(10) # this displays only the first 10 rows. Take out ".head()" to display a larger view of the data.
|
Inferential Statistics.ipynb
|
ericmjl/be-stats-iap2016
|
mit
|
Okay, so here's the important, potentially billion-dollar market question: Is inhibitor 1 any good?
Basically, the question we're asking is this: Is the there a difference between the enzyme's activity under inhibitor 1 vs. the control?
Here are a few problems we face here:
We don't know what distribtion the inhibitor and the control data came from. You might be tempted to assume a Normal (N~(mu,sd)) distribution around the mean of each group, but you'd have to justify why this is a rational choice.
The error bars come from the sampled data, not from the so-called "population" data.
Is there a way around this?
Permutation
We can perform a permutation test. Here's the setup.
we want to know whether two groups are statistically different or not, BUT
we do not have a rationally-defensible underlying distribution to model the data explicitly,
Therefore...
assume that the treatments do not matter
compute what the distribution of difference of menas will be like if the treatment labels did not matter.
then, calculate the probability that two populations are different under this permutation distribution assumption.
|
import numpy as np
differences = []
for i in range(1000):
# Select out the two columns of data of interest
means = data[['Inhibitor 1', 'Control']]
# Select
means = means.apply(np.random.permutation, axis=1).mean()
difference = means['Control'] - means['Inhibitor 1']
differences.append(difference)
differences = np.array(differences)
plt.hist(differences, label='Null')
plt.axvline(data.mean()['Control'] - data.mean()['Inhibitor 1'], color='red', label='Data')
plt.legend()
data_diff = data.mean()['Control'] - data.mean()['Inhibitor 1']
np.sum(differences >= data_diff) / len(differences)
|
Inferential Statistics.ipynb
|
ericmjl/be-stats-iap2016
|
mit
|
The probability of seeing this or more difference, assuming that the inhibitor treatment has no effect, is about 3 out of 20 times. We might not be so convinced that this is a good drug.
Notes
Once again, we have chosen a relevant statistic (difference of means), and computed its distribution under a "null" distribution, and compared the statistic provided by the data to the null model.
The Sampling Distribution
In this section, we will learn:
What model fitting is all about.
The difference between the "underlying" parameter, from the population, and the "sample" (or "measured") parameter.
What is model fitting all about? It's basically about finding the parameter set that best describes your data.
Let's start by taking a random sample of data from a Normal(10, 2) distribution.
|
sample = norm.rvs(10, 0.5, size=6) # we will draw 6 instances from the normal distribution.
sns.kdeplot(sample, color='blue')
population = norm.rvs(10, 0.5, size=10000)
sns.kdeplot(sample, color='blue', label='sample')
sns.kdeplot(population, color='red', label='population')
plt.legend()
|
Inferential Statistics.ipynb
|
ericmjl/be-stats-iap2016
|
mit
|
Create a new distribution called fitted, and tweak its parameters so that it fits the sample distribution.
Discussion
What are your parameter values?
What's happening here? Isn't the sample drawn from the same distribution as the population?
How could the sample parameters and population parameters be different?
The key point here is that the samples are random samples of the population. The computed mean from the sample may not necessarily match with the actual population mean.
Central Limit Theorem
The central limit theorem is central to statistics.
Quoting from Wikipedia:
In probability theory, the central limit theorem (CLT) states that, given certain conditions, the arithmetic mean of a sufficiently large number of iterates of independent random variables, each with a well-defined expected value and well-defined variance, will be approximately normally distributed, regardless of the underlying distribution.
We're going to experimentally look at what this statement means.
A crazy dice
Let's say that we have a crazy dice with an underlying distribution that we'd never expect to encounter.
|
xs = range(1,7) # numbers 1 through 6
ps = [0.4, 0.1, 0, 0.2, 0.3, 0]
crazy_dice = rv_discrete(name='crazy_dice', values=[xs, ps])
|
Inferential Statistics.ipynb
|
ericmjl/be-stats-iap2016
|
mit
|
Instructor demo: Let's visualize this distribution.
|
crazy_dice.pmf(xs)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(xs, crazy_dice.pmf(xs), 'ro', ms=12)
ax.vlines(xs, [0]*len(xs), crazy_dice.pmf(xs), color='red', lw=4)
|
Inferential Statistics.ipynb
|
ericmjl/be-stats-iap2016
|
mit
|
With this dice, we are essentially saying that we expect the dice to throw 1s (40% of the time), 5s (30% of the time), 4s (20% of the time), and 2s (10% of the time), with no expectation of getting 3s and 6s.
Now, let's roll the dice 4 times. What's the mean?
|
# Class activity
sample1 = crazy_dice.rvs(size=50)
sns.kdeplot(sample1)
np.mean(sample1)
|
Inferential Statistics.ipynb
|
ericmjl/be-stats-iap2016
|
mit
|
Roll the dice 4 times again. What's the mean?
|
# Class activity
sample2 = crazy_dice.rvs(size=4)
np.mean(sample2)
|
Inferential Statistics.ipynb
|
ericmjl/be-stats-iap2016
|
mit
|
Roll the dice 4 times, but repeat 1000 times now. What's the distribution of the means?
|
# Class activity
means = []
for i in range(1000):
mean = np.mean(crazy_dice.rvs(size=4))
means.append(mean)
# plt.hist(np.array(means), color='green')
sns.kdeplot(np.array(means), color='blue') # plot the density plot
sns.kdeplot(norm.rvs(2.9,0.6,size=100000), color='red') # plot an approximation of the actual distribution
|
Inferential Statistics.ipynb
|
ericmjl/be-stats-iap2016
|
mit
|
<h4>Demo of scikit - Underfit, Normal, Overfit example</h4>
Purpose: Demonstrate how higher order polynomials can fit complex non-linear shape
This demo contains AWS ML equivalent example of underfitting vs overfitting example described here:<br>
http://scikit-learn.org/stable/auto_examples/model_selection/plot_underfitting_overfitting.html
|
# Function to generate target value for a given x.
true_func = lambda X: np.cos(1.5 * np.pi * X)
np.random.seed(0)
# Training Set: No. of random samples used for training the model
n_samples = 30
x = np.sort(np.random.rand(n_samples))
y = true_func(x) + np.random.randn(n_samples) * 0.1
# Test Set: 100 samples for which we want the model to predict value
n_test = 100
x_test = np.linspace(0, 1, n_test)
y_test_actual = true_func(x_test) + np.random.randn(n_test) * 0.1
x[:5]
x[:5],y[:5]
# Function to add more features from existing features
# in this case degree is the desired order of polynomials
# Example degree 3 with 1 feature x would output: x,x^2,x^3
# Similary, if there are multiple features x1,x2: x1,x2,x1*x2,x1^2,x1^2*x2,x1^3....and so forth
def generate_higher_order(degrees, x):
# Generate higher order features from a given set of features.
poly = PolynomialFeatures(degree = degrees,
include_bias = False)
x_new = poly.fit_transform(x)
df = pd.DataFrame(x_new)
df.columns = df.columns.map(lambda n: 'x' + str(n))
return df
data_path = r'..\Data\RegressionExamples\under_over_fit_30samples'
# degrees for feature generation
degrees = [1, 4, 15]
# Generate training set for each of the degree
for d in degrees:
df = generate_higher_order(d, x.reshape((n_samples, 1)))
df['y'] = y
df.to_csv(os.path.join(data_path,'fit_degree_{0}_example_train{1}.csv'.format(d,n_samples)),
index = True,
index_label = 'Row')
# Generate Evaluation set. Contains all the features and target.
# Generate Test set. Contains only the features. AWSML would predict the target
for d in degrees:
df = generate_higher_order(d, x_test.reshape((n_test, 1)))
df.to_csv(os.path.join(data_path,'fit_degree_{0}_example_test{1}.csv'.format(d, n_samples)),
index = True,
index_label = 'Row')
df['y'] = y_test_actual
df.to_csv(os.path.join(data_path,'fit_degree_{0}_example_eval{1}.csv'.format(d, n_samples)),
index = True,
index_label = 'Row')
# Pull Predictions
df_samples = pd.read_csv(os.path.join(data_path, 'fit_degree_1_example_train30.csv'),
index_col = 'Row')
df_actual = pd.read_csv(os.path.join(data_path, 'fit_degree_1_example_eval30.csv'),
index_col = 'Row')
df_d1_predicted = pd.read_csv(
os.path.join(data_path,'output_deg_1',
'bp-aYBztCIPIdb-fit_degree_1_example_test30.csv.gz'))
df_d1_predicted.columns = ["Row","y_predicted"]
fig = plt.figure(figsize = (12, 8))
plt.scatter(x = df_samples['x0'],
y = df_samples['y'],
color = 'b',
label='samples')
plt.scatter(x = df_actual['x0'],
y = df_actual['y'],
color = 'r',
label = 'true function')
plt.scatter(x = df_actual['x0'],
y = df_d1_predicted['y_predicted'],
color = 'g',
label = 'predicted with degree 1')
plt.title('Model with degree 1 feature - Underfit')
plt.grid(True)
plt.legend()
|
17-09-27-AWS Machine Learning A Complete Guide With Python/05 - Improving the model/03 - ml_underfit_overfit_normal_30samples.ipynb
|
arcyfelix/Courses
|
apache-2.0
|
Polynomial with degree 1 is a straight line - Underfitting<br>
Training RMSE:0.5063, Evaluation RMSE:0.4308, Baseline RMSE:0.689
|
fig = plt.figure(figsize = (12, 8))
plt.boxplot([df_actual['y'],
df_d1_predicted['y_predicted']],
labels=['actual','predicted with deg1'])
plt.title('Box Plot - Actual, Predicted')
plt.ylabel('Target Attribute')
plt.grid(True)
|
17-09-27-AWS Machine Learning A Complete Guide With Python/05 - Improving the model/03 - ml_underfit_overfit_normal_30samples.ipynb
|
arcyfelix/Courses
|
apache-2.0
|
<h4>Model with degree 4 features</h4>
|
df_d4_predicted = pd.read_csv(
os.path.join(data_path,'output_deg_4',
'bp-W4oBOhwClbH-fit_degree_4_example_test30.csv.gz'))
df_d4_predicted.columns = ["Row","y_predicted"]
fig = plt.figure(figsize = (12, 8))
plt.scatter(x = df_samples['x0'],
y = df_samples['y'],
color = 'b',
label = 'samples')
plt.scatter(x = df_actual['x0'],
y = df_actual['y'],
color = 'r',
label = 'true function')
plt.scatter(x = df_actual['x0'],
y = df_d4_predicted['y_predicted'],
color = 'g',
label = 'predicted with degree 4')
plt.title('Model with degree 4 features - normal fit')
plt.grid(True)
plt.legend()
|
17-09-27-AWS Machine Learning A Complete Guide With Python/05 - Improving the model/03 - ml_underfit_overfit_normal_30samples.ipynb
|
arcyfelix/Courses
|
apache-2.0
|
Good Fit with degree 4 polynomial<br>
Training RMSE:0.2563, Evaluation RMSE:0.1493, Baseline RMSE:0.689
|
fig = plt.figure(figsize = (12, 8))
plt.boxplot([df_actual['y'],
df_d1_predicted['y_predicted'],
df_d4_predicted['y_predicted']],
labels=['actual','predicted with deg1','predicted with deg4'])
plt.title('Box Plot - Actual, Predicted')
plt.ylabel('Target Attribute')
plt.grid(True)
|
17-09-27-AWS Machine Learning A Complete Guide With Python/05 - Improving the model/03 - ml_underfit_overfit_normal_30samples.ipynb
|
arcyfelix/Courses
|
apache-2.0
|
<h4>Model with degree 15 features</h4>
|
df_d15_predicted = pd.read_csv(
os.path.join(data_path,'output_deg_15',
'bp-rBWxcnPN3zu-fit_degree_15_example_test30.csv.gz'))
df_d15_predicted.columns = ["Row","y_predicted"]
fig = plt.figure(figsize = (12, 8))
plt.scatter(x = df_samples['x0'],
y = df_samples['y'],
color = 'b',
label = 'samples')
plt.scatter(x = df_actual['x0'],
y = df_actual['y'],
color = 'r',
label = 'true function')
plt.scatter(x = df_actual['x0'],
y = df_d15_predicted['y_predicted'],
color = 'g',
label = 'predicted with degree 15')
plt.grid(True)
plt.legend()
|
17-09-27-AWS Machine Learning A Complete Guide With Python/05 - Improving the model/03 - ml_underfit_overfit_normal_30samples.ipynb
|
arcyfelix/Courses
|
apache-2.0
|
Not quite over fitting as shown in sci-kit example; fit is actually pretty good here.<br>
Training RMSE:0.2984, Evaluation RMSE:0.1222, Baseline RMSE:0.689
|
fig = plt.figure(figsize = (12, 8))
plt.boxplot([df_actual['y'],
df_d1_predicted['y_predicted'],
df_d4_predicted['y_predicted'],
df_d15_predicted['y_predicted']],
labels = ['actual','predicted deg1','predicted deg4','predicted deg15'])
plt.title('Box Plot - Actual, Predicted')
plt.ylabel('Target Attribute')
plt.grid(True)
|
17-09-27-AWS Machine Learning A Complete Guide With Python/05 - Improving the model/03 - ml_underfit_overfit_normal_30samples.ipynb
|
arcyfelix/Courses
|
apache-2.0
|
Spectra creation
The Spectra class is echidna's most fundamental class. It holds the core data structure and provides much of the core functionality required. Coincidentally, this guide will be centred around this class, how to create it and then some manipulations of the class.
We'll begin with how to create an instance of the Spectra class. It is part of the echidna.core.spectra module, so we will import this and make a Spectra instance.
|
import echidna.core.spectra as spectra
|
getting_started.ipynb
|
mjmottram/echidna
|
mit
|
Now we need a config file to create the spectrum from. There is an example config file in echidna/config. If we look at the contents of this yaml file, we see it tells the Spectra class to create a data structure to hold two parameters:
energy_mc, with lower limit 0, upper limit 10 and 1000 bins
radial_mc, with lower limit 0, upper limit 15000 and 1500 bins
This config should be fine for us. We can load it using the load_from_file method of the SpectraConfig class:
|
import echidna
config = spectra.SpectraConfig.load_from_file(echidna.__echidna_base__ +
"/echidna/config/example.yml")
print config.get_pars()
|
getting_started.ipynb
|
mjmottram/echidna
|
mit
|
And there you have it, we've created a Spectra object.
Filling the spectrum
Ok, so we now have a spectrum, let's fill it with some events. We'll generate random energies from a Gaussian distribution and random positions from a Uniform distribution. Much of echidna is built using the numpy and SciPy packages and we will use them here to generate the random numbers. We'll also generate a third random number to simulate some form rudimentary detector efficiency.
|
# Import numpy
import numpy
# Generate random energies from a Gaussin with mean (mu) and sigma (sigma)
mu = 2.5 # MeV
sigma = 0.15 # MeV
# Generate random radial position from a Uniform distribution
outer_radius = 5997 # Radius of SNO+ AV
# Detector efficiency
efficiency = 0.9 # 90%
for event in range(num_decays):
energy = numpy.random.normal(mu, sigma)
radius = numpy.random.uniform(high=outer_radius)
event_detected = (numpy.random.uniform() < efficiency)
if event_detected: # Fill spectrum with values
spectrum.fill(energy_mc=energy, radial_mc=radius)
|
getting_started.ipynb
|
mjmottram/echidna
|
mit
|
Note: you probably won't see any entries in the above. For large arrays, numpy only prints the first three and last three entries. Since our energy range is in the middle, all our events are in the ... part at the moment. But we will see entries printed out later when we apply some cuts.
Plotting
Another useful way to inspect the Spectra created is to plot it. Support is available within echidna to plot using either ROOT or matplotlib and there are some useful plotting functions available in the plot an plot_root modules.
|
import echidna.output.plot as plot
import echidna.output.plot_root as plot_root
|
getting_started.ipynb
|
mjmottram/echidna
|
mit
|
To plot the projection of the spectrum on the energy_mc axis:
|
fig1 = plot.plot_projection(spectrum, "energy_mc",
fig_num=1, show_plot=False)
plt.show()
|
getting_started.ipynb
|
mjmottram/echidna
|
mit
|
We can also project onto two dimensions and plot a surface:
|
fig_3 = plot.plot_surface(spectrum, "energy_mc", "radial_mc",
fig_num=3, show_plot=False)
plt.show()
|
getting_started.ipynb
|
mjmottram/echidna
|
mit
|
By default the "weighted smear" method considers all bins within a $\pm 5\sigma$ range. For the sake of speed, we will reduce this to 3 here. Also set the energy resolution - 0.05 for 5%.
|
smearer.set_num_sigma(3)
smearer.set_resolution(0.05)
|
getting_started.ipynb
|
mjmottram/echidna
|
mit
|
this should hopefully only create a couple of seconds.
The following code shows how to make a simple script, using matplotlib, to overlay the original and smeared spectra.
|
import numpy as np
import matplotlib.pyplot as plt
def overlay_spectra(original, smeared, dimension="energy_mc", fig_num=1):
""" Overlay original and smeared spectra.
Args:
original (echidna.core.spectra.Spectra): Original spectrum.
smeared (echidna.core.spectra.Spectra): Smeared spectrum.
dimension (string, optional): Dimension to project onto.
Default is "energy_mc".
fignum (int, optional): Figure number, if producing multiple
figures. Default is 1.
Returns:
matplotlib.figure.Figure: Figure showing overlaid spectra.
"""
fig = plt.figure(num=fig_num)
ax = fig.add_subplot(1, 1, 1)
par = original.get_config().get_par(dimension)
width = par.get_width()
# Define array of bin boundaries (1 more than number of bins)
bins = np.linspace(par._low, par._high, par._bins+1)
# Define array of bin centres
x = bins[:-1] + 0.5*width
# Overlay two spectra using projection as weight
ax.hist(x, bins, weights=original.project(dimension),
histtype="stepfilled", color="RoyalBlue",
alpha=0.5, label=original._name)
ax.hist(x, bins, weights=smeared.project(dimension),
histtype="stepfilled", color="Red",
alpha=0.5, label=smeared._name)
# Add label/style
plt.legend(loc="upper right")
plt.ylim(ymin=0.0)
plt.xlabel(dimension + " [" + par.get_unit() + "]")
plt.ylabel("Events per " + str(width) + " " + par.get_unit() + " bin")
return fig
fig_4 = overlay_spectra(spectrum, smeared_spectrum, fig_num=4)
plt.show()
|
getting_started.ipynb
|
mjmottram/echidna
|
mit
|
Other spectra manipulations
We now have a nice smeared version of our original spectrum. To prepare the spectrum for a final analysis there are a few final manipulations we may wish to do.
Region of Interest (ROI)
There is a special version of the shrink method called shrink_to_roi that can be used for ROI cuts. It saves some useful information about the ROI in the Spectra class instance, including the efficiency i.e. integral of spectrum after cut divided by integral of spectrum before cut.
|
roi = (mu - 0.5*sigma, mu + 1.45*sigma) # To get nice shape for rebinning
smeared_spectrum.shrink_to_roi(roi[0], roi[1], "energy_mc")
print smeared_spectrum.get_roi("energy_mc")
|
getting_started.ipynb
|
mjmottram/echidna
|
mit
|
We can now verify that Q is an orthognal matrix. We first check that $\boldsymbol{Q}^{-1} = \boldsymbol{Q}^{T}$ by computing $\boldsymbol{Q}\boldsymbol{Q}^{-1}$
|
print(Q.dot(Q.T))
|
Lecture08.ipynb
|
garth-wells/IA-maths-Jupyter
|
mit
|
We can see that $\boldsymbol{Q}\boldsymbol{Q}^{-1} = \boldsymbol{I}$ (within numerical precision). We can check that the colums of $\boldsymbol{Q}$ are orthonormal
|
import itertools
# Build pairs (0,0), (0,1), . . . (0, n-1), (1, 2), (1, 3), . . .
pairs = itertools.combinations_with_replacement(range(len(Q)), 2)
# Compute dot product of column vectors q_{i} \cdot q_{j}
for p in pairs:
col0, col1 = p[0], p[1]
print ("Dot product of column vectors {}, {}: {}".format(col0, col1, Q[:, col0].dot(Q[:, col1])))
|
Lecture08.ipynb
|
garth-wells/IA-maths-Jupyter
|
mit
|
The columns of $\boldsymbol{Q}$ are orthonormal, and $\boldsymbol{Q}^{T}$ is also a rotation matrix and has orthonormal columns. Therefore, the rows of $\boldsymbol{Q}$ are also orthonormal.
|
# Compute dot product of row vectors q_{i} \cdot q_{j}
pairs = itertools.combinations_with_replacement(range(len(Q)), 2)
for p in pairs:
row0, row1 = p[0], p[1]
print ("Dot product of row vectors {}, {}: {}".format(row0, row1, Q[row0, :].dot(Q[row1, :])))
|
Lecture08.ipynb
|
garth-wells/IA-maths-Jupyter
|
mit
|
Finally, we check the determinant of $\boldsymbol{Q}$:
|
print("Determinant of Q: {}".format(np.linalg.det(Q)))
|
Lecture08.ipynb
|
garth-wells/IA-maths-Jupyter
|
mit
|
Goal
We want to generate observed arrival times, in a format similar to GTFS. The GTFS schedule will be useful in this process, data was downloaded from Transit Feeds, the schema of the data is in ttc_gtfs_create.sql and it is processed to a more useful format in PostgreSQL with ttc_gtfs_process.sql.
From gtfs, we can get a sense of the target data count, how many stops are scheduled on the three subway lines for which we have data?
|
sql = '''SELECT COUNT(1)
FROM gtfs.stop_times
INNER JOIN gtfs.trips USING (trip_id)
INNER JOIN gtfs.routes USING (route_id)
INNER JOIN gtfs.calendar USING (service_id)
WHERE monday AND route_type = 1 AND route_short_name != '3'
'''
with con.cursor() as cur:
cur.execute(sql)
print(cur.fetchone()[0])
|
doc/filtering_observed_arrivals.ipynb
|
CivicTechTO/ttc_subway_times
|
gpl-3.0
|
This is a ball park figure we are aiming for in our filtering.
Creating a materialized view of the raw poll data for a given day Wednesday, June 14th 2017
|
sql = '''DROP MATERIALIZED VIEW IF EXISTS test_day CASCADE;
CREATE MATERIALIZED VIEW test_day AS
SELECT requestid, stationid, lineid, create_date, request_date, station_char, subwayline, system_message_type,
timint, traindirection, trainid, train_message
FROM requests_serverless
INNER JOIN ntas_data_serverless USING (requestid)
WHERE request_date >= '2019-07-17'::DATE + interval '5 hours'
AND request_date < '2019-07-17'::DATE + interval '29 hours'
'''
with con:
with con.cursor() as cur:
cur.execute(sql)
with con.cursor() as cur:
cur.execute('SELECT COUNT(1) FROM test_day')
print(cur.fetchone()[0])
|
doc/filtering_observed_arrivals.ipynb
|
CivicTechTO/ttc_subway_times
|
gpl-3.0
|
Cool. Definitely some work to do.
Trying out a very basic filter, which has a Known Issue
|
sql = '''SELECT COUNT(DISTINCT (requestid, lineid, trainid, traindirection, stationid))
FROM test_day
WHERE train_message = 'AtStation' OR timint < 1'''
with con.cursor() as cur:
cur.execute(sql)
print(cur.fetchone()[0])
|
doc/filtering_observed_arrivals.ipynb
|
CivicTechTO/ttc_subway_times
|
gpl-3.0
|
It's a start.
If every line takes more than an hour to do a round-trip, we might be able to look for a distinct train-line-direction-station combination for each hour.
|
sql = '''WITH trips AS (SELECT route_short_name, (SELECT trip_id FROM gtfs.trips WHERE trips.route_id = routes.route_id LIMIT 1)
FROM gtfs.routes
WHERE route_type = 1 AND route_short_name != '3' )
SELECT route_short_name, MIN(arrival_time) AS "Start Time", MIN(stop_sequence) ||'-'||MAX(stop_sequence) AS "Stops", MAX(arrival_time) - MIN(arrival_time) AS "Half-trip time"
FROM gtfs.stop_times
INNER JOIN trips USING(trip_id)
GROUP BY route_short_name, trip_id
ORDER BY route_short_name, trip_id
'''
trips = pandasql.read_sql(sql, con)
trips
|
doc/filtering_observed_arrivals.ipynb
|
CivicTechTO/ttc_subway_times
|
gpl-3.0
|
So any given train on line 1 or 2 shouldn't pass the same station going the same direction in an hour. So we could add the hour in a DISTINCT query.
What's up with Line 4? It's short, but not two stations short... According to TransitFeeds, a GTFS host and exploration platform, Line 4 trains start the day at non-terminus stations. Line 4 actually makes 5 stops, and it takes 8 minutes to go from one terminus to another, with a two and a half minute layover at each terminus.
Potential issues:
- headways varying throughout the day
- delays can push a unique train stop arrival at a station into multiple time boxes.
Better solution:
- look at each train chronologically through the day and
* identify when there are multiple observations in a same trip at a same station
* identify when the train changes direction
|
sql = ''' WITH unique_trains AS
(SELECT lineid::TEXT, COUNT(DISTINCT trainid) AS "Number of trains in a day"
FROM test_day
GROUP BY lineid)
, unique_trips AS(SELECT route_short_name AS lineid, COUNT(DISTINCT trip_id) AS "Number of scheduled trips"
FROM gtfs.routes -- ON lineid::TEXT = route_short_name
INNER JOIN gtfs.trips USING (route_id)
INNER JOIN gtfs.calendar USING (service_id)
WHERE monday AND route_type = 1 AND route_short_name != '3'
GROUP BY route_short_name)
SELECT *
FROM unique_trains
INNER JOIN unique_trips USING (lineid)
ORDER BY lineid'''
pandasql.read_sql(sql, con)
|
doc/filtering_observed_arrivals.ipynb
|
CivicTechTO/ttc_subway_times
|
gpl-3.0
|
According to wikipedia the number of trains for each line is:
|line | number of trains|
|-----|----------------:|
|1 | 76 |
|2 | 62 |
| 4 | 6 |
So the
|
sql = ''' SELECT trainid, lineid, traindirection, stationid, station_char, create_date, request_date, timint, train_message
FROM test_day
INNER JOIN (SELECT trainid FROM test_day WHERE lineid = 1 AND create_date::TIME > '07:00'::TIME LIMIT 1) one_train USING (trainid)
WHERE (timint < 1 OR train_message != 'Arriving') AND lineid = 1
ORDER BY create_date
'''
one_train = pandasql.read_sql(sql, con)
one_train
|
doc/filtering_observed_arrivals.ipynb
|
CivicTechTO/ttc_subway_times
|
gpl-3.0
|
Using the filtered schema instead
|
sql = '''CREATE MATERIALIZED VIEW filtered.test_day AS
SELECT requestid, stationid, lineid, create_date, request_date, station_char, subwayline, system_message_type,
timint, traindirection, trainid, train_message
FROM filtered.requests
INNER JOIN filtered.ntas_data USING (requestid)
WHERE request_date >= '2017-06-14'::DATE + interval '5 hours'
AND request_date < '2017-06-14'::DATE + interval '29 hours'
'''
with con:
with con.cursor() as cur:
cur.execute(sql)
sql = ''' SELECT trainid, lineid, traindirection, stationid, station_char, create_date, request_date, timint, train_message
FROM filtered.test_day
INNER JOIN (SELECT trainid FROM filtered.test_day WHERE lineid = 1 AND create_date::TIME > '07:00'::TIME LIMIT 1) one_train USING (trainid)
WHERE (timint < 1 OR train_message != 'Arriving') AND lineid = 1
ORDER BY create_date
'''
one_train = pandasql.read_sql(sql, con)
one_train
|
doc/filtering_observed_arrivals.ipynb
|
CivicTechTO/ttc_subway_times
|
gpl-3.0
|
Ah. We can see train 136 skipped station 14. Fortunately, we have unfiltered data from the same day
|
sql = ''' SELECT trainid, lineid, traindirection, stationid, station_char, create_date, create_date + timint * interval '1 minute' AS expected_arrival, timint, train_message
FROM test_day
WHERE trainid = 136 AND (timint < 1 OR train_message != 'Arriving') AND lineid = 1
ORDER BY create_date + timint * interval '1 minute'
'''
train_136 = pandasql.read_sql(sql, con)
train_136
train_136.iloc[[14]]
|
doc/filtering_observed_arrivals.ipynb
|
CivicTechTO/ttc_subway_times
|
gpl-3.0
|
So we have an expected arrival time at Osgoode station from the unfiltered dataset, meaning that it can have some use after all! However, we can see at the end that the train is super delayed
|
train_136[train_136['create_date'] > datetime.datetime(2017, 6, 15, 1,30)]
|
doc/filtering_observed_arrivals.ipynb
|
CivicTechTO/ttc_subway_times
|
gpl-3.0
|
So this doesn't seem like a particularly good example, since the train is just ultimately stuck at Sheppard West station until the end of the (scraping) day. The solution in this case would probably be to just filter out any of these observations where train_message == 'Delayed' and timint > 2. Let's try to see if we can find anything else.
|
train_136[train_136['train_message'] == 'Delayed']
|
doc/filtering_observed_arrivals.ipynb
|
CivicTechTO/ttc_subway_times
|
gpl-3.0
|
Lucky for us, train 136 is delayed a second time in our day, around 12:55.
|
train_136[(train_136['create_date'] > datetime.datetime(2017, 6, 14, 12, 50)) & (train_136['create_date'] < datetime.datetime(2017, 6, 14, 13, 30))]
|
doc/filtering_observed_arrivals.ipynb
|
CivicTechTO/ttc_subway_times
|
gpl-3.0
|
It seems like we could actually be fine if we just filtered out observations with Delayed and timint <1. The delayed records could be useful to store in a separate table for their own analysis, but they don't appear to really fill in the gaps here
|
train_136[(train_136['create_date'] > datetime.datetime(2017, 6, 14, 12, 50))
& (train_136['create_date'] < datetime.datetime(2017, 6, 14, 13, 30))
& ((train_136['train_message'] != 'Delayed') | (train_136['timint'] < 1.0 ))]
|
doc/filtering_observed_arrivals.ipynb
|
CivicTechTO/ttc_subway_times
|
gpl-3.0
|
Coincidentally, this period of time also features a short-turn, at 13:15, and we want to identify distinct trips (where trains turn around, either at the end of the usual run, or early). This should be relatively easy to implement with the traindirection column
|
split_trips = '''CREATE SEQUENCE IF NOT EXISTS trip_ids;
CREATE MATERIALIZED VIEW test_day_w_trips AS
SELECT trainid, lineid, traindirection, stationid, station_char, create_date, create_date + timint * interval '1 minute' AS expected_arrival, timint, train_message,
CASE traindirection WHEN lag(traindirection) OVER w THEN currval('trip_ids') ELSE nextval('trip_ids') END AS trip_id
FROM test_day
WHERE (timint < 1 OR train_message = 'AtStation')
WINDOW w AS (PARTITION BY lineid, trainid ORDER BY create_date + timint * interval '1 minute')
'''
with con:
with con.cursor() as cur:
cur.execute(split_trips)
|
doc/filtering_observed_arrivals.ipynb
|
CivicTechTO/ttc_subway_times
|
gpl-3.0
|
A final step is to group together multiple observations at a same station, during a same trip, to get an approximation of arrival and "departure" time.
|
final_step = ''' DROP MATERIALIZED VIEW IF EXISTS test_day_final;
CREATE MATERIALIZED VIEW test_day_final AS
SELECT trainid, lineid, traindirection, stationid, station_char, trip_id,
MIN(expected_arrival) AS estimated_arrival, MAX(expected_arrival) AS estimated_departure,
CASE (ARRAY_AGG(train_message ORDER BY expected_arrival))[1] WHEN 'AtStation' THEN 1 ELSE 0 END AS exact_arr,
CASE (ARRAY_AGG(train_message ORDER BY expected_arrival DESC))[1] WHEN 'AtStation' THEN 1 ELSE 0 END AS exact_dep
FROM test_day_w_trips
GROUP BY trainid, lineid, traindirection, stationid, station_char, trip_id
'''
with con:
with con.cursor() as cur:
cur.execute(final_step)
|
doc/filtering_observed_arrivals.ipynb
|
CivicTechTO/ttc_subway_times
|
gpl-3.0
|
Woo! Now to test how well this process did
|
cnt = '''SELECT COUNT(*) FROM test_day_final'''
with con.cursor() as cur:
cur.execute(cnt)
print('The number of station stops made is', cur.fetchone()[0])
|
doc/filtering_observed_arrivals.ipynb
|
CivicTechTO/ttc_subway_times
|
gpl-3.0
|
Huh. 5k higher than the scheduled number of station stops
|
sql = ''' WITH observed_trips AS
(SELECT lineid::TEXT, COUNT(DISTINCT trip_id) AS "Number of observed trips"
FROM test_day_final
GROUP BY lineid)
, unique_trips AS(SELECT route_short_name AS lineid, COUNT(DISTINCT trip_id) AS "Number of scheduled trips"
FROM gtfs.routes -- ON lineid::TEXT = route_short_name
INNER JOIN gtfs.trips USING (route_id)
INNER JOIN gtfs.calendar USING (service_id)
WHERE monday AND route_type = 1 AND route_short_name != '3'
GROUP BY route_short_name)
SELECT *
FROM observed_trips
INNER JOIN unique_trips USING (lineid)
ORDER BY lineid'''
pandasql.read_sql(sql, con)
|
doc/filtering_observed_arrivals.ipynb
|
CivicTechTO/ttc_subway_times
|
gpl-3.0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.