code stringlengths 38 801k | repo_path stringlengths 6 263 |
|---|---|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
SAMPLE_TEXT = """
[[[0,[5,8]],[[1,7],[9,6]]],[[4,[1,2]],[[1,4],2]]]
[[[5,[2,8]],4],[5,[[9,9],0]]]
[6,[[[6,2],[5,6]],[[7,6],[4,7]]]]
[[[6,[0,7]],[0,9]],[4,[9,[9,0]]]]
[[[7,[6,4]],[3,[1,3]]],[[[5,5],1],9]]
[[6,[[7,3],[3,2]]],[[[3,8],[5,7]],4]]
[[[[5,4],[7,7]],8],[[8,3],8]]
[[9,3],[[9,9],[6,[4,9]]]]
[[2,[[7,7],7]],[[5,8],[[9,3],[0,2]]]]
[[[[5,2],5],[8,[3,7]]],[[5,[7,5]],[4,4]]]
"""
# + pycharm={"name": "#%%\n"}
import json
# + pycharm={"name": "#%%\n"}
def tokenize_line(line):
return json.loads(line)
def parse_text(raw_text):
return [tokenize_line(l) for l in raw_text.split("\n") if l]
def read_input():
with open("input.txt", "rt") as f:
return f.read()
# + pycharm={"name": "#%%\n"}
from dataclasses import dataclass
from typing import Union, List, Optional
from treelib import Node, Tree
# + pycharm={"name": "#%%\n"}
class PairNode:
def __init__(self):
self.left: Optional["PairNode"] = None
self.parent: Optional["PairNode"] = None
self.right: Optional["PairNode"] = None
self.value: Optional["int"] = None
def is_value(self):
return self.value is not None
def is_pair(self):
return self.left is not None
def could_split(self):
return self.is_value() and self.value > 9
def do_split(self):
left_value = self.value // 2
right_value = self.value - left_value
self.value = None
self.left = PairNode()
self.left.value = left_value
self.left.parent = self
self.right = PairNode()
self.right.value = right_value
self.right.parent = self
def depth(self) -> int:
depth = 0
parent = self.parent
while parent:
depth += 1
parent = parent.parent
return depth
def could_explode(self):
return self.is_pair() and self.depth() >= 4
def do_explode(self):
value_left = self.find_value_left()
value_right = self.find_value_right()
if value_left:
value_left.value += self.left.value
if value_right:
value_right.value += self.right.value
self.left.parent = None
self.right.parent = None
self.left = None
self.right = None
self.value = 0
def find_leftmost_value(self, node: "PairNode"):
if node.is_value():
return node
else:
return self.find_leftmost_value(node.left)
def find_rightmost_value(self, node: "PairNode"):
if node.is_value():
return node
else:
return self.find_rightmost_value(node.right)
def find_value_right(self):
node_from = self
parent = self.parent
while parent:
# We need to find a node that expands to the right
if parent.left == node_from:
return self.find_leftmost_value(parent.right)
node_from = parent
parent = parent.parent
return None
def find_value_left(self):
node_from = self
parent = self.parent
while parent:
# We need to find a node that expands to the left
if parent.right == node_from:
return self.find_rightmost_value(parent.left)
node_from = parent
parent = parent.parent
return None
def pprint(self, tree: Tree):
if self.parent:
parent = id(self.parent)
else:
parent = None
if self.is_value():
tree.create_node(str(self.value), id(self), parent=parent)
else:
tree.create_node(f"[ depth={self.depth()}", id(self), parent=parent)
self.left.pprint(tree)
self.right.pprint(tree)
def __str__(self):
if self.is_value():
return str(self.value)
else:
return f"[{self.left},{self.right}]"
def __repr__(self):
if self.is_value():
return str(self.value)
else:
return f"Pair({self.left}, {self.right})"
def magnitude(self):
if self.is_value():
return self.value
else:
return 3 * self.left.magnitude() + 2 * self.right.magnitude()
@dataclass
class PairTree:
root: PairNode
def pprint(self):
tree = Tree()
self.root.pprint(tree)
print(tree)
def reduce(self):
# print(self.root)
while True:
explosions = self.find_explosions(self.root)
if explosions:
explosions[0].do_explode()
# print(self.root)
continue
splits = self.find_splits(self.root)
if splits:
splits[0].do_split()
# print(self.root)
continue
break
def find_explosions(self, node: PairNode) -> List[PairNode]:
if not isinstance(node, PairNode):
return []
result = []
result.extend(self.find_explosions(node.left))
if node.could_explode():
result.append(node)
result.extend(self.find_explosions(node.right))
return result
def find_splits(self, node: PairNode) -> List[PairNode]:
if not isinstance(node, PairNode):
return []
result = []
result.extend(self.find_splits(node.left))
if node.could_split():
result.append(node)
result.extend(self.find_splits(node.right))
return result
def add(self, other: "PairTree"):
new_root = PairNode()
new_root.left = self.root
new_root.left.parent = new_root
new_root.right = other.root
new_root.right.parent = new_root
self.root = new_root
def magnitude(self):
return self.root.magnitude()
def is_list(arg):
return isinstance(arg, list)
def get_pairs(pairs, parent):
left_value, right_value = pairs
left = PairNode()
parent.left = left
left.parent = parent
if isinstance(left_value, int):
left.value = left_value
else:
get_pairs(left_value, left)
right = PairNode()
parent.right = right
right.parent = parent
if isinstance(right_value, int):
right.value = right_value
else:
get_pairs(right_value, right)
def build_tree(line):
root = PairNode()
get_pairs(line, root)
return PairTree(root)
# + pycharm={"name": "#%%\n"}
# Explosion tests
def verify_reduction(input, expected):
tree = build_tree(parse_text(input)[0])
tree.reduce()
assert str(tree.root) == expected
verify_reduction("[[[[[9,8],1],2],3],4]", "[[[[0,9],2],3],4]")
verify_reduction("[7,[6,[5,[4,[3,2]]]]]", "[7,[6,[5,[7,0]]]]")
verify_reduction("[[6,[5,[4,[3,2]]]],1]", "[[6,[5,[7,0]]],3]")
verify_reduction("[[3,[2,[1,[7,3]]]],[6,[5,[4,[3,2]]]]]", "[[3,[2,[8,0]]],[9,[5,[7,0]]]]")
verify_reduction("[[[[[4,3],4],4],[7,[[8,4],9]]],[1,1]]", "[[[[0,7],4],[[7,8],[6,0]]],[8,1]]")
# + pycharm={"name": "#%%\n"}
def verify_addition(*args):
expected = args[-1]
tree = build_tree(parse_text(args[0])[0])
for a in args[1:-1]:
other = build_tree(parse_text(a)[0])
# print(tree.root, "+", other.root)
tree.add(other)
tree.reduce()
assert str(tree.root) == expected
verify_addition("[[[[4,3],4],4],[7,[[8,4],9]]]", "[1,1]", "[[[[0,7],4],[[7,8],[6,0]]],[8,1]]")
# + pycharm={"name": "#%%\n"}
verify_addition("[1,1]", "[2,2]", "[3,3]", "[4,4]", "[[[[1,1],[2,2]],[3,3]],[4,4]]")
# + pycharm={"name": "#%%\n"}
verify_addition("[1,1]", "[2,2]", "[3,3]", "[4,4]", "[5,5]", "[[[[3,0],[5,3]],[4,4]],[5,5]]")
# + pycharm={"name": "#%%\n"}
verify_addition("[1,1]", "[2,2]", "[3,3]", "[4,4]", "[5,5]", "[6,6]", "[[[[5,0],[7,4]],[5,5]],[6,6]]")
# + pycharm={"name": "#%%\n"}
SAMPLE_ADDITION = """
[[[0,[4,5]],[0,0]],[[[4,5],[2,6]],[9,5]]]
[7,[[[3,7],[4,3]],[[6,3],[8,8]]]]
[[2,[[0,8],[3,4]]],[[[6,7],1],[7,[1,6]]]]
[[[[2,4],7],[6,[0,5]]],[[[6,8],[2,8]],[[2,1],[4,5]]]]
[7,[5,[[3,8],[1,4]]]]
[[2,[2,2]],[8,[8,1]]]
[2,9]
[1,[[[9,3],9],[[9,0],[0,7]]]]
[[[5,[7,4]],7],1]
[[[[4,2],2],6],[8,7]]
"""
lines = parse_text(SAMPLE_ADDITION)
tree = build_tree(lines[0])
for l in lines[1:]:
other = build_tree(l)
tree.add(other)
tree.reduce()
assert str(tree.root) == "[[[[8,7],[7,7]],[[8,6],[7,7]]],[[[0,7],[6,6]],[8,7]]]"
# + pycharm={"name": "#%%\n"}
def verify_magnitude(input, expected):
tree = build_tree(parse_text(input)[0])
assert tree.magnitude() == expected
verify_magnitude("[9,1]", 29)
verify_magnitude("[[1,2],[[3,4],5]]", 143)
verify_magnitude("[[[[0,7],4],[[7,8],[6,0]]],[8,1]]", 1384)
verify_magnitude("[[[[1,1],[2,2]],[3,3]],[4,4]]", 445)
verify_magnitude("[[[[3,0],[5,3]],[4,4]],[5,5]]", 791)
verify_magnitude("[[[[5,0],[7,4]],[5,5]],[6,6]]", 1137)
verify_magnitude("[[[[8,7],[7,7]],[[8,6],[7,7]]],[[[0,7],[6,6]],[8,7]]]", 3488)
# + pycharm={"name": "#%%\n"}
SAMPLE_ADDITION_2 = """
[[[0,[5,8]],[[1,7],[9,6]]],[[4,[1,2]],[[1,4],2]]]
[[[5,[2,8]],4],[5,[[9,9],0]]]
[6,[[[6,2],[5,6]],[[7,6],[4,7]]]]
[[[6,[0,7]],[0,9]],[4,[9,[9,0]]]]
[[[7,[6,4]],[3,[1,3]]],[[[5,5],1],9]]
[[6,[[7,3],[3,2]]],[[[3,8],[5,7]],4]]
[[[[5,4],[7,7]],8],[[8,3],8]]
[[9,3],[[9,9],[6,[4,9]]]]
[[2,[[7,7],7]],[[5,8],[[9,3],[0,2]]]]
[[[[5,2],5],[8,[3,7]]],[[5,[7,5]],[4,4]]]
"""
lines = parse_text(SAMPLE_ADDITION_2)
tree = build_tree(lines[0])
for l in lines[1:]:
other = build_tree(l)
tree.add(other)
tree.reduce()
assert str(tree.root) == "[[[[6,6],[7,6]],[[7,7],[7,0]]],[[[7,7],[7,7]],[[7,8],[9,9]]]]"
assert tree.magnitude() == 4140
# + pycharm={"name": "#%%\n"}
lines = parse_text(read_input())
tree = build_tree(lines[0])
for l in lines[1:]:
other = build_tree(l)
tree.add(other)
tree.reduce()
tree.magnitude()
# + pycharm={"name": "#%%\n"}
def largest_magnitude(lines):
def get_magnitude(line1, line2):
tree = build_tree(line1)
tree.add(build_tree(line2))
tree.reduce()
return tree.magnitude()
max_magnitude = 0
for line1 in lines:
for line2 in lines:
if line1 == line2:
continue
max_magnitude = max(max_magnitude, get_magnitude(line1, line2), get_magnitude(line2, line1))
return max_magnitude
# + pycharm={"name": "#%%\n"}
largest_magnitude(parse_text(SAMPLE_ADDITION_2))
# + pycharm={"name": "#%%\n"}
largest_magnitude(parse_text(read_input()))
# + pycharm={"name": "#%%\n"}
| projects/day18/day18.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Micro-Learning Sessions
# ## Python en Cápsulas
#
# El objetivo de esta mini-tutoría es hacer un breve repaso de Python, sus tipos de datos, estructuras de control de flujo y lectura y escritura de archivos. Al finalizar este breve tutorial podrás:
#
# - Manejar los tipos de datos nativos de python
# - Manejar algunos tipos de datos / clases provenientes de librerías
# - Crear programas simples orientados a calcular cantidades de interés.
# - Leer, escribir y procesar archivos de datos en los formatos estándares.
# +
# Here we go !
# -
# ### Tipos de datos básicos y sus operaciones
# Entre los tipos de datos básicos que python posee tenemos a los enteros, flotantes, strings o cadenas de caracteres y Booleanos. Procedemos a revisar cada uno y sus posibles relaciones.
# Enteros
a=2
type(a)
# Flotantes
b=2.1
type(b)
# Strings o cadenas de caracteres
c='hola'
type(c)
# Booleanos
d=True
type(d)
# ¿Que pasaría si sumo a + b?
suma1=a+b
print(suma1) # función de python para imprimir en pantalla.
# (Útil fuera de Jupyter)
type(suma1)
# Observar que todo entero puede representante como flotante, pero no al contrario, por tanto hay una jerarquía natural de tipos de datos.
# ¿y si multiplico a * c?
# ¿podemos multiplicar un string con un número?
print(a*c)
# +
# en efecto se puede, es decir, esta operación está bien definida.
# -
print(b*c)
# +
# y claramente esta no.
# -
print(a*False)
print(a*True)
print(False*True) # true y false se comportan como 1 y 0 cuando se consideran en la multiplicación.
# +
# ¿cuando son útiles estos tipos de datos?
# -
print(a==2)
print(b>a)
print(b<a)
# ### Tipado dinámico
# ¿En que otros lenguajes ha programado?
# +
a=2 # es suficiente para crear una variable, asignarle tipo y valor.
# ¿cómo sería el equivalente en los lenguajes de programación que conoce?
# +
a=3.2 # esto es suficiente para cambiar el tipo y reasignar valor.
# ¿cómo sería el equivalente en los lenguajes de programación que conoce?
# -
# # Listas (el caballo de batalla de Python)
# Para crear una lista vacía escribimos un par de corchetes cerrados [ ]:
L=[]
# Podemos defirla listando uno a uno sus valores
L1=[1,2,3,4,5]
# o bien creando una lista vacia agregando uno a uno sus valores,
# utilizando el método append
L2=[]
L2.append(1)
L2.append(2)
L2.append(3)
L2.append(4)
L2.append(5)
L1
L1==L2
# una lista puede contener cualquier tipo de datos
L3=[1,'hola',True, 3.12]
# inclusive puede contener listas o cualquier otra estructura de mayor complejidad
L3.append([1,2,3,4,5])
print(L3)
# +
# Indices
# -
# Podemos llamar cualquier elemento de una lista escribiendo el nombre de la variable y entre corchetes el índice del elemento que deseamos, como Python tiene indexado cero, para el primer elemento escribimos L[0].
print(L3[0])
print(L3[2])
# Podemos eliminar un elemento partícular de una lista usando el método remove()
L3.remove(3.12)
print(L3)
# También podemos empalmar dos listas haciendo
L1=['a','b','c']
L2=[1,2,3]
L1.extend(L2)
print(L1)
# Tamaño de una lista
len(L1)
# Consideremos una lista mas compleja. Para este ejemplo utilizaré la librería numpy
import numpy as np # esta forma de importar librerías es común en python
L=np.random.random(100)
# Veamos la lista:
print(L)
# notemos que los datos no están ordenados (pues se creo agregando números de forma aleatoria). Para tener intuición visual sobre esta lista, podemos graficar indice vs valor, usando la librería matplotlib.
import matplotlib.pyplot as plt
plt.figure()
plt.plot(L)
plt.xlabel('i')
plt.ylabel('L[i]')
plt.show()
# Si esta lista estuviese ordenada de mayor a menor, veríamos una curva creciente. Procedamos a ordenarla.
L.sort()
plt.plot(L)
# o bien, podríamos querer estos datos de forma decreciente:
L=sorted(L,reverse=True)
plt.plot(L)
# ## Estructuras de control de flujo
# +
# ciclo for:
# -
for i in range(10): # range es una función que nos devuelve iterables
print('hola planeta ',i+1)
# Podemos colocar condiciones en nuestro flujo de operaciones, colocando sentencias if, e.g.
# Consideremos el siguiente escenario. Tenemos un conjunto de padres e hijos que asistirán a un evento, y el departamento de marketing/logística está preparando regalos para ambos grupos. En este caso, un set de caramelos para los niños y blocks de notas de la marca para adultos. Dado que las edades de cada participante están en una lista, ¿como saber cuantos regalos infantiles y para adultos se deben comprar?
RANGO_EDADES=[i for i in range(1,85)]
EDADES=[]
import random
for i in range(201):
EDADES.append(random.choice(RANGO_EDADES))
# +
#
# -
# +
# ciclo lógico while
numero_especial=0
i=0
while numero_especial<100:
numero_especial=i*(i+1)
print(numero_especial)
i=i+1
# -
# pero imprimió el 110 ... ¿como evitar que esto ocurra?
# # lectura de archivos en Python
# hay muchas formas de abrir un archivo en Python, la forma nativa es a través de la función open. Para ello nos descargamos el dataset disponible en
# https://timeseries.weebly.com/uploads/2/1/0/8/21086414/sea_ice.csv
fname='/Users/aa/Downloads/sea_ice.csv'
f = open(fname).readlines()
firstLine = f.pop(0)
# para explorarlos necesitamos una lista en donde vaciarlos:
artico=[]
antartico=[]
for line in f:
datos=line.split(',')
artico.append(float(datos[1])) # agregamos a la lista el dato, pero haciendo
antartico.append(float(datos[2])) # un cast de str a float
plt.figure()
plt.plot(artico)
plt.plot(antartico)
plt.xlabel('Mes')
plt.ylabel('Hielo Marino')
plt.show()
# # Escritura de archivos
# para escribir archivos utilizamos la misma función open, pero esta vez usando la opción 'w'.
fname='/Users/aa/hola.txt'
almacenar=open(fname,'w')
# en este caso escribiremos algo simple: una string. Para tal fin, utilizaremos el método write.
almacenar.write('\n')
almacenar.write('12\t 3123\n')
# el proceso de escritura se ejecuta haciendo un flush o cerrando el archivo
almacenar.flush()
almacenar.write('Linea número 2')
almacenar.close()
# +
# Tarea: Hacer una copia del archivo previamente descargado sin la fila de los campos.
# +
file=open('/Users/aa/Downloads/sea_ice.csv','r')
k=len(file.readlines())
print(k)
salida=open('/Users/aa/copia_sea_ice.csv','w')
file=open('/Users/aa/Downloads/sea_ice.csv','r')
for i in range(k):
a=file.readline()
if i==0: continue
a=a.split(',')
salida.write(a[1]+'\t'+a[2]+'\n')
salida.close()
# -
# ### Leer archivos con la librería numpy
# Si tenemos archivos solo con datos numéricos, por ejemplo un archivo de valores numéricos tabulados o un csv sin strs, podemos usar la librería numpy para leerlo. Tomemos el archivo previamente descarga
import numpy as np
Datos=np.loadtxt('/Users/aa/copia_sea_ice.csv')
# podemos ver las dimensiones del arreglo cargado utilizando el método shape
Datos.shape
# # Diccionarios
# Son estructuras definidas por pares de claves y valores. Comparando con la lista, los índices son las claves, y el valor de cada entrada corresponde a un valor de un diccionario. La diferencia principal está precisamente en la forma de indexar.
#
# Podemos utilizar nombres (strings) como índices, o números, e incluso listas. Es una estructura extremadamente flexible. En lo siguiente, veremos como definirlos y como iterar sobre ellos.
A=dict([])
type(A)
# Diccionario Nombre / Rut
A['<NAME>']='2236542-k'
A['<NAME>']='3236542-1'
A['<NAME>']='1236542-2'
A['<NAME>']='2536542-3'
A['<NAME>']='6236542-1'
A
# Metodo key()
A.keys()
A.values()
# +
# Si detectan algún bug o fallo escribir a:
# <EMAIL>
# Todos los interesado en contribuir a este proyecto
# pueden hacerlo a través del envío de nuevas versiones
# o al hacer fork de este repositorio.
# -
https://github.com/ajalvarez/zentapython
| Clase_1_y_2.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Twitter US Airline Sentiment
from fastai.text import *
# ## Dataset
path = Path('/media/gilbert/948A92E98A92C760/Local_Programming/Datasets/Other/Twitter US Airline Sentiment Dataset')
path.ls()
df = pd.read_csv(path/'Tweets.csv')
df.head()
train_df, valid_df = df.loc[:12000,:], df.loc[12000:,:]
len(train_df), len(valid_df)
data_lm = TextLMDataBunch.from_df(Path(path), train_df, valid_df, text_cols=10, bs=32)
data_clas = TextClasDataBunch.from_df(Path(path), train_df, valid_df, text_cols=10, label_cols=1, bs=32)
data_lm.show_batch()
data_clas.show_batch()
# ## Language model
learn = language_model_learner(data_lm, pretrained_model=URLs.WT103, drop_mult=0.3)
learn.lr_find()
learn.recorder.plot()
learn.fit_one_cycle(1, 1e-2, moms=(0.8, 0.7))
learn.unfreeze()
learn.lr_find()
learn.recorder.plot()
learn.fit_one_cycle(10, 1e-3, moms=(0.8,0.7))
learn.save('twitter-sentiment-lm')
# Testing our language model
TEXT = "I liked "
N_WORDS = 40
N_SENTENCES = 2
print("\n".join(learn.predict(TEXT, N_WORDS, temperature=0.75) for _ in range(N_SENTENCES)))
learn.save_encoder('twitter-sentiment-enc')
# ## Classifier
learn = text_classifier_learner(data_clas, pretrained_model=URLs.WT103, drop_mult=0.3)
learn.load_encoder('twitter-sentiment-enc')
learn.lr_find()
learn.recorder.plot()
learn.fit_one_cycle(1, 1e-2, moms=(0.8, 0.7))
learn.freeze_to(-2)
learn.fit_one_cycle(1, slice(1e-2/(2.6**4),1e-2), moms=(0.8,0.7))
learn.freeze_to(-3)
learn.fit_one_cycle(1, slice(5e-3/(2.6**4),5e-3), moms=(0.8,0.7))
learn.unfreeze()
learn.fit_one_cycle(2, slice(1e-3/(2.6**4),1e-3), moms=(0.8,0.7))
print(learn)
learn.predict("I really loved the flight")
| FastAI/Twitter US Airline Sentiment.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + [markdown] id="frJfNrUOrJKG"
# # Train Tokenizer and Prepare Dataset
#
# This notebook presents the process for creating the PictoBERT tokenizer and preparing dataset.
#
#
# + [markdown] id="-axoYjs4rX5O"
# ## Dataset
# As our task is word-sense language modeling, we need a word-sense labeled dataset. Besides, as the task consists of predicting word-senses in sequence, we need a dataset with all the nouns, verbs, adjectives, and adverbs labeled. The well-known and used dataset that comes closest to that is the SemCor 3.0 \cite{miller1993semantic}, which is labeled with senses from WordNet 3.0 and counts with 20 thousand annotated sentences. However, it is too tiny for BERT pre-training, originally trained with a 3,300M words dataset. Also, SemCor has sentences in formal text rather than conversational, which we consider more significant for an also conversational task like pictogram prediction.
#
# The Child Language Data Exchange System (CHILDES) \cite{macwhinney2014childes} is a ~2 million sentence multilingual corpus composed of transcribed children's speech. As it is from conversational data, we decide to use it as a training dataset. To make it possible, we labeled part of CHILDES with word-senses using SupWSD \cite{papandreaetal:EMNLP2017Demos}. We choose sentences in North American English. The result is a 955 k sentence labeled corpus that we call SemCHILDES (Semantic CHILDES).
#
# This [Notebook](https://github.com/jayralencar/pictoBERT/blob/main/SemCHILDES.ipynb) present the procedure for building SemCHILDES.
#
#
# + [markdown] id="new0QpJYrtjD"
# ### Download Dataset
#
# The dataset used in this nootebook can be downloaded [here](https://drive.google.com/file/d/18xuy-PmffJxTgG76x5nio9f18lCjE_kL/view?usp=sharing). Or running the following cell.
# + colab={"base_uri": "https://localhost:8080/"} id="z0q7JIR5q_vb" outputId="1490bd11-0e4a-48a8-e829-af9306c42f59"
# !gdown https://drive.google.com/uc?id=18xuy-PmffJxTgG76x5nio9f18lCjE_kL
# + colab={"base_uri": "https://localhost:8080/"} id="wvUCWs_dsZN4" outputId="68acd24a-d839-4705-dd74-949e6019bcd0"
examples = open("./all_mt_2.txt",'r').readlines()
examples = [s.rstrip() for s in examples]
len(examples)
# + [markdown] id="WUKh4mNHsQTs"
# ## Training Tokenizer
#
# To allow the usage of a different vocabulary on BERT, we have to train a new tokenizer. Before inputting data into a language model, it is necessary to tokenize it. Tokenization consists of splitting the words in a sentence according to some rules and then transform the split tokens into numbers. Those numbers are what the model will process. Initially, BERT uses a Word Piece tokenizer that split sentences into words or subwords (e.g., \textquote{playing} into \textquote{play##} and \textquote{##ing}). To allow the use of word-senses, we trained a Word Level tokenizer, which split words in a sentence by whitespace. It enables the usage of sense keys.
#
# We use Hugging Face's tokenizers lib.
# + colab={"base_uri": "https://localhost:8080/"} id="tRV6hzvDsMUn" outputId="29d8fe67-8cb0-479c-eec0-9642d2ea6862"
# !pip install tokenizers
# + [markdown] id="EUz8yH1_socD"
# ### Create Tokenizer
# + id="b4wnm5PIsjTg"
from tokenizers import Tokenizer
from tokenizers.models import WordLevel
from tokenizers.pre_tokenizers import WhitespaceSplit
from tokenizers.processors import BertProcessing
sense_tokenizer = Tokenizer(WordLevel(unk_token="[UNK]"
))
sense_tokenizer.add_special_tokens(["[SEP]", "[CLS]", "[PAD]", "[MASK]","[UNK]"])
sense_tokenizer.pre_tokenizer = WhitespaceSplit()
sep_token = "[SEP]"
cls_token = "[CLS]"
pad_token = "[PAD]"
unk_token = "[UNK]"
sep_token_id = sense_tokenizer.token_to_id(str(sep_token))
cls_token_id = sense_tokenizer.token_to_id(str(cls_token))
pad_token_id = sense_tokenizer.token_to_id(str(pad_token))
unk_token_id = sense_tokenizer.token_to_id(str(unk_token))
sense_tokenizer.post_processor = BertProcessing(
(str(sep_token), sep_token_id), (str(cls_token), cls_token_id)
)
# + [markdown] id="Frqymlejtnwb"
# ### Train tokenizer
# + colab={"base_uri": "https://localhost:8080/"} id="DZwDolO9tyAx" outputId="0a38f79e-7183-49ec-f33d-3760bef97efa"
from tokenizers.trainers import WordLevelTrainer
g = WordLevelTrainer(special_tokens=["[UNK]"])
sense_tokenizer.train_from_iterator(examples, trainer=g)
print("Vocab size: ", sense_tokenizer.get_vocab_size())
# + [markdown] id="OvGkqAa_tzV_"
# ### Save tokenizer
#
# It is necessary to export the created tokenizer to enable its usage in the future. If you want to use a different tokenizer that we used for training PictoBERT, you have to download the JSON file and upload it in the next steps' notebooks (create model, train).
# + id="zRdq2h_Dt3in"
sense_tokenizer.save("./senses_tokenizer.json")
# + [markdown] id="TfFF3NzwvIHB"
# ## Dataset Preparation
#
# We load the trained tokenizer and the dataset and perform data encoding and spliting.
# + [markdown] id="5ikkraCZyu-p"
# ### Split Data
#
# We splited in 98/1/1 train, test and validation. To change this, alter TEST_SIZE below.
# + id="lnmSVO4Qyua0"
TEST_SIZE = 0.02
from sklearn.model_selection import train_test_split
train_idx, val_idx = train_test_split(list(range(len(examples))), test_size=TEST_SIZE, random_state=32)
test_idx, val_idx = train_test_split(val_idx, test_size=0.5, random_state=3)
# + id="Am-wd9aty-kw"
import numpy as np
train_examples = np.array(examples).take(train_idx)
val_examples = np.array(examples).take(val_idx)
test_examples = np.array(examples).take(test_idx)
# + [markdown] id="gMLsAwyPvcMj"
# ### Load tokenizer
#
# It is necessary to load the trained tokenizer using the `PreTrainedTokenizerFast` class from Hugging Face Transformers lib.
#
# To ensure the success of this demonstration, we download the [final tokenizer](https://drive.google.com/file/d/1-2g-GCxjBwESqDn3JByAJABU9Dkuqy0m/view?usp=sharing) used for training PictoBERT in the next cell.
#
#
#
# + colab={"base_uri": "https://localhost:8080/"} id="Srj9W7R2wHca" outputId="3083a31f-8245-4d35-e868-1f909d6d374b"
# !gdown https://drive.google.com/uc?id=1-2g-GCxjBwESqDn3JByAJABU9Dkuqy0m
# + colab={"base_uri": "https://localhost:8080/"} id="b6xFgObGwe2O" outputId="53a9b8ec-a140-476c-fa29-f05769a41150"
# !pip install transformers
# + id="eydbCQ09v-T9"
TOKENIZER_PATH = "./childes_all_new.json" # you can change this path to use your custom tokenizer
from transformers import PreTrainedTokenizerFast
loaded_tokenizer = PreTrainedTokenizerFast(tokenizer_file=TOKENIZER_PATH)
loaded_tokenizer.pad_token = "[PAD]"
loaded_tokenizer.sep_token = "[SEP]"
loaded_tokenizer.mask_token = "[MASK]"
loaded_tokenizer.cls_token = "[CLS]"
loaded_tokenizer.unk_token = "[UNK]"
# + [markdown] id="eCvK_29Fw0qw"
# ### Tokenizer function
#
# This function encodes the examples using the tokenizer. Notice that we used a sequence length of 32, but you can change this value.
# + id="q7SCW3n_w2-W"
max_len = 32
def tokenize_function(tokenizer,examples):
# Remove empty lines
examples = [line for line in examples if len(line) > 0 and not line.isspace()]
bert = tokenizer(
examples,
padding="max_length",
max_length=max_len,
return_special_tokens_mask=True,
truncation=True
)
ngram = tokenizer(examples,add_special_tokens=False).input_ids
return bert,ngram
# + id="UBufKUexxIWu"
train_tokenized_examples, train_ngram = tokenize_function(loaded_tokenizer,train_examples)
val_tokenized_examples, val_ngram = tokenize_function(loaded_tokenizer,val_examples)
test_tokenized_examples, test_ngram = tokenize_function(loaded_tokenizer,test_examples)
# + [markdown] id="RXd24eCVzWlo"
# ### Save data
#
# We transform the data in dicts and save using pickle
# + id="PwufgwOjzWBN"
from torch import tensor
def make_dict(examples,ngrams):
return {
"input_ids": examples.input_ids,
"attention_mask":examples.attention_mask,
"special_tokens_mask":examples.special_tokens_mask,
"ngrams":ngrams
}
# + id="gIqULblRzi1y"
import pickle
TRAIN_DATA_PATH = "./train_data.pt"
TEST_DATA_PATH = "./test_data.pt"
VAL_DATA_PATH = "./val_data.pt"
pickle.dump(make_dict(train_tokenized_examples, train_ngram),open(TRAIN_DATA_PATH,'wb'))
pickle.dump(make_dict(val_tokenized_examples,val_ngram),open(TEST_DATA_PATH,'wb'))
pickle.dump(make_dict(test_tokenized_examples, test_ngram),open(VAL_DATA_PATH ,'wb'))
| Train_Tokenizer_and_Prepare_Dataset.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# ### Google Earth Engine meets Geopandas
# **Author:** <NAME><br>
# **Description:** Extracting Landsat 8 TOA and CHIRPS precipitation data from Google Earth Engine and use Geopandas capabilities to create time series analysis. Furthermore, data will be visualized through a time series viewer and also a heat map.
# %matplotlib inline
import ee, datetime, folium
import pandas as pd
from IPython.display import Image
from pylab import *
import matplotlib.pyplot as plt
import seaborn as sns
import geopandas as gpd
from folium.plugins import HeatMap
ee.Initialize()
# ### Create random point grid from shapefile
# Our area of interest is the Mexican state Chiapas. We only going to create two points per polygon. By increasing this number, the computation time on retrieving information through Google Earth Engine will increase.
chiapas = gpd.read_file('data/chiapas/chiapas.shp')
X = chiapas.to_crs({'init': 'epsg:4326'})
# +
def get_random_points(X):
n = 1
x_min, y_min, x_max, y_max = X.bounds
x = np.random.uniform(x_min, x_max, n)
y = np.random.uniform(y_min, y_max, n)
gdf_points = gpd.GeoSeries(gpd.points_from_xy(x, y))
gdf_points = gdf_points[gdf_points.within(X)]
return gdf_points
x_list = []
for index, row in X.iterrows():
x = gpd.GeoDataFrame({'CVE_MUN':row['CVE_MUN'],
'CVE_ENT':row['CVE_ENT'],
'NOM_MUN':row['NOM_MUN'],
'OID':row['OID'],
'geometry':get_random_points(row['geometry'])})
x_list.append(x)
Y = pd.concat(x_list)
# -
# **Note:** Next Step takes between 5 and 30 minutes depending on our choice of random points per polygon. If you would like to avoid this step, continue with importing points file in data folder. <br><br> **Continue two code cells below!**
# ### Retrieve Landsat 8 TOA and CHIRPS Precipitation Data from Google Earth Engine
# Data will be also reshaped after retrieve. This step might take up to 8 minutes if your random point per polygon is set to 2. To be fair, the sample size is rather small for the analysis. I'd recommend to use the CSV File named **points.csv**.
# +
# Set start and end date
startTime = datetime.datetime(2013, 2, 3)
endTime = datetime.datetime(2019, 5, 25)
# Create image collection
l8 = ee.ImageCollection('LANDSAT/LC08/C01/T1_RT').filterDate(startTime, endTime)
precipitation = ee.ImageCollection('UCSB-CHG/CHIRPS/PENTAD').filterDate(startTime, endTime)
def _getInfo(image_collection, point):
return image_collection.getRegion(point,500).getInfo()
def get_ndvi(x,point, row):
header = x[0]
data = array(x[1:])
iTime = header.index('time')
time = [datetime.datetime.fromtimestamp(i/1000) for i in (data[0:,iTime].astype(int))]
# List of used image bands
band_list = ['B5',u'B4']
iBands = [header.index(b) for b in band_list]
yData = data[0:,iBands].astype(np.float)
# Calculate NDVI
red = yData[:,0]
nir = yData[:,1]
ndvi = (nir - red) / (nir + red)
# Reshape NDVI array into Pandas Dataframe
df = pd.DataFrame(data = ndvi*-1, index = time, columns = ['ndvi'])
df_red = pd.DataFrame(data = red, index = time, columns = ['red'])
l8_time_series = df.dropna()
# Resampling
monthly_landsat = l8_time_series.resample('M', how = 'mean')
monthly_landsat['landsat_id'] = str(data[0][0])
monthly_landsat['x'] = point['coordinates'][0]
monthly_landsat['y'] = point['coordinates'][1]
monthly_landsat['CVE_MUN'] = row['CVE_MUN']
monthly_landsat['CVE_ENT'] = row['CVE_ENT']
monthly_landsat['NOM_MUN'] = row['NOM_MUN']
monthly_landsat['OID'] = row['OID']
return monthly_landsat
def get_precipitation(x,point,row):
# Reshape Chirps precipitation data
header = x[0]
data = array(x[1:])
iTime = header.index('time')
time = [datetime.datetime.fromtimestamp(i/1000) for i in (data[0:,iTime].astype(int))]
band_list = ['precipitation']
iBands = [header.index(b) for b in band_list]
chirps = data[0:,iBands].astype(np.float)
df = pd.DataFrame(data = chirps, index = time, columns = ['precipitation'])
chirps_time_series = df.dropna()
# Resampling
monthly_chirps = chirps_time_series.resample('M', how = 'mean')
monthly_chirps['chirps_id'] = str(data[0][0])
monthly_chirps['x'] = point['coordinates'][0]
monthly_chirps['y'] = point['coordinates'][1]
monthly_chirps['CVE_MUN'] = row['CVE_MUN']
monthly_chirps['CVE_ENT'] = row['CVE_ENT']
monthly_chirps['NOM_MUN'] = row['NOM_MUN']
monthly_chirps['OID'] = row['OID']
return monthly_chirps
start_time = datetime.datetime.now()
l8_list = []
pp_list = []
for index , row in Y.iterrows():
point = {'type':'Point', 'coordinates':[row['geometry'].x,row['geometry'].y]};
_x = _getInfo(l8, point)
_y = _getInfo(precipitation, point)
l8_list.append(get_ndvi(_x,point,row))
pp_list.append(get_precipitation(_y,point,row))
df_l8 = pd.concat(l8_list)
df_l8 = df_l8.reset_index()
df_pp = pd.concat(pp_list)
df_pp = df_pp.reset_index()
pp = df_pp.copy()
pp = df_pp[df_pp['index']>'2013-07-01']
ll8 = df_l8.copy()
ll8 = df_l8[df_l8['index']>'2013-07-01']
df = pd.merge(pp,ll8, on = ['index','CVE_MUN','CVE_ENT','NOM_MUN','OID','x','y'])
# df.to_csv('data/chiapas/points.csv',index=False)
end_time = datetime.datetime.now()
print('\nTotal run time:', end_time - start_time, '\n')
# -
# **Note:**
# Instead of waiting 5 to 30 minutes (depends on variable n), load points file with 554 points.
df = pd.read_csv('data/chiapas/points.csv')
# ### Convert Pandas to GeoPandas DataFrame
gdf = gpd.GeoDataFrame(df, geometry = gpd.points_from_xy(df.y, df.x))
gdf = gdf.drop(columns=['x','y'])
# +
dates = gdf['index'].unique()
time_series_list = []
for i in dates:
time_series_list.append((gdf[gdf['index']==i].set_index(['NOM_MUN','index']).groupby(level=[0,1]).mean()))
df_time_series = pd.concat(time_series_list).reset_index()
df_time_series = df_time_series.merge(X[['geometry','NOM_MUN']])
gdf_time_series = gpd.GeoDataFrame(df_time_series)
gdf_time_series['index'] = pd.to_datetime(gdf_time_series['index'])
# -
fig, ax = plt.subplots(figsize = (12,10), subplot_kw = {'aspect':'equal'})
gdf_time_series[gdf_time_series['index']=='2013-07-31'].plot(column = 'precipitation',cmap = 'Blues',ax = ax)
fig, ax = plt.subplots(figsize = (12,10), subplot_kw = {'aspect':'equal'})
gdf_time_series[gdf_time_series['index']=='2013-07-31'].plot(column = 'ndvi',cmap = 'YlGn',ax = ax)
# ### Create Time Series Viewer
# In this last part, we are going to use widgets to browse through the Time-Series in order to see all time steps.
# +
from IPython.display import display, clear_output
import ipywidgets as widgets
drop_dfu = widgets.Dropdown(options=sorted(gdf_time_series['index'].unique()), description='Choose Date:',
disabled=False,layout={'width': 'max-content'})
display(drop_dfu)
def c(i):
vmin, vmax = gdf_time_series['precipitation'].min(), gdf_time_series['precipitation'].max()
fig,ax = plt.subplots(1,2,figsize=(25,15),subplot_kw={'aspect':'equal'})
gdf_time_series[gdf_time_series['index']==drop_dfu.value].plot(column='ndvi',cmap='YlGn',ax=ax[0])
gdf_time_series[gdf_time_series['index']==drop_dfu.value].plot(column='precipitation',cmap='Blues',ax=ax[1])
for i in range(2):
ax[i].axis('off')
ax[i].set_title(["ndvi","precipitation"][i], fontsize=20)
def on_change(change):
if change['name'] == 'value' and (change['new'] != change['old']):
clear_output()
display(drop_dfu)
c(drop_dfu.value)
drop_dfu.observe(on_change)
# -
# ### Precipitation Heat Map
# Create a precipitation heat map on average precipitation values throughout the whole time series.
# +
points_gdf = gdf_time_series.copy()
points_gdf['x'] = points_gdf.centroid.x
points_gdf['y'] = points_gdf.centroid.y
precipitation = points_gdf.set_index('NOM_MUN')[['index','precipitation']].groupby(level=0).mean()
points_gdf = points_gdf[['NOM_MUN','x','y']].drop_duplicates()
points_gdf['precipitation']=precipitation.values
points_gdf = points_gdf[points_gdf['precipitation']>25]
points_array = points_gdf[['y', 'x']].values
m = folium.Map(location = [16.25, -92.45], tiles = 'stamentoner', zoom_start = 7, control_scale = True)
HeatMap(points_array).add_to(m)
m
# -
# ### NDVI Heat Map
# Create a NDVI heat map on average NDVI values throughout the whole time series.
# +
points_gdf = gdf_time_series.copy()
points_gdf['x'] = points_gdf.centroid.x
points_gdf['y'] = points_gdf.centroid.y
ndvi = points_gdf.set_index('NOM_MUN')[['index','ndvi']].groupby(level=0).mean()
points_gdf = points_gdf[['NOM_MUN','x','y']].drop_duplicates()
points_gdf['ndvi'] = ndvi.values
points_gdf = points_gdf[points_gdf['ndvi']>0.25]
points_array = points_gdf[['y', 'x']].values
m = folium.Map(location = [16.25, -92.45], tiles = 'stamentoner', zoom_start = 7, control_scale = True)
HeatMap(points_array).add_to(m)
m
# -
# ### Forecast
from fbprophet import Prophet
# +
df_x = gdf_time_series.copy()
df_x['precipitation_change']=df_x['precipitation'].pct_change(12)*100
df_x['ndvi_change']=df_x['ndvi'].pct_change(12)*100
df_x = df_x.fillna(0)
def create_prophet_df(x, field):
x['ds']=x['index']
x=x.set_index(['NOM_MUN','index'])
x['y']=x[field]
return x
def _forecast(x, indices, periods, freq):
fcst=[]
for i in indices:
_dataframe=x.loc[i]
m = Prophet()
m.add_regressor('precipitation_change')
m.add_regressor('ndvi_change')
m.fit(_dataframe)
future = m.make_future_dataframe(periods=periods, freq=freq, include_history=False)
future['precipitation_change'] = 0
future['ndvi_change'] = 0
forecast=m.predict(future)[['yhat','ds']]
forecast['NOM_MUN'] = i
fcst.append(forecast)
return pd.concat(fcst)
def forecast(dataframe, item):
x = create_prophet_df(dataframe,item)
forecast =_forecast(x, dataframe.NOM_MUN.unique(), 5, 'M')
forecast = forecast.merge(dataframe[['NOM_MUN','geometry']].drop_duplicates('NOM_MUN'))
forecast.columns = [item, 'Date', 'NOM_MUN', 'geometry']
return forecast
# -
gdf_forecast_precipitation = forecast(df_x,'precipitation')
gdf_forecast_ndvi = forecast(df_x,'ndvi')
gdf_forecast_final=gpd.GeoDataFrame(gdf_forecast_ndvi.merge(gdf_forecast_precipitation[['NOM_MUN','Date','precipitation']]))
fig, ax = plt.subplots(figsize = (12,10), subplot_kw = {'aspect':'equal'})
gdf_forecast_final[gdf_forecast_final['Date']=='2019-07-31'].plot(column = 'ndvi',cmap = 'YlGn',ax = ax)
| 008_EE_meets_Geopandas.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 2
# language: python
# name: python2
# ---
import numpy as np
import pandas as pd
from pandas import Series, DataFrame
df=pd.read_json('./ranked.json')
df2=pd.read_json('../../05_DataMining_New_Columns/01_Preprocessing/First.json')
df.head(2)
df.uniRank.replace(-1,np.nan,inplace=True)
df.uniRank.mean()
df['paper']=df.papersGLOB+(df.papersIRAN*1/3)
df.set_index('inx',inplace=True)
del df['papersIRAN']
del df['papersGLOB']
df.head()
df2.gre=df.gre
df2.highLevelBachUni=df.highLevelBachUni
df2.highLevelMasterUni=df.highLevelMasterUni
df.to_json('First.json',date_format='utf8')
| 06_DM_UseAppliedUni/01_Preprocessing/Finally.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Multi-label deep learning with scikit-multilearn
#
# Deep learning methods have expanded in the python community with many tutorials on performing classification using neural networks, however few out-of-the-box solutions exist for multi-label classification with deep learning, scikit-multilearn allows you to deploy single-class and multi-class DNNs to solve multi-label problems via problem transformation methods. Two main deep learning frameworks exist for Python: keras and pytorch, you will learn how to use any of them for multi-label problems with scikit-multilearn. Let's start with loading some data.
# +
import numpy
import sklearn.metrics as metrics
from skmultilearn.dataset import load_dataset
X_train, y_train, feature_names, label_names = load_dataset('emotions', 'train')
X_test, y_test, _, _ = load_dataset('emotions', 'test')
# -
# ## Keras
#
# Keras is a neural network library that supports multiple backends, most notably the well-established tensorflow, but also the popular on Windows: CNTK, as scikit-multilearn supports both Windows, Linux and MacOSX, you can you a backend of choice, as described in the backend selection tutorial. To install Keras run:
#
# ```bash
# pip install -U keras
# ```
#
# ### Single-class Keras classifier
# We train a two-layer neural network using Keras and tensortflow as backend (feel free to use others), the network is fairly simple 12 x 8 RELU that finish with a sigmoid activator optimized via binary cross entropy. This is a case from the [Keras example page](https://keras.io/scikit-learn-api/). Note that the model creation function must create a model that accepts an input dimension and outpus a relevant output dimension. The Keras wrapper from scikit-multilearn will pass relevant dimensions upon fitting.
# +
from keras.models import Sequential
from keras.layers import Dense
def create_model_single_class(input_dim, output_dim):
# create model
model = Sequential()
model.add(Dense(12, input_dim=input_dim, activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(output_dim, activation='sigmoid'))
# Compile model
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
return model
# -
# Let's use it with a problem transformation method which converts multi-label classification problems to single-label single-class problems, ex. Binary Relevance which trains a classifier per label. We will use 10 epochs and disable verbosity.
# +
from skmultilearn.problem_transform import BinaryRelevance
from skmultilearn.ext import Keras
KERAS_PARAMS = dict(epochs=10, batch_size=100, verbose=0)
clf = BinaryRelevance(classifier=Keras(create_model_single_class, False, KERAS_PARAMS), require_dense=[True,True])
clf.fit(X_train, y_train)
result = clf.predict(X_test)
# -
# ### Multi-class Keras classifier
#
# We now train a multi-class neural network using Keras and tensortflow as backend (feel free to use others) optimized via categorical cross entropy. This is a case from the [Keras multi-class tutorial](https://machinelearningmastery.com/multi-class-classification-tutorial-keras-deep-learning-library/). Note again that the model creation function must create a model that accepts an input dimension and outpus a relevant output dimension. The Keras wrapper from scikit-multilearn will pass relevant dimensions upon fitting.
def create_model_multiclass(input_dim, output_dim):
# create model
model = Sequential()
model.add(Dense(8, input_dim=input_dim, activation='relu'))
model.add(Dense(output_dim, activation='softmax'))
# Compile model
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
return model
# We use the Label Powerset multi-label to multi-class transformation approach, but this can also be used with all the advanced label space division methods available in scikit-multilearn. Note that we set the second parameter of our Keras wrapper to true, as the base problem is multi-class now.
from skmultilearn.problem_transform import LabelPowerset
clf = LabelPowerset(classifier=Keras(create_model_multiclass, True, KERAS_PARAMS), require_dense=[True,True])
clf.fit(X_train,y_train)
y_pred = clf.predict(X_test)
# ## Pytorch
#
# Pytorch is another often used library, that is compatible with scikit-multilearn via the skorch wrapping library, to use it, you must first install the required libraries:
#
# ```bash
# pip install -U skorch torch
# ```
#
# To start, import:
import torch
from torch import nn
import torch.nn.functional as F
from skorch import NeuralNetClassifier
# ### Single-class pytorch classifier
# We train a two-layer neural network using pytorch based on a simple example from the [pytorch example page](https://nbviewer.jupyter.org/github/dnouri/skorch/blob/master/notebooks/Basic_Usage.ipynb). Note that the model's first layer has to agree in size with the input data, and the model's last layer is two-dimensions, as there are two classes: 0 or 1.
input_dim = X_train.shape[1]
class SingleClassClassifierModule(nn.Module):
def __init__(
self,
num_units=10,
nonlin=F.relu,
dropout=0.5,
):
super(SingleClassClassifierModule, self).__init__()
self.num_units = num_units
self.dense0 = nn.Linear(input_dim, num_units)
self.dense1 = nn.Linear(num_units, 10)
self.output = nn.Linear(10, 2)
def forward(self, X, **kwargs):
X = F.relu(self.dense0(X))
X = F.relu(self.dense1(X))
X = torch.sigmoid(self.output(X))
return X
# We now wrap the model with skorch and use scikit-multilearn for Binary Relevance classification.
net = NeuralNetClassifier(
SingleClassClassifierModule,
max_epochs=20,
verbose=0
)
# +
from skmultilearn.problem_transform import BinaryRelevance
clf = BinaryRelevance(classifier=net, require_dense=[True,True])
clf.fit(X_train.astype(numpy.float32),y_train)
y_pred = clf.predict(X_test.astype(numpy.float32))
# -
# ### Multi-class pytorch classifier
# Similarly we can train a multi-class DNN, this time hte last layer must agree with size with the number of classes.
nodes = 8
input_dim = X_train.shape[1]
hidden_dim = int(input_dim/nodes)
output_dim = len(numpy.unique(y_train.rows))
class MultiClassClassifierModule(nn.Module):
def __init__(
self,
input_dim=input_dim,
hidden_dim=hidden_dim,
output_dim=output_dim,
dropout=0.5,
):
super(MultiClassClassifierModule, self).__init__()
self.dropout = nn.Dropout(dropout)
self.hidden = nn.Linear(input_dim, hidden_dim)
self.output = nn.Linear(hidden_dim, output_dim)
def forward(self, X, **kwargs):
X = F.relu(self.hidden(X))
X = self.dropout(X)
X = F.softmax(self.output(X), dim=-1)
return X
# Now let's skorch-wrap it:
net = NeuralNetClassifier(
MultiClassClassifierModule,
max_epochs=20,
verbose=0
)
from skmultilearn.problem_transform import LabelPowerset
clf = LabelPowerset(classifier=net, require_dense=[True,True])
clf.fit(X_train.astype(numpy.float32),y_train)
y_pred = clf.predict(X_test.astype(numpy.float32))
| docs/source/multilabeldnn.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: 'Python 3.7.11 64-bit (''spleen'': conda)'
# name: python3
# ---
# +
import numpy as np
import scipy.sparse as sparse
import spatialpower.neighborhoods.permutationtest as perm_test
import multiprocessing as mp
from datetime import datetime
import errno
from joblib import Parallel, delayed
import os
from glob import glob
from matplotlib_venn import venn3, venn2
import matplotlib.pyplot as plt
# + code_folding=[]
def run_test_nosave(A, B, H_gt, size, n_jobs, trials, graph, threshold):
'''
Runs the permutation test, and calculates signficant interaction pairs.
Parameters
----------
size : int, size of graph to calculate.
n_jobs: int, number of parallel jobs to spawn
trials: int, number of shuffles in empirical distribution
plot : bool, generate histogram of each pairwise relation if True.
Returns
-------
enriched_pairs : array-like
depleted_pairs : array-like
'''
n_cell_types = B.shape[1]
args = (A, B, size, graph, n_cell_types)
arg_list = [args for i in range(0, trials)]
results = Parallel(n_jobs=n_jobs, verbose=50, backend="sequential")(
delayed(perm_test.permutation_test_trial_wrapper)(args) for args in arg_list)
#parse_results(results, size, out_dir)
arr = np.dstack(results) # stack into a 3-D array
n_types = arr.shape[0]
enriched_pairs = []
depleted_pairs = []
for i in range(0, n_types):
for j in range(0, n_types):
ground_truth_score = H_gt[i, j]
emp_dist = arr[i, j, :]
indices, = np.where(emp_dist < ground_truth_score)
p = (len(emp_dist) - len(indices) + 1) / (len(emp_dist) + 1)
if p <= threshold:
enriched_pairs.append([i, j, p])
elif p >= 1 - threshold:
depleted_pairs.append([i, j, p])
# Write results matrix.
#np.save(out_dir + "enriched_pairs.npy", np.array(enriched_pairs))
#np.save(out_dir + "depleted_pairs.npy", np.array(depleted_pairs))
return enriched_pairs, depleted_pairs
# -
A = sparse.load_npz('./spleen_data/for_paper/stitched_graph_noblank.npz')
B = np.load('./spleen_data/for_paper/B_full_image_heuristic_4.npy')
p = np.divide(np.sum(B, axis=0), A.shape[0])
H_gt = perm_test.calculate_neighborhood_distribution_sparse(A, B)
enrichment_pairs, avoidance_pairs = run_test_nosave(A, B, H_gt, A.shape[0], n_jobs=10, trials=1000, graph=composite_graph, threshold = 0.1)
#b = a[a[:,2].argsort()]
enrichment_pair_arr = np.array(enrichment_pairs)
enrichment_pair_arr_sorted = enrichment_pair_arr[enrichment_pair_arr[:,2].argsort()]
np.save('./spleen_data/for_paper/image4_enrichments.npy', enrichment_pair_arr_sorted[enrichment_pair_arr_sorted[:,2] < 0.01])
enrichment_pairs_1 = np.load('./spleen_data/for_paper/image1_enrichments.npy')
enrichment_pairs_2 = np.load('./spleen_data/for_paper/image2_enrichments.npy')
enrichment_pairs_3 = np.load('./spleen_data/for_paper/image3_enrichments.npy')
enrichment_pairs_4 = np.load('./spleen_data/for_paper/image4_enrichments.npy')
enrichment_pairs_list_1 = enrichment_pairs_1[:, :2].astype(int).tolist()
enrichment_pairs_list_2 = enrichment_pairs_2[:, :2].astype(int).tolist()
enrichment_pairs_list_3 = enrichment_pairs_3[:, :2].astype(int).tolist()
enrichment_pairs_list_4 = enrichment_pairs_3[:, :2].astype(int).tolist()
enrichment_pairs_list_1.remove([27,27])
enrichment_pairs_list_2.remove([27,27])
enrichment_pairs_list_3.remove([27,27])
enrichment_pairs_list_4.remove([27,27])
# +
#Convert pairs to pair IDs
pair_id_dict = dict()
id_counter = 0
for i in range(0, 27):
for j in range(0,27):
pair_id_dict[(i,j)] = id_counter
id_counter += 1
# -
def parse_arr_to_tuple(l):
res = []
for i in l:
x = i[0]
y = i[1]
res.append((x,y))
return res
enrichment_pairs_tuples_1 = parse_arr_to_tuple(enrichment_pairs_list_1)
enrichment_pairs_tuples_2 = parse_arr_to_tuple(enrichment_pairs_list_2)
enrichment_pairs_tuples_3 = parse_arr_to_tuple(enrichment_pairs_list_3)
enrichment_pairs_tuples_4 = parse_arr_to_tuple(enrichment_pairs_list_4)
x = set(enrichment_pairs_tuples_1).union(enrichment_pairs_tuples_3)
set(enrichment_pairs_tuples_2).difference(x)
# ## Compare to real data
A = sparse.load_npz('./spleen_data/for_paper/A_full_balbc3.npz') #BALBC-1
B = np.load('./spleen_data/for_paper/B_full_balbc3.npy')
p = np.divide(np.sum(B, axis=0), A.shape[0])
H_gt = perm_test.calculate_neighborhood_distribution_sparse(A, B)
enrichment_pairs, avoidance_pairs = run_test_nosave(A, B, H_gt, A.shape[0], n_jobs=10, trials=1000, graph=nx.from_scipy_sparse_matrix(A), threshold = 0.1)
enrichment_pair_arr = np.array(enrichment_pairs)
enrichment_pair_arr_sorted = enrichment_pair_arr[enrichment_pair_arr[:,2].argsort()]
np.save('./spleen_data/for_paper/balbc3_enrichments.npy', enrichment_pair_arr_sorted[enrichment_pair_arr_sorted[:,2] < 0.01])
balbc1 = np.load('./spleen_data/for_paper/balbc1_enrichments.npy')
balbc2 = np.load('./spleen_data/for_paper/balbc2_enrichments.npy')
balbc3 = np.load('./spleen_data/for_paper/balbc3_enrichments.npy')
balbc1_pairs_list = balbc1[:, :2].astype(int).tolist()
balbc2_pairs_list = balbc2[:, :2].astype(int).tolist()
balbc3_pairs_list = balbc3[:, :2].astype(int).tolist()
# +
balbc1_enrichment_pairs_tuples = parse_arr_to_tuple(balbc1_pairs_list)
balbc2_enrichment_pairs_tuples = parse_arr_to_tuple(balbc2_pairs_list)
balbc3_enrichment_pairs_tuples = parse_arr_to_tuple(balbc3_pairs_list)
# -
venn3((set(balbc1_enrichment_pairs_tuples), set(balbc2_enrichment_pairs_tuples), set(balbc3_enrichment_pairs_tuples)), set_labels=('BALBC-1', 'BALBC-2', 'BALBC-3'))
#plt.savefig('./spleen_data/figures/BALBC_RST_venn.pdf')
plt.show()
# ## Stitch together shuffled tiles
from glob import glob
pals_B_arr_names = np.sort(glob('./spleen_data/for_paper/tiles/239_cell_tiles/shuffling_experiment/B_hueristic_pals*'))
bfollicle_B_arr_names = np.sort(glob('./spleen_data/for_paper/tiles/239_cell_tiles/shuffling_experiment/B_hueristic_bfollicle*'))
redpulp_B_arr_names = np.sort(glob('./spleen_data/for_paper/tiles/239_cell_tiles/shuffling_experiment/B_hueristic_redpulp*'))
marginalzone_B_arr_names = np.sort(glob('./spleen_data/for_paper/tiles/239_cell_tiles/shuffling_experiment/B_hueristic_marginalzone*'))
# +
b_follicle_count = 51
pals_count = 94
red_pulp_count = 174
marginal_zone_count = 69
print("B Follicle Tiles ", b_follicle_count)
print("PALS Tiles ", pals_count)
print("Red Pulp Tiles ", red_pulp_count)
print("Marginal Zone Tiles", marginal_zone_count)
# -
# Assign the tiles to tissues.
bfollicle_tiles_per_tissue = np.random.choice(bfollicle_B_arr_names, (20, b_follicle_count), replace=False)
pals_tiles_per_tissue = np.random.choice(pals_B_arr_names, (20, pals_count), replace=False)
redpulp_tiles_per_tissue = np.random.choice(redpulp_B_arr_names, (20, red_pulp_count), replace=False)
marginalzone_tiles_per_tissue = np.random.choice(marginalzone_B_arr_names, (20, marginal_zone_count), replace=False)
for j in range(0, 20):
tissue_tiles = np.concatenate((bfollicle_tiles_per_tissue[j], pals_tiles_per_tissue[j],
redpulp_tiles_per_tissue[j], marginalzone_tiles_per_tissue[j]))
np.random.shuffle(tissue_tiles) #Shuffles in place
for i in range(0, len(tissue_tiles)):
B_tile = np.load(tissue_tiles[i])
if i == 0:
#This is the first tile.
B_composite = B_tile
else:
B_composite = np.vstack((B_composite, B_tile))
np.save('./spleen_data/for_paper/tiles/239_cell_tiles/shuffling_experiment/B_composite_' + str(j) + '.npy',
B_composite)
# ### Parse shuffled tiles permutation results
from glob import glob
results_arr = glob('./spleen_data/for_paper/tiles/239_cell_tiles/shuffling_experiment/enriched_pairs*')
# +
def parse_arr_to_tuple(l):
res = []
for i in l:
x = i[0]
y = i[1]
res.append((x,y))
return res
def parse_permutation_test_results(arr_path, alpha=0.01):
arr = np.load(arr_path)
sig_ixns = arr[arr[:,2] < alpha]
sig_ixns_list = sig_ixns[:, :2].astype(int).tolist()
tuple_list = parse_arr_to_tuple(sig_ixns_list)
tuple_set = set(tuple_list)
return tuple_set
# -
results_sets = [parse_permutation_test_results(i) for i in results_arr]
# +
#for each interaction, count in how many tissues it was observed.
possible_ixns = []
for i in range(0, 27):
for j in range(0, 27):
possible_ixns.append((i,j))
ixn_counts = dict(zip(possible_ixns, [0 for x in range(0, len(possible_ixns))]))
# -
for ixn in possible_ixns:
for result_set in results_sets:
if ixn in result_set:
ixn_counts[ixn] += 1
ixn_counts_list = list(ixn_counts.values())
n_tissues_with_interaction, counts = np.unique(ixn_counts_list, return_counts=True)
print(n_tissues_with_interaction)
print(counts)
# +
import matplotlib
from matplotlib import cm, colors
import matplotlib.pyplot as plt
import seaborn as sns
matplotlib.rcParams.update({'axes.linewidth': 0.25,
'xtick.major.size': 2,
'xtick.major.width': 0.25,
'ytick.major.size': 2,
'ytick.major.width': 0.25,
'pdf.fonttype': 42,
'font.sans-serif': 'Arial'})
sns.set_style('whitegrid')
sns.barplot(x=n_tissues_with_interaction[:], y=counts[:], color = (2/255, 158/255, 115/255))
plt.ylabel(r'Count of unique interactions')
plt.xlabel(r'Number of tissues where interaction was significant (p<0.01)')
#plt.savefig('./spleen_data/figures/IST_shuffledtiles_overlap_barplot.pdf')
#plt.savefig('./spleen_data/figures/Figure2G.pdf')
plt.show()
# -
# ### Compare to real data
real_data_all_shared = set.intersection(set(balbc1_enrichment_pairs_tuples), set(balbc2_enrichment_pairs_tuples), set(balbc3_enrichment_pairs_tuples))
# +
ist_data_all_shared = []
for ixn in possible_ixns:
if ixn_counts[ixn] == 20:
ist_data_all_shared.append(ixn)
# -
# ### Binomial Trials
from scipy import stats
# +
import matplotlib
from matplotlib import cm, colors
import matplotlib.pyplot as plt
matplotlib.rcParams.update({'axes.linewidth': 0.25,
'xtick.major.size': 2,
'xtick.major.width': 0.25,
'ytick.major.size': 2,
'ytick.major.width': 0.25,
'pdf.fonttype': 42,
'font.sans-serif': 'Arial'})
plt.clf()
sns.set_style('whitegrid')
sns.set_palette('colorblind')
x = [i for i in range(0,21)]
sns.lineplot(x, stats.binom.sf(0,x, 1), label = r'20 ISTs')
sns.lineplot(x, stats.binom.sf(0,x, 0.95), label = r'19 ISTs')
sns.lineplot(x, stats.binom.sf(0,x, 0.75), label = r'15 ISTs')
sns.lineplot(x, stats.binom.sf(0,x, 0.50), label = r'10 ISTs')
sns.lineplot(x, stats.binom.sf(0,x, 0.25), label = r'5 ISTs')
sns.lineplot(x, stats.binom.sf(0,x, 0.1), label = r'2 ISTs')
sns.lineplot(x, stats.binom.sf(0,x, 0.05), label = r'1 IST')
plt.xticks([i for i in range(0,21,2)])
plt.ylabel(r"Probability of Observing Interaction")
plt.xlabel(r"N samples")
#plt.savefig('./spleen_data/figures/binomial_probabilities_ISTabundance.pdf')
#plt.savefig('./spleen_data/figures/Figure2I.pdf')
plt.show()
# +
import matplotlib
from matplotlib import cm, colors
import matplotlib.pyplot as plt
matplotlib.rcParams.update({'axes.linewidth': 0.25,
'xtick.major.size': 2,
'xtick.major.width': 0.25,
'ytick.major.size': 2,
'ytick.major.width': 0.25,
'pdf.fonttype': 42,
'font.sans-serif': 'Arial'})
venn2((set(ist_data_all_shared), real_data_all_shared), set_labels=(r'All ISTs', r"All RST") )
#plt.savefig('./spleen_data/figures/IST_RST_comparison.pdf')
#plt.savefig('./spleen_data/figures/Figure2H.pdf')
plt.show()
# -
set(ist_data_all_shared)
| codex_spleen/ProspectivePower_2mn.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + [markdown] id="view-in-github" colab_type="text"
# <a href="https://colab.research.google.com/github/Ransaka/Angular2-RecordRTC/blob/master/Untitled42.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
# + id="p4r_gFtIsMvC"
import pandas as pd
import numpy as np
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score,train_test_split,GridSearchCV
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
import matplotlib.pyplot as plt
from sklearn.metrics import classification_report
import seaborn as sns
# + id="nMIoZB1nyhXA"
train = pd.read_csv('/content/train_cleaned_and_encoded.csv')
# + id="oAPzRTIxr-84"
validation = pd.read_csv('/content/validation_scaled_cleaned.csv')
# + id="XhqWCCLaSDVw"
test = pd.read_csv('/content/test_cleaned_scaled.csv')
# + colab={"base_uri": "https://localhost:8080/"} id="gKMEiNteSMDa" outputId="dd7af122-b06f-470c-e287-d16c122c24ba"
test.shape
# + colab={"base_uri": "https://localhost:8080/"} id="v4kfoseAstiU" outputId="c1d7497f-e79a-4b50-b636-db794204a400"
train.shape
# + colab={"base_uri": "https://localhost:8080/"} id="9UqTqJMtstwO" outputId="a9db0346-202e-44dc-8726-7ae90e5d5fd7"
validation.shape
# + colab={"base_uri": "https://localhost:8080/"} id="K93wn05nSQvG" outputId="a75c3697-4afe-488a-a0f5-d82247369477"
train.columns
# + colab={"base_uri": "https://localhost:8080/"} id="PMP2rmWiywrF" outputId="5a8c2d11-de76-4779-bb5d-2ae3587967fe"
validation.columns
# + colab={"base_uri": "https://localhost:8080/"} id="--uOYldptDnK" outputId="498ca2be-0242-4a68-e748-2e05effec594"
test.columns
# + id="UFHeYrJGyyEd"
del train['Unnamed: 0']
# + id="u1VKfB1XSWTx"
del test['Unnamed: 0']
# + id="PMDbuGMmtCMF"
del validation['Unnamed: 0']
# + colab={"base_uri": "https://localhost:8080/", "height": 531} id="Qwk-ZzWXzFse" outputId="c3eb9861-a8ac-430e-fbd3-9b577e0d30e1"
train.sample(10)
# + colab={"base_uri": "https://localhost:8080/", "height": 531} id="P0x78gPPtTe4" outputId="f32af389-c07c-4066-94f6-3aab91db4d5a"
test.sample(10)
# + colab={"base_uri": "https://localhost:8080/", "height": 531} id="481VGYUItTqd" outputId="b56597da-9c12-488a-f885-781b64dec43e"
validation.sample(10)
# + id="kNN_hHXnzKj_"
cat_cols = [x for x in train.columns if train[x].dtype=="O"]
# + colab={"base_uri": "https://localhost:8080/", "height": 35} id="YTGzoOMIzkhE" outputId="d1dc339d-2646-4784-bb20-0b915d99bf2a"
cat_cols.pop(-2)
# + colab={"base_uri": "https://localhost:8080/"} id="IzQHzY020m7l" outputId="7cda64e3-ed7b-4e9a-dd77-3496094c18ca"
cat_cols
# + id="802ZxUXnxfMx"
meta = {}
for col in cat_cols:
meta[col] = list(train[col].unique())
# + id="rVQOQywJxfJ9"
for key in meta.keys():
cats = meta[key]
codes = [x for x in range(len(cats))]
d = {n:code for n,code in zip(cats,codes)}
test[key] = test[key].map(d)
# + id="gWsMJEoRt2nf"
for key in meta.keys():
cats = meta[key]
codes = [x for x in range(len(cats))]
d = {n:code for n,code in zip(cats,codes)}
train[key] = train[key].map(d)
# + id="oWonAc-Yt9Ec"
for key in meta.keys():
cats = meta[key]
codes = [x for x in range(len(cats))]
d = {n:code for n,code in zip(cats,codes)}
validation[key] = validation[key].map(d)
# + colab={"base_uri": "https://localhost:8080/", "height": 232} id="oz1Ix6BnxfHo" outputId="85a15b86-6a94-434c-a7f5-7cdd29a06140"
test.head()
# + colab={"base_uri": "https://localhost:8080/", "height": 232} id="39El3bCkuLUT" outputId="434cad7a-090d-4900-8722-23eb44c78988"
train.head()
# + colab={"base_uri": "https://localhost:8080/", "height": 232} id="h6e1HgTJuLIv" outputId="2d0c2ca2-8248-45fe-9bda-4a0e90a303eb"
validation.head()
# + id="HsTSnGDCSlQv"
test.to_csv('test_cleaned_and_encoded.csv')
# + colab={"base_uri": "https://localhost:8080/", "height": 399} id="PB3hUiPjxe40" outputId="12d6fda8-1d6b-4bcc-fb59-3ec9f1056423"
plt.boxplot(train['booked_before_n_days'])
# + id="5_BGe-wVxe0e"
train_df = train[train.booked_before_n_days.apply(lambda x:True if x<220 else False)]
# + colab={"base_uri": "https://localhost:8080/", "height": 399} id="Q_XPYqIkxeyG" outputId="c38b90b9-4f09-4add-a3f0-0bf9e84afd53"
plt.boxplot(train_df['booked_before_n_days'])
# + colab={"base_uri": "https://localhost:8080/", "height": 399} id="Jrg7UZIPuvjQ" outputId="2cc5f68f-8a39-450a-aae1-9b495813efa7"
plt.boxplot(train_df['Room_Rate'])
# + colab={"base_uri": "https://localhost:8080/", "height": 399} id="69P1VW0VvYHs" outputId="9551a66b-e805-48c5-e6b0-a3e78012f3c2"
plt.boxplot(train_df['Discount_Rate'])
# + colab={"base_uri": "https://localhost:8080/", "height": 297} id="SRPYHCQNv1S8" outputId="ca4a33f8-6555-4503-b931-fed4e400dfcc"
sns.histplot(train_df['Discount_Rate'])
# + id="XG6mhe7HxewP"
from sklearn.preprocessing import StandardScaler,MinMaxScaler
# + id="Zn9-YdNFxeue"
scaler = MinMaxScaler()
# + colab={"base_uri": "https://localhost:8080/"} id="iNO3v7grxeqF" outputId="d512c99b-d687-4926-cfd6-4213fda589ce"
scaler.fit_transform(np.array(train_df.Expected_checkin_Year).reshape(-1,1))
# + colab={"base_uri": "https://localhost:8080/", "height": 282} id="tfXfNtFXxeHb" outputId="4d821d70-7528-4ccd-df88-1149ab407d75"
sns.histplot(scaler.fit_transform(np.array(train_df.Expected_checkin_Year).reshape(-1,1)))
# + id="I9dlZyLj13LW"
train_df_bkp = train_df.copy()
# + id="0v8iehCtzH8X"
train_df_bkp[train_df_bkp.drop(['Reservation_Status','Reservation-id'],1).columns] = scaler.fit_transform(train_df[train_df.drop(['Reservation_Status','Reservation-id'],1).columns])
# + colab={"base_uri": "https://localhost:8080/", "height": 438} id="TIGyyfIgxybF" outputId="7a6eb262-4b37-4314-d923-246e4b723e93"
train_df_bkp
# + id="szlbO6V7xesp"
# train_df['Expected_checkin_Year'] = scaler.fit_transform(np.array(train_df.Expected_checkin_Year).reshape(-1,1))
# + colab={"base_uri": "https://localhost:8080/"} id="YJoumRooxen4" outputId="0c58e512-0d26-4b96-a90d-cb509ca7bebc"
train_df_bkp.shape
# + id="iCiSNy6Sxeld"
train_df_bkp.to_csv('train_cleaned_and_encoded.csv')
# + id="aE5r2IiSxefN"
validation_bkp = validation.copy()
# + id="KN9DRZ9WxebX"
validation_bkp[validation_bkp.drop(['Reservation_Status','Reservation-id'],1).columns] = scaler.fit_transform(validation_bkp[validation_bkp.drop(['Reservation_Status','Reservation-id'],1).columns])
# + id="Kk5jU8sfxeZi" colab={"base_uri": "https://localhost:8080/", "height": 438} outputId="044c12fb-0e9a-47e5-f96c-0beddab74a02"
validation_bkp
# + id="waKbx893xeXY"
validation_bkp.to_csv('validation_scaled_cleaned.csv')
# + id="YTci0ZqExeTd"
test_bkp = test.copy()
# + id="-fyckHZjxeRl" colab={"base_uri": "https://localhost:8080/"} outputId="b3f7442c-3822-4912-895a-a1dd04897d07"
test_bkp.shape
# + id="r5p_B3IlxePP" colab={"base_uri": "https://localhost:8080/"} outputId="2f357e63-7bec-423e-c6ad-d50087a131ff"
validation_bkp.shape
# + id="3Vsve6J6xeMl" colab={"base_uri": "https://localhost:8080/"} outputId="4167ddea-cc09-4c89-8ab4-75d767fa16f0"
train_df_bkp.shape
# + id="6Ss7BHrVxeCg"
test_bkp[test_bkp.drop(['Reservation-id'],1).columns] = scaler.fit_transform(test_bkp[test_bkp.drop(['Reservation-id'],1).columns])
# + id="rzs0mWPkxeAw" colab={"base_uri": "https://localhost:8080/"} outputId="96b62559-ea22-4275-e32a-f6c911a5f6a2"
test_bkp.shape
# + id="15kJ_xZOxd-l"
test_bkp.to_csv('test_cleaned_scaled.csv')
# + id="z8E7PLcnxd8a" colab={"base_uri": "https://localhost:8080/", "height": 361} outputId="beac3a10-0772-4fbb-d302-97a24d7f1287"
g = sns.countplot(new_train['Reservation_Status'])
# g.set_xticklabels(['Not Fraud','Fraud'])
plt.show()
# + colab={"base_uri": "https://localhost:8080/", "height": 709} id="Q90zd1guO7UE" outputId="d46ba2cd-0bf5-4368-84e4-4adc3d3ff414"
#Visualization
#Create a new figure and make the size (12,10)
plt.figure(figsize=(12,10))
sns.barplot(x=new_train['Income'], y=new_train['Meal_Type'],palette=sns.cubehelix_palette(len(new_train['Income'])))
# Place the region names at a 90-degree angle.
plt.xticks(rotation= 45)
plt.xlabel('Region')
plt.ylabel('Region Happiness Ratio')
plt.title('Happiness rate for regions')
plt.show()
# + [markdown] id="81BhkrgKp16m"
# ## Start
# + id="OOsx71B_xUgr"
new_train = pd.read_csv('/content/train_cleaned_and_encoded.csv')
# + id="amqLjRdy9zHY"
del new_train['Unnamed: 0']
# + id="fiJNZ1d3xjUG"
from imblearn.over_sampling import RandomOverSampler
ros = RandomOverSampler(random_state=42)
x_ros, y_ros = ros.fit_resample(X, y)
# + id="QOFYy2tTb07T"
X = new_train.drop(['Reservation_Status','Reservation-id'],1)
y = new_train['Reservation_Status'].map({"Check-In":1,"Canceled":2,"No-Show":3})
# + colab={"base_uri": "https://localhost:8080/", "height": 422} id="QLv4ao_sFx8e" outputId="44b9b58b-d943-42f3-bc75-0524be6cec35"
pd.DataFrame(x_ros,columns=X.columns)
# + colab={"base_uri": "https://localhost:8080/"} id="sQEunsmpcTxc" outputId="4bb41280-7880-4de2-9509-18d3405ea35b"
list(X.columns)
# + colab={"base_uri": "https://localhost:8080/"} id="Omv3Se2VbBKt" outputId="6894c4cf-c58a-487a-98db-8254e51e45a3"
train.isna().sum()
# + id="zqXwgScQbgtO"
# validate = validation
# + id="-7IsUETNeR3f"
# validate = validate.drop(['Reservation-id'],1)
# + colab={"base_uri": "https://localhost:8080/"} id="HaeXhVvve2tq" outputId="bc84f5ed-49bb-4ebd-c444-52d5011834c3"
X.shape
# + id="Jh_roL0xx-Lm"
validation= pd.read_csv('/content/validation_scaled_cleaned.csv')
# + id="3o3Ihg8yyGSA"
del validation['Unnamed: 0']
# + id="lkodJwpHeR5r"
X_val = validation.drop(['Reservation_Status','Reservation-id'],1)
y_val = validation['Reservation_Status'].map({"Check-In":1,"Canceled":2,"No-Show":3})
# + colab={"base_uri": "https://localhost:8080/"} id="Vg5z5k0Se2wF" outputId="8a94b66d-6041-42a6-e955-93b14a56bc42"
X_val.shape
# + id="g6zg2xARfGT9"
# y_val
# + id="CfuH0GUUZqPz"
import numpy as np
import pandas as pd
import os
#Import sklearn classes
from sklearn.model_selection import train_test_split,RepeatedKFold, cross_val_score,KFold, RepeatedStratifiedKFold
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier,export_graphviz
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier, BaggingClassifier
from sklearn.dummy import DummyClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
# sklearn utility to compare algorithms
from sklearn import model_selection
# + colab={"base_uri": "https://localhost:8080/"} id="Hy-x9Yf4nQkk" outputId="cdfaa3f7-c87a-45ef-d1a4-8764017be012"
# !pip install eli5
# + id="LB4yQ0_yiiDQ"
# %matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns
import graphviz
import warnings
warnings.filterwarnings('ignore')
from eli5 import explain_weights,show_weights
from yellowbrick import ROCAUC
from yellowbrick.classifier import ClassificationReport
from sklearn.metrics import f1_score
# + colab={"base_uri": "https://localhost:8080/"} id="corpHGa5BKY6" outputId="e902a4db-e811-421f-96ac-227dca377c55"
X.shape
# + colab={"base_uri": "https://localhost:8080/"} id="Y78fAP2WnOpt" outputId="d27182b2-8f97-409b-9c34-2710341d4159"
pca=PCA(n_components=24)
pca.fit(X)
print('Variance explained by the principal components(in decreasing order): ',pca.explained_variance_ratio_)
print('PCA singular values: ',pca.singular_values_)
X1=pca.transform(X)
print('Shape of transformed X: ',X1.shape)
# + colab={"base_uri": "https://localhost:8080/"} id="JDt1MfWqnwIv" outputId="bdf8d638-7cce-47f9-d1f9-e0c859b73c3e"
dum=DummyClassifier(strategy='most_frequent')
dum=dum.fit(X,y)
#compute accuracy
score=dum.score(X_val, y_val)
f1 = f1_score(y_val,dum.predict(X_val),average='macro')
print("Dummy Classifier Accuracy: %.2f%%" % (score * 100.0))
print("Dummy Classifier f1_score: {}".format(f1))
# + colab={"base_uri": "https://localhost:8080/", "height": 424} id="MwAfe85voGtG" outputId="9981846d-77cc-4788-f83d-8a0258b43f4e"
strategy = "most_frequent"
CV_N_REPEATS=20
BINS=10
scores = cross_val_score(dum,X, y,
cv=RepeatedKFold(n_repeats=CV_N_REPEATS),
scoring=None)
scores_dummy = scores.copy()
score_line = "Scores (Accuracy) mean={0:.2f} +/- {1:.2f} (1 s.d.)".format(scores.mean(),scores.std())
plt.figure(figsize=(7,7))
fig, ax = plt.subplots()
pd.Series(scores).hist(ax=ax, bins=BINS)
ax.set_title(f"RepeatedKFold ({len(scores)} folds) with DummyClassifier({strategy})\n" + score_line);
ax.set_xlabel("Score")
ax.set_ylabel("Frequency")
# + id="ZYOtcgExoLTP"
def plot_tree_graph(model,columns,class_names):
#This function plots the constructed decision tree
dot_data = export_graphviz(model,feature_names=columns,class_names=class_names)
graph = graphviz.Source(dot_data)
return graph
def confusion_mat(y_pred,y_test):
plt.figure()
sns.set(font_scale=1.5)
cm = confusion_matrix(y_pred, y_test)
sns.heatmap(cm, annot=True, fmt='g')
plt.title('Confusion matrix', y=1.1)
plt.ylabel('Actual label')
plt.xlabel('Predicted label')
plt.show()
# + colab={"base_uri": "https://localhost:8080/", "height": 437} id="Zz6o5DGVoqx9" outputId="c767c863-2a90-4174-8809-cb609cba7003"
knn=KNeighborsClassifier(n_neighbors=3,n_jobs=10,p=2)
knn.fit(x_ros,y_ros)
scores = cross_val_score(knn, X_val, y_val, cv=RepeatedStratifiedKFold(n_repeats=CV_N_REPEATS))
print(f"Accuracy mean={scores.mean():0.2f} +/- {scores.std():0.2f} (1 s.d.)")
y_pred_1 = knn.predict(X_val)
print(f1_score(y_val,y_pred_1,average='macro'))
confusion_mat(y_pred_1,y_val)
# + colab={"base_uri": "https://localhost:8080/"} id="lxpFlACzozQK" outputId="adf1cddd-bb4a-45ac-aa2d-4fe1224e48aa"
for depth in [n for n in range(10,21,1)]:
dt=DecisionTreeClassifier(random_state=1, max_depth=depth)
dt=dt.fit(x_ros,y_ros)
dt_scores = cross_val_score(dt, X_val, y_val, cv=RepeatedStratifiedKFold(n_repeats=CV_N_REPEATS))
y_pred_dt = dt.predict(X_val)
print(depth,f"Accuracy mean={dt_scores.mean():0.2f} +/- {dt_scores.std():0.2f} (1 s.d.)",f1_score(y_val,y_pred_dt,average='macro'))
# + id="MYHi54U38s6m" colab={"base_uri": "https://localhost:8080/"} outputId="4b3b4711-e095-4d97-b882-268038156ef9"
dt=DecisionTreeClassifier(random_state=1, max_depth=15)
dt=dt.fit(x_ros,y_ros)
dt_scores = cross_val_score(dt, X_val, y_val, cv=RepeatedStratifiedKFold(n_repeats=CV_N_REPEATS))
y_pred_dt = dt.predict(X_val)
print(depth,f"Accuracy mean={dt_scores.mean():0.2f} +/- {dt_scores.std():0.2f} (1 s.d.)",f1_score(y_val,y_pred_dt,average='macro'))
# + id="tmZeIw3K5wlZ"
y_pred_dt2 = dt.predict(X_val)
# + colab={"base_uri": "https://localhost:8080/"} id="NLfADkQv5nxC" outputId="73fbddb5-3b53-45c7-b015-2be3e5703034"
f1_score(y_val,y_pred_dt2,average='macro')
# + colab={"base_uri": "https://localhost:8080/", "height": 403} id="Cw95pu49roeN" outputId="274568b5-c71c-4889-f21c-4e5e8225c34b"
confusion_mat(y_pred_dt2, y_val)
# + colab={"base_uri": "https://localhost:8080/", "height": 34} id="Lv-8LwpVo-w5" outputId="0f3f4bf0-63a4-47a2-9af9-fed20bc26b4e"
plt.figure()
graph=plot_tree_graph(dt,X.columns,class_names=['1','2','3'])
# + colab={"base_uri": "https://localhost:8080/"} id="KVBLbht5pCZH" outputId="da5e5c60-425b-4880-ca90-f500d324e8ae"
bag=BaggingClassifier(n_estimators=20,oob_score=True,max_samples=10,max_features=10)
bag=bag.fit(x_ros,y_ros)
bag_scores = cross_val_score(bag, X_val, y_val, cv=RepeatedStratifiedKFold(n_repeats=CV_N_REPEATS))
print("Accuracy mean={0:0.2f} +/- {1:0.2f} (1 s.d.)".format(scores.mean(),scores.std()))
print("Out of bag score: {0:0.2f}".format(bag.oob_score_*100) );
# + id="Rs--XQE49ClX"
from sklearn.metrics import roc_auc_score
# + colab={"base_uri": "https://localhost:8080/"} id="B0bkdSf-p9d0" outputId="a0973861-7101-420c-f62f-4a3a4c60b170"
sample_leaf_options = [10,20,30,25,35,40]
for leaf_size in sample_leaf_options :
modelrf = RandomForestClassifier(n_estimators = 200, n_jobs = -1,random_state =50, min_samples_leaf = leaf_size)
modelrf.fit(x_ros,y_ros)
print("\n Leaf size :", leaf_size)
print ("AUC - ROC : ", accuracy_score(y_val,modelrf.predict(X_val)))
print(f1_score(y_val,modelrf.predict(X_val),average='macro'))
# + colab={"base_uri": "https://localhost:8080/", "height": 386} id="rcEFaGRhq7-A" outputId="4442bff0-1614-431e-a397-556e0b913d0d"
feature_names=X.columns.values
show_weights(modelrf,feature_names=feature_names)
# + colab={"base_uri": "https://localhost:8080/", "height": 454} id="bYwD2gEA_J6i" outputId="7f4b4119-a80d-4ede-d8cb-2da72654e879"
modelgb = GradientBoostingClassifier(n_estimators=100,max_depth=32)
modelgb.fit(x_ros,y_ros)
print(depth)
print(accuracy_score(y_val,modelgb.predict(X_val)))
print(f1_score(y_val,modelgb.predict(X_val),average='macro'))
confusion_mat(modelgb.predict(X_val),y_val)
# + id="rSD7jVeJEfxX"
from keras.layers import Dense,Dropout
from keras.models import Sequential
import tensorflow as tf
# + id="V1Xi12WSVTLF"
Reservation_Status_checkIn = list(train_df_bkp[train_df_bkp['Reservation_Status']=='Check-In'].index)
# + colab={"base_uri": "https://localhost:8080/"} id="St_oXaXjWUUT" outputId="ee6d9a8a-99bd-429a-ea07-635f94045d33"
len(Reservation_Status_checkIn)
# + id="-f0vxxnYW0eV"
import random
# + id="plDxTcR1W_yb"
filtered_idx = random.sample(Reservation_Status_checkIn,6000)
# + id="MmlHThS3XOqg"
train_sliced = train_df_bkp.loc[filtered_idx]
# + id="og1M6xDlVvZV"
no_show = train_df_bkp[train_df_bkp['Reservation_Status']=='No-Show']
# + id="BKp2_vefVzyc"
canceled = train_df_bkp[train_df_bkp['Reservation_Status']=='Canceled']
# + id="6qxFtYSuX_DC"
new_train = pd.concat([train_sliced, no_show, canceled])
# + colab={"base_uri": "https://localhost:8080/", "height": 438} id="Wdxnn1avYSO2" outputId="28920661-3e84-4306-cb21-881d47544970"
new_train
# + id="1pJRwo9mYYO4"
new_train.to_csv('train_slised.csv')
# + id="8M1_ImHPYnfb"
# + colab={"base_uri": "https://localhost:8080/"} id="Sl5MzE4T_J-d" outputId="7a99dfd4-e90b-4d09-ab03-be543ac92205"
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import RandomizedSearchCV
# Create param grid.
param_rf=[{'n_estimators' : list(range(10,150,15)),
'max_features' : list(range(6,32,5)),
'max_depth' : list(range(2,36,2)),
'min_samples_split':list(range(1,6,1)),
'min_samples_leaf':list(range(1,6,1)),
'min_weight_fraction_leaf':list(range(0,5,1))
}]
# Create grid search object
clfrfgs = RandomizedSearchCV(RandomForestClassifier(oob_score=True), param_distributions = param_rf, n_iter=50, cv = 5, refit=True,verbose=1, n_jobs=-1)
# Fit on data
best_clf = clfrfgs.fit(x_ros, y_ros)
print(best_clf.best_params_)
best_clf.best_score_
# + colab={"base_uri": "https://localhost:8080/"} id="TK0S1YTEKb2H" outputId="66eb9e00-3e4d-4319-fe0f-8f13a540ae9e"
print(f1_score(y_val,best_clf.predict(X_val),average='macro'))
# + id="_eqkcLcEtR0w"
import re
regex = re.compile(r"\[|\]|<", re.IGNORECASE)
X.columns = [regex.sub("_", col) if any(x in str(col) for x in set(('[', ']', '<'))) else col for col in X.columns.values]
X_val.columns = [regex.sub("_", col) if any(x in str(col) for x in set(('[', ']', '<'))) else col for col in X_val.columns.values]
# X_test.columns = [regex.sub("_", col) if any(x in str(col) for x in set(('[', ']', '<'))) else col for col in X_train.columns.values]
# + id="whAD68ZnsTBa"
from xgboost import XGBClassifier, plot_importance,to_graphviz
# fit model on training data
param = {'max_depth': 20, 'eta': 0.8,"tree_method":"gpu_hist", 'subsample':1,'learning_rate':0.01, 'n_estimators':1000,'reg_lambda':0.1}
xgb = XGBClassifier(**param)
xgb.fit(x_ros, y_ros)
y_pred = xgb.predict(X_val)
# evaluate predictions
xgb_score = accuracy_score(y_val, y_pred)
print("Accuracy of XGB Classifier: {0:0.2f}".format(xgb_score * 100.0));
#Plot the confusion matrix
confusion_mat(y_pred, y_val)
# + colab={"base_uri": "https://localhost:8080/"} id="hr-9mQs5C6mJ" outputId="b0f83fcf-227a-4b57-f03e-fc66846044e4"
param_test1 = {
'max_depth':range(3,10,2),
'min_child_weight':range(1,6,2)
}
gsearch1 = GridSearchCV(estimator = XGBClassifier( learning_rate =0.1, n_estimators=140, max_depth=5,min_child_weight=1, gamma=0, subsample=0.8, colsample_bytree=0.8,objective= 'multi:softmax', nthread=4, scale_pos_weight=1, seed=27),
param_grid = param_test1,n_jobs=4,iid=False, cv=5)
gsearch1.fit(X,y)
# + colab={"base_uri": "https://localhost:8080/"} id="jZ9s-oFhDFoe" outputId="3d66e02d-8e02-4423-8f9b-67c5b9704b1b"
gsearch1.cv_results_
# + colab={"base_uri": "https://localhost:8080/"} id="1EmpSmExDFrM" outputId="877f702e-f286-41ea-b231-42b58548c5c8"
gsearch1.best_score_
# + colab={"base_uri": "https://localhost:8080/"} id="KvjEYuPODFwh" outputId="e71400ec-8133-4ae4-fc9f-5ab0c0502609"
gsearch1.best_params_
# + colab={"base_uri": "https://localhost:8080/"} id="shDimwQjDFzD" outputId="3a4627b1-100c-4e21-c605-9ebd7afffc31"
param_test2 = {
'max_depth':[3,5,7,9],
'min_child_weight':[1,3,5]
}
gsearch2 = GridSearchCV(estimator = XGBClassifier( learning_rate =0.1, n_estimators=140, max_depth=5,min_child_weight=1, gamma=0, subsample=0.8, colsample_bytree=0.8,objective= 'multi:softmax', nthread=4, scale_pos_weight=1, seed=27),
param_grid = param_test2,n_jobs=4,iid=False, cv=5)
gsearch2.fit(X,y)
# + colab={"base_uri": "https://localhost:8080/"} id="NLxDXd1NKUXq" outputId="59b5b22c-2241-4ded-8528-2c3253a99ea3"
gsearch2.best_params_
# + colab={"base_uri": "https://localhost:8080/"} id="OkwRISr3Noxi" outputId="838ae125-d195-4abc-f997-8dec165eb845"
gsearch2.best_score_
# + colab={"base_uri": "https://localhost:8080/"} id="YnqlPlHZKUVl" outputId="de9474f6-ea07-4e23-8ee8-69245668e5e1"
param_test3 = {
'gamma':[i/10.0 for i in range(0,5)]
}
gsearch3 = GridSearchCV(estimator = XGBClassifier( learning_rate =0.1, n_estimators=140, max_depth=3,min_child_weight=1, gamma=0, subsample=0.8, colsample_bytree=0.8,objective= 'multi:softmax', nthread=4, scale_pos_weight=1,seed=27),
param_grid = param_test3,n_jobs=4,iid=False, cv=5)
gsearch3.fit(X,y)
# + colab={"base_uri": "https://localhost:8080/"} id="V-Eg8rHcKUS_" outputId="7f161fc6-aa13-4394-cc9f-b849795385e6"
gsearch3.best_score_
# + colab={"base_uri": "https://localhost:8080/"} id="REMGc7D8KUQc" outputId="59173dca-9907-4afa-867c-4020fab9133f"
gsearch3.best_params_
# + colab={"base_uri": "https://localhost:8080/"} id="arqxjP_HOGa-" outputId="edd55258-8054-413a-99e8-df966654157e"
param_test4 = {
'subsample':[i/10.0 for i in range(6,10)],
'colsample_bytree':[i/10.0 for i in range(6,10)]
}
gsearch4 = GridSearchCV(estimator = XGBClassifier( learning_rate =0.1, n_estimators=140, max_depth=3,min_child_weight=1, gamma=0.2, subsample=0.8, colsample_bytree=0.8,objective= 'multi:softmax', nthread=4, scale_pos_weight=1,seed=27),
param_grid = param_test4,n_jobs=4,iid=False, cv=5)
gsearch4.fit(X,y)
# + colab={"base_uri": "https://localhost:8080/"} id="jzjDD5aOOGYv" outputId="cad61afc-8cfc-4277-ac52-f2655162d346"
gsearch4.best_score_
# + colab={"base_uri": "https://localhost:8080/"} id="pokCPf5TRVqI" outputId="10c8ec8d-9016-44fa-91ef-a4a20e51c8a7"
gsearch4.best_params_
# + colab={"base_uri": "https://localhost:8080/"} id="ztDZZVcMRVth" outputId="c7751853-459c-48e9-833d-620de21ac633"
param_test5 = {
'reg_alpha':[1e-5, 1e-2, 0.1, 1, 100]
}
gsearch5 = GridSearchCV(estimator = XGBClassifier( learning_rate =0.1, n_estimators=177, max_depth=3,
min_child_weight=1, gamma=0.3, subsample=0.6, colsample_bytree=0.7,
objective= 'multi:softmax', nthread=4, scale_pos_weight=1,seed=27),
param_grid = param_test5,n_jobs=4,iid=False, cv=5)
gsearch5.fit(X,y)
# + colab={"base_uri": "https://localhost:8080/"} id="htHq2cZSRVwg" outputId="f13e6d20-995e-4585-da91-199d4d6aafaa"
gsearch5.best_score_
# + colab={"base_uri": "https://localhost:8080/"} id="Noe6Auz2RVzm" outputId="26965464-b9d7-49b2-debb-0b3b38c9c457"
gsearch5.best_params_
# + colab={"base_uri": "https://localhost:8080/"} id="JSScSNbpRV11" outputId="b9f034f9-ae90-439c-9b4d-79f86b97b21d"
param_test6 = {
'learning_rate':[0.1, 0.01, 0.05, 0.02]
}
gsearch6 = GridSearchCV(estimator = XGBClassifier( learning_rate =0.1, n_estimators=177, max_depth=3,
min_child_weight=1, gamma=0.2, subsample=0.6, colsample_bytree=0.7,reg_alpha=100,objective= 'multi:softmax', nthread=4, scale_pos_weight=1,seed=27),
param_grid = param_test6,n_jobs=4,iid=False, cv=5)
gsearch6.fit(X,y)
# + colab={"base_uri": "https://localhost:8080/"} id="S-h_fUqxRV43" outputId="c6d1555f-9edd-40e5-d69c-605f14ffaa1c"
gsearch6.best_score_
# + colab={"base_uri": "https://localhost:8080/"} id="Ie-pa6QtOGT6" outputId="7fdd5eed-3fb7-4696-8a4b-099bceab5bb1"
gsearch6.best_params_
# + id="soxTqq_3aml5"
gb_final = XGBClassifier( learning_rate =0.01,
n_estimators=1000,
max_depth=3,
min_child_weight=1,
gamma=0.2,
subsample=0.6,
colsample_bytree=0.7,
reg_alpha=0.1,
tree_method = "gpu_hist",
nthread=4,
scale_pos_weight=1,
seed=27).fit(X,y)
# + colab={"base_uri": "https://localhost:8080/"} id="Ydh2ZDagamjv" outputId="e15df589-e9f7-49f0-f489-1545841d1638"
f1_score(y_val,xgb.predict(X_val),average='macro')
# + colab={"base_uri": "https://localhost:8080/"} id="08F5NQvUwwiW" outputId="1751b4d3-c472-4c8c-f861-dbbbe2ec1fc9"
f1_score(y_val,gb_final.predict(X_val),average='macro')
# + id="6d75vLvbamhQ"
# gb_final.predict(X_test)
# + id="pL0AuafcameX"
# + id="SkLwkBZeOGQy"
# + id="4wa5WdRvCsL-"
# f1_score(y_val,y_pred,average='macro')
# + id="LokvqUP-v-Xy"
X.columns = [regex.sub("_", col) if any(x in str(col) for x in set(('[', ']', '<'))) else col for col in X.columns.values]
# + colab={"base_uri": "https://localhost:8080/", "height": 338} id="hZuN7l5_rRsC" outputId="80fdd319-5fd3-4020-8cbe-13b25a632838"
from sklearn.ensemble import VotingClassifier
ensemble_knn_rf_xgb=VotingClassifier(estimators= [('bag',bag),('Random Forest', dt)], voting='hard')
ensemble_knn_rf_xgb.fit(X,y)
#compute accuracy
print('The ensembled model with all the 3 classifiers is:',ensemble_knn_rf_xgb.score(X_val,y_val))
#make predictions
y_pred = ensemble_knn_rf_xgb.predict(X_val)
#Plot the confusion matrix
confusion_mat(y_pred, y_val)
# + id="zg2lJCFtwsZR"
from sklearn.metrics import f1_score
# + colab={"base_uri": "https://localhost:8080/"} id="KQdcuu1Sl3A0" outputId="60b74d6d-f8a4-40e4-d96e-056698cb55d7"
# + colab={"base_uri": "https://localhost:8080/"} id="GD-xOykvv52v" outputId="c540158b-3d74-4e5d-8f03-ce7593ecffb2"
f1_score(y_val, ensemble_knn_rf_xgb.predict(X_val),average='macro')
# + id="hyF6vq5QfZmC"
# + [markdown] id="BaPPsQHdfbJG"
# The best model so far is DT
# + colab={"base_uri": "https://localhost:8080/"} id="fwt7apIBb2O2" outputId="5b84b195-7ae1-412e-cf32-381ef94e1f42"
dt.score(X_val,y_val)
# + colab={"base_uri": "https://localhost:8080/"} id="Rz-4ybTPd2Sy" outputId="c8596ccb-5c5d-47f5-977e-d8f974ef077f"
print(classification_report(y_val,dt.predict(X_val)))
# + colab={"base_uri": "https://localhost:8080/"} id="yujAzsfajqMp" outputId="80bcce66-9065-4397-a6e1-93c28915f94e"
dt
# + id="LlgXdojYejxO"
import pickle
# + id="BdFIP_yLestN"
pickle.dump(dt, open('dt_with_36_f1_score', 'wb'))
# + id="dbQvcf52e6zI"
dt_with_36_f1_score = pickle.load(open('/content/dt_with_36_f1_score', 'rb'))
# + colab={"base_uri": "https://localhost:8080/"} id="4PPu4EJLfDfN" outputId="8fabe016-9993-4255-fefe-22ab98f0b662"
dt_with_36_f1_score.predict(X_val)
# + id="NJv3d7eb3-tP"
test = pd.read_csv('/content/test_cleaned_scaled.csv')
# + colab={"base_uri": "https://localhost:8080/", "height": 232} id="R3HUVVKu4bwO" outputId="b33fd3ff-0618-4c88-b774-4a485ebee5aa"
test.head()
# + colab={"base_uri": "https://localhost:8080/"} id="tQEhv-AB4rqM" outputId="300e84d6-4957-41be-e4de-693aea9f16c6"
dt.n_features_
# + colab={"base_uri": "https://localhost:8080/"} id="2cNyhnar4wPz" outputId="fdf57914-44e9-4ec1-9b8a-c07c90cba6f5"
X.columns
# + id="0XKgueCl_DCg"
test = pd.read_csv('/content/test_cleaned_scaled.csv')
# + colab={"base_uri": "https://localhost:8080/", "height": 232} id="4AiGXOTr_Wq6" outputId="df984e28-5cdc-4d94-ce1d-f876edc24324"
test.head()
# + id="rHq0KjSu_NsK"
test = test.drop(['Reservation-id','Unnamed: 0'],1)
# + id="iXUUdNKGTCDo"
dt_predictions = dt.predict(test)
# + id="erBHJvYiTo9P"
pd.DataFrame({"Reservation-id":test['Reservation-id'],"Reservation_Status":dt_predictions}).to_csv('submission3.csv')
# + [markdown] id="SJfDEyRSwGu2"
# # Ensemble Learning
#
#
# + id="qLgLdbgSBd6o"
import pandas as pd
import numpy as np
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import MinMaxScaler
# + colab={"base_uri": "https://localhost:8080/", "height": 215} id="fMpB1cmGwYUF" outputId="410087e1-b04f-40e7-8b21-05323afc4ca1"
train.head()
# + id="I54uTQzIwqS2"
train.Expected_checkin_Year = scaler.inverse_transform(train.Expected_checkin_Year)
# + colab={"base_uri": "https://localhost:8080/"} id="_nvL2Qomw9Aq" outputId="9c12dabe-25a7-47fd-fff3-8cf010d916a2"
train.shape
# + colab={"base_uri": "https://localhost:8080/"} id="_i6GEHZk9kux" outputId="d994cfef-38e2-4980-b6d5-37bd4427dcf4"
list(train.columns)
# + colab={"base_uri": "https://localhost:8080/"} id="Q_1Gnx_59qs7" outputId="71161732-1b6a-416a-ccf5-7c0c9683dc01"
list(validation.columns)
# + colab={"base_uri": "https://localhost:8080/"} id="X-egbxqQ9Ioe" outputId="ed2150b6-d06b-4da4-faff-0237be28c9c3"
validation.shape
# + id="Tzp8xUuZxGoq"
train.Expected_checkin_Year = train.Expected_checkin_Year.apply(lambda yr:np.mod(yr,2000))
# + id="01Ig8azPxi_X"
validation.Expected_checkin_Year = validation.Expected_checkin_Year.apply(lambda yr:np.mod(yr,2000))
# + id="fkBTRdcVx6oi"
values_train = train.drop(['Reservation_Status'],1).values
# + id="oLBTSSdS1rfL"
values_validate = validation.drop(['Reservation_Status','Reservation-id','isWeekend_trip'],1).values
# + id="9Nj_-QPRym6a"
imputer = SimpleImputer()
# + colab={"base_uri": "https://localhost:8080/"} id="b5WjhuO76P2X" outputId="dbb15cb0-053b-4616-80b9-0f814258f712"
values_validate.shape
# + colab={"base_uri": "https://localhost:8080/"} id="7wI_7Ps06TLL" outputId="c66df274-9dae-463d-9764-951bc90a471b"
values_train.shape
# + id="u4Q7GSGLyqtt"
imputedData_train = imputer.fit_transform(values_train)
# + id="AgOnIAwq1_Rp"
imputedData_validation = imputer.fit_transform(values_validate)
# + colab={"base_uri": "https://localhost:8080/"} id="To-wThokyu_T" outputId="70083c12-a3d3-4b95-9920-5dc2bb0ed177"
imputedData_train
# + colab={"base_uri": "https://localhost:8080/"} id="tvcGIv0n6ilG" outputId="45126931-a0cb-4cc1-ff2c-ae0150652e68"
imputedData_validation
# + id="jFzhJiX4zAMr"
scaler2 = MinMaxScaler(feature_range=(0, 1))
# + id="6L1eqwrazGiv"
normalizedData_train = scaler2.fit_transform(imputedData_train)
# + id="LHRowCdu6n-w"
normalizedData_validation = scaler2.fit_transform(imputedData_validation)
# + id="yRhT9GUvzNkM"
from sklearn import model_selection
from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier
# + id="nraIHz3CzmQd"
y_stk = train['Reservation_Status'].map({"Check-In":1,"Canceled":2,"No-Show":3})
# + id="zTEOv5zZ60BO"
y_stk_val = validation['Reservation_Status'].map({"Check-In":1,"Canceled":2,"No-Show":3})
# + id="Il-Dcm2i6yNH"
y_stk_val = np.array(y_stk_val)
# + id="cRUK0GlbzzF7"
y_stk = np.array(y_stk)
# + id="qQ5QZuH0zSgp"
X_stk = normalizedData_train
# + id="vSwcD-0q7CAl"
X_stk_val = normalizedData_validation
# + colab={"base_uri": "https://localhost:8080/"} id="SxI-9B1kz_oJ" outputId="53069b94-621b-4b99-8fef-c9007241596a"
kfold = model_selection.KFold(n_splits=10, random_state=7)
cart = DecisionTreeClassifier()
num_trees = 200
model_bagg = BaggingClassifier(base_estimator=cart, n_jobs =10,n_estimators=num_trees, random_state=7)
results = model_selection.cross_val_score(model_bagg, X, y, cv=kfold)
print(results.mean())
# + colab={"base_uri": "https://localhost:8080/"} id="qI2jQLCkFgmp" outputId="a4c52b4a-3d18-414b-e744-21e81c53dc24"
model_bagg.fit(X,y)
# + id="XeAQhSO_FgqA"
predicted_bagg= model_bagg.predict(X_val)
# + colab={"base_uri": "https://localhost:8080/"} id="df2bIXn6FguS" outputId="3930f894-59ed-4983-87e4-58ccb6b58d75"
f1_score(y_val,predicted_bagg,average='macro')
# + colab={"base_uri": "https://localhost:8080/"} id="aXqwe5Qw0ANN" outputId="3e7befbd-1ec9-49a4-e441-dc3bef4c5023"
from sklearn.ensemble import AdaBoostClassifier
seed = 7
num_trees = 100
kfold = model_selection.KFold(n_splits=20, random_state=seed)
model_ada = AdaBoostClassifier(n_estimators=num_trees,learning_rate =0.01, random_state=seed)
results = model_selection.cross_val_score(model_ada, X, y, cv=kfold)
print(results.mean())
# + colab={"base_uri": "https://localhost:8080/"} id="EDEDf4iOB_IV" outputId="ac837895-5738-440f-8662-29cc15124ce9"
model_ada.fit(X,y)
# + id="oq5Zbw7wD8Q3"
predicted_ada = model_ada.predict(X_val)
# + colab={"base_uri": "https://localhost:8080/"} id="6iDwzXSgEFH9" outputId="90504416-f6b8-4a1b-ab66-e67f0e1b3bff"
f1_score(y_val,predicted_ada,average='macro')
# + colab={"base_uri": "https://localhost:8080/"} id="98G6dJev0iIz" outputId="8b856436-2dd7-4bac-e490-532ad904597b"
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.ensemble import VotingClassifier
kfold = model_selection.KFold(n_splits=10, random_state=seed)
# create the sub models
estimators = []
model1 = LogisticRegression()
estimators.append(('logistic', model1))
model2 = DecisionTreeClassifier(max_depth=30)
estimators.append(('cart', model2))
model3 = SVC()
estimators.append(('svm', model3))
# create the ensemble model
ensemble = VotingClassifier(estimators)
results = model_selection.cross_val_score(ensemble, X, y, cv=kfold)
print(results.mean())
# + colab={"base_uri": "https://localhost:8080/"} id="vzGI73p30-vp" outputId="548368f9-f085-44ca-8427-3de7c6ca2277"
ensemble.fit(X,y)
# + colab={"base_uri": "https://localhost:8080/"} id="vFoTfTp3841B" outputId="7d8bea05-b3dc-4a01-d22d-1937f94178cd"
X_stk_val
# + id="iObCJjkp7Os-"
predicted_ens = ensemble.predict(X_val)
# + colab={"base_uri": "https://localhost:8080/"} id="XjoJsY2T820m" outputId="c29e16f0-596f-409c-df8a-1dea42fba242"
ensemble.score(X_val,y_val)
# + colab={"base_uri": "https://localhost:8080/"} id="MgSRE5sU-WLY" outputId="ca9a7e0b-ac3b-4e71-b925-44e8e9b8ee77"
y_stk_val.shape
# + colab={"base_uri": "https://localhost:8080/"} id="hhWdi_G3-X3a" outputId="44223901-e491-4cf8-a240-394b973dd7b6"
predicted_ens.shape
# + colab={"base_uri": "https://localhost:8080/"} id="2EU4n9mO-Hty" outputId="bf43f2d9-4b8f-4b69-a72d-f7c2f9b66002"
f1_score(y_val,predicted_ens,average='macro')
# + colab={"base_uri": "https://localhost:8080/"} id="dNLulKLU-SDb" outputId="b30c3262-ea14-42ef-e6ec-5ae981363a60"
results
# + id="2q4FZ_lzBnIh"
# + id="o_6H967hBnFO"
# + id="HIjt_-SBBm_1"
# + id="ert0PPnWBmwK"
from sklearn.datasets import make_blobs
from sklearn.naive_bayes import GaussianNB
# + colab={"base_uri": "https://localhost:8080/"} id="KxWQbpK0Bq8E" outputId="a009600e-eca2-4fb2-e727-f0543b7d87d0"
model = GaussianNB()
model.fit(X,y)
# + colab={"base_uri": "https://localhost:8080/"} id="Xedi4Cd6BvtD" outputId="b6cffed5-74c8-4058-ae0d-0f693f789186"
model.score(X_val,y_val)
# + colab={"base_uri": "https://localhost:8080/"} id="Rx516V_xB4-f" outputId="41a23c24-c95f-4fe5-92c9-91c4c9df2534"
f1_score(y_val,model.predict(X_val),average='macro')
# + id="i9Rf0eR3COxo"
# + id="Sk3bIP4cC50L"
# + colab={"base_uri": "https://localhost:8080/", "height": 690} id="T8G8eN2ZC5xC" outputId="b7bd3452-3d51-4ce7-b5f8-0e9b2bcf128c"
# use mlp for prediction on multi-label classification
from numpy import asarray
from sklearn.datasets import make_multilabel_classification
from keras.models import Sequential
from keras.layers import Dense
def get_model(n_inputs, n_outputs):
model = Sequential()
model.add(Dense(20, input_dim=n_inputs, kernel_initializer='he_uniform', activation='relu'))
model.add(Dense(n_outputs, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam')
return model
n_inputs, n_outputs = X.shape[0], 3
# get model
model = get_model(n_inputs, n_outputs)
# fit the model on all data
model.fit(np.array(X).reshape(1,-1), np.array(y).reshape(1,-1), verbose=0, epochs=100)
# + colab={"base_uri": "https://localhost:8080/"} id="zh_s6ECGC5tP" outputId="bfc8eb17-b11a-4260-fa37-91c118659782"
y.shape
# + id="uHHv8_POC5p8"
| Untitled42.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3 (ipykernel)
# language: python
# name: python3
# ---
# First, go to https://www.nasdaq.com/market-activity/stocks/screener and download the CSV file to a local directory.
#
# Then, you're ready to run the following code to load the data into Beneath.
# + cell_id="00000-19fb5a92-cc34-456e-b3a1-86919341d821" deepnote_cell_type="code" deepnote_to_be_reexecuted=false execution_millis=151 execution_start=1624284595311 source_hash="197bf27c" tags=[]
import beneath
import pandas as pd
import numpy as np
# + cell_id="00001-c123bfa5-1bee-4290-8d5e-e4ed7b0f4efd" deepnote_cell_type="code" deepnote_to_be_reexecuted=false execution_millis=1811 execution_start=1624284669170 source_hash="e1e4cd4f" tags=[]
# !beneath auth SECRET
# + cell_id="00003-60da7cbd-3aef-476b-9eed-d60180ace0b9" deepnote_cell_type="code" deepnote_to_be_reexecuted=false execution_millis=12 execution_start=1624285680865 source_hash="9c2adef4" tags=[]
df = pd.read_csv("data/stock_symbols.csv")
# -
df = df.drop(['Last Sale', 'Net Change', '% Change', 'Market Cap', 'IPO Year', 'Volume'], axis=1)
df = df.rename(columns={"Symbol": "symbol", "Name": "name", "Sector": "sector", "Country": "country", "Industry": "industry"})
df = df.replace(np.nan, '', regex=True)
# + cell_id="00005-f51983fd-9eb8-4f29-882f-0d365a4b5b00" deepnote_cell_type="code" deepnote_to_be_reexecuted=false execution_millis=1479 execution_start=1624285686169 source_hash="2f85f526" tags=[]
DATE = "August 30th, 2021"
await beneath.write_full(
"examples/financial-reference-data/stock_symbols",
df,
key=["symbol"],
description=f"""
Stock symbols listed on the NASDAQ, NYSE, and AMEX exchanges. Pulled from the NASDAQ Stock Screener on {DATE}.
""",
recreate_on_schema_change=True,
)
# -
| examples/financial-reference-data/load_stock_symbols.ipynb |
# -*- coding: utf-8 -*-
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .r
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: R
# language: R
# name: ir
# ---
# # Validation d'un modèle de régression
# Lorsque nous avons une modèle de régression linéaire simple, l'évaluation de la qualité du modèle est relativement simple. Cependant, plus un modèle de régression est sophistiqué, plus il se pose la question de comment valider le modèle.
#
# Une régression est au final un modèle de prédiction ou d'estimation pour la variable dépendante sur la base des variables indépendantes. La meilleure façon d'évaluer la qualité du modèle est d'**évaluer sa capacité de faire des prédictions correctes sur la base de nouvelles données**. Ceci permet également d'éviter qu'un modèle puisse se baser sur le fait d'avoir déjà «vu» une donnée particulière et de l'utiliser pour la prédiction. Ceci porte le danger de faire une prédiction parfaite pour toutes les données connues, et de faire une mauvaise prédiction dans tous les autres cas. On dit alors que le modèle fait du **over-fitting** et qu'il **généralise mal** aux nouvelles données. C'est un problème avec tous les modèles de régression sophistiqués.
#
# La stratégie générale que nous pouvons adapter est la suivante: le jeu de données que nous avons au début est divisé en deux jeux:
#
# 1. un **jeu de données de calibration** pour déterminer les paramètres du modèle
# 2. un **jeu de données de test** pour déterminer la qualité du modèle au niveau de la capacité de prédiction
#
# Nous allons typiquement utiliser 80-90% du jeu de données initial pour la calibration du modèle, et le 10-20% restant pour la validation.
# Regardons comment on peut diviser un jeu de données initial en jeux de données de calibration et de test. Commençons par lire un fichier de données:
d = read.csv(file="ch-socioeco-typologie.tsv", sep="\t")
# Dans ce cas, nous utilisons 90% des données pour le jeu de données de calibration:
idx = sample(nrow(d), size=0.9*nrow(d))
dtrain = d[idx,]
dtest = d[-idx,]
# Les 90% sont spécifiés avec le `0.9` dans le paramètre `size`. Il faut évidemment encore ajuster le nom de la variable `d`.
# Pour pouvoir illustrer l'évaluation d'un modèle, nous devons d'abord en faire un. Prenons le [modèle de régression logistique de la semaine passée](../25-regression/regression-logistique.ipynb):
reglogit = glm(typologie_binaire ~ ADO + NADHO + NADRET + AD3PRIM + AD3SEC, family=binomial(link="logit"), data=dtrain)
# Notez que nous avons utilisé le jeu de données __`dtrain`__ et non `d`.
#
# Maintenant nous pouvons appliquer le modèle au jeu de données de test (`newdata=dtest`):
reglogit_predictions = predict(reglogit, newdata=dtest)
# Dans le cas d'une régression logistique, nous pouvons faire un **tableau simple avec le nombre de cas prédits correctement ou non**.
#
# Avec notre régression logistique binomiale, nous devons d'abord traduire la probabilité estimée en classes (`U` pour les centres urbains, `N` pour les autres), ce que nous pouvons faire avec une condition:
pred_classes = ifelse(reglogit_predictions > 0.5, 'U', 'N')
# Et maintenant nous pouvons dresser notre tableau de comparaison:
table(pred_classes, dtest$typologie_binaire)
# Notez que ce tableau est très similaire que nous avons déjà calculé la semaine passée, sauf que maintenant nous l'avons calculé sur le jeu de données de test.
#
# Et nous pouvons calculer la proportion de réponses justes:
sum(pred_classes == dtest$typologie_binaire) / nrow(dtest)
# ce qui nous donne 81% de réponses justes pour le jeu de données de test.
# Nous pouvons évidemment faire le même calcul pour le jeu de données de calibration:
pred_train = predict(reglogit, newdata=dtrain)
pred_train_classes = ifelse(pred_train > 0.5, 'U', 'N')
sum(pred_train_classes == dtrain$typologie_binaire) / nrow(dtrain)
# Dans la grande majorité des cas, la proportion de réponses justes est plus élevée pour le jeu de données de calibration. Ceci est normal étant donné que le modèle a pu être ajusté spécifiquement à ce jeu de données de calibrage. Par contre, c'est uniquement la proportion de réponses justes pour le jeu de données de test qui est véritablement importante.
# Pour les cas où la **variable dépendante est continue** (et non catégorielle), nous pouvons par exemple calculer l'erreur absolu moyen (Mean Absolute Error MAE) sur la base du jeu de données de test. Voici l'exemple de la régression linéaire de la semaine passée:
d2 = read.csv(file="../25-regression/data-zh-be.tsv", sep="\t")
idx = sample(nrow(d2), size=0.9*nrow(d2))
dtrain2 = d2[idx,]
dtest2 = d2[-idx,]
reglin = lm(PMSDIV ~ ADCFARM + PRPROT + PRCATH + PRJEW + PFGEN + PFBAC, data=dtrain2)
lm_pred = predict(reglin, newdata=dtest2)
# `lm_pred` contient maintenant les valeurs prédites pour le jeu de données test. Nous pouvons calculer l'erreur absolu moyen avec:
summary(abs(lm_pred - dtest2$PMSDIV))
# Nous avons donc un erreur moyen d'environ 64 personnes pour le nombre de personnes divorcées. L'erreur absolu médian quant à lui est d'environ 44 personnes.
#
# Est-ce que c'est beaucoup ou peu? Nous pouvons mettre en relation cette valeur avec le nombre de personnes divorcées:
erreur_relative = abs(lm_pred - dtest2$PMSDIV) / dtest2$PMSDIV
summary(erreur_relative)
# ce qui nous fait donc un erreur absolu moyen relatif d'environ 13.5%, et l'erreur absolu médian relatif d'environ 9.8%.
# ## Cross-validation (validation croisée)
# La méthode de validation présentée ci-dessus est très simple et facile à comprendre. Par contre, elle présente quelques problèmes:
#
# - en cas de petits jeux de données, réserver une bonne partie des données uniquement pour les tests peut être problématique
#
# - en raison de la sélection aléatoire du jeu de données de calibration et de test, chaque calcul du modèle donnera une erreur légèrement différente
#
# En conséquence, plusieurs méthodes alternatives ont été développées. La cross-validation est une telle alternative, qui est plutôt une famille de méthodes que d'une seule méthode, car il y a beaucoup de variantes qui existent. Nous allons nous limiter à deux cas, la ___«leave-one-out cross-validation»___ et la ___«k-fold cross-validation»___.
#
# Dans le cas de la **«leave-one-out cross-validation»**, on enlève une ligne du jeu de données, puis on calcule le modèle sur les données restante, et on calcule l'erreur d'estimation pour la ligne enlevée. On refait cette procédure pour chaque ligne, et on calcule l'erreur moyen.
#
# Dans le cas de la ___«k-fold cross-validation»___, on divise le jeu de données initial en $k$ partitions de taille égale. Une partition sert de jeu de validation et les autres $k-1$ partitions pour la calibration. Puis on refait la même procédure avec une autre partition pour la validation.
#
# Le principe reste au final le même que celui présenté plus haut.
#
# Nous n'allons pas calculer la validation croisée ici, mais il est une bonne chose de connaître à peu près le principe.
| 26-glm/2-validation-regr.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Jupyter Notebook 3: Disentanglement Scores, Latent Space Plots
# ## Dentate Gyrus Dataset
import scanpy as sc
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
import sys
import util_loss as ul
#import the package to use
import beta_vae
import dhsic_vae
from dentate_features import *
from all_obs_linear_classifier_package import *
import os,glob
# +
data = sc.read("./data/dentate_gyrus_normalized.h5ad")
#Adding more features
data.obs["seq_depth"] = np.sum(data.X,axis=1)
data.obs["exp_gene"] = np.count_nonzero(data.X.toarray(),axis=1)
min_dep = min(data.obs['seq_depth'])
data.obs["seq_depth"] = data.obs["seq_depth"] - min_dep
fac_seq = max(data.obs["seq_depth"])/10
data.obs['seq_depth'] = data.obs["seq_depth"]/fac_seq
data.obs['seq_depth'] = data.obs['seq_depth'].astype('int64')
data.obs['seq_depth'] = np.where(data.obs['seq_depth']==10, 9,data.obs['seq_depth'])
min_exp = min(data.obs['exp_gene'])
data.obs["exp_gene"] = data.obs["exp_gene"] - min_exp
fac_exp = max(data.obs["exp_gene"])/10
data.obs['exp_gene'] = data.obs["exp_gene"]/fac_exp
data.obs['exp_gene'] = data.obs['exp_gene'].astype('int64')
data.obs['exp_gene'] = np.where(data.obs['exp_gene']==10, 9,data.obs['exp_gene'])
print(data.obs)
# +
'''
Difference scores between features are calculated: 1st level
'''
# Restoring pre-trained models
os.chdir("./models_dentate/")
path = "latent5_alpha50_c30/"
scg_model = beta_vae.VAEArithKeras(x_dimension= data.shape[1],z_dimension=5,
alpha=5,c_max=30)
scg_model.restore_model()
print(scg_model)
observation = "4_observation" #a name to identify the score files
L = 20 #number of samples in a batch
B = 2 #number of batches
try:
os.makedirs(path+observation+"_disentangled_score/")
except OSError:
print ("Check if path %s already exists" % path)
else:
print ("Successfully created the directory ", path+observation+"_disentangled_score/")
for i in range(5):
df = feature_scores(model=scg_model,L=L,B=B,data=data)
print(df)
df.to_csv(path+observation+"_disentangled_score/matrix_all_dim"+str(i)+".csv",index=False)
# -
'''
Difference scores between features are are now classified
'''
os.chdir("/models_dentate/")
path = "latent5_alpha50_c30/"
observation="4_observation"
feature_classification(path=path,z_dim = 5,observation=observation)
# +
'''
Creating latent space plots for each feature and also
saving the latent space values for each feature
'''
from convert_to_latent_space import *
#observations = ["age(days)","clusters","exp_gene","seq_depth"]
observations = ["clusters"]
os.chdir("/models_dentate/")
path = "latent5_alpha50_c30/"
scg_model = beta_vae_5.C_VAEArithKeras(x_dimension= data.shape[1],z_dimension=5,model_to_use=path,
alpha=5,c_max=30)
scg_model.restore_model()
for obs in observations:
single_feature_to_latent(path=path,adata=data,feature=obs,model=scg_model,z_dim=5)
os.chdir("/models_dentate/")
# +
'''
Difference scores within features are calculated: 2nd level
It depends on the function 'single_feature_to_latent' used in the previous section.
'''
from latent_space_scores import *
os.chdir("/models_dentate/")
path = "latent5_alpha50_c30/"
observation = "clusters" #feature name to identify the score files
L = 20 #number of samples in a batch
B = 2 #number of batches
data = pd.read_csv(path+"cells_latent_"+observation+"/cells_in_latent.csv",index_col = 0)
#print(data)
try:
os.makedirs(path+observation+"_disentangled_score/")
except OSError:
print ("Check if path %s already exists" % path)
else:
print ("Successfully created the directory ", path+observation+"_disentangled_score/")
for i in range(2):
df = latent_space_scores(L=L,B=B,data=data)
print(df)
df.to_csv(path+observation+"_disentangled_score/matrix_all_dim"+str(i)+".csv",index=False)
# +
'''
Latent Space scores within feature is now classified
'''
os.chdir("/models_dentate/")
path = "latent5_alpha50_c30/"
feature_classification(path=path,z_dim = 5,observation="clusters") #keep changing the observation
# +
'''
Plot KL Divergence per dimension over epochs
'''
from kl_divergence_plot import *
os.chdir("/models_dentate/")
path = "latent5_alpha50_c30/"
plot_kl_loss(path=path,z_dim=5)
| JN3_dentate_analysis.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
import numpy as np
import matplotlib.pyplot as plt
import sys
import os
import re
from typing import List
from collections import defaultdict
training_text_filename = "paul_graham.txt"
training_raw_text = open(
training_text_filename,
'r',
encoding='utf-8')\
.read()\
.lower()
period_freqs = [len(x.split(" ")) for x in training_raw_text.split(".")]
comma_freqs = [len(x.split(" ")) for x in training_raw_text.split(",")]
# Alpha-numeric and spaces only
# We will re-add punctuation later via normal distributions
training_raw_text = re.sub("[^a-z0-9'\"\s]", "", training_raw_text)
# Remove duplicate sequential space characters
training_raw_text = re.sub("\s+", " ", training_raw_text)
def tokenize_string(input_text):
tokens = []
stop_words = set(open("stop_words.txt", "r").read().split('\n'))
pre_tokenized = input_text.split(" ")
# Prevents the next chunk from breaking when a stop word ends the data
while pre_tokenized[-1] in stop_words:
pre_tokenized = pre_tokenized[:-1]
for i in range(len(pre_tokenized)):
# Avoids duplication of words when grouping stop words with subsequent ones
if i != 0 and pre_tokenized[i-1] in stop_words:
continue
# Base case, no grouping needed
if pre_tokenized[i] not in stop_words:
tokens.append(pre_tokenized[i])
continue
# Group stop words with subsequent ones until the next word is no longer a stop word
j = i
while pre_tokenized[j] in stop_words:
j += 1
tokens.append(" ".join(pre_tokenized[i:j+1]))
return tokens
tokens = tokenize_string(training_raw_text)
print(tokens[:20])
len(set(tokens))
markov_model = defaultdict(dict)
# Must be sufficiently small enough to prevent over-fitting and large enough to prevent under-fitting
# If you see constantly repeated phrases, this value needs to be changed
input_window = 2
inputs, outputs = [], []
for i in range(len(tokens) - input_window):
# Using tuple since they are not mutable
context = tuple(tokens[i:i+input_window])
target = tokens[i+input_window]
if target not in markov_model[context]:
markov_model[context][target] = 0
markov_model[context][target] += 1
first_key = list(markov_model.keys())[0]
print(f"{' '.join(first_key)} -> {markov_model[first_key]}")
# Normalize probabilities and restructure model for prediction efficiency
for context, poss in markov_model.items():
total_freq = sum(list(poss.values()))
markov_model[context] = {target: freq / total_freq for target, freq in poss.items()}
markov_model = {context: tuple(zip(*list(poss.items()))) for context, poss in markov_model.items()}
print(f"{' '.join(first_key)} -> {markov_model[first_key]}")
seed_idx = np.random.randint(0, len(tokens) - input_window)
seed = tuple(tokens[i:i+input_window])
print("SEED:")
print(" ".join(seed))
print("GENERATED (first 20 words, no punctuation):")
full_randoms = 0
outputs = []
for _ in range(50):
if seed not in markov_model:
idx = np.random.randint(0, len(markov_model))
o = list(markov_model.keys())[idx]
full_randoms += 1
else:
o = tuple(np.random.choice(markov_model[seed][0], 1, p=markov_model[seed][1]).tolist())
# o = (list(markov_model[seed][0])[np.argmax(markov_model[seed][1])],)
if input_window == 1:
seed = tuple(*(list(seed)[1:] + list(o)))
else:
seed = tuple(list(seed)[1:] + list(o))
outputs.append(o)
# Splitting and joining here since the punctuation model cares about words not phrases
results = (" ".join([" ".join(phrase) for phrase in outputs])).split(" ")
print(" ".join(results[:20]))
print(f"{full_randoms} fully random selections")
p_mean, p_std = np.mean(period_freqs), np.std(period_freqs)
c_mean, c_std = np.mean(comma_freqs), np.std(comma_freqs)
idx = 0
stop_words = set(open("stop_words.txt", "r").read().split('\n'))
while True:
next_p = np.random.normal(p_mean, p_std, 1).round(0).astype(int)[0]
next_c = np.random.normal(c_mean, c_std, 1).round(0).astype(int)[0]
if next_p + idx >= len(results) or next_c + idx >= len(results):
results[-1] += "."
break
# Favoring shorter sentences
symb = ","
if next_p <= next_c:
idx += next_p
symb = "."
else:
idx += next_c
while results[idx] in stop_words and not idx >= len(results):
idx += 1
results[idx] += symb
print("Final results:")
print(" ".join(results))
| notebooks/markov_model_generation.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# **[Data Visualization: From Non-Coder to Coder Micro-Course Home Page](https://www.kaggle.com/learn/data-visualization-from-non-coder-to-coder)**
#
# ---
#
# In this tutorial, you'll learn how to create advanced **scatter plots**.
#
# # Set up the notebook
#
# As always, we begin by setting up the coding environment. (_This code is hidden, but you can un-hide it by clicking on the "Code" button immediately below this text, on the right._)
# + _kg_hide-input=true _kg_hide-output=true
import pandas as pd
import matplotlib.pyplot as plt
# %matplotlib inline
import seaborn as sns
print("Setup Complete")
# -
# # Load and examine the data
#
# We'll work with a (_synthetic_) dataset of insurance charges, to see if we can understand why some customers pay more than others.
#
# 
#
# If you like, you can read more about the dataset [here](https://www.kaggle.com/mirichoi0218/insurance/home).
# +
# Path of the file to read
insurance_filepath = "./input/insurance.csv"
# Read the file into a variable insurance_data
insurance_data = pd.read_csv(insurance_filepath)
# -
# As always, we check that the dataset loaded properly by printing the first five rows.
insurance_data.head()
# # Scatter plots
#
# To create a simple **scatter plot**, we use the `sns.scatterplot` command and specify the values for:
# - the horizontal x-axis (`x=insurance_data['bmi']`), and
# - the vertical y-axis (`y=insurance_data['charges']`).
sns.scatterplot(x=insurance_data['bmi'], y=insurance_data['charges'])
# The scatterplot above suggests that [body mass index](https://en.wikipedia.org/wiki/Body_mass_index) (BMI) and insurance charges are **positively correlated**, where customers with higher BMI typically also tend to pay more in insurance costs. (_This pattern makes sense, since high BMI is typically associated with higher risk of chronic disease._)
#
# To double-check the strength of this relationship, you might like to add a **regression line**, or the line that best fits the data. We do this by changing the command to `sns.regplot`.
sns.regplot(x=insurance_data['bmi'], y=insurance_data['charges'])
# # Color-coded scatter plots
#
# We can use scatter plots to display the relationships between (_not two, but..._) three variables! One way of doing this is by color-coding the points.
#
# For instance, to understand how smoking affects the relationship between BMI and insurance costs, we can color-code the points by `'smoker'`, and plot the other two columns (`'bmi'`, `'charges'`) on the axes.
sns.scatterplot(x=insurance_data['bmi'], y=insurance_data['charges'], hue=insurance_data['smoker'])
# This scatter plot shows that while nonsmokers to tend to pay slightly more with increasing BMI, smokers pay MUCH more.
#
# To further emphasize this fact, we can use the `sns.lmplot` command to add two regression lines, corresponding to smokers and nonsmokers. (_You'll notice that the regression line for smokers has a much steeper slope, relative to the line for nonsmokers!_)
sns.lmplot(x="bmi", y="charges", hue="smoker", data=insurance_data)
# The `sns.lmplot` command above works slightly differently than the commands you have learned about so far:
# - Instead of setting `x=insurance_data['bmi']` to select the `'bmi'` column in `insurance_data`, we set `x="bmi"` to specify the name of the column only.
# - Similarly, `y="charges"` and `hue="smoker"` also contain the names of columns.
# - We specify the dataset with `data=insurance_data`.
#
# Finally, there's one more plot that you'll learn about, that might look slightly different from how you're used to seeing scatter plots. Usually, we use scatter plots to highlight the relationship between two continuous variables (like `"bmi"` and `"charges"`). However, we can adapt the design of the scatter plot to feature a categorical variable (like `"smoker"`) on one of the main axes. We'll refer to this plot type as a **categorical scatter plot**, and we build it with the `sns.swarmplot` command.
sns.swarmplot(x=insurance_data['smoker'],
y=insurance_data['charges'])
# Among other things, this plot shows us that:
# - on average, non-smokers are charged less than smokers, and
# - the customers who pay the most are smokers; whereas the customers who pay the least are non-smokers.
#
# # What's next?
#
# Apply your new skills to solve a real-world scenario with a **[coding exercise](https://www.kaggle.com/kernels/fork/2951535)**!
# ---
# **[Data Visualization: From Non-Coder to Coder Micro-Course Home Page](https://www.kaggle.com/learn/data-visualization-from-non-coder-to-coder)**
#
#
| code/visualization/4_scatter-plots.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# ## Import packages
import pandas as pd
import numpy as np
import os
# ### Import data
# set path of the data
processed_data_path = os.path.join(os.path.pardir, 'data', 'processed')
train_data_path = os.path.join(processed_data_path, 'train.csv')
test_data_path = os.path.join(processed_data_path, 'test.csv')
train_df = pd.read_csv(train_data_path, index_col = 'PassengerId')
test_df = pd.read_csv(test_data_path, index_col = 'PassengerId')
# ## Prepare data
train_df.drop('Age_State', axis=1, inplace = True)
train_df.columns
# **Survived** is the target variable
test_df.info()
# We are to predict survival for passengers in test data
# matrix x contains traiing features while array y has the target variable
X = train_df.loc[:, 'Age':].to_numpy().astype('float')
y = train_df.Survived.ravel()
print(f"Shape of X: {X.shape}")
print(f"Shape of y: {y.shape}")
# split X into train and test data
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 42, test_size=.2)
print(f"The training data has {X_train.shape[0]} observations \nThe test data has {X_test.shape[0]} observations")
y_train.shape
np.mean(y_train)
np.mean(y_test)
# Check out class imbalance
from sklearn.dummy import DummyClassifier
model_dummy = DummyClassifier(strategy='most_frequent', random_state=0)
model_dummy.fit(X_train, y_train)
print(f"The score of the dummy model is {round((model_dummy.score(X_test, y_test)),2)}")
# The baseline model's accuracy is **59%**
from sklearn.metrics import accuracy_score, recall_score, precision_score, confusion_matrix
print(f"The accuracy score is {round(accuracy_score(y_test, model_dummy.predict(X_test)), 2)}")
# ## Kaggle submission preparation
test_df.drop('Age_State', axis=1, inplace = True)
test_X = test_df.to_numpy().astype('float')
# get predictions
predictions = model_dummy.predict(test_X)
submission_df = pd.DataFrame({"PassengerId": test_df.index, "Survived": predictions})
submission_df.head(3)
submission_data_path = os.path.join(os.path.pardir, 'data', 'external')
submission_file_path = os.path.join(submission_data_path, '01_dummy.csv')
submission_df.to_csv(submission_file_path, index=False)
def get_submission_file(model, filename):
test_X = test_df.to_numpy().astype('float')
# make predictions
predictions = model.predict(test_X)
# submission dataframe
submission_df = pd.DataFrame({"PassengerId": test_df.index, "Survived": predictions})
# submission file
submission_data_path = os.path.join(os.path.pardir, 'data', 'external')
submission_file_path = os.path.join(submission_data_path, filename)
# write to the file
submission_df.to_csv(submission_file_path, index=False)
# ## Logistic Regression
from sklearn.linear_model import LogisticRegression
model_1 = LogisticRegression(max_iter = 1000)
model_1.fit(X_train, y_train)
model_1.score(X_test, y_test)
y_pred = model_1.predict(X_test)
print(f"The accuracy of the model is {round(accuracy_score(y_test, model_1.predict(X_test)), 2)}")
print(f"The precision is {round(precision_score(y_test, y_pred), 2)}")
print(f"The recall is {round(recall_score(y_test, y_pred))}")
model_1.coef_
get_submission_file(model_1,'02_lr.csv')
# ## Hyperparameter optimization
model_2 = LogisticRegression(random_state=0, max_iter = 1500)
from sklearn.model_selection import GridSearchCV
parameters = {'C':[1.0, 10.0, 50.0, 100.0, 1000.0], 'penalty': ['l2']}
clf = GridSearchCV(model_2, param_grid=parameters, cv=3)
clf.fit(X_train, y_train)
# Fix the above error and generate the 3rd kaggle submission
get_submission_file(clf, '3_lr2.csv')
# ## Feature normalization and standardization
from sklearn.preprocessing import MinMaxScaler, StandardScaler
# #### Feature normalization
scaler = MinMaxScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_train_scaled[:,0].min(), X_train_scaled[:,0].max()
#normalize test data
X_test_scaled = scaler.fit_transform(X_test)
# #### Feature standardization
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.fit_transform(X_test)
# ### Create model after standardization
model_4 = LogisticRegression(random_state = 0, max_iter = 1500)
parameters = {'C':[1.0, 10.0, 50.0, 100.0, 1000.0], 'penalty': ['l2']}
clf = GridSearchCV(model_2, param_grid=parameters, cv=3)
clf.fit(X_train_scaled, y_train)
clf.best_score_
clf.score(X_test_scaled, y_test)
# ## Model persistence
# import pickle library
import pickle
# create file paths
model_file_path = os.path.join(os.path.pardir, 'models', 'lr_model.pkl')
scaler_file_path = os.path.join(os.path.pardir, 'models', 'lr_scaler.pkl')
# open the files to write
model_file_pickle = open(model_file_path, 'wb')
scaler_file_pickle = open(scaler_file_path, 'wb')
# persist the model and the scaler
pickle.dump(clf, model_file_pickle)
pickle.dump(scaler, scaler_file_pickle)
# close the file
model_file_pickle.close()
scaler_file_pickle.close()
# ## Load the persisted files
# open file in read mode
model_file_pickle = open(model_file_path, 'rb')
scaler_file_pickle = open(scaler_file_path, 'rb')
clf_loaded = pickle.load(model_file_pickle)
scaler_loaded = pickle.load(scaler_file_pickle)
# close the files
model_file_pickle.close()
scaler_file_pickle.close()
clf_loaded
scaler_loaded
# transform test data using loaded scaler object
X_test_scaled = scaler_loaded.fit_transform(X_test)
clf_loaded.score(X_test_scaled, y_test)
| notebooks/Building Predictive Models.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + [markdown] id="view-in-github" colab_type="text"
# <a href="https://colab.research.google.com/github/andrewwhite5/DS-Unit-1-Sprint-1-Dealing-With-Data/blob/master/module2-loadingdata/LS_DS_112_Loading_Data.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
# + [markdown] id="-c0vWATuQ_Dn" colab_type="text"
# # Lambda School Data Science - Loading, Cleaning and Visualizing Data
#
# Objectives for today:
# - Load data from multiple sources into a Python notebook
# - !curl method
# - CSV upload method
# - Create basic plots appropriate for different data types
# - Scatter Plot
# - Histogram
# - Density Plot
# - Pairplot
# - "Clean" a dataset using common Python libraries
# - Removing NaN values "Interpolation"
# + [markdown] id="grUNOP8RwWWt" colab_type="text"
# # Part 1 - Loading Data
#
# Data comes in many shapes and sizes - we'll start by loading tabular data, usually in csv format.
#
# Data set sources:
#
# - https://archive.ics.uci.edu/ml/datasets.html
# - https://github.com/awesomedata/awesome-public-datasets
# - https://registry.opendata.aws/ (beyond scope for now, but good to be aware of)
#
# Let's start with an example - [data about flags](https://archive.ics.uci.edu/ml/datasets/Flags).
# + [markdown] id="wxxBTeHUYs5a" colab_type="text"
# ## Lecture example - flag data
# + id="nc-iamjyRWwe" colab_type="code" outputId="1bc06497-ae46-4859-ab34-ea2d494a06c3" colab={"base_uri": "https://localhost:8080/", "height": 1000}
# Step 1 - find the actual file to download
# From navigating the page, clicking "Data Folder"
flag_data_url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/flags/flag.data'
# You can "shell out" in a notebook for more powerful tools
# https://jakevdp.github.io/PythonDataScienceHandbook/01.05-ipython-and-shell-commands.html
# Funny extension, but on inspection looks like a csv
# !curl https://archive.ics.uci.edu/ml/machine-learning-databases/flags/flag.data
# Extensions are just a norm! You have to inspect to be sure what something is
# + id="UKfOq1tlUvbZ" colab_type="code" colab={}
# Step 2 - load the data
# How to deal with a csv? 🐼
import pandas as pd
flag_data = pd.read_csv(flag_data_url)
# + id="exKPtcJyUyCX" colab_type="code" outputId="48d6997f-4278-4605-9a74-0e1efa90dba7" colab={"base_uri": "https://localhost:8080/", "height": 301}
# Step 3 - verify we've got *something*
flag_data.head()
# + id="rNmkv2g8VfAm" colab_type="code" outputId="2e2b7b54-5777-41d7-9681-d9da73063928" colab={"base_uri": "https://localhost:8080/", "height": 544}
# Step 4 - Looks a bit odd - verify that it is what we want
flag_data.count()
# + id="iqPEwx3aWBDR" colab_type="code" outputId="c60d0c07-11fb-4c38-e162-505cdb37ea33" colab={"base_uri": "https://localhost:8080/", "height": 114}
# !curl https://archive.ics.uci.edu/ml/machine-learning-databases/flags/flag.data | wc
# + id="5R1d1Ka2WHAY" colab_type="code" outputId="4ad52376-775c-4c0e-8c02-d5563fec6d8a" colab={"base_uri": "https://localhost:8080/", "height": 1000}
# So we have 193 observations with funny names, file has 194 rows
# Looks like the file has no header row, but read_csv assumes it does
help(pd.read_csv)
# + id="EiNiR6vExQUt" colab_type="code" colab={}
# ?pd.read_csv
# + id="oQP_BuKExQWE" colab_type="code" colab={}
??pd.read_csv
# + id="o-thnccIWTvc" colab_type="code" outputId="fd6197d1-2413-4b90-94f0-5a188737c349" colab={"base_uri": "https://localhost:8080/", "height": 301}
# Alright, we can pass header=None to fix this
flag_data = pd.read_csv(flag_data_url, header=None)
flag_data.head()
# + id="iG9ZOkSMWZ6D" colab_type="code" outputId="48366494-dc2f-4783-da6e-0e437fb70945" colab={"base_uri": "https://localhost:8080/", "height": 544}
flag_data.count()
# + id="gMcxnWbkWla1" colab_type="code" outputId="d1f73b12-83ac-480f-e216-e3d7e8b6ba93" colab={"base_uri": "https://localhost:8080/", "height": 544}
flag_data.isna().sum()
# + [markdown] id="AihdUkaDT8We" colab_type="text"
# ### Yes, but what does it *mean*?
#
# This data is fairly nice - it was "donated" and is already "clean" (no missing values). But there are no variable names - so we have to look at the codebook (also from the site).
#
# ```
# 1. name: Name of the country concerned
# 2. landmass: 1=N.America, 2=S.America, 3=Europe, 4=Africa, 4=Asia, 6=Oceania
# 3. zone: Geographic quadrant, based on Greenwich and the Equator; 1=NE, 2=SE, 3=SW, 4=NW
# 4. area: in thousands of square km
# 5. population: in round millions
# 6. language: 1=English, 2=Spanish, 3=French, 4=German, 5=Slavic, 6=Other Indo-European, 7=Chinese, 8=Arabic, 9=Japanese/Turkish/Finnish/Magyar, 10=Others
# 7. religion: 0=Catholic, 1=Other Christian, 2=Muslim, 3=Buddhist, 4=Hindu, 5=Ethnic, 6=Marxist, 7=Others
# 8. bars: Number of vertical bars in the flag
# 9. stripes: Number of horizontal stripes in the flag
# 10. colours: Number of different colours in the flag
# 11. red: 0 if red absent, 1 if red present in the flag
# 12. green: same for green
# 13. blue: same for blue
# 14. gold: same for gold (also yellow)
# 15. white: same for white
# 16. black: same for black
# 17. orange: same for orange (also brown)
# 18. mainhue: predominant colour in the flag (tie-breaks decided by taking the topmost hue, if that fails then the most central hue, and if that fails the leftmost hue)
# 19. circles: Number of circles in the flag
# 20. crosses: Number of (upright) crosses
# 21. saltires: Number of diagonal crosses
# 22. quarters: Number of quartered sections
# 23. sunstars: Number of sun or star symbols
# 24. crescent: 1 if a crescent moon symbol present, else 0
# 25. triangle: 1 if any triangles present, 0 otherwise
# 26. icon: 1 if an inanimate image present (e.g., a boat), otherwise 0
# 27. animate: 1 if an animate image (e.g., an eagle, a tree, a human hand) present, 0 otherwise
# 28. text: 1 if any letters or writing on the flag (e.g., a motto or slogan), 0 otherwise
# 29. topleft: colour in the top-left corner (moving right to decide tie-breaks)
# 30. botright: Colour in the bottom-left corner (moving left to decide tie-breaks)
# ```
#
# Exercise - read the help for `read_csv` and figure out how to load the data with the above variable names. One pitfall to note - with `header=None` pandas generated variable names starting from 0, but the above list starts from 1...
# + id="aDskc0FABPwf" colab_type="code" outputId="fb2235a9-510a-47db-d16c-19513491d7a5" colab={"base_uri": "https://localhost:8080/", "height": 401}
col_headers = ['name','landmass','zone','area','population','language','religion','bars','stripes','colours','red',
'green','blue','gold','white','black','orange','mainhue','circles','crosses','saltires','quarters',
'sunstars','crescent','triangle','icon','animate','text','topleft','botright']
flag_data = pd.read_csv(flag_data_url, header=None, names=col_headers)
flag_data.head()
# + id="gSzv6hj2CB7z" colab_type="code" outputId="13e09f2b-7cfd-40cb-a951-5e9491990a66" colab={"base_uri": "https://localhost:8080/", "height": 130}
flag_data.mask['language']
1 = 'English'
2 = 'Spanish'
3 = 'French'
4 = 'German'
5 = 'Slavic'
6 = 'Other Indo-European'
7 = 'Chinese'
8 = 'Arabic'
# + id="QAujUMYPC7n9" colab_type="code" outputId="6741c122-de3a-4174-ffc5-6ba3a4cb46aa" colab={"base_uri": "https://localhost:8080/", "height": 310}
flag_data['language'] = flag_data['language'].map[1='English', 2='Spanish', 3='French', 4='German', 5='Slavic', 6='Other Indo-European', 7='Chinese', 8='Arabic']
# + id="h5bn5uKQDlvJ" colab_type="code" outputId="fbbd1760-d43d-485f-cbc9-31d1c6da4901" colab={"base_uri": "https://localhost:8080/", "height": 698}
language = {
1 : 'English',
2 : 'Spanish',
3 : 'French',
4 : 'German',
5 : 'Slavic',
6 : 'ther Indo-European',
7 : 'Chinese',
8 : 'Arabic',
9 : 'Japanese/Turkish/Finnish/Magyar',
10 : 'Others'
}
flag_data1 = flag_data.copy()
flag_data1[5] = flag_data1[5].map(language)
flag_data1.head()
# + id="MG6Z5hPZKgEk" colab_type="code" outputId="579c1879-b520-4127-fa7b-df8beec05ebf" colab={"base_uri": "https://localhost:8080/", "height": 401}
di = {1:"English", 2:"Spanish", 3:"French", 4:"German", 5:"Slavic", 6:"Other Indo-European",
7:"Chinese", 8:"Arabic", 9:"Japanese/Turkish/Finnish/Magyar", 10:"Others"}
flag_data['language'] = flag_data.replace({"language": di})
flag_data.head()
# + [markdown] id="ObjOm2EjD3Fj" colab_type="text"
# ##Reading other CSV's
# + id="57JySbZuDtan" colab_type="code" colab={}
link1 = 'https://raw.githubusercontent.com/BJanota11/DS-Unit-1-Sprint-1-Dealing-With-Data/master/module2-loadingdata/drinks_with_regions.csv'
link2 = 'https://raw.githubusercontent.com/BJanota11/DS-Unit-1-Sprint-1-Dealing-With-Data/master/module2-loadingdata/drinks_with_regions_index.csv'
link3 = 'https://raw.githubusercontent.com/BJanota11/DS-Unit-1-Sprint-1-Dealing-With-Data/master/module2-loadingdata/drinks_with_regions_header.csv'
# + id="Vy1Q10yUEOik" colab_type="code" outputId="46fef61d-88ff-4a80-dcec-2a9b06faed7b" colab={"base_uri": "https://localhost:8080/", "height": 221}
df = pd.read_csv(link1)
print(df.shape)
df.head()
# + id="gLEI8Jj8EXEg" colab_type="code" outputId="c87d91eb-d78c-44f6-8065-14ee3a6774cb" colab={"base_uri": "https://localhost:8080/", "height": 221}
df = pd.read_csv(link2, index_col=0)
print(df.shape)
df.head()
# + id="9LEzJXrkEZCk" colab_type="code" outputId="0b0e1884-3e85-42c3-f327-bb2fe695539d" colab={"base_uri": "https://localhost:8080/", "height": 221}
df = pd.read_csv(link3, header=3) # Could also use "skiprows" instead of "header"
print(df.shape)
df.head()
# + [markdown] id="XUgOnmc_0kCL" colab_type="text"
# ## Loading from a local CSV to Google Colab
# + id="-4LA4cNO0ofq" colab_type="code" outputId="99f8de6f-b6f3-4a66-b2c9-807303878b79" colab={"resources": {"http://localhost:8080/nbextensions/google.colab/files.js": {"data": "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", "ok": true, "headers": [["content-type", "application/javascript"]], "status": 200, "status_text": ""}}, "base_uri": "https://localhost:8080/", "height": 41}
from google.colab import files
uploaded = files.upload()
# + [markdown] id="aI2oN4kj1uVQ" colab_type="text"
# # Part 2 - Basic Visualizations
# + [markdown] id="INqBGKRl88YD" colab_type="text"
# ## Basic Data Visualizations Using Matplotlib
# + id="6FsdkKuh8_Rz" colab_type="code" outputId="8bbcfe35-f460-43e8-c3e4-e24aa59c1e62" colab={"base_uri": "https://localhost:8080/", "height": 295}
import matplotlib.pyplot as plt
# Scatter Plot
plt.scatter(df.beer_servings, df.wine_servings)
plt.title('Wine Servings by Beer Servings')
plt.xlabel('Beer Servings')
plt.ylabel('Wine Servings')
plt.show()
# + id="huwUQ7zE9gkD" colab_type="code" outputId="7e763cf2-d9f1-42d3-e827-76917dd94878" colab={"base_uri": "https://localhost:8080/", "height": 269}
# Histogram
plt.hist(df.total_litres_of_pure_alcohol, bins=20);
# + id="CSmpwXQN9o8o" colab_type="code" colab={}
# Seaborn Density Plot
# + id="TMMJG5rQ-g_8" colab_type="code" outputId="1628e6f4-7527-49b3-8088-a268ad2b6aea" colab={"base_uri": "https://localhost:8080/", "height": 729}
# Seaborn Pairplot
import seaborn as sns
sns.pairplot(df);
# + [markdown] id="ipBQKbrl76gE" colab_type="text"
# ## Create the same basic Visualizations using Pandas
# + id="qWIO8zuhArEr" colab_type="code" colab={}
# Pandas Histogram - Look familiar?
# + id="zxEajNvjAvfB" colab_type="code" colab={}
# Pandas Scatterplot
# + id="XjR5i6A5A-kp" colab_type="code" colab={}
# Pandas Scatter Matrix - Usually doesn't look too great.
# + [markdown] id="tmJSfyXJ1x6f" colab_type="text"
# # Part 3 - Deal with Missing Values
# + [markdown] id="bH46YMHEDzpD" colab_type="text"
# ## Diagnose Missing Values
#
# Lets use the Adult Dataset from UCI. <https://github.com/ryanleeallred/datasets>
# + id="NyeZPpxRD1BA" colab_type="code" outputId="6d1e3142-f09c-42a2-c831-57e901ee11f2" colab={"base_uri": "https://localhost:8080/", "height": 420}
df = pd.read_csv('https://raw.githubusercontent.com/ryanleeallred/datasets/master/adult.csv', na_values='?')
print(df.shape)
df.head()
# + id="ODZNjrz4RsIT" colab_type="code" outputId="469467be-5d31-4ad4-af47-79b98aee2d81" colab={"base_uri": "https://localhost:8080/", "height": 289}
df.isna().sum()
# + id="DyOBwv6-Rvug" colab_type="code" outputId="7bc56f96-1e03-446e-bacd-45701e251b10" colab={"base_uri": "https://localhost:8080/", "height": 748}
df.country.value_counts()
# + id="7PUqZuNySp4w" colab_type="code" outputId="2af5e23a-ad2f-4538-b9f3-1e945966291d" colab={"base_uri": "https://localhost:8080/", "height": 170}
df.country.unique()
# + id="7tdMZNiZTE__" colab_type="code" outputId="415be7ab-b7d0-48d0-be58-f1c4862ca4b3" colab={"base_uri": "https://localhost:8080/", "height": 403}
df.dropna(subset=['country'], inplace=True)
df.shape
df.head()
# + [markdown] id="SYK5vXqt7zp1" colab_type="text"
# ## Fill Missing Values
# + id="32ltklnQ71A6" colab_type="code" outputId="61053654-0c9b-454f-ca32-fc171cfe86e7" colab={"base_uri": "https://localhost:8080/", "height": 273}
df.mode()
# + id="rmidez3vVLLU" colab_type="code" outputId="260e9c6b-a8ba-49dd-9144-ced519ce0a21" colab={"base_uri": "https://localhost:8080/", "height": 289}
df.fillna(df.mode())
df.isna().sum()
# + id="jjPPI4eHVeQC" colab_type="code" outputId="6175fb27-ee75-4ea5-aa3f-4096dd81f6c5" colab={"base_uri": "https://localhost:8080/", "height": 403}
df.head()
# + [markdown] id="nPbUK_cLY15U" colab_type="text"
# ## Your assignment - pick a dataset and do something like the above
#
# This is purposely open-ended - you can pick any data set you wish. It is highly advised you pick a dataset from UCI or a similar semi-clean source. You don't want the data that you're working with for this assignment to have any bigger issues than maybe not having headers or including missing values, etc.
#
# After you have chosen your dataset, do the following:
#
# - Import the dataset using the method that you are least comfortable with (!curl or CSV upload).
# - Make sure that your dataset has the number of rows and columns that you expect.
# - Make sure that your dataset has appropriate column names, rename them if necessary.
# - If your dataset uses markers like "?" to indicate missing values, replace them with NaNs during import.
# - Identify and fill missing values in your dataset (if any)
# - Don't worry about using methods more advanced than the `.fillna()` function for today.
# - Create one of each of the following plots using your dataset
# - Scatterplot
# - Histogram
# - Density Plot
# - Pairplot (note that pairplots will take a long time to load with large datasets or datasets with many columns)
#
# If you get that done and want to try more challenging or exotic things, go for it! Use documentation as illustrated above, and follow the 20-minute rule (that is - ask for help if you're stuck!).
#
# If you have loaded a few traditional datasets, see the following section for suggested stretch goals.
# + id="NJdISe69ZT7E" colab_type="code" colab={}
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
# %matplotlib inline
from sklearn.model_selection import train_test_split
# + id="8-3jGY5UXOOz" colab_type="code" outputId="7996c280-623f-4bb7-f9f0-fd9e6a392192" colab={"resources": {"http://localhost:8080/nbextensions/google.colab/files.js": {"data": "<KEY> "ok": true, "headers": [["content-type", "application/javascript"]], "status": 200, "status_text": ""}}, "base_uri": "https://localhost:8080/", "height": 75}
from google.colab import files
uploaded = files.upload()
# + id="p1G7QUtEaRf_" colab_type="code" colab={}
df = pd.read_csv('bridges.data.version1') # Storing cleveland CSV to pandas dataframe
# + id="zl2oNuI9gUAd" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 221} outputId="6f08ea68-9538-4327-b357-d440d8c33c93"
print(df.shape)
df.head()
# + id="PgmR7d7ny2nQ" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 669} outputId="4d20acad-5b6f-40fa-e968-a5bbdfc68b4e"
# Changing the names of the columns
col_headers = ['Identifier','River','Location','Year Erected','Purpose','Length','# of Lanes','Clear-G','T or D','Material','Span','Rel-L','Type']
bridgedf = pd.read_csv('bridges.data.version1', header=None, names=col_headers)
bridgedf.head(20)
# + id="fA_7_2ToA_WJ" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 255} outputId="0961fce3-b775-41f4-f3d3-241b6f91a56b"
bridgedf.isna().sum() # Checking for NaN -- appears that all missing values were filled in with "?"
# + id="v0RlmRbFBPN9" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 34} outputId="13bf814e-e03b-4f52-ceb2-353a3b1c5475"
bridgedf['Length'].value_counts()['?']
# + id="hzwA-b88DStm" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 34} outputId="0a30e8de-ebb5-4271-c8c2-4cbf25f5f91a"
bridgedf['Length'].value_counts()['?']
# + id="jAv353afEqup" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 297} outputId="36f19ee9-b687-4de0-e242-5cf170efe68b"
bridgedf.describe() # Can't find median/mean for Length because NaN values are classified as "?"
# + id="XiGuMV-2KAOY" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 669} outputId="0948cb9d-8241-490f-a111-07aa9c17cd23"
# Turn values in Length to ints and turn ? to NaN
bridgedf['Length'] = pd.to_numeric(bridgedf['Length'], errors='coerce')
# Turn values in # of Lanes to ints and turn ? to NaN
bridgedf['# of Lanes'] = pd.to_numeric(bridgedf['# of Lanes'], errors='coerce')
bridgedf.head(20)
# + id="9FtHPuYRP0uF" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 204} outputId="adb94646-900d-4561-fcab-67ff377bf4c7"
# Checking to make sure "?" values in # of Lanes were changed to NaN
bridgedf.tail()
# + id="jGoJ-sSJNKsh" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 359} outputId="949c01f0-46ea-4feb-fb26-040fc1e48a15"
# Replace all other "?" values with "NaN"
bridgedf = bridgedf.replace('?',np.NaN)
bridgedf.head(10)
# + id="KAdDwtXfK6ZW" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 297} outputId="0a374aa5-d5b5-4e8c-a580-353fac817282"
bridgedf.describe()
# + id="jKnj558kOmWy" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 255} outputId="ec6701f6-eda1-4d08-85b9-4fff84f3f763"
bridgedf.isnull().sum()
# + id="goEMXljDOZxz" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 204} outputId="d64cfe48-0dfc-4fff-fc66-630a610eafaa"
bridgedf.tail()
# + id="N3spmIbPLAmS" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 359} outputId="530df7e2-12c7-4296-dac4-588202d41dce"
# Length column: Fill in NaN values with mean -- mean and median appear to be the same
bridgedf['Length'] = bridgedf['Length'].fillna(bridgedf['Length'].mean())
# # of Lanes column: Fill in NaN values with mean
bridgedf['# of Lanes'] = bridgedf['# of Lanes'].fillna(bridgedf['# of Lanes'].mean())
# Other columns: Fill in NaN values with value above -- there are missing values at the bottom of the dataframe, but not at the top
bridgedf = bridgedf.fillna(method = 'ffill')
bridgedf.head(10)
# + id="9d8VabV4HVJK" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 255} outputId="30591649-2060-450b-a7a4-991125193c4f"
# Check to make sure all NaN values were filled
bridgedf.isna().sum()
# + [markdown] id="MUvI5e3fQ3jW" colab_type="text"
# ##Scatterplot
# + id="9xjRi8v_QnTA" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 295} outputId="08c67ee6-d936-47f1-f2fd-14a2d414b476"
# Since there are only 107 total values and 27 of those were filled with the mean, you can see a clear line where those values were filled in
plt.scatter(bridgedf['Year Erected'], bridgedf['Length'])
plt.title('Length of Bridges by Year Erected')bridgedf['Length']
plt.xlabel('Year Erected')
plt.ylabel('Length')
plt.show()
# + [markdown] id="0QsfKvrkSHyt" colab_type="text"
# ##Histogram
# + id="I6zoXWDQSCjw" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 295} outputId="6a762979-716f-455f-a7e6-6b48b11178d2"
plt.hist(bridgedf['Type'], stacked=True)
plt.title('Bridge Types Erected')
plt.xlabel('Bridge Type')
plt.ylabel('Number of Bridges')
bridgedf['Type'].hist;
# + [markdown] id="tBAt7OkISL3V" colab_type="text"
# ## Density Plot
# + id="NlsI3AXiSK9U" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 617} outputId="6e7a1c4b-0e53-4243-c3c8-2a40502439cf"
sns.distplot(bridgedf['Length'], hist=True, kde=True, bins=int(50), color = 'green', hist_kws={'edgecolor':'black'}, kde_kws={'linewidth': 3})
sns.set(rc={'figure.figsize':(20,10)});
# + [markdown] id="jXv4cF-SSMPC" colab_type="text"
# ## Pairplot
# + id="CoP-LP6aVOqY" colab_type="code" colab={}
??sns.pairplot()
# + id="7gEJxDUNVCfZ" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 1000} outputId="bc514f83-45d1-46ab-d47e-5eb6e3124ccc"
sns.pairplot(bridgedf)
# + id="JYk-Y9FeSLjl" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 323} outputId="1f0b54e3-60c3-4199-c3b3-12ac2c6bc27e"
# It appears I can't specify the columns I want to use
sns.pairplot(bridgedf['Year Erected'],bridgedf['Length'],bridgedf['# of Lanes'])
# + [markdown] id="MZCxTwKuReV9" colab_type="text"
# ## Stretch Goals - Other types and sources of data
#
# Not all data comes in a nice single file - for example, image classification involves handling lots of image files. You still will probably want labels for them, so you may have tabular data in addition to the image blobs - and the images may be reduced in resolution and even fit in a regular csv as a bunch of numbers.
#
# If you're interested in natural language processing and analyzing text, that is another example where, while it can be put in a csv, you may end up loading much larger raw data and generating features that can then be thought of in a more standard tabular fashion.
#
# Overall you will in the course of learning data science deal with loading data in a variety of ways. Another common way to get data is from a database - most modern applications are backed by one or more databases, which you can query to get data to analyze. We'll cover this more in our data engineering unit.
#
# How does data get in the database? Most applications generate logs - text files with lots and lots of records of each use of the application. Databases are often populated based on these files, but in some situations you may directly analyze log files. The usual way to do this is with command line (Unix) tools - command lines are intimidating, so don't expect to learn them all at once, but depending on your interests it can be useful to practice.
#
# One last major source of data is APIs: https://github.com/toddmotto/public-apis
#
# API stands for Application Programming Interface, and while originally meant e.g. the way an application interfaced with the GUI or other aspects of an operating system, now it largely refers to online services that let you query and retrieve data. You can essentially think of most of them as "somebody else's database" - you have (usually limited) access.
#
# *Stretch goal* - research one of the above extended forms of data/data loading. See if you can get a basic example working in a notebook. Image, text, or (public) APIs are probably more tractable - databases are interesting, but there aren't many publicly accessible and they require a great deal of setup.
# + id="f4QP6--JBXNK" colab_type="code" colab={}
| module2-loadingdata/LS_DS_112_Loading_Data.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
import requests
from time import sleep
import pandas as pd
GOOGLE_MAPS_API_URL = 'https://maps.googleapis.com/maps/api/geocode/json'
params = {
'address': '',
'sensor': 'false',
'region': 'br',
'key':'[API-KEY]'
}
# +
df = pd.read_csv('data/UBS-no-DF-abril-2018.csv')
for index, row in df.iterrows():
params['address'] = row['ENDEREÇO DA UNIDADE']
req = requests.get(GOOGLE_MAPS_API_URL, params=params)
res = req.json()
try:
print(res['results'][0]['geometry']['location']['lat'],',',res['results'][0]['geometry']['location']['lng'])
except:
print(res)
sleep(0.5)
# -
| geocode ubs.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 2
# language: python
# name: python2
# ---
% matplotlib notebook
import matplotlib.pyplot as plt
import numpy as np
import pandas
import torch, torch.utils.data, torchvision
import PIL
import os.path
import time
import skimage, skimage.io
import time
import copy
from my_utils import *
MEAN = [0.485, 0.456, 0.406] # expected by pretrained resnet18
STD = [0.229, 0.224, 0.225] # expected by pretrained resnet18
# # Full model
# load the data and add a column for occurrences
df = pandas.read_csv('./data/train.csv')
grouped = df.groupby('Id')
df['occurrences'] = grouped.Id.transform('count')
# define transformations with data augmentation.
# These are the same transformations that were used for the toy_model
transforms_augm = torchvision.transforms.Compose([
torchvision.transforms.RandomRotation(degrees=20.0), # Data augmentation
torchvision.transforms.RandomGrayscale(), # Data augmentation
# torchvision.transforms.Resize((224,int(224.0*16.0/9.0))),
torchvision.transforms.Resize((224,224)),
torchvision.transforms.ToTensor(), # Expected by pretrained neural network
torchvision.transforms.Normalize(MEAN, STD) # Expected by pretrained neural network
])
# Load the full dataset. Using a random subset as the validation set is difficult because
# many of the categories appear only a single time. I could try to use cross-validation instead,
# but for the moment I am just going to ignore the validation set.
full_data = WhaleDataset(df,'./data/',transform=transforms_augm)
full_dataloader = {'train': torch.utils.data.DataLoader(full_data,\
batch_size=4,\
num_workers=4,\
shuffle=True,\
sampler=None)}
# load the toy_model
toy_model = torch.load('./toy_model_all_layers_trained.pt')
print toy_model.fc
# +
# Create the full model from the toy nodel by replacing the last layer
full_model = copy.deepcopy(toy_model)
# freeze layers
for params in full_model.parameters():
params.requires_grad == False
# Create new final layer (unfrozen by default)
num_in = full_model.fc.in_features
num_out = len(full_dataloader['train'].dataset.categories)
full_model.fc = torch.nn.Linear(num_in,num_out)
# define the device
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
full_model.to(device)
print full_model.fc
# -
# Choose the loss function (criterion) and optimizer.
# I make the same choice as for the toy_model.
criterion = torch.nn.CrossEntropyLoss()
full_optimizer = torch.optim.Adam(full_model.fc.parameters(),lr=0.001)
# train the full model
full_model, loss_vals, acc_vals = train_with_restart(
full_model,full_dataloader,criterion,full_optimizer,device,\
use_val=False,num_epochs=30)
torch.save(full_model,'full_model.pt')
plt.figure()
plt.plot(range(1,31),loss_vals['train'],'-k')
plt.xlabel('Epoch')
plt.ylabel('Training Loss')
# Maybe I should increase the periodicity of the restarts a bit.
| full_model.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Introduction to numpy
# This material is inspired from different source:
#
# * https://github.com/SciTools/courses
# * https://github.com/paris-saclay-cds/python-workshop/blob/master/Day_1_Scientific_Python/01-numpy-introduction.ipynb
# ### Difference between python list and numpy array
# Python offers some data containers to store data. Lists are generally used since they allow for flexibility.
x = [i for i in range(10)]
x
# At a first glance, numpy array seems to offer the same capabilities.
import numpy as np
x = np.arange(10)
x
# To find the difference, we need to focus on the low-level implementation of these two containers.
#
# A python list is a contiguous array in memory containing the references to the stored object. It allows for instance to store different data type object within the same list.
x = [1, 2.0, 'three']
x
print('The type of x is: {}'.format(x))
for idx, elt in enumerate(x):
print('The type of the {}-ith element is" {}'.format(idx, type(elt)))
# Numpy arrays, however, are directly storing the typed-data. Therefore, they are not meant to be used with mix type.
x = np.arange(3)
print('The type of x is: {}'.format(type(x)))
print('The data type of x is: {}'.format(x.dtype))
# ### Create numpy array
# Try out some of these ways of creating NumPy arrays. See if you can produce:
#
# * a NumPy array from a list of numbers,
# * a 3-dimensional NumPy array filled with a constant value -- either 0 or 1,
# * a NumPy array filled with a constant value -- not 0 or 1. (Hint: this can be achieved using the last array you created, or you could use np.empty and find a way of filling the array with a constant value),
# * a NumPy array of 8 elements with a range of values starting from 0 and a spacing of 3 between each element, and
# * a NumPy array of 10 elements that are logarithmically spaced.
#
# How could you change the shape of the 8-element array you created previously to have shape (2, 2, 2)? Hint: this can be done without creating a new array.
# ### Indexing
# Note that the NumPy arrays are zero-indexed:
data = np.random.randn(10000, 5)
data[0, 0]
# It means that that the third element in the first row has an index of [0, 2]:
data[0, 2]
# We can also assign the element with a new value:
data[0, 2] = 100.
print(data[0, 2])
# NumPy (and Python in general) checks the bounds of the array:
print(data.shape)
data[60, 10]
# Finally, we can ask for several elements at once:
data[0, [0, 3]]
# You can even pass a negative index. It will go from the end of the array.
data[-1, -1]
data[data.shape[0] - 1, data.shape[1] - 1]
# ### Slices
# You can select ranges of elements using slices. To select first two columns from the first row, you can use:
data[0, 0:2]
# Note that the returned array does not include third column (with index 2).
#
# You can skip the first or last index (which means, take the values from the beginning or to the end):
data[0, :2]
# If you omit both indices in the slice leaving out only the colon (:), you will get all columns of this row:
data[0, :]
# ### Filtering data
data
# We can produce a boolean array when using comparison operators.
data > 0
# This mask can be used to select some specific data.
data[data > 0]
# It can also be used to affect some new values
data[data > 0] = np.inf
data
# Answer the following quizz:
#
# * Print the element in the $1^{st}$ row and $10^{th}$ cloumn of the data.
# * Print the elements in the $3^{rd}$ row and columns of $3^{rd}$ and $15^{th}$.
# * Print the elements in the $4^{th}$ row and columns from $3^{rd}$ t0 $15^{th}$.
# * Print all the elements in column $15$ which their value is above 0.
data = np.random.randn(20, 20)
# ### Broadcasting
# Broadcasting applies these three rules:
#
# * If the two arrays differ in their number of dimensions, the shape of the array with fewer dimensions is padded with ones on its leading (left) side.
#
# * If the shape of the two arrays does not match in any dimension, either array with shape equal to 1 in a given dimension is stretched to match the other shape.
#
# * If in any dimension the sizes disagree and neither has shape equal to 1, an error is raised.
#
# Note that all of this happens without ever actually creating the expanded arrays in memory! This broadcasting behavior is in practice enormously powerful, especially given that when NumPy broadcasts to create new dimensions or to 'stretch' existing ones, it doesn't actually duplicate the data. In the example above the operation is carried out as if the scalar 1.5 was a 1D array with 1.5 in all of its entries, but no actual array is ever created. This can save lots of memory in cases when the arrays in question are large. As such this can have significant performance implications.
# <img src="broadcasting.png">
# Replicate the above exercises. In addition, how would you make the matrix multiplication between 2 matrices.
X = np.random.random((1, 3))
Y = np.random.random((3, 5))
# ### Views on Arrays
#
# NumPy attempts to not make copies of arrays. Many NumPy operations will produce a reference to an existing array, known as a "view", instead of making a whole new array. For example, indexing and reshaping provide a view of the same memory wherever possible.
#
# +
arr = np.arange(8)
arr_view = arr.reshape(2, 4)
# Print the "view" array from reshape.
print('Before\n', arr_view)
# Update the first element of the original array.
arr[0] = 1000
# Print the "view" array from reshape again,
# noticing the first value has changed.
print('After\n', arr_view)
# -
# What this means is that if one array (`arr`) is modified, the other (`arr_view`) will also be updated : the same memory is being shared. This is a valuable tool which enables the system memory overhead to be managed, which is particularly useful when handling lots of large arrays. The lack of copying allows for very efficient vectorized operations.
#
# Remember, this behaviour is automatic in most of NumPy, so it requires some consideration in your code, it can lead to some bugs that are hard to track down. For example, if you are changing some elements of an array that you are using elsewhere, you may want to explicitly copy that array before making changes. If in doubt, you can always copy the data to a different block of memory with the copy() method.
#
# For example:
# +
arr = np.arange(8)
arr_view = arr.reshape(2, 4).copy()
# Print the "view" array from reshape.
print('Before\n', arr_view)
# Update the first element of the original array.
arr[0] = 1000
# Print the "view" array from reshape again,
# noticing the first value has changed.
print('After\n', arr_view)
# -
# ### Final exercise
def trapz_slow(x, y):
area = 0.
for i in range(1, len(x)):
area += (x[i] - x[i-1]) * (y[i] + y[i-1])
return area / 2
# #### Part 1
#
# Create two arrays $x$
# and $y$, where $x$ is a linearly spaced array in the interval $[0,3]$ of length 3000, and y represents the function $f(x)=x^2$ sampled at $x$
#
# #### Part 2
#
# Use indexing (not a for loop) to find the 10 values representing $y_i+y_{i−1}$
# for i between 1 and 11.
#
# Hint: What indexing would be needed to get all but the last element of the 1d array `y`. Similarly what indexing would be needed to get all but the first element of a 1d array.
#
# #### Part 3
#
# Write a function `trapz(x, y)`, that applies the trapezoid formula to pre-computed values, where x and y are 1-d arrays. The function should not use a for loop.
#
# #### Part 4
#
# Verify that your function is correct by using the arrays created in #1 as input to trapz. Your answer should be a close approximation of $\sum 30 x^2$ which is 9
#
# #### Part 5 (extension)
#
# `numpy` and `scipy.integrate` provide many common integration schemes. Find the documentation for NumPy's own version of the trapezoidal integration scheme and check its result with your own.
| 01_numpy/notebook.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
import altair as alt
movies = 'https://vega.github.io/vega-datasets/data/movies.json'
# +
import altair as alt
movies = 'https://vega.github.io/vega-datasets/data/movies.json'
###These events describe a click-and-drag with or without shift key
require_shift='[mousedown[event.shiftKey], mouseup] > mousemove'
require_noshift = '[mousedown[!event.shiftKey], mouseup] > mousemove'
#Highlighting the selection interval works when you change the 'require_shift' to 'require_noshift'
highlight = alt.selection_interval(on=require_shift)
#Highlighting the selection interval works when you change the 'require_shift' to 'require_noshift'
selector = alt.selection_interval(translate=require_noshift, bind='scales')
alt.Chart(movies).mark_circle().add_selection(selector).add_selection(highlight).encode(
x='Rotten_Tomatoes_Rating:Q',
y=alt.Y('IMDB_Rating:Q', axis=alt.Axis(minExtent=30)), # use min extent to stabilize axis title placement
).properties(
width=600,
height=400
)
# -
| scrapbook_code/for_github.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# %matplotlib inline
#
# ================================================================
# Compute sparse inverse solution with mixed norm: MxNE and irMxNE
# ================================================================
#
# Runs an (ir)MxNE (L1/L2 [1]_ or L0.5/L2 [2]_ mixed norm) inverse solver.
# L0.5/L2 is done with irMxNE which allows for sparser
# source estimates with less amplitude bias due to the non-convexity
# of the L0.5/L2 mixed norm penalty.
#
# References
# ----------
# .. [1] <NAME>., <NAME>. and <NAME>.
# "Mixed-norm estimates for the M/EEG inverse problem using accelerated
# gradient methods", Physics in Medicine and Biology, 2012.
# https://doi.org/10.1088/0031-9155/57/7/1937.
#
# .. [2] <NAME>., <NAME>., and <NAME>.
# "Improved MEG/EEG source localization with reweighted mixed-norms",
# 4th International Workshop on Pattern Recognition in Neuroimaging,
# Tuebingen, 2014. 10.1109/PRNI.2014.6858545
#
# +
# Author: <NAME> <<EMAIL>>
# <NAME> <<EMAIL>>
#
# License: BSD (3-clause)
import numpy as np
import mne
from mne.datasets import sample
from mne.inverse_sparse import mixed_norm, make_stc_from_dipoles
from mne.minimum_norm import make_inverse_operator, apply_inverse
from mne.viz import (plot_sparse_source_estimates,
plot_dipole_locations, plot_dipole_amplitudes)
print(__doc__)
data_path = sample.data_path()
fwd_fname = data_path + '/MEG/sample/sample_audvis-meg-eeg-oct-6-fwd.fif'
ave_fname = data_path + '/MEG/sample/sample_audvis-ave.fif'
cov_fname = data_path + '/MEG/sample/sample_audvis-shrunk-cov.fif'
subjects_dir = data_path + '/subjects'
# Read noise covariance matrix
cov = mne.read_cov(cov_fname)
# Handling average file
condition = 'Left Auditory'
evoked = mne.read_evokeds(ave_fname, condition=condition, baseline=(None, 0))
evoked.crop(tmin=0, tmax=0.3)
# Handling forward solution
forward = mne.read_forward_solution(fwd_fname)
# -
# Run solver
#
#
# +
alpha = 55 # regularization parameter between 0 and 100 (100 is high)
loose, depth = 0.2, 0.9 # loose orientation & depth weighting
n_mxne_iter = 10 # if > 1 use L0.5/L2 reweighted mixed norm solver
# if n_mxne_iter > 1 dSPM weighting can be avoided.
# Compute dSPM solution to be used as weights in MxNE
inverse_operator = make_inverse_operator(evoked.info, forward, cov,
depth=depth, fixed=True,
use_cps=True)
stc_dspm = apply_inverse(evoked, inverse_operator, lambda2=1. / 9.,
method='dSPM')
# Compute (ir)MxNE inverse solution with dipole output
dipoles, residual = mixed_norm(
evoked, forward, cov, alpha, loose=loose, depth=depth, maxit=3000,
tol=1e-4, active_set_size=10, debias=True, weights=stc_dspm,
weights_min=8., n_mxne_iter=n_mxne_iter, return_residual=True,
return_as_dipoles=True)
# -
# Plot dipole activations
#
#
# +
plot_dipole_amplitudes(dipoles)
# Plot dipole location of the strongest dipole with MRI slices
idx = np.argmax([np.max(np.abs(dip.amplitude)) for dip in dipoles])
plot_dipole_locations(dipoles[idx], forward['mri_head_t'], 'sample',
subjects_dir=subjects_dir, mode='orthoview',
idx='amplitude')
# Plot dipole locations of all dipoles with MRI slices
for dip in dipoles:
plot_dipole_locations(dip, forward['mri_head_t'], 'sample',
subjects_dir=subjects_dir, mode='orthoview',
idx='amplitude')
# -
# Plot residual
#
#
ylim = dict(eeg=[-10, 10], grad=[-400, 400], mag=[-600, 600])
evoked.pick_types(meg=True, eeg=True, exclude='bads')
evoked.plot(ylim=ylim, proj=True, time_unit='s')
residual.pick_types(meg=True, eeg=True, exclude='bads')
residual.plot(ylim=ylim, proj=True, time_unit='s')
# Generate stc from dipoles
#
#
stc = make_stc_from_dipoles(dipoles, forward['src'])
# View in 2D and 3D ("glass" brain like 3D plot)
#
#
solver = "MxNE" if n_mxne_iter == 1 else "irMxNE"
plot_sparse_source_estimates(forward['src'], stc, bgcolor=(1, 1, 1),
fig_name="%s (cond %s)" % (solver, condition),
opacity=0.1)
# Morph onto fsaverage brain and view
#
#
# +
morph = mne.compute_source_morph(stc, subject_from='sample',
subject_to='fsaverage', spacing=None,
sparse=True, subjects_dir=subjects_dir)
stc_fsaverage = morph.apply(stc)
src_fsaverage_fname = subjects_dir + '/fsaverage/bem/fsaverage-ico-5-src.fif'
src_fsaverage = mne.read_source_spaces(src_fsaverage_fname)
plot_sparse_source_estimates(src_fsaverage, stc_fsaverage, bgcolor=(1, 1, 1),
fig_name="Morphed %s (cond %s)" % (solver,
condition), opacity=0.1)
| dev/_downloads/075ba1175413b0aa0dc66e721f312729/plot_mixed_norm_inverse.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Probabilistic Multiple Cracking Model of Brittle-Matrix Composite: One-by-One Crack Tracing Algorithm
#
#
#
# Annotated version of an algorithm implementation published in [citation and link will be added upon paper publication]
# %matplotlib notebook
import numpy as np
from scipy.optimize import newton
import matplotlib.pylab as plt
# + hide_input=true language="html"
# <style>
# .output_wrapper button.btn.btn-default,
# .output_wrapper .ui-dialog-titlebar {
# display: none;
# }
# </style>
# -
# ## Crack bridge
#
# This example uses the crack bridge model with a single fiber.
# Given a constant bond-slip law, the stress and strain distribution in the crack vicinity
# (a) has the profiles (b,c) 
# ### Material parameters
# | Symbol | Unit | Description
# | :-: | :-: | :- |
# | $E_\mathrm{m}$ | MPa | Elastic modulus of matrix |
# | $E_\mathrm{f}$ | MPa | Elastic modulus of reinforcement |
# | $V_\mathrm{f}$ |- | reinforcement ratio |
# | $T$ | N/mm$^3$ | Bond intensity |
# | $\sigma_\mathrm{cu}$ | MPa | Composite strength |
# | $\sigma_\mathrm{mu}$ | MPa | Scale parameter of matrix strength distribution |
# | $m$ | - | Weibull modulus |
# | $L$ | [mm] | Specimen length |
# | $n_\mathrm{points}$ | - | Number of discretization points |
#
# The following initial values of material parameters are defined to globally defined variables used in the algorithm. They can be modified and the notebook can be subsequently run from top again.
Em=25e3 # [MPa] matrix modulus
Ef=180e3 # [MPa] fiber modulus
vf=0.01 # reinforcement ratio
T=12. # bond intensity
sig_cu=10.0 # [MPa] composite strength
sig_mu=3.0 # [MPa] matrix strength
m=10000 # Weibull shape modulus
# ### Calculation of matrix stress and fiber strain profiles
#
# The one-by-one crack tracing algorithm requires a crack bridge model delivering two field variables centered at a crack bridge:
#
# - returning the matrix stress profile, and
# - reinforcement strain profile.
#
# Alternatively, instead of $\varepsilon_\mathrm{f}$, crack opening can be used to evaluate the nominal composite strain $\varepsilon_\mathrm{c}$ as described in the paper.
# +
def get_sig_m(z, sig_c): # matrix stress (*\label{sig_m}*)
sig_m = np.minimum(z * T * vf / (1 - vf), Em * sig_c / (vf * Ef + (1 - vf) * Em))
return sig_m
def get_eps_f(z, sig_c): # reinforcement strain (*\label{sig_f}*)
sig_m = get_sig_m(z, sig_c)
eps_f = (sig_c - sig_m * (1 - vf)) / vf / Ef
return eps_f
# -
# ## Tensile test modeled as evolving chain of crack bridges
#
# Subsidiary methods required to integrate the state fields along the tensile test specimen
# ### Update the distances $z$ of material points $x$ to a nearest cracks $x_K$
#
# Distance of a global points $x$ from a nearest crack stored as a field variable $z(x)$.
def get_z_x(x, XK): # distance to the closest crack (*\label{get_z_x}*)
z_grid = np.abs(x[:, np.newaxis] - np.array(XK)[np.newaxis, :])
return np.amin(z_grid, axis=1)
# ### Find the load factor needed to trigger a crack in all material points
#
# For each point $x$, solve a non-linear equation delivering the crack-initiation load, accounting for arbitrary type of bond-slip law at the level of the crack-bridge model.
import warnings # import exceptions
warnings.filterwarnings("error", category=RuntimeWarning)
def get_sig_c_z(sig_mu, z, sig_c_pre):
# crack initiating load at a material element
fun = lambda sig_c: sig_mu - get_sig_m(z, sig_c)
try: # search for the local crack load level
return newton(fun, sig_c_pre)
except (RuntimeWarning, RuntimeError):
# solution not found (shielded zone) return the ultimate composite strength
return sig_cu
# ### Identify the next crack position and corresponding composite stress
#
# Find the smallest load factor along the specimen. Return the corresponding composite stress and the crack position $y$.
def get_sig_c_K(z_x, x, sig_c_pre, sig_mu_x):
# crack initiating loads over the whole specimen
get_sig_c_x = np.vectorize(get_sig_c_z)
sig_c_x = get_sig_c_x(sig_mu_x, z_x, sig_c_pre)
y_idx = np.argmin(sig_c_x)
return sig_c_x[y_idx], x[y_idx]
# ## Crack tracing algorithm
#
# Define a function identifying the cracks one-by-one and recording the composite response.
n_x=5000
L_x=500
def get_cracking_history(update_progress=None):
x = np.linspace(0, L_x, n_x) # specimen discretization (*\label{discrete}*)
sig_mu_x = sig_mu * np.random.weibull(m, size=n_x) # matrix strength (*\label{m_strength}*)
Ec = Em * (1-vf) + Ef*vf # [MPa] mixture rule
XK = [] # recording the crack postions
sig_c_K = [0.] # recording the crack initating loads
eps_c_K = [0.] # recording the composite strains
CS = [L_x, L_x/2] # crack spacing
sig_m_x_K = [np.zeros_like(x)] # stress profiles for crack states
idx_0 = np.argmin(sig_mu_x)
XK.append(x[idx_0]) # position of the first crack
sig_c_0 = sig_mu_x[idx_0] * Ec / Em
sig_c_K.append(sig_c_0)
eps_c_K.append(sig_mu_x[idx_0] / Em)
while True:
z_x = get_z_x(x, XK) # distances to the nearest crack
sig_m_x_K.append(get_sig_m(z_x, sig_c_K[-1])) # matrix stress
sig_c_k, y_i = get_sig_c_K(z_x, x, sig_c_K[-1], sig_mu_x) # identify next crack
if sig_c_k == sig_cu: # (*\label{no_crack}*)
break
if update_progress: # callback to user interface
update_progress(sig_c_k)
XK.append(y_i) # record crack position
sig_c_K.append(sig_c_k) # corresponding composite stress
eps_c_K.append( # composite strain - integrate the strain field
np.trapz(get_eps_f(get_z_x(x, XK), sig_c_k), x) / np.amax(x)) # (*\label{imple_avg_strain}*)
XK_arr = np.hstack([[0], np.sort(np.array(XK)), [L_x]])
CS.append(np.average(XK_arr[1:]-XK_arr[:-1])) # crack spacing
sig_c_K.append(sig_cu) # the ultimate state
eps_c_K.append(np.trapz(get_eps_f(get_z_x(x, XK), sig_cu), x) / np.amax(x))
CS.append(CS[-1])
if update_progress:
update_progress(sig_c_k)
return np.array(sig_c_K), np.array(eps_c_K), sig_mu_x, x, np.array(CS), np.array(sig_m_x_K)
# ## Interactive application
#
# To provide an interactive interface within the `jupyter` notebook, this code
# combines the packages `ipywidgets` with `matplotlib`. This code is specific
# to the jupyter environment and has nothing to do with the actual algorithmic
# structure. This code has purely infrastructural character and is kept here for completeness.
# +
## Interactive application
import ipywidgets as ipw
n_steps = 20
margs_sliders = {
name : ipw.FloatSlider(description=desc, value=val,
min=minval, max=maxval, step=(maxval-minval) / n_steps,
continuous_update=False)
for name, desc, val, minval, maxval in [
('Em', r'\(E_\mathrm{m}\)', 28000, 1000, 50000),
('Ef', r'\(E_\mathrm{f}\)', 180000, 1000, 250000),
('vf', r'\(V_\mathrm{f}\)', 0.01, 0.00001, 0.4),
('T', r'\(T\)', 8, 0.0001, 20),
('sig_cu', r'\(\sigma_\mathrm{cu}\)', 10, 3, 100),
('sig_mu', r'\(\sigma_\mathrm{mu}\)',5.0, 1, 10),
('m', r'\(m\)',4,0.8,100),
('L_x', r'\(L\)',500,200,2000)
]
}
margs_sliders['n_x'] = ipw.IntSlider(description='n_x', value=200,
min=20, max=1000, step=10)
crack_slider = ipw.IntSlider(description='crack', value=0, min=0, max=1, step=1)
progress = ipw.FloatProgress(min=0, max=1) # instantiate the bar
fig, (ax, ax_sig_x) = plt.subplots(1,2,figsize=(8,3),tight_layout=True)
ax_cs = ax.twinx()
def update_progress(sig):
progress.value = sig
def init():
for key, sl in margs_sliders.items():
globals()[key] = sl.value
sig_c_K, eps_c_K, sig_mu_x, x, CS, sig_m_x_K = get_cracking_history(update_progress) # (*\label{calc_curve}*)
progress.max = margs_sliders['sig_cu'].value
ax.plot(eps_c_K, sig_c_K, marker='o') # (*\label{show_curve1}*)
ax_sig_x.plot(x, sig_mu_x, color='red')
current_sig_m_x_K = []
current_x = []
def reset_crack_slider(x, sig_m_x_K):
global current_sig_m_x_K, current_x, sig_m_line, sig_eps_marker
current_sig_m_x_K = sig_m_x_K
current_x = x
n_cracks = len(sig_m_x_K)
crack_slider.max = n_cracks-1
crack_slider.value = 0
sig_m_line, = ax_sig_x.plot(x, sig_m_x_K[0])
sig_eps_marker, = ax.plot([0],[0],color='magenta',marker='o')
def update_crack_slider(crack):
global sig_m_line, sig_eps_marker
global sig_c_K, eps_c_K
if len(current_sig_m_x_K) > 0:
sig_m_line.set_ydata(current_sig_m_x_K[crack])
sig_eps_marker.set_data(eps_c_K[crack],sig_c_K[crack])
def update(**mparams):
global sig_c_K, eps_c_K
for key, val in mparams.items():
globals()[key] = val
ax.clear()
ax_cs.clear()
ax_sig_x.clear()
sig_c_K, eps_c_K, sig_mu_x, x, CS, sig_m_x_K = get_cracking_history(update_progress) # (*\label{calc_curve}*)
n_c = len(eps_c_K) - 2 # numer of cracks
ax.plot(eps_c_K, sig_c_K, marker='o', label='%d cracks:' % n_c) # (*\label{show_curve1}*)
ax.set_xlabel(r'$\varepsilon_\mathrm{c}$ [-]'); ax.set_ylabel(r'$\sigma_\mathrm{c}$ [MPa]')
ax_sig_x.plot(x, sig_mu_x, color='orange')
ax_sig_x.fill_between(x, sig_mu_x, 0, color='orange',alpha=0.1)
ax_sig_x.set_xlabel(r'$x$ [mm]'); ax_sig_x.set_ylabel(r'$\sigma$ [MPa]')
ax.legend()
eps_c_KK = np.array([eps_c_K[:-1], eps_c_K[1:]]).T.flatten()
CS_KK = np.array([CS[:-1],CS[:-1]]).T.flatten()
ax_cs.plot(eps_c_KK, CS_KK, color='gray')
ax_cs.fill_between(eps_c_KK, CS_KK, color='gray', alpha=0.2)
ax_cs.set_ylabel(r'$\ell_\mathrm{cs}$ [mm]');
reset_crack_slider(x, sig_m_x_K)
def slider_layout():
layout = ipw.Layout(grid_template_columns='1fr 1fr')
slider_list = tuple(margs_sliders.values())
grid = ipw.GridBox(slider_list, layout=layout)
hbox_pr = ipw.HBox([progress])
hbox = ipw.HBox([crack_slider])
box = ipw.VBox([hbox_pr, hbox, grid])
display(box)
init()
slider_layout()
ipw.interactive_output(update_crack_slider, {'crack':crack_slider})
ipw.interactive_output(update, margs_sliders);
# -
| annotated_fragmentation.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # RGI-07: Region 08 (Scandinavia)
# ##### <NAME> & <NAME>, August 2021
#
# No changes to RGI6
import geopandas as gpd
import pandas as pd
import matplotlib.pyplot as plt
import subprocess
import os
from utils import mkdir
# ## Files and storage paths
# +
# Region of interest
reg = 8
# go down from rgi7_scripts/workflow
data_dir = '../../rgi7_data/'
# Level 2 GLIMS files
l2_dir = os.path.join(data_dir, 'l2_sel_reg_tars')
# Output directories
output_dir = mkdir(os.path.join(data_dir, 'l3_rgi7a'))
output_dir_tar = mkdir(os.path.join(data_dir, 'l3_rgi7a_tar'))
# RGI v6 file for comparison later
rgi6_reg_file = os.path.join(data_dir, 'l0_RGIv6', '07_rgi60_Scandinavia.zip')
# -
# ### Load the input data
# Read L2 files
shp = gpd.read_file('tar://' + l2_dir + f'/RGI{reg:02d}.tar.gz/RGI{reg:02d}/RGI{reg:02d}.shp')
# ## Apply selection criteria to reproduce RGI-6 for this region and check result
# ### Step 1: extract RGI6 from GLIMS data and do a check
#...extract RGI06 from GLIMS based on 'geog_area'
RGI_ss = shp.loc[shp['geog_area']=='Randolph Glacier Inventory; Umbrella RC for merging the RGI into GLIMS']
# ### extraction of RGI-6 via 'geog_area' is not possible so try to reproduce it in an other way
# do that based on relevant submission IDs (611, 362, 363, 364, 365)
RGI_ss = (shp.loc[shp['subm_id'].isin([611, 362, 363, 364, 365])])
# #### load reference data (here RGI6) to enable comparison
# +
# Just to know the name of the file to open from zip
import zipfile
with zipfile.ZipFile(rgi6_reg_file, "r") as z:
for f in z.filelist:
if '.shp' in f.filename:
fname = f.filename
# load reference data
ref_odf = gpd.read_file('zip://' + rgi6_reg_file + '/' + fname)
# -
# #### Number of elements (differences do not necessarily depict major problems)
print('Number of glaciers in new RGI subset:', len(RGI_ss))
print('Number of glaciers in reference data:', len(ref_odf))
print('Difference:', len(RGI_ss)-len(ref_odf))
# #### check for dublicate glacier IDs
print('Dublicate IDs in RGI-6:', len(ref_odf)-len(ref_odf['GLIMSId'].unique()))
print('Dublicate IDs in reproduction:', len(RGI_ss)-len(RGI_ss['glac_id'].unique()))
# #### Check for 'nominal glaciers' in the RGI6 original data and delete them from new RGI subset from GLIMS if they are in there
# how many nominals in RGI06 (identifiable via 'Status' attribute in RGI 06)
nom = ref_odf.loc[ref_odf.Status == 2].copy()
len(nom)
nom
# drop nominal glaciers from new RGI subset
RGI_ss = (RGI_ss.loc[~RGI_ss['glac_id'].isin(nom['GLIMSId'])])
# #### Total area
# add an area field to RGI_ss and reference data
RGI_ss['area'] = RGI_ss.to_crs({'proj':'cea'}).area
ref_odf['area'] = ref_odf.to_crs({'proj':'cea'}).area
nom['area'] = nom.to_crs({'proj':'cea'}).area
# print and compare area values
Area_Rep = RGI_ss['area'].sum()/1000000
print('Area Rep [km²]:', Area_Rep)
Area_RGI6 = ref_odf['area'].sum()/1000000
print('Area RGI6 [km²]:', Area_RGI6)
Area_nom = nom['area'].sum()/1000000
print('Area Nom [km²]:', Area_nom)
d = (Area_Rep + Area_nom - Area_RGI6)
d_perc = (d/Area_Rep*100)
print('Area difference [km²]:',d,'/','percentage:', d_perc)
# ### result of check (RGI from Glims global data base vs. RGI06 original):
# #### difference in number of glaciers: 0
# #### dublicate IDs: 8 in RGI-6, 11 in reproduced data
# #### nominal glaciers: 4
# #### area difference: 3.2 km² / 0.1 %
# #### general comment: in general reproduction works... area differences obviously from outline revisions (G016345E67139N and G018055E68083N), as well as vertex shifts between data-sets. Glacier G008363E61600N is wrongly located (shifted to north) in RGI-6, correct in GLIMS.
# ## Write out and tar
# +
dd = mkdir(f'{output_dir}/RGI{reg:02d}/', reset=True)
print('Writing...')
RGI07_reg10.to_file(dd + f'RGI{reg:02d}.shp')
print('Taring...')
print(subprocess.run(['tar', '-zcvf', f'{output_dir_tar}/RGI{reg:02d}.tar.gz', '-C', output_dir, f'RGI{reg:02d}']))## Write out and tar
# -
# ## Find missing glaciers
from utils import haversine
import numpy as np
import progressbar
def xy_coord(geom):
"""To compute CenLon CenLat ourselves"""
x, y = geom.xy
return x[0], y[0]
df_ref = ref_odf.copy()
rgi7 = RGI_ss.copy()
# Remove nominal
df_ref = df_ref.loc[df_ref.Status != 2].copy()
# +
# compute CenLon CenLat ourselves
rp = df_ref.representative_point()
coordinates = np.array(list(rp.apply(xy_coord)))
df_ref['CenLon'] = coordinates[:, 0]
df_ref['CenLat'] = coordinates[:, 1]
# -
df_ref_orig = df_ref.copy()
# Loop over all RGI7 glaciers and find their equivalent in ref
df_ref = df_ref_orig.copy()
not_found = {}
to_drop = []
for i, (ref_area, lon, lat) in progressbar.progressbar(enumerate(zip(rgi7['area'].values, rgi7.CenLon.values, rgi7.CenLat.values)), max_value=len(rgi7)):
# dist = haversine(lon, lat, df_ref.CenLon.values, df_ref.CenLat.values)
dist = (lon - df_ref.CenLon.values)**2 + (lat - df_ref.CenLat.values)**2
found = False
for j in np.argsort(dist)[:10]:
s6 = df_ref.iloc[j]
if np.allclose(s6['area'], ref_area, rtol=0.001):
found = True
to_drop.append(s6.name)
break
if not found:
not_found[i] = df_ref.iloc[np.argsort(dist)[:10]]
if len(to_drop) > 1000:
df_ref.drop(labels=to_drop, inplace=True)
to_drop = []
df_ref.drop(labels=to_drop, inplace=True)
print(len(not_found), len(df_ref))
pb_rgi7 = rgi7.iloc[list(not_found.keys())]
pb_rgi7.plot(edgecolor='k');
plt.title('GLIMS');
df_ref.plot(edgecolor='k');
plt.title('RGI6');
# Output directories
output_dir = mkdir(os.path.join(data_dir, 'l3_problem_glaciers'))
output_dir_tar = mkdir(os.path.join(data_dir, 'l3_problem_glaciers_tar'))
# +
dd = mkdir(f'{output_dir}/RGI{reg:02d}/', reset=True)
print('Writing...')
pb_rgi7.to_file(dd + f'RGI{reg:02d}_glims.shp')
df_ref.to_file(dd + f'RGI{reg:02d}_ref.shp')
print('Taring...')
print(subprocess.run(['tar', '-zcvf', f'{output_dir_tar}/RGI{reg:02d}.tar.gz', '-C', output_dir, f'RGI{reg:02d}']))
# -
| workflow/RGI08.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + [markdown] id="view-in-github" colab_type="text"
# <a href="https://colab.research.google.com/github/andrebelem/ensino/blob/main/Guia_B%C3%A1sico.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
# + [markdown] id="6_uSnW-BxUH-"
# <br>
# # Python Notebook com funções básicas<br>
#
# Criado por [<NAME>](mailto:<EMAIL>) @ [Observatório Oceanográfico](http://www.observatoiriooceanografico.uff.br) 2021 (versão 1) para disciplina de **Modelagem e Otimização de Sistemas Agrícolas e Ambientais** (e para quem mais se interessar)<br>
# <br>
# Para você usar o Python de forma eficiente, você precisa saber algumas operações básicas. Não é necessário saber tudo isso de cabeça, mas ao menos você pode usar esse notebook para "copiar" algumas soluções quando for necessário.<br>
# As linhas abaixo podem funcionar de forma separada ou conjunta. A sugestão é que você vá executando cada linha e estudando tanto o seu conteúdo quanto o resultado. Copie para o seu Google Drive e modifique quando necessário (além de incluir suas próprias anotações).<br>
#
# Este Notebook foi criado para ser usado no **Google Colab**, mas também serve o Jupyter Notebook ou o Jupyter Lab.
# + [markdown] id="L6Vi5i-OCshe"
# # Variáveis e *Strings*
#
# Quando você precisa armazenar valores, fazemos isso com **Variáveis**. Já uma **_String_** é onde armazenamos uma série de caracteres, entre aspas simples ou duplas.
#
# Veja os exemplos abaixo:
#
# + id="SmA1tXpqCoFC"
# (note que todos os comentários nas linhas de código iniciam por "hashtag" ou #)
# esta é uma frase clássica de todo o curso de linguagem de programação
print("Hello World")
# + id="rkT2XWR_DZ-1"
# da mesma forma que eu posso colocar o que quero imprimir em uma **_string_**
msg = "Hello World"
print(msg)
# + id="zg7o5YjADufD"
# posso juntar duas strings ou outra informação aqui
msg1 = "hello "
msg2 = 'world' # e note que não faz diferença ter as aspas simples ou duplas
print(msg1 + msg2)
# + id="gecHXAYuEw08"
# e você pode ainda juntar números no meio de texto
numero = 2
print(f'Hello world {numero}x') # note que neste caso colocamos o numero entre {} e um 'f' na frente do texto
# + id="pgMhCxcdFarR"
# caso você queria formatar o número, veja como é fácil
# imagine pi 3.14159265359
pi = 3.14159265359
print(pi) # imprimindo direto
print(f'Pi={pi}') # com formato
print(f'Pi={pi:.4f}') # neste caso limitamos em 4 casas decimais
# + [markdown] id="9gSCblRAJGgG"
# # Listas
#
# Digamos agora que você precisa criar uma lista com nomes específicos ou uma série de itens, para depois acessar os itens usando um índice ou dentro de um loop de repetição. Usamos aqui o símbolo **[** **]**.
#
# Veja os exemplos abaixo:
# + id="-bvk-_mxJoQk"
# lista de localidades
myloc = ['Almada', 'Fazenda Cariri','Córrego do Meio','Ponte Quebrada']
# ou se eu quiser, de códigos (Estações por exemplo)
mycod = ['SAMBA001','SAMBA002','SAMBA003','SAMBA004']
# ao dar print, fazemos apenas 1x
myloc
# + id="Flm7wMbtKI28"
# ou assim
print(mycod)
# + id="FB_HHWZ9KN_u"
#ou posso acessar apenas 1 valor da lista
print(f'primeiro valor :{myloc[0]}') # imprime o primeiro valor da lista
print(f'último valor :{myloc[-1]}') # note que o último é referenciado como -1
print(f'misturando tudo :{myloc[2]} e {mycod[-1]}') # tudo misturado
# + id="fV85ltcELB6j"
# posso ainda fazer um loop ou laço. Veja que a sintaxe é especial e a identação também é importante
for loc in myloc:
print(f'Localidade:{loc}')
# + id="PEE7A2u2LcDD"
# listas podem começar vazias e depois adicionamos coisas
meus_locais = []
meus_locais.append(myloc[0]) # e posso misturar listas diferentes com o append
meus_locais.append(mycod[0])
meus_locais.append(myloc[1])
meus_locais.append(mycod[1])
print(meus_locais)
# + id="O95L0kDSL32P"
# posso ainda criar listas numéricas
serie_numeros = []
# em um laço
for x in range(0,12): # note que o valor inicial é 0 e o final é 12
serie_numeros.append(x)
print(serie_numeros) # note que a saida só vai até 11 (!) isso é característico do python
# + id="3ijl6-y4MT--"
# Posso ainda criar uma série numérica diretamente e com uma equação
serie_numeros = [x**2 for x in range(0,12)] # neste caso estou elevando ao quadrado
serie_numeros
# + id="x66BEGrpMw48"
# também posso "fatiar" uma lista
print(f'Começando a partir do 2° da série:{serie_numeros[2:]}')
print(f'do 2° ao antipenúltimo da série:{serie_numeros[2:-2]}')
print(f'pulando de 2 em 2:{serie_numeros[0:-1:2]}')
# + [markdown] id="RDHgqLialew_"
# #Condicionantes
#
# Quando trabalhamos com variáveis, **declarações** são usadas para testar condições particulares e responder apropriadamente uma pergunta sobre uma variável ou os valores guardados em uma lista, por exemplo
#
# Veja os exemplos abaixo:
# + id="O4SSIgGtl8fY"
# primeiro eu declaro minha variável
x = 0
# teste se é igual a um número
print(f'teste 1: igualdade :{x == 1}')
# teste se é diferente de um númer
print(f'teste 2: diferença :{x != 1}') # deve ser verdadeiro já que x=0
# teste se é maior, maior ou igual
print(f'teste 3: maior :{x > 1}')
print(f'teste 4: maior ou igual :{x >= 1}')
# teste se é menos, menos ou igual
print(f'teste 5: menor :{x < 1}') # deve ser verdadeiro já que x=0
print(f'teste 6: menor ou igual :{x <= 1}') # deve ser verdadeiro já que x=0
# + id="K7TtHN2Xn3YG"
# é possível ainda validar condicionantes em listas
mycod = ['SAMBA001','SAMBA002','SAMBA003','SAMBA004']
'SAMBA003' in mycod # o resultado deve ser True
# + id="_w4zftZloKSj"
# ou você pode declara uma variável Booleana (verdadeiro ou falso)
estacao_completa = True
pixel_valido = False
# + id="lhosvHfIoenf"
# Uma condição pode ser testada tanto de forma numérica quanto booleana
# primeiro a numérica
profundidade = 500
if profundidade >100:
print('Aqui é Fundo')
# ou várias condicionantes
if profundidade < 100:
print('Raso')
elif profundidade >= 100 and profundidade <= 700:
print('Fundo')
else:
print('Muito fundo')
# + id="pn2tJapxprWH"
# agora a booleana
estacao_completa = False
if estacao_completa:
print('estação foi completa')
else:
print('estação incompleta .. completando agora')
estacao_completa = True # note que o que identifica o controle do if-else é a identação
print(estacao_completa) # verifica se mudou de False para True
# + [markdown] id="htM-7r63qlzm"
# #Dicionários
#
# Os dicionários são listas de variáveis que armazenam conexões entre informações. Cada item de um dicionário é um par de valores-chave
#
# Veja os exemplos abaixo:
#
# + id="oXZozMsdq1vA"
# dicionário de culturas
cultura = {'Nome':'Soja',
'Plantio':'Agosto',
'Rendimento':45}
cultura
# + id="iUEFbRDPznnh"
# você pode ainda acrescentar mais valores.
cultura['Colheita'] = 'Dezembro'
cultura
# + id="Szjc_QRz1rqP"
# e ainda fazer um print de valores selecionados:
print('A Cultura é '+cultura['Nome'] + ' com rendimento de '+ str(cultura['Rendimento']) + ' kg/ha')
# note a conversão de um valor inteiro para string para o Rendimento
# + id="gQHvH1F77h63"
# note que você pode chamar 1 elemento do dicionário
cultura['Colheita']
# + [markdown] id="SLyfc_rGG-Gy"
# Embora este conceito de dicionário seja bastante amplo, não perca muito seu tempo aprendendo sobre dicionarios já que há outra ferramenta muito mais poderosa chamada `pandas` (e que veremos em outra oportunidade).
#
# + [markdown] id="r_TzLqb0HR_x"
# #Laços de repetição (loops)
#
# Os laços são interações muito importantes no Python porque permitem que você programe um número grande de operações repetitivas. Essa é justamente a força de qualquer linguagem de programação.<br>
#
# Um laço do tipo `for` é usado para interagir dentro de uma sequência (ou seja, uma lista, uma tupla, um dicionário, um conjunto, etc etc). Outro tipo de laço é o `while`, também muito útil. Veja os exemplos abaixo.
# + id="iU6i1467LfB_"
# for aplicado em uma lista. Primeiro, eu tenho que ter a lista !
culturas = ['Soja','Milho','Café','Arroz']
# veja o número de itens da sua lista
len(culturas)
# agora faça o laço 'for'
for cultivo in culturas: # note que esta linha termina em ":"
print(f'O cultivo é {cultivo}') # note que a identação desta linha é diferente
# não há indicativo do final das operações do laço. Então, o controle é feito pela identação
# + id="pQYJ8LeGMMwm"
# o laço pode ser feito sobre caracteres em uma variável
# e posso ainda contar dentro de um laço
ic = 0
for x in 'climatologicamente':
ic = ic+1
print(f'O caracter {ic} é {x}')
# + id="s2jnW0MWMmq_"
# você pode fazer o laço sobre uma faixa de valores
print('Exemplo 1 *****************')
for i in range(6):
print(f'Número {i}')
# faça um experimento: apague o ":" no final da linha do for e veja o erro que ele mostra (invalid sintax)
print('Exemplo 2 *****************')
# outro tipo de range
for i in range(4,8):
print(f'Número {i}')
print('Exemplo 3 *****************')
# outro tipo de range (com float)
import numpy as np # note que para isso você precisa de uma biblioteca
for i in np.arange(2.0,4.0,0.5): # entre 2 e 4, com step de 0.5
print(f'Número {i}')
# + id="jy2CwnOrN7a0"
# outro exemplo muito útil é você aplicar uma condição `if` nas operações
for x in range(6):
if x == 3: # note como o if é construido, a identação, e o ":" no final do if e do else
print("--- passou pela metade")
else:
print(f'A sequencia é {x}')
# + id="Z7zBj6DlOlyj"
# while simples - como aplicar em uma sequencia aberta
contador = 1
while contador < 5: # modifique para "<=" para ver o que acontece
print(f'O número {contador} é menor do que 5')
contador += 1
print(f'Acabei o laço com o contador igual à {contador}')
# + id="hgS6k-quPFNU"
# while - veja como condicionar a parada
contador = 1
while contador < 5: # modifique para "<=" para ver o que acontece
print(f'O número {contador} é menor do que 5')
if contador == 3:
break # nesse caso, eu quebrei a sequencia antes
contador += 1
print(f'Acabei o laço com o contador igual à {contador}')
# + [markdown] id="bwpBjiAnPZfP"
# #Funções
#
# Funções são muito importantes ! porque você pode executar códigos ou tarefas específicas sobre um bloco de dados ou organizar funções repetitivas.<br>
#
# Note que um detalhe importante é você comentar BEM a sua função de forma que um usuário qualquer entenda o que você fez.
# + id="OK7imMiiQIRg"
# um exemplo muito simples
def adicione(a, b):
'Esta função é tão simples que não precisa de *contrato*'
'Um *contrato* é o texto que vai aqui logo depois do def e que indica o que essa rotina faz'
'criada por MeuNome em 2021 (por exemplo, para sabermos quem fez)'
result = a + b
return result
# agora veja como posso chama-la
soma = adicione(5, 7)
print(f'O resultado é {soma}')
# o resultado tem que ser 12
# + id="V79wVIeXQygA"
# uma função pode (deve?!) ser colocada em uma linha no colab para facilitar sua vida
# não necessariamente você vai ter que chamá-la sempre.
def find_numero_mais_alto(numbers):
'encontra o número mais alto'
highest = 0
for n in numbers:
if n > highest:
highest = n
return highest
# note a estrutura de construção acima, identado e com os ":" nos lugares certos
# executando esta linha, a função já está definida.
# + id="7nBaKSswROeh"
# agora criei uma lista com vários números e chamo a função
scores = [21, 14, 72, 148, 54]
top_score = find_numero_mais_alto(scores)
print(f'O número mais alto é {top_score}')
# O resultado deve ser 148
# + [markdown] id="35eBzR_qSIZj"
# Existe uma infinidade de coisas que você pode fazer com funções e acima estão as mais simples. Mas procure saber que você pode ainda usar parâmetros e argumentos (ou `*args`), palavras-chave (ou `keywords`), entre outras. Abaixo estão alguns exemplos.
#
# + id="54I2T3hpSpXv"
# Exemplo 1
def tipo_cultivo(produtor, *args):
print(produtor, 'é o produtor')
for cultivo in culturas:
print(f'Cultivo: {cultivo}')
# + id="vsc8UvXnTBmr"
# note que o primeiro argumento é o host e os outros são os cultivos no exemplo acima.
tipo_cultivo('Seu José', 'Milho', 'Soja', 'Feijão', 'Cana')
# + id="6Z23cRHcUEid"
def tabela_preços(produtor, **kwargs):
print(produtor, "preços:")
for key, value in kwargs.items():
print(key, value)
# + [markdown] id="QBDKq9MLURzF"
# `**kwargs` é semelhante a `*args`, exceto que é usado para dizer a uma função para aceitar qualquer número de argumentos de palavra-chave, que podem ser chamados assim:
# + id="genypnPUUYaP"
tabela_preços("Seu José", milho=98, cana=250, soja=176)
# + [markdown] id="d30MXE0UUvHs"
# ###Melhores Práticas
# ####**Princípio de responsabilidade única**
#
# Você pode ter ouvido falar do princípio da responsabilidade única. Isso significa que suas funções devem se concentrar apenas em lidar com um **único** aspecto de seu programa.<br>
#
# Por exemplo, digamos que você queira escrever algum código que faça três coisas: buscar um dado na web, extrair dados da web e imprimir os dados no terminal. Você não escreveria uma função que extraísse os dados da página da web E imprimisse os resultados no terminal, porque talvez um dia você precise alterar seu código para salvar esses resultados em um arquivo ou enviá-los para outro programa.<br>
#
# Você pode notar que quebrar seu código em funções reutilizáveis menores evita que ele se torne exponencialmente mais complicado e o mantém flexível para reutilização em sua base de código (e de outras pessoas).<br>
# ####**Nomeando suas funções**
# Uma função bem nomeada deve quase ser lida como uma frase quando usada. Quando alguém está lendo o código, deve ser imediatamente óbvio o que está acontecendo no código. Uma boa regra é projetar e nomear sua função de forma que ela possa ser usada para simplificar um conjunto mais complexo de operações em uma única expressão. E **nunca use** nomes que confundam variáveis com funções ou que sejam idênticas à funções que já existem no python (por exemplo, a função `pi` no pacote `math`. Se você quiser ter seu próprio `pi`, use o nome `my_pi`).
# + id="ytjJ2fERVt30"
# seu pi
import math
print(f'O pi real é {math.pi}')
def my_pi():
return(3.14)
print(f'O meu pi é {my_pi()}')
# + [markdown] id="hY6MCJ_SWyxX"
# #Imprimindo resultados
#
# Por último, e não menos importante, seguem algumas regras básicas para você imprimir resultados no seu terminal.<br>
#
# O comando `print` muda um pouco dependendo da versão do python e do ambiente que você está. A regra de ouro é *seja o mais simples possível*. Seguem alguns exemplos:
# + id="4maHX-WnXe3T"
print() # imprime "nada"
print('\n') # imprime uma nova linha
print('') # imprime uma linha vazia
message = 'imprime qualquer texto...'
print(message)
# um pouco mais complexo
import math
print('O valor e pi é ' + str(math.pi) + '(você sabia ?)') # note que pi é um número e print só trabalha com caracteres
# imprimindo formatado
print(f'O valor de pi é {math.pi}')
print(f'ou arredondando {math.pi:.3f}') # note que arredondamos aqui para 3 casas decimais
print(f'ou próximo de {int(math.pi):d}') # note que arredondamos um float para um inteiro
# + [markdown] id="ESqo1npqYtub"
# ####**Seja muito feliz com o Python !**
| Guia_Basico_Python.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# Making the First Data Frame (Postcode and Neighbourhood)
# Importing required Libraries
import pandas as pd
import wikipedia as wp
# Web Scrapping the Wikipedia Page
html = wp.page("List of postal codes of Canada: M").html().encode("UTF-8")
df = pd.read_html(html)[0]
# Removing Entries that have 'Not Assignes' Borough
df = df[df.Borough != 'Not assigned']
# Grouping Neighbourhood based on Post Codes
df = df.groupby(['Postcode','Borough'])['Neighbourhood'].apply(', '.join).reset_index()
# +
# For 'Not Assigned' Neighbourhood, copying the data from Borough
# Getting ready for Data Transfer from Columns to List
Borough = list(df['Borough'])
Neighbourhood = list(df['Neighbourhood'])
# Copying the Data
for i,v in enumerate(Neighbourhood):
if (Neighbourhood[i]=='Not assigned'):
Neighbourhood[i]=Borough[i]
# Getting data back from list to Column
df['Neighbourhood']=Neighbourhood
df['Borough']=Borough
# -
# Data Frame is now Ready
df
| Week 3/(Part 1 of 3) Assignment.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + [markdown] id="EJSoXpxXaCXS"
# #A classical ML, supervised learning classification example, using XGBoost & sklearn / imblearn pipeline with SMOTE & custom transformer on the titanic dataset.
# + [markdown] id="MKfueN764jqP"
# #Version information.
# + colab={"base_uri": "https://localhost:8080/"} id="XOrUmwPy1ld7" outputId="ebc01dc5-391f-4ee4-f5f4-9911361658d6"
import numpy as np
import pandas as pd
import matplotlib
import matplotlib.pyplot as plt
import platform # For checking python version
import sklearn # For Classifical ML
message = " Versions "
print("*" * len(message))
print(message)
print("*" * len(message))
print("Scikit-learn version {}".format(sklearn.__version__))
print("Numpy version {}".format(np.__version__))
print("Pandas version {}".format(pd.__version__))
print("Matplotlib version {}".format(matplotlib.__version__))
print("Python version {}".format(platform.python_version()))
# + [markdown] id="EUt-xNtQ4nyv"
# #Load data.
# + id="QX8TIJfi1XZZ"
train = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/applied_AI_ML/CA1/titanic/train.csv')
test = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/applied_AI_ML/CA1/titanic/test.csv')
# + [markdown] id="W9EQ4P0qzVd0"
# #Data visualization & analysis.
# + [markdown] id="OsOfkVefbQvR"
# ###Display first 5 rows of train & test dataframes.
# + colab={"base_uri": "https://localhost:8080/", "height": 310} id="2eAzq5mDbPsv" outputId="18c7e9e4-2468-4008-9452-13d07c243a9c"
# Dislay train data.
train.head()
# + colab={"base_uri": "https://localhost:8080/", "height": 241} id="qtXFC3KH00n0" outputId="2519af17-24f6-4641-96e1-3516c579615d"
# Dislay test data.
test.head()
# + [markdown] id="5pZgvHOW5aEu"
# ###Display description of train dataframe.
# + colab={"base_uri": "https://localhost:8080/", "height": 269} id="0dpP6jgI2dLf" outputId="2024a0b6-ed98-4e77-e582-15a2a8327a54"
train.describe().T
# + [markdown] id="7_JvRJ6G0VDT"
# ###Display data type of features in train dataframe.
# + colab={"base_uri": "https://localhost:8080/"} id="aKhmlOCV0QdU" outputId="c0b84189-a9a4-4f75-8031-8f0462327d00"
# Check for numerical or categorical data
train.dtypes
# + [markdown] id="2U3PcMRRhdC4"
# ###Number of unique values in each feature.
# + colab={"base_uri": "https://localhost:8080/", "height": 295} id="OoynB3qdhdLK" outputId="4a101924-7112-45a3-aa40-6bce7ee28b24"
print("PassengerId", train['PassengerId'].nunique())
print("Survived", train['Survived'].nunique())
print("Pclass", train['Pclass'].nunique())
print("Name", train['Name'].nunique())
print("Sex", train['Sex'].nunique())
print("Age", train['Age'].nunique())
print("SibSp", train['SibSp'].nunique())
print("Parch", train['Parch'].nunique())
print("Ticket", train['Ticket'].nunique())
print("Fare", train['Fare'].nunique())
print("Cabin", train['Cabin'].nunique())
print("Embarked", train['Embarked'].nunique())
"""
print()
print("Name_prefix", train['Name_prefix'].nunique())
print("gender", train['gender'].nunique())
print("Age_bin", train['Age_bin'].nunique())
print("Ticket_prefix", train['Ticket_prefix'].nunique())
print("Ticket_num", train['Ticket_num'].nunique())
print("Cabin_count", train['Cabin_count'].nunique())
print("Embarked_num", train['Embarked_num'].nunique())
"""
# + [markdown] id="A6SFyqLY52s2"
# ###Check missing data.
# + colab={"base_uri": "https://localhost:8080/", "height": 659} id="4E-AQysR4gtu" outputId="b5b88d6d-2ed8-412d-ed55-6ba88230c422"
# Check for missing data
# Generating the summary
print('Missing Values \n', train.isnull().sum())
# Generating a distribution of the missing values
import missingno as msno
msno.matrix(train)
# + [markdown] id="6I50UOoB6Flv"
# ###Display correlation between numerical features.
#
# + colab={"base_uri": "https://localhost:8080/", "height": 596} id="JKV3M1Qw6E8G" outputId="ef2334a7-0022-4ab2-beb6-529cdde784a9"
# Correlation
import matplotlib.pyplot as plt
import seaborn as sns
plt.figure(figsize = (15,10))
sns.heatmap(train.corr(),square=True,annot=True,cmap='RdBu',vmin=-1,vmax=1)
plt.show()
# + [markdown] id="vvlbZSmt6zq-"
# ###Display pair plot.
# + id="0QSrcBEJ6z0O" colab={"base_uri": "https://localhost:8080/", "height": 875} outputId="bbba3b10-1a37-4eef-d52a-ff695237c79b"
sns.pairplot(train.dropna(), kind='scatter', diag_kind='kde')
plt.show()
# + [markdown] id="CP0aoH34897S"
# ###Display pair plot using target label 'Survived' as hue.
# + id="HFqS-yGG7ImV" colab={"base_uri": "https://localhost:8080/", "height": 872} outputId="9c365652-c11e-410b-8f92-0cf450b36f10"
sns.pairplot(train.dropna(), hue="Survived", size=2)
plt.show()
# + [markdown] id="3UNKh9SkIgQF"
# #4. Feature extraction (custom transformer).
# + id="bIQVu102dlFM"
from sklearn.preprocessing import FunctionTransformer
def prefix_fr_name(df):
# Extract prefix from Name.
df['Name_prefix'] = df['Name'].str.split(r"\, |. ", expand=True)[1]
return df
prefix_fr_name_transformer = FunctionTransformer(prefix_fr_name)
# + id="ORK49nnQd6le"
def convert_gender(df):
# Convert gender from str to int64.
convert = []
for item in df['Sex']:
if item == 'male':
convert.append(1)
elif item == 'female':
convert.append(2)
else:
convert.append(0)
df['gender'] = convert # assign list to df col
return df
convert_gender_transformer = FunctionTransformer(convert_gender)
# + id="27jNNfiLf8Fe"
def band_age(df):
# Band Age into bins.
df['Age_bin'] = pd.cut(df['Age'].fillna(df['Age'].median()), bins=[0,15,30,45,60,999], labels=[5,4,3,2,1])
df['Age_bin'] = df['Age_bin'].astype('int64')
return df
band_age_transformer = FunctionTransformer(band_age)
# + id="gorpdjXFgjaD"
def ext_ticket(df):
# Extract prefix & numbers from Ticket.
df['Ticket_prefix'] = df['Ticket'].str.split(r"[0-9]", expand=True)[0]
df['Ticket_num'] = df['Ticket'].str.replace(r"\D+",'0')
def convert_Ticket_num(col):
# Convert items from str to float.
nums = []
for i, r in enumerate(col):
nums.append((float(r)))
return nums
df['Ticket_num'] = convert_Ticket_num(df['Ticket_num'])
return df
ext_ticket_transformer = FunctionTransformer(ext_ticket)
# + id="ANE9m6T8hfC6"
def Cabin_count(df):
# Count the number of cabins that corresponds to each passenger.
count = []
for r in df['Cabin']:
if type(r) == str:
count.append(len(r))
else:
count.append(0)
df['Cabin_count'] = count
return df
Cabin_count_transformer = FunctionTransformer(Cabin_count)
# + colab={"base_uri": "https://localhost:8080/"} id="zWX8ioFeigzJ" outputId="b1d3b452-5e81-4404-e5ce-6950f05104a4"
# convert Embarked from alphabets to numbers based on median fare.
# Notice that C corresponds to the highest median fare & Q the lowest.
print(train['Embarked'].value_counts())
print(train.groupby(['Embarked'])['Fare'].median())
def convert_Embarked(df):
# Convert Embarked alphabets to numbers.
convert = []
for a in df['Embarked']:
if a == 'Q':
convert.append(1)
elif a == 'S':
convert.append(2)
elif a == 'C':
convert.append(3)
else:
convert.append(0)
df['Embarked_num'] = convert
return df
convert_Embarked_transformer = FunctionTransformer(convert_Embarked)
# + [markdown] id="CwWU5AH3h3Vc"
# #Feature engineering (custom transformer).
# + id="4DijJ4hbS-Wk"
def feat_eng_num(df):
# Engineer artificial composite features based on feature correlations.
df['gender_d_Pclass'] = df['gender'] / df['Pclass']
df['gender_p_Age_bin'] = df['gender'] + df['Age_bin']
df['gender_p_Parch'] = df['gender'] + df['Parch']
df['gender_p_SibSp'] = df['gender'] + df['SibSp']
df['gender_p_Cabin_count'] = df['gender'] + df['Cabin_count']
df['gender_p_Embarked_num'] = df['gender'] + df['Embarked_num']
df['gender_m_Fare'] = df['gender'] * df['Fare']
df['Fare_d_Pclass'] = df['Fare'] / df['Pclass']
df['Fare_p_Cabin_count'] = df['Fare'] + df['Cabin_count']
df['Fare_p_Embarked_num'] = df['Fare'] + df['Embarked_num']
return df
feat_eng_num_transformer = FunctionTransformer(feat_eng_num)
# + [markdown] id="lN2Qi2-Z5BFe"
# ###Drop the unused/unwanted columns in the train dataframe.
# + id="pTAORHZf3rN3"
def drop_col(df):
df = df.drop([
'PassengerId',
'Pclass',
'Name',
#'Sex',
'Age',
'SibSp',
'Parch',
'Ticket',
'Fare',
'Cabin',
'Embarked',
# Extracted columns
#'Name_prefix',
'gender',
'Age_bin',
'Ticket_prefix',
'Ticket_num',
'Cabin_count',
'Embarked_num',
],
axis=1)
#print(df.columns)
return df
drop_col_transformer = FunctionTransformer(drop_col)
# + [markdown] id="L-C-KaTN9F7V"
# #Data Preparation
#
# 1. Randomized train data.
# 2. Separate the feature from the label.
# 3. Use SMOTE for upsampling.
# 4. Handle the Categorical and Numeric data separately.
# 5. Handle missing values.
# + id="8A2j3DQu4c6Q"
# Randomized all rows in the train dataset.
train = train.sample(frac=1.0, random_state=22)
# + id="wsR9RN_7_LBB"
# Separate the features from the label
# The label here is the Load Status
X = train.drop('Survived', axis= 1)
y = train['Survived']
#print(X.head().T)
#print(y.head())
# + id="carBsLDIExBO" colab={"base_uri": "https://localhost:8080/"} outputId="6005f7b9-cb0a-4195-b6b0-c9200d462094"
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state=22)
print(len(X_train), len(y_train))
X_train_cols = X_train.columns
#y_train_cols = y_train.columns
# + [markdown] id="imoQe2aiST7m"
# ###Install SMOTE.
# + colab={"base_uri": "https://localhost:8080/"} id="wXWMpeJmSYJH" outputId="9394255a-80f1-4ac8-f72e-95e05b958d21"
# !pip install smote
# + [markdown] id="NJ_VgReVyty6"
# ####Use SMOTE for upsampling.
# + colab={"base_uri": "https://localhost:8080/"} id="bJ_VMprcysx6" outputId="c7fa2666-8710-445e-aba7-385dfb667587"
# Using SMOTE to upsample train data.
# This don't need to be in pipeline as it applies to train data only.
import imblearn
print(imblearn.__version__)
from imblearn.over_sampling import SMOTENC
kn = int(len(X_train)*0.05)
print(kn)
# smote_nc will go into the imblearn pipeline below.
smote_nc = SMOTENC(categorical_features=[0,1,2,4,5,6,7,8], k_neighbors=kn, random_state=22)
# + id="sduKf1FeAFud"
# 0 to 8 are categorical features in SMOTENC.
# Original
#PassengerId int64
#Pclass int64
#Name object
#Sex object # NOT drop 0
#Age float64
#SibSp int64
#Parch int64
#Ticket object
#Fare float64
#Cabin object
#Embarked object
# Categorical Extracted
#Name_prefix # NOT drop 1
#Embarked_num
#Ticket_prefix
# Numerical Extracted
#gender
#Age_bin
#Ticket_num
#Cabin_count
# Numerical Engineered # ALL NOT drop
#gender_d_Pclass 2
#gender_p_Age_bin 3
#gender_p_Parch 4
#gender_p_SibSp 5
#gender_p_Cabin_count 6
#gender_p_Embarked_num 7
#gender_m_Fare 8
#Fare_d_Pclass # numerical
#Fare_p_Cabin_count # numerical
#Fare_p_Embarked_num # numerical
# + [markdown] id="IJarmKkRTdib"
# ###Install & import category_encoders.
#
# https://contrib.scikit-learn.org/category_encoders/index.html
# + id="3LL_M4jvTdqJ" colab={"base_uri": "https://localhost:8080/"} outputId="afbb5505-4897-455b-d666-0cc9393a25ad"
# !pip install category_encoders
from category_encoders import TargetEncoder, BinaryEncoder, CatBoostEncoder, WOEEncoder, LeaveOneOutEncoder, JamesSteinEncoder
# + [markdown] id="KTTkCYLgE1X-"
# #Creating Pipeline for the model.
# + id="4rKYhDMAE-7O"
#from sklearn.pipeline import Pipeline, make_pipeline
from imblearn.pipeline import Pipeline, make_pipeline # imblearn NOT sklearn
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder, LabelEncoder, OrdinalEncoder
from sklearn.preprocessing import StandardScaler, Normalizer, MinMaxScaler, MaxAbsScaler, RobustScaler, QuantileTransformer, PowerTransformer
from sklearn.decomposition import PCA
# + id="tTSCc7VEJykr"
#Numeric Transformation Pipeline
numeric_transformer = make_pipeline(
SimpleImputer(strategy='median'),
StandardScaler(),
#MinMaxScaler(feature_range=(-1,1)),
PowerTransformer(),
PCA(),
)
#Categorical Transformation Pipeline
categorical_transformer = make_pipeline(
SimpleImputer(strategy='constant', fill_value='missing'),
#OneHotEncoder(handle_unknown='ignore'),
BinaryEncoder(verbose=0),
CatBoostEncoder(verbose=0),
)
# + [markdown] id="wpZmRlnQFJWl"
# ### Compose the 2 types of transformers using ColumnTransformer.
#
# + id="dUjqkpdELgjL"
from sklearn.compose import ColumnTransformer, make_column_transformer
from sklearn.compose import make_column_selector
# ColumnTransformer takes in a list of tranformers that perform on columns only.
ct = make_column_transformer(
(numeric_transformer, make_column_selector(dtype_include=[np.float64, np.int64])),
(categorical_transformer, make_column_selector(dtype_include=['object', 'category'])),
)
# + [markdown] id="Ebv_x8OhIO6q"
# ###Install XGboost.
# + id="iyhDYqZsIOM5" colab={"base_uri": "https://localhost:8080/"} outputId="61a78868-30d2-4727-eb84-f812ecd32db1"
# !pip install xgboost
# + id="2AXzZddCFM1F"
# Combine the preprocessor with the Estimator
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC, LinearSVC, NuSVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier
from sklearn.linear_model import LogisticRegression, Perceptron, SGDClassifier
#from sklearn.naive_bayes import GaussianNB
import xgboost as xgb
# + [markdown] id="kK2-yX5AZPQU"
# #Training.
#
# + [markdown] id="jSCpEz2LougO"
# ###Algorithm comparison.
# #### Quick visual inspection on the performance of various estimator including pre-built Ensemble
# + id="sFzlbbJIoxM4" colab={"base_uri": "https://localhost:8080/", "height": 695} outputId="1ea566a3-913f-421a-ad45-644f4ead3c07"
from sklearn.metrics import plot_roc_curve
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')
fig, ax = plt.subplots()
#Create a list of classifiers to do a quick test
classifiers = [
LogisticRegression(),
Perceptron(),
SGDClassifier(),
KNeighborsClassifier(n_neighbors=3),
SVC(),
SVC(kernel="rbf", C= 0.025, probability=True),
NuSVC(probability=True),
DecisionTreeClassifier(),
RandomForestClassifier(),
AdaBoostClassifier(),
GradientBoostingClassifier(),
xgb.XGBClassifier(objective='binary:logistic',
tree_method='gpu_hist'), # Use GPU (Need to change Colab runtime type to use GPU).
]
for clf in classifiers:
# pipeline
pipe_grp = make_pipeline(
prefix_fr_name_transformer,
convert_gender_transformer,
band_age_transformer,
ext_ticket_transformer,
Cabin_count_transformer,
convert_Embarked_transformer,
feat_eng_num_transformer,
drop_col_transformer,
ct,
smote_nc,
clf,
)
pipe_grp.fit(X_train, y_train)
print("%s score: %.3f" % (clf.__class__.__name__, pipe_grp.score(X_test, y_test)))
roc_disp = plot_roc_curve(pipe_grp, X_test, y_test, ax=ax, name='{}'.format(clf.__class__.__name__))
print(roc_disp)
plt.show()
# + [markdown] id="XPYobwxKgxDM"
# ###Create pipeline with 1 XGBClassifier.
# + id="lcbIss39w7_7"
pipe = make_pipeline(
prefix_fr_name_transformer,
convert_gender_transformer,
band_age_transformer,
ext_ticket_transformer,
Cabin_count_transformer,
convert_Embarked_transformer,
feat_eng_num_transformer,
drop_col_transformer,
ct,
smote_nc,
xgb.XGBClassifier(
objective='binary:logistic',
tree_method='gpu_hist'), # Use GPU (Need to change Colab runtime type to use GPU).
#GradientBoostingClassifier(),
)
#model = pipe.fit(X_train, y_train)
# + [markdown] id="yf_xeaDFwwLD"
# ###Auto-hyperparameter tuning.
# + id="leXLSFdvwwXz" colab={"base_uri": "https://localhost:8080/"} outputId="2271158e-b1d3-4f21-e25d-4112d2cfc1bb"
import scipy.stats as stats
from sklearn.utils.fixes import loguniform
from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
from sklearn.metrics import make_scorer
from sklearn.metrics import accuracy_score
from time import time
# specify parameters and distributions to sample from
#param_dist = {'xgbclassifier__max_depth': [3,5,7,9,12],
# 'xgbclassifier__n_estimators': np.random.randint(low=300, high=900, size=10, dtype=int),
# 'xgbclassifier__learning_rate': np.random.uniform(low=0.05, high=0.1, size=30),}
param_dist = {'xgbclassifier__max_depth': [3, 5, 7],
'xgbclassifier__n_estimators': [100, 300, 500],
'xgbclassifier__learning_rate': [0.1, 0.05, 0.01],}
# run randomized search
n_iter_search=10
scoring = {'AUC': 'roc_auc', 'Accuracy': make_scorer(accuracy_score)}
random_search = RandomizedSearchCV(estimator=pipe,
param_distributions=param_dist,
n_iter=n_iter_search,
#scoring ='roc_auc',
scoring = scoring,
refit='AUC',
return_train_score=True,
cv=5)
#xgb.XGBClassifier().get_params().keys()
#print(pipe.get_params().keys())
start = time()
#best_model = grid_search.fit(X_train, y_train)
best_model = random_search.fit(X_train, y_train)
print("RandomizedSearchCV took %.2f seconds for %d candidates"
" parameter settings." % ((time() - start), n_iter_search))
#print(grid_search.cv_results_)
print(random_search.cv_results_)
# + id="CmoYW0WN8fyL" colab={"base_uri": "https://localhost:8080/"} outputId="534d6c92-ba47-4f2a-f53b-6b4082b7f727"
#Get the estimator model
best_classifier = best_model.best_estimator_
#Print out the hyperparameters
params = best_classifier['xgbclassifier'].get_params()
print("Best max_depth:", params['max_depth'])
print("Best n_estimators:", params['n_estimators'])
print("Best learning_rate:", params['learning_rate'])
# + [markdown] id="uNLUlDQaFi1N"
# ### Validation and Evaluation.
# + id="IeVghkVVFi8z" colab={"base_uri": "https://localhost:8080/"} outputId="e482cdd2-f5e0-40d4-bbec-d2d761f22cf2"
from sklearn import metrics
y_pred = best_model.predict(X_test)
print(y_pred)
#Summarise the fit of the classifier_model
print(metrics.classification_report(y_test,y_pred))
print(metrics.confusion_matrix(y_test,y_pred))
# + [markdown] id="JW1R42uaFux3"
# ### ROC Curve
# + id="x2fQ5TXSz2K3" colab={"base_uri": "https://localhost:8080/", "height": 279} outputId="3996d48c-2946-467d-b9de-e9debaf510ec"
roc_disp = plot_roc_curve(best_model, X_test, y_test)
# + [markdown] id="q1-0XSjAAdWs"
# ###Feature importance.
# + id="Y8vdj_KUAcQm"
from sklearn.inspection import permutation_importance
result = permutation_importance(best_model, X_train, y_train, n_repeats=3, random_state=22)
# + id="rfl3Wd2Yg1nx" colab={"base_uri": "https://localhost:8080/"} outputId="1fc9d683-34cc-4753-aee7-37ca740ecfb6"
importances_mean_df = pd.DataFrame(data=result.importances_mean.reshape(1,len(X_train.columns)), columns= X_train.columns)
print("Feature importance mean:")
print((importances_mean_df.T)[0].sort_values())
importances_std_df = pd.DataFrame(data=result.importances_std.reshape(1,len(X_train.columns)), columns= X_train.columns)
print()
print("Feature importance std:")
print((importances_std_df.T)[0].sort_values())
# + [markdown] id="-H-2k0cdSyKE"
# #Predict test data from file (unlabeled test set).
# + id="8fpPYTbTNf6J" colab={"base_uri": "https://localhost:8080/"} outputId="94edcff7-ee2a-4f48-f49f-cc2a08f029ee"
y_pred = best_model.predict(test)
print(y_pred)
y_pred = pd.DataFrame(y_pred, columns=['Survived'])
print(y_pred)
print(y_pred.value_counts(normalize=True))
print(y_pred.value_counts())
results = pd.concat([test['PassengerId'], y_pred], axis=1)
print(results)
results.to_csv('submission.csv', index=False)
print(pd.read_csv('submission.csv'))
| imblearn_XGB_titanic.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# New York City Taxi Data with Time Series
# ========================================
#
# We read NYC Taxi data from Google Cloud Storage using the parquet format.
# ### Connect to a cluster on Google Container Engine
from dask.distributed import Client, progress
c = Client()
c
# ### Load Parquet Data
# +
import gcsfs
import dask.dataframe as dd
df = dd.read_parquet('gcs://anaconda-public-data/nyc-taxi/nyc.parquet', storage_options={'token': 'anon'})
df = df.persist()
progress(df)
# -
# %time df.passenger_count.sum().compute()
# %time df.groupby(df.passenger_count).size().compute().sort_index()
# %time df.head() # Fast roundtrip access. Faster than video frame-rate
# %time df.loc['2015-05-05'].head() # Fast random access based on time
# ### Datetime operations
# %matplotlib inline
(df.passenger_count
.resample('1d')
.var()
.compute()
.plot(title='Passenger Rides Resampled by Day', figsize=(10, 4)));
# ### Tip Fraction, grouped by day-of-week and hour-of-day
# +
df2 = df[(df.tip_amount > 0) & (df.fare_amount > 0)]
df2['tip_fraction'] = df2.tip_amount / df2.fare_amount
# Group df.tpep_pickup_datetime by hour
hour = df2.groupby(df2.index.dt.hour).tip_fraction.mean().persist()
progress(hour)
# -
# ### Plot results
# +
from bokeh.plotting import figure, output_notebook, show
output_notebook()
fig = figure(title='Tip Fraction',
x_axis_label='Hour of day',
y_axis_label='Tip Fraction',
height=300)
fig.line(x=hour.index.compute(), y=hour.compute(), line_width=3)
fig.y_range.start = 0
show(fig)
| notebook/examples/06-nyc-parquet.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + [markdown] id="view-in-github" colab_type="text"
# <a href="https://colab.research.google.com/github/DebadityaShome/Deep-learning-practice/blob/main/PyTorch/tutorials/linearNN_on_dummyData.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
# + id="EEKLR6rw2_Yz"
import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
# + id="TuojiFYx3C2G"
# Input (temp, rainfall, humidity)
inputs = 100. * np.random.random((45, 3)).astype('float32')
targets = 100. * np.random.random((45, 2)).astype('float32')
inputs = torch.from_numpy(inputs)
targets = torch.from_numpy(targets)
# + [markdown] id="EllOq7NC822w"
# ## **Dataset and DataLoader**
# + id="ZuugEqAe7XfD"
from torch.utils.data import TensorDataset
# + colab={"base_uri": "https://localhost:8080/"} id="s_XCvs977sFl" outputId="f3133a26-5a47-405f-9fe8-674bf1d5d184"
# Define dataset
train_ds = TensorDataset(inputs, targets) # Tuples of X, y tensor pairs
train_ds[0:3]
# + id="yamJfmVU9GL0"
from torch.utils.data import DataLoader
# + id="u1HlhQNn9Vd2"
# Define dataloader
batch_size = 5
train_dl = DataLoader(train_ds, batch_size, shuffle=True)
# + colab={"base_uri": "https://localhost:8080/"} id="-lYo6v8-9emA" outputId="b9f4f41c-edd9-4136-8457-101f1dd7fe65"
# Print and check one training data batch
for xb, yb in train_dl:
print(xb)
print(yb)
break
# + colab={"base_uri": "https://localhost:8080/"} id="nq-u6mqD9xc9" outputId="6e9c4b47-4eaa-4cc9-a2c7-e3a601da93b2"
# Define a simple single-layer linear neural network
model = nn.Linear(3, 2)
print(model.weight)
print(model.bias)
# + colab={"base_uri": "https://localhost:8080/"} id="c403eVqi-G4Y" outputId="107455e1-3d75-42e0-bc06-5103ccee7bfa"
# Printing all model parameters
list(model.parameters())
# + colab={"base_uri": "https://localhost:8080/"} id="dK5QrXPG-v3t" outputId="59e4a72d-0ee7-4061-84cf-c8113333cdcf"
# Generate predictions
preds = model(inputs)
preds
# + colab={"base_uri": "https://localhost:8080/"} id="bsLfsYbo_Ihu" outputId="c03f5395-e075-4226-f369-198bb90374d9"
# Define loss function
loss_fn = F.mse_loss
# Calculate loss
loss = loss_fn(model(inputs), targets)
print(loss)
# + id="7s7-7VnoBkvg"
# Define optimizer
opt = torch.optim.SGD(model.parameters(), lr=1e-5)
# + id="CfolSuHECAKq"
# Custom training loop
def fit(num_epochs, model, loss_fn, opt, train_dl):
for epoch in range(num_epochs):
for xb, yb in train_dl:
pred = model(xb)
loss = loss_fn(pred, yb)
loss.backward()
opt.step()
opt.zero_grad()
if (epoch+1) % 10 == 0:
print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))
# + colab={"base_uri": "https://localhost:8080/"} id="3xY2U4jYDLWp" outputId="f5c27ae6-e4af-4061-a116-623e36221393"
fit(100, model, loss_fn, opt, train_dl)
| PyTorch/tutorials/linearNN_on_dummyData.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
import numpy as np
import pandas as pd
import fuzzymatcher
from fuzzywuzzy import fuzz
from fuzzywuzzy import process
df = pd.read_csv('aka.csv', encoding = "ISO-8859-1", dtype='unicode')
df.info()
# +
df_right = df[df.kind_id != "7"]
df_right.info()
# -
df_right.describe()
df_left = pd.read_csv('enc.csv', encoding = "ISO-8859-1")
df_left.info()
df_left ["Program Genre"].value_counts()
df_right = df_right.astype(str).apply(lambda x: x.str.lower())
df_left = df_left.astype(str).apply(lambda x: x.str.lower())
# +
#Dropped columns by cutting out in excel. See diff between title4 & title5
#df_right.drop(df_right.columns[[2,5,7,8,9,20]], axis=1, inplace=True)
# -
df_right.head()
df_right.info()
df_left.drop(df_left.head().columns[[5,6,8,9]], axis=1, inplace=True)
df_left.head()
df_right["title"].head()
df_left["Program Title"] = df_left["Program Title"].str.replace('[.]','')
df_left["Program Title"]
(process.extract(x, df_right, scorer= fuzz.ratio) for x in df_left)
# +
#This works but needs tweaking
names_array=[]
ratio_array=[]
def match_names(wrong_names,correct_names):
for row in wrong_names:
x=process.extractOne(row, correct_names)
names_array.append(x[0])
ratio_array.append(x[1])
return names_array,ratio_array
#imdb names dataset
wrong_names=df_left["Program Title"].dropna().values
#enc names dataset
correct_names=df_right["title"].dropna().values
name_match,ratio_match=match_names(wrong_names,correct_names)
df_left['correct_name']=pd.Series(name_match)
df_left['name_ratio']=pd.Series(ratio_match)
print(df_left[['Program Title','correct_name','name_ratio']].head(10))
# +
#df_right.to_csv("testing2.csv")
# -
df_merge = pd.merge(df_left, df_right, left_on= "correct_name", right_on = "title")
print(df_merge.head(10))
df_merge.to_csv("merged-aka.csv")
###########
# +
#DOES NOT WORK
#Columns to match on from df_left
df_left.dropna().values
df_right.dropna().values
left_on = ["Program Title", "First Air Year"]
# Columns to match on from df_right
right_on = ["title", "production_year"]
fuzzymatcher.link_table(df_left, df_right, left_on, right_on)
# -
#DOES NOT WORK
fuzzymatcher.fuzzy_left_join(df_left, df_right, left_on = "Program Title", right_on = "title")
| merge/merge-steve.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# + colab={} colab_type="code" id="um-4bFgKlAsN"
import numpy as np
import pandas as pd
import tensorflow as tf
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.layers import (
Dense,
Input,
LSTM,
Embedding,
Dropout,
Activation,
SpatialDropout1D
)
from tensorflow.keras.models import Model, load_model
from tensorflow.keras.callbacks import ModelCheckpoint
from ast import literal_eval
from sklearn.model_selection import train_test_split
from tensorflow.python.keras import backend as K
sess = tf.Session()
K.set_session(sess)
# + colab={} colab_type="code" id="QjA_p_8GlAsX"
df = pd.read_csv('data/pandas_data_frame.csv', index_col=0)
all_data = df.where((pd.notnull(df)), '')
all_data['hashtag'] = all_data['hashtag'].apply(literal_eval)
full_text = all_data['tidy_tweet'][(all_data['label']=='1.0') | (all_data['label']=='0.0')]
y = all_data['label'][(all_data['label']=='1.0') | (all_data['label']=='0.0')]
# + colab={} colab_type="code" id="iwpPbi0IlAsi"
max_len = 120
texts = full_text.tolist()
texts = [' '.join(t.split()[:max_len]) for t in texts]
texts = np.array(texts, dtype=object)[:, np.newaxis]
# + colab={"base_uri": "https://localhost:8080/", "height": 51} colab_type="code" executionInfo={"elapsed": 631, "status": "ok", "timestamp": 1562955859204, "user": {"displayName": "", "photoUrl": "", "userId": ""}, "user_tz": -120} id="NpqhS6GllAsl" outputId="900432b1-893d-4980-aca8-c412577e8ea6"
x_train, x_val, y_train, y_val = train_test_split(texts, y, random_state=1992, test_size=0.2)
print(x_train.shape,y_train.shape)
print(x_val.shape,y_val.shape)
# + colab={"base_uri": "https://localhost:8080/", "height": 1000} colab_type="code" executionInfo={"elapsed": 17482724, "status": "ok", "timestamp": 1562974171826, "user": {"displayName": "", "photoUrl": "", "userId": ""}, "user_tz": -120} id="ZGKy8cPflAss" outputId="c16f1c56-ab2f-429b-a1c5-d98840518a00"
import sys
sys.path.append("../")
from personal_library.sce_keras.loss_functions import f1_loss
from personal_library.sce_keras.metrics_functions import f1
from personal_library.sce_keras.layers.elmo import ElmoEmbeddingLayer
from personal_library.sce_keras.callbacks import (
LearningRateDecay,
WarmUpCosineDecayScheduler
)
num_classes = 1
batch_size = 512
epochs = 200
learnRate = 0.001
lstm_out = 200
warmup_epoch = 20
warm_up_lr = WarmUpCosineDecayScheduler(learning_rate_base=learnRate,
warmup_learning_rate=0,
warmup_epoch=warmup_epoch,
hold_base_rate_steps=5,
verbose=0)
checkpoint_path = "/content/gdrive/My Drive/model_wehigts/8_w.hdf5"
checkpoint_path1 = "/content/gdrive/My Drive/model_wehigts/8_ch.hdf5"
checkpointer = ModelCheckpoint(filepath=checkpoint_path,
monitor='val_f1', verbose=2,
save_best_only=True, mode='max')
checkpointer1 = ModelCheckpoint(filepath=checkpoint_path1,
monitor='val_loss', verbose=2,
save_best_only=False, mode='min')
input_text = Input(shape=(1,), dtype="string", name='input_0')
x = ElmoEmbeddingLayer(trainable=False)(input_text)
x = Dropout(0.3)(x)
x = Dense(256, activation='relu')(x)
x = Dense(num_classes, activation="sigmoid")(x)
model = Model(inputs=[input_text], outputs=x)
model.summary()
# 'binary_crossentropy'
model.compile(loss='binary_crossentropy',#f1_loss,
optimizer='adam',
metrics=['accuracy', f1])
sess.run(tf.global_variables_initializer())
sess.run(tf.tables_initializer())
history = model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_data=(x_val, y_val),
callbacks=[checkpointer, checkpointer1, warm_up_lr]
)
# + colab={"base_uri": "https://localhost:8080/", "height": 51} colab_type="code" executionInfo={"elapsed": 13560194, "status": "ok", "timestamp": 1562974380814, "user": {"displayName": "", "photoUrl": "", "userId": ""}, "user_tz": -120} id="Jg2khQqIlAsv" outputId="bc3c601b-7afd-4894-bffc-ef1d035a3732"
from sklearn.metrics import f1_score, accuracy_score
#Load best model
model.load_weights(checkpoint_path)
y_pred = model.predict(x_val, batch_size=1)
y_pred = np.where(y_pred > 0.5, 1, 0)
print("Own emmbeding f1_sklearn: {}".format(f1_score(y_val.astype(float), y_pred)))
print("Own emmbeding accuracy: {}".format(accuracy_score(y_val.astype(float), y_pred)))
# + colab={} colab_type="code" id="2kNZJc__lAsx"
| jupyter/8.Elmo.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# 
# +
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
# %matplotlib inline
sns.set_style("whitegrid")
# -
df_train = pd.read_csv("Data/train.csv")
df_test = pd.read_csv("Data/test.csv")
df_train.drop(['Name'],1,inplace =True)
df_train.head()
df_test.drop(["Name"],1, inplace =True)
df_test.head()
print("Shape Of Training Data:", df_train.shape)
print("Shape Of Test Data :", df_test.shape)
print("Missing Values In Training Dataset: ", df_train.isnull().sum())
print("-"*50)
print("Missing Values In Test Dataset : ", df_test.isnull().sum())
# #### Removing Missing Values In "Embarked"
# > Data can have missing values for a number of reasons such as observations that were not recorded and data corruption.
# Handling missing data is important as many machine learning algorithms do not support data with missing values.
df_train.drop(['Cabin'], 1 ,inplace =True)
df_test.drop(['Cabin'],1 , inplace =True)
df_train.drop(['Ticket'], 1, inplace = True)
df_test.drop(['Ticket'], 1, inplace = True)
df_train.dropna(subset=['Embarked'],inplace =True)
df_test['Fare'] =df_test['Fare'].fillna(35)
df_test.head()
df_test.isnull().sum()
df_train.head()
df_train['Age'].describe()
df_train.groupby('Survived')['Survived'].value_counts()
df_train.groupby('Survived')['Age'].mean()
df_train.groupby(['Survived','Sex','Pclass'])['Age'].mean()
#Training Data
age_groupby_train = df_train.groupby(['Survived','Sex','Embarked','Pclass'])['Age'].mean()
#Test Data
age_groupby_test = df_test.groupby(['Sex','Embarked','Pclass'])['Age'].mean()
# ## Train Data Age Missing Values Replacement By Mean Values Basis On
# * Sex
# * Embarked
# * Pclass
df_train['Age'].fillna(value = -1,inplace =True)
for row in range(len(age_groupby_train.index)):
df_train.loc[(df_train['Survived'] == age_groupby_train.index[row][0]) &
(df_train['Sex']== age_groupby_train.index[row][1]) &
(df_train['Embarked']== age_groupby_train.index[row][2])&
(df_train['Pclass']== age_groupby_train.index[row][3])&
(df_train['Age']==-1),'Age']=age_groupby_train.values[row]
# ## Test Data Age Missing Values Replacement By Mean Values Basis On
# * Sex
# * Embarked
# * Pclass
df_test['Age'].fillna(value = -1,inplace =True)
for row in range(len(age_groupby_test.index)):
df_test.loc[(df_test['Sex']== age_groupby_test.index[row][0]) &
(df_test['Embarked']== age_groupby_test.index[row][1])&
(df_test['Pclass']== age_groupby_test.index[row][2])&
(df_test['Age']==-1),'Age']=age_groupby_test.values[row]
print("Missing Values of Age in Training Dataset :", df_train.isnull().sum() )
print("Missing Values of Age in Test Dataset :", df_test.isnull().sum() )
df_train.head()
# ### Label Enconder
from sklearn.preprocessing import LabelEncoder
# ### Label Encoding
#
# ###### Male -> 1
#
# ###### Female -> 0
# +
le = LabelEncoder()
le.fit(df_train["Sex"])
df_train.loc[:,'Sex'] = le.transform(df_train['Sex'])
le.fit(df_train["Embarked"])
df_train.loc[:,'Embarked'] = le.transform(df_train['Embarked'])
le = LabelEncoder()
le.fit(df_test["Sex"])
df_test.loc[:,'Sex'] = le.transform(df_test['Sex'])
le.fit(df_test["Embarked"])
df_test.loc[:,'Embarked'] = le.transform(df_test['Embarked'])
# -
df_train.head()
# ### Split Data In X ,y
df_train.head()
train_x = df_train[['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'Embarked']]
train_y =df_train[['Survived']]
train_x.head()
train_y.head()
from sklearn.ensemble import RandomForestClassifier
lr = RandomForestClassifier(criterion='gini',
max_depth= 5,
max_leaf_nodes= 14,
min_samples_leaf= 3,
min_samples_split= 10,
n_estimators= 350)
lr.fit(train_x,train_y)
test_y = df_test[['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'Embarked']]
PassengerId =df_test['PassengerId']
preds_y = lr.predict(test_y)
submission = pd.DataFrame({'PassengerId':PassengerId,'Survived':preds_y})
submission.head()
# +
filename = 'Titanic_Predictions_Random_forest.csv'
submission.to_csv(filename,index=False)
print('Saved file: ' + filename)
# -
pr = pd.read_csv(filename)
pr.shape
#Save Model
import pickle
model = 'model.sav'
pickle.dump(lr, open(model, 'wb'))
| Kaggle comptetion Titanic(Random Forest).ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python [conda env:Business Analytics]
# language: python
# name: conda-env-Business_Analytics-py
# ---
# + id="DDk_NO3hDbRg" colab_type="code" colab={}
import pandas as pd
# + id="cG0EO_CwDbRo" colab_type="code" colab={}
import numpy as np
# + id="02oNuTyyDbRu" colab_type="code" colab={}
import plotly.express as px
# + id="_6_8N97dDbRy" colab_type="code" colab={}
import plotly.figure_factory as ff
# + id="VR6f9D_RDbR1" colab_type="code" colab={}
data_covid19 = "https://raw.githubusercontent.com/nytimes/covid-19-data/master/us-counties.csv"
# + id="x7gjBFYhDbR4" colab_type="code" colab={}
df_covid = pd.read_csv(data_covid19)
# + id="KVAptvP2DbR7" colab_type="code" outputId="6c810636-899d-4c3e-85c6-adb03ca3fcf2" colab={"base_uri": "https://localhost:8080/", "height": 204}
df_covid.head()
# + id="zBxdrXu8DbR_" colab_type="code" outputId="831c2d9a-58b3-4c56-f077-08816271b3f3" colab={"base_uri": "https://localhost:8080/", "height": 34}
import os
print(os.getcwd())
# + id="m6ORUpmoDbSB" colab_type="code" colab={}
df_population_csv = "https://raw.githubusercontent.com/jhu-business-analytics/covid-19-case-python-data-analysis/master/original_data_files/ACSST1Y2018.S0101_data_with_overlays_2020-04-02T080504.csv"
df_population = pd.read_csv(df_population_csv)
# + id="_zZLtEAqDbSE" colab_type="code" outputId="250a1c3b-2254-4c44-e775-fa125425b34c" colab={"base_uri": "https://localhost:8080/", "height": 204}
df_states_csv = "https://raw.githubusercontent.com/jhu-business-analytics/covid-19-case-python-data-analysis/master/original_data_files/state-geocodes-v2018.csv"
df_states = pd.read_csv(df_states_csv)
df_states.head()
# + id="6rL2G7nWDbSG" colab_type="code" colab={}
df_counties_csv = "https://raw.githubusercontent.com/jhu-business-analytics/covid-19-case-python-data-analysis/master/original_data_files/all-geocodes-v2018.csv"
df_counties = pd.read_csv(df_counties_csv)
# + id="lPKpui_tDbSI" colab_type="code" colab={}
df_hospitals_csv ="https://raw.githubusercontent.com/jhu-business-analytics/covid-19-case-python-data-analysis/master/original_data_files/Hospitals.csv"
df_hospitals = pd.read_csv(df_hospitals_csv)
# + id="hzv5QPKJDbSK" colab_type="code" outputId="6e45f914-86ca-4c8f-d8f1-2e87322cd0a1" colab={"base_uri": "https://localhost:8080/", "height": 457}
df_population.head()
# + id="_S1kr5o9DbSM" colab_type="code" colab={}
df_population.columns = df_population.iloc[0]
# + id="LGnKzHY2DbSN" colab_type="code" outputId="73e54ddb-f9b9-48b9-feec-b485e92d6137" colab={"base_uri": "https://localhost:8080/", "height": 525}
df_population.head()
# + id="w8CWQCOTDbSP" colab_type="code" colab={}
df_population = df_population[1:]
# + id="wW1hoy8DDbSR" colab_type="code" outputId="a94f3cb9-2cde-46a2-8453-00b4a41f456f" colab={"base_uri": "https://localhost:8080/", "height": 1000}
df_population.columns.tolist()
# + id="Gle8zlW9DbST" colab_type="code" colab={}
margin_error = df_population.columns.str.startswith("Margin of Error!!")
# + id="3i4U5baVDbSV" colab_type="code" colab={}
df_pop_values = df_population.loc[:,~margin_error]
# + id="ryx_zsFCDbSW" colab_type="code" colab={}
df_us_pop = df_pop_values.drop(columns=df_pop_values.columns[(df_pop_values == '(X)').any()])
# + id="Eb1z4JE1DbSX" colab_type="code" outputId="ce57d163-658a-4ef6-b09d-1d33157d0a30" colab={"base_uri": "https://localhost:8080/", "height": 474}
df_us_pop.head()
# + id="CeRSaLujDbSZ" colab_type="code" colab={}
df_us_pop.columns = df_us_pop.columns.str.strip("Estimate!!")
# + id="NDy3HWhIDbSa" colab_type="code" colab={}
df_us_pop.columns = df_us_pop.columns.str.replace("!!Total population", "")
# + id="lAMPXYd4DbSb" colab_type="code" outputId="8d143e0b-95cb-400b-e129-b4bf3a06f1f3" colab={"base_uri": "https://localhost:8080/", "height": 474}
df_us_pop.head()
# + id="c-QD1MGcDbSc" colab_type="code" colab={}
uspop_col = ['d', 'Geographic Area N','Total','Male','Female','Total!!SELECTED AGE CATEGORIES!!Under 18 year','Male!!SELECTED AGE CATEGORIES!!Under 18 year','Female!!SELECTED AGE CATEGORIES!!Under 18 year','Total!!SELECTED AGE CATEGORIES!!60 years and over','Male!!SELECTED AGE CATEGORIES!!60 years and over','Female!!SELECTED AGE CATEGORIES!!60 years and over','Total!!SUMMARY INDICATORS!!Median age (years)','Total!!SUMMARY INDICATORS!!Sex ratio (males per 100 females)','Total!!SUMMARY INDICATORS!!Age dependency ratio','Total!!SUMMARY INDICATORS!!Old-age dependency ratio','Total!!SUMMARY INDICATORS!!Child dependency ratio' ]
# + id="4wMrYkeCDbSe" colab_type="code" colab={}
df_us_pop_filter = df_us_pop.filter(items = uspop_col)
# + id="btd-E9o8DbSf" colab_type="code" outputId="c3f44c41-ff13-4256-8a64-635dacc5e0f7" colab={"base_uri": "https://localhost:8080/", "height": 445}
df_us_pop_filter.head()
# + id="-dab4rHjDbSg" colab_type="code" colab={}
df_us_pop_filter.columns = df_us_pop_filter.columns.str.replace("!!SELECTED AGE CATEGORIES!!"," ")
# + id="ZcPdTD4nDbSh" colab_type="code" colab={}
df_us_pop_filter.columns = df_us_pop_filter.columns.str.replace("Total!!SUMMARY INDICATORS!!","")
# + id="Eb9ZnQLiDbSi" colab_type="code" outputId="bedf241e-a763-43cf-aa17-8681fdb6707c" colab={"base_uri": "https://localhost:8080/", "height": 408}
df_us_pop_filter.head()
# + id="jgmsvwdxDbSk" colab_type="code" outputId="2c0932a4-6a47-49f4-dc6c-e3921910304c" colab={"base_uri": "https://localhost:8080/", "height": 204}
df_states.head()
# + id="NntURYC8DbSl" colab_type="code" outputId="031a9528-65a6-4dd9-9ffc-78abe289ec71" colab={"base_uri": "https://localhost:8080/", "height": 255}
df_counties.head()
# + id="dksHwL3MDbSn" colab_type="code" colab={}
df_states = pd.read_csv(df_states_csv, skiprows = 5)
# + id="YXOA757ADbSo" colab_type="code" colab={}
df_county = pd.read_csv(df_counties_csv,skiprows = 4)
# + id="Hfb7NQVGDbSp" colab_type="code" outputId="9fd21cb4-8e2c-44cf-af13-394d320ef2fa" colab={"base_uri": "https://localhost:8080/", "height": 204}
df_states.head()
# + id="v_mlI9ODDbSq" colab_type="code" outputId="db3b677b-eee5-4534-8731-12509c6fd126" colab={"base_uri": "https://localhost:8080/", "height": 221}
df_county.head()
# + id="SxlBlwUhDbSs" colab_type="code" colab={}
df_county = df_county[df_county["County Code (FIPS)"]!=0]
# + id="06O5JhM6DbSt" colab_type="code" colab={}
df_county[["State Code (FIPS)", "County Code (FIPS)"]] = df_county[["State Code (FIPS)", "County Code (FIPS)"]].astype(str)
# + id="ajPmSN-hDbSu" colab_type="code" colab={}
df_county["State Code (FIPS)"] = df_county["State Code (FIPS)"].str.zfill(2)
# + id="7hrsd8iMDbSv" colab_type="code" colab={}
df_county["County Code (FIPS)"] = df_county["County Code (FIPS)"].str.zfill(3)
# + id="uXMAF2C0DbSw" colab_type="code" outputId="69637229-9d84-4001-fc3e-8e5b1faf4056" colab={"base_uri": "https://localhost:8080/", "height": 221}
df_county.head()
# + id="3fjPnzLZDbSx" colab_type="code" outputId="71644a3c-edaf-449e-f596-a70efdf8ba76" colab={"base_uri": "https://localhost:8080/", "height": 221}
df_county.tail()
# + id="LgOvmX7eDbSy" colab_type="code" colab={}
df_county["full_county_fips"] = df_county["State Code (FIPS)"] + df_county["County Code (FIPS)"]
# + id="D-Ewsa_DDbSz" colab_type="code" outputId="bbf610b4-fe1a-4d74-86ed-a49a1f56c371" colab={"base_uri": "https://localhost:8080/", "height": 221}
df_county.head()
# + id="WZG8JhIQDbS0" colab_type="code" colab={}
df_states["State (FIPS)"] = df_states["State (FIPS)"].astype(str)
# + id="bjU9JDRIDbS1" colab_type="code" colab={}
df_states["State (FIPS)"] = df_states["State (FIPS)"].str.zfill(2)
# + id="jRiWNeiKDbS2" colab_type="code" outputId="8cf73a62-2358-4e23-df07-d64b6b0545f6" colab={"base_uri": "https://localhost:8080/", "height": 204}
df_states.head()
# + id="I9P4jFBFDbS3" colab_type="code" colab={}
df_county = pd.merge(df_county,
df_states[["State (FIPS)", "Name"]],
how = "left",
left_on = "State Code (FIPS)",
right_on = "State (FIPS)")
# + id="jgsr4HNRDbS4" colab_type="code" outputId="3dc290bb-6a62-453c-c01f-8c01bc44c0f1" colab={"base_uri": "https://localhost:8080/", "height": 221}
df_county.head()
# + id="t3mhGsXGDbS5" colab_type="code" colab={}
df_county["county_state_name"] = df_county["Area Name (including legal/statistical area description)"] + ", " + df_county["Name"]
# + id="Jh8UPOf8DbS6" colab_type="code" outputId="ec7b250d-8334-4daf-e7f0-d9161613f2e9" colab={"base_uri": "https://localhost:8080/", "height": 306}
df_county.head()
# + id="hDmyzJX4DbS7" colab_type="code" colab={}
df_county_pop = pd.merge(df_us_pop_filter,
df_county[["county_state_name", "full_county_fips"]],
how = "left",
left_on = "Geographic Area N",
right_on = "county_state_name"
)
# + id="Se2C4p4YDbS8" colab_type="code" outputId="a70264e8-8a0c-4ac1-af4b-4c590f0ef884" colab={"base_uri": "https://localhost:8080/", "height": 445}
df_county_pop.head()
# + id="dumCEjrJDbS9" colab_type="code" outputId="f33d5907-f2af-4f81-adff-11bac5e13ae1" colab={"base_uri": "https://localhost:8080/", "height": 442}
df_county_pop.info()
# + id="JgHIHHgJDbS-" colab_type="code" colab={}
df_county_pop = df_county_pop[df_county_pop["full_county_fips"].notnull()]
# + id="q-93FxeIDbS_" colab_type="code" colab={}
int_list = [
'Total',
'Male',
'Female',
'Total Under 18 year',
'Male Under 18 year',
'Female Under 18 year',
'Total 60 years and over',
'Male 60 years and over',
'Female 60 years and over']
# + id="wzDas9kEDbTA" colab_type="code" colab={}
float_list = [
'Median age (years)',
'Sex ratio (males per 100 females)',
'Age dependency ratio',
'Old-age dependency ratio',
'Child dependency ratio']
# + id="A4Mpd2ucDbTA" colab_type="code" colab={}
df_county_pop[int_list] = df_county_pop[int_list].astype(int)
df_county_pop[float_list] = df_county_pop[float_list].astype(float)
# + id="72EIfzh-DbTB" colab_type="code" colab={}
df_county_pop["percent_under18"] = (df_county_pop["Total Under 18 year"]/df_county_pop["Total"])*100
# + id="uwvvh4AiDbTC" colab_type="code" colab={}
df_county_pop["percent_over60"] = (df_county_pop["Total 60 years and over"]/df_county_pop["Total"])*100
# + id="4dm8oxt8DbTD" colab_type="code" outputId="1155f817-cc32-4b19-e997-18a888dbf85c" colab={"base_uri": "https://localhost:8080/", "height": 445}
df_county_pop.head()
# + id="qT45OPsSDbTE" colab_type="code" outputId="d1f92705-fd7c-4d19-8aa6-4d6fc6636a76" colab={"base_uri": "https://localhost:8080/", "height": 564}
df_hospitals.head()
# + id="odVFifU8zBZF" colab_type="code" outputId="6efa3be9-48b1-414d-913d-e9829ea1bb00" colab={"base_uri": "https://localhost:8080/", "height": 595}
df_hospitals.columns.tolist()
# + id="aiLQtsGQDbTF" colab_type="code" colab={}
df_hospitals = df_hospitals[df_hospitals["COUNTYFIPS"] != "NOT AVAILABLE"]
# + id="_BuLYldZDbTG" colab_type="code" colab={}
df_hospitals = df_hospitals[df_hospitals["COUNTYFIPS"].notnull()]
# + id="ibbE-u3hDbTG" colab_type="code" colab={}
df_county_hospitals = df_hospitals[df_hospitals["BEDS"] != -999]
# + id="nzIk25UODbTH" colab_type="code" colab={}
df_county_hospitals = df_county_hospitals.groupby("COUNTYFIPS").agg({"BEDS": "sum",
"NAME": "count"}).reset_index()
# + id="DuYRchjsDbTI" colab_type="code" outputId="2fa3c683-2768-43ef-e45f-d9469eef8f69" colab={"base_uri": "https://localhost:8080/", "height": 204}
df_county_hospitals.head()
# + id="I_GV1q8jDbTJ" colab_type="code" colab={}
df_county_hospitals = df_county_hospitals.rename(columns = {"NAME": "hospital_count", "BEDS":"hospital_bed_count"})
# + id="NPTiis1_DbTK" colab_type="code" outputId="833de2ef-d61e-451e-b64c-fd39ff527669" colab={"base_uri": "https://localhost:8080/", "height": 204}
df_county_hospitals.head()
# + id="QwJOuh_GDbTK" colab_type="code" colab={}
df_county_health = pd.merge(df_county_pop,
df_county_hospitals,
how = "left",
left_on = "full_county_fips",
right_on = "COUNTYFIPS")
# + id="lHS3uMlzDbTL" colab_type="code" outputId="33efe1bc-8486-4fd7-9041-e824fba735ac" colab={"base_uri": "https://localhost:8080/", "height": 445}
df_county_health.head()
# + id="f7gqUU5tDbTM" colab_type="code" outputId="2d697537-995b-4249-9540-fb18c4f7e7e5" colab={"base_uri": "https://localhost:8080/", "height": 527}
df_county_health.info()
# + id="15CMdINnDbTN" colab_type="code" colab={}
df_county_health = df_county_health[df_county_health["COUNTYFIPS"].notnull()]
# + id="oB29mcPADbTO" colab_type="code" colab={}
df_county_health.to_csv("us_county_population_hospital_data_2018.csv")
# + id="GA2VAgBCDbTP" colab_type="code" colab={}
df_total_pop = df_county_health.sort_values(by = "Total", ascending = False)
# + id="tq0_gL1QDbTP" colab_type="code" colab={}
df_total_top20 = df_total_pop.head(20)
# + id="BtMCi_cMDbTQ" colab_type="code" colab={}
bar_total_pop = px.bar(df_total_top20,
x = "Geographic Area N",
y = "Total",
title = "US Counties with the Highest Total Population",
labels = {"Geographic Area N": "County, State Name", "Total": "Total Population"})
# + id="dxYEGnulDbTR" colab_type="code" outputId="a1ef246e-6e1a-4fe6-821a-35240f065cdf" colab={"base_uri": "https://localhost:8080/", "height": 542}
bar_total_pop
# + id="A5SGeHyQDbTS" colab_type="code" colab={}
bubble_u18_o60 = px.scatter(df_county_health,
x = "percent_over60",
y = "percent_under18",
size = "hospital_bed_count",
hover_data = ['Geographic Area N',"Total"],
title = "Percentage of Population Under 18 and Over 60 in US Counties",
labels = {"Geographic Area N": "County, State Name",
"Total": "Total Population",
"percent_over60": "Percent of County Population over 60 years old",
"percent_under18": "Percent of County Population under 18 years old"})
# + id="MlcLStNLDbTT" colab_type="code" outputId="fa42a754-adc9-4b0a-e086-734f4bec4849" colab={"base_uri": "https://localhost:8080/", "height": 542}
bubble_u18_o60
# + id="-xlAhzeY4SSc" colab_type="code" colab={}
df_county_health["hospitalbeds_per1000"] = (df_county_health["hospital_bed_count"]/df_county_health["Total"]) *1000
# + id="QI9M-FLrTJO6" colab_type="code" colab={}
bubble_u18_o60_beds = px.scatter(df_county_health,
x = "percent_over60",
y = "percent_under18",
size = "hospitalbeds_per1000",
hover_data = ['Geographic Area N',"Total"],
title = "Percentage of Population Under 18 and Over 60 in US Counties",
labels = {"Geographic Area N": "County, State Name",
"Total": "Total Population",
"percent_over60": "Percent of County Population over 60 years old",
"percent_under18": "Percent of County Population under 18 years old",
"hospitalbeds_per1000": "Number of Hospital Beds per 1000 People"})
# + id="cY-7tf5_TMeD" colab_type="code" outputId="03b56332-516a-49c0-a774-b2ed5f38b116" colab={"base_uri": "https://localhost:8080/", "height": 542}
bubble_u18_o60_beds
# + id="doU5PbDxTfWC" colab_type="code" outputId="9ce8a1de-f624-4c32-f5ed-b7bbed9cedbd" colab={"base_uri": "https://localhost:8080/", "height": 204}
df_covid.tail()
# + id="H7hvFE9PmzyA" colab_type="code" colab={}
df_covid_apr18 = df_covid[df_covid["date"]== "2020-04-18"]
# + id="ghKisFGY_elh" colab_type="code" colab={}
df_covid_apr18["fips"] = df_covid_apr18["fips"].astype(str)
# + id="cHPXhji2IAlT" colab_type="code" colab={}
df_covid_apr18["fips"] = df_covid_apr18["fips"].str.replace(".", "z")
# + id="MNzsApuDIN4q" colab_type="code" colab={}
df_covid_apr18["fips"] = df_covid_apr18["fips"].str.replace("z0", "")
# + id="yuuPJ0mzAfX9" colab_type="code" colab={}
df_covid_apr18["fips"] = df_covid_apr18["fips"].str.zfill(5)
# + id="nEPuGPp-Aq6e" colab_type="code" outputId="6798f23c-9ad3-4584-c382-e5fb82b2a604" colab={"base_uri": "https://localhost:8080/", "height": 204}
df_covid_apr18.head()
# + id="VKZ5HhY6Asnh" colab_type="code" colab={}
df_county_health = pd.merge(df_county_health,
df_covid_apr18[["fips", "cases", "deaths"]],
how = "left",
left_on = "full_county_fips",
right_on = "fips")
# + id="vpdd6snwJHTf" colab_type="code" outputId="d5f56f55-7e00-4ce4-93bf-0d15e646b5c8" colab={"base_uri": "https://localhost:8080/", "height": 445}
df_county_health.head()
# + id="z0-asff2JKQq" colab_type="code" colab={}
df_county_health["cases_per1000"] = (df_county_health["cases"]/df_county_health["Total"])*1000
df_county_health["deaths_per1000"] = (df_county_health["deaths"]/df_county_health["Total"])*1000
# + id="HhIi7pveJOwB" colab_type="code" colab={}
covid_corr = df_county_health.corr()
# + id="5joix02JJUrb" colab_type="code" outputId="c1e22d68-8783-4ac5-8f3b-3dd1a165a4b7" colab={"base_uri": "https://localhost:8080/", "height": 952}
covid_corr
# + id="xseikqDOJWKB" colab_type="code" colab={}
county_covid19_heatmap = ff.create_annotated_heatmap(z = covid_corr.values,
x=list(covid_corr.columns),
y=list(covid_corr.index),
annotation_text=covid_corr.round(2).values,
showscale = True
)
# + id="nX8wGWdbJbpN" colab_type="code" outputId="8c293b79-6697-42f6-9006-7bb372ce0c97" colab={"base_uri": "https://localhost:8080/", "height": 542}
county_covid19_heatmap
# + id="x1e85LlRJo7A" colab_type="code" colab={}
bar_total_over60 = px.bar(df_total_top20,
x = "Geographic Area N",
y = "Total 60 years and over",
title = "US Counties with the Highest Total 60 Years and Over Population",
labels = {"Geographic Area N": "County, State Name", "Total 60 years and over": "Total 60 years and over"})
# + id="wHPft50Bj4Jw" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 542} outputId="9d9a27ab-20b9-4506-c67c-02571774bb3c"
bar_total_over60
# + id="CPOwqPa6j5TP" colab_type="code" colab={}
| Andrea_Python_Assignment_1_(1).ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
# Copyright 2021 <NAME>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# +
import json
import random
import numpy as np
import pandas as pd
random.seed(42)
np.random.seed(42)
# -
# Loading Caltech metadata:
# +
images_list_json = '/data/fagner/training/data/caltech_images_20201110ufam.json'
with open(images_list_json) as f:
images = json.load(f)
test_images = pd.DataFrame(images['images'])
split_json = '../data/caltech_splits_v3.json'
with open(split_json) as f:
split = json.load(f)
test_images = test_images[test_images['location'].isin(split['val'])].copy()
cct_annotations = pd.DataFrame(images['annotations'])
test_images_labeled = pd.merge(test_images,
cct_annotations,
how='left',
left_on='id',
right_on='image_id')
# -
def binarize_categories(row):
if row['category_id'] == 30:
return 0
else:
return 1
test_images_labeled['category'] = test_images_labeled.apply(binarize_categories, axis=1)
# #### Sampling 5000 instances from the test set
# * Must include at least one empty and one nonempty image for each location
# * Must keep the binary class proportion
def get_instance_per_location(df):
selected_instances = []
empty_count = 0
nonempty_count = 0
for location in df.location.unique():
empty = df[(df.location == location) & (df.category == 0)]
if len(empty) > 0:
selected_instances.append(empty.sample(1)['image_id'].values[0])
empty_count += 1
nonempty = df[(df.location == location) & (df.category == 1)]
if len(nonempty) > 0:
selected_instances.append(nonempty.sample(1)['image_id'].values[0])
nonempty_count += 1
return selected_instances, empty_count, nonempty_count
def sample_instances(df, category, num_samples):
samples = df[df.category == category].sample(num_samples)
return list(samples['image_id'])
NUM_SAMPLES = 5000
num_empty_samples = int(NUM_SAMPLES * test_images_labeled.category.value_counts()[0]/len(test_images_labeled))
num_nonempty_samples = NUM_SAMPLES - num_empty_samples
sel_instances, empty_count, nonempty_count = get_instance_per_location(test_images_labeled)
empty_samples = sample_instances(
test_images_labeled[~test_images_labeled.image_id.isin(sel_instances)],
category=0,
num_samples=(num_empty_samples - empty_count))
nonempty_samples = sample_instances(
test_images_labeled[~test_images_labeled.image_id.isin(sel_instances)],
category=1,
num_samples=(num_nonempty_samples - nonempty_count))
sel_instances = sel_instances + empty_samples + nonempty_samples
# #### Save test_sample spliting
selected_instances = test_images_labeled[test_images_labeled.image_id.isin(sel_instances)]
# +
with open(images_list_json) as json_file:
all_images = json.load(json_file)
all_images['info']['version'] = '20201110ufam_test_small'
instances_2_json = selected_instances[['seq_num_frames',
'date_captured',
'seq_id',
'height',
'width',
'location',
'rights_holder',
'file_name',
'id_x',
'frame_num']]
instances_2_json = instances_2_json.rename(columns={'id_x': 'id'})
instances_2_json = instances_2_json.to_dict('records')
all_images['images'] = instances_2_json
metadata_json = '/data/fagner/training/data/caltech_images_20201110ufam_test_sample.json'
with open(metadata_json, 'w') as outfile_images:
json.dump(all_images, outfile_images, indent=2)
| notebooks/cct_val_sample_split.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 2
# language: python
# name: python2
# ---
# <img src="http://imgur.com/1ZcRyrc.png" style="float: left; margin: 20px; height: 55px">
#
# # Ensembles and Random Forests
#
# _Author: <NAME> (DC)_
#
# *Adapted from Chapter 8 of [An Introduction to Statistical Learning](http://www-bcf.usc.edu/~gareth/ISL/)*
#
# ---
# ## Learning Objectives
#
# Students will be able to:
#
# - Understand how and why decision trees can be improved using bagging and random forests.
# - Build random forest models for classification and regression.
# - Know how to extract the most important predictors in a random forest model.
#
# ## Lesson Guide
# - [Introduction](#introduction)
# - [Part 1: Manual Ensembling](#part-one)
# - [Part 2: Bagging](#part-two)
# - [Manually Implementing Bagged Decision Trees](#manual-bagged)
# - [Bagged Decision Trees in `scikit-learn`](#manual-sklearn)
# - [Estimating Out-of-Sample Error](#oos-error)
#
#
# - [Part 3: Random Forests](#part-three)
# - [Part 4: Building and Tuning Decision Trees and Random Forests](#part-four)
# - [Optional: Predicting Salary With a Decision Tree](#decision-tree)
# - [Predicting Salary With a Random Forest](#random-forest-demo)
# - [Comparing Random Forests With Decision Trees](#comparing)
#
#
# - [Optional: Tuning Individual Parameters](#tuning)
# - [Summary](#summary)
# +
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
# %matplotlib inline
# -
# <a id="introduction"></a>
# ## Introduction
# ### What is Ensembling?
#
# **Ensemble learning (or "ensembling")** is the process of combining several predictive models in order to produce a combined model that is more accurate than any individual model. For example, given predictions from several models we could:
#
# - **Regression:** Take the average of the predictions.
# - **Classification:** Take a vote and use the most common prediction.
#
# For ensembling to work well, the models must be:
#
# - **Accurate:** They outperform the null model.
# - **Independent:** Their predictions are generated using different processes.
#
# **The big idea:** If you have a collection of individually imperfect (and independent) models, the "one-off" mistakes made by each model are probably not going to be made by the rest of the models, and thus the mistakes will be discarded when you average the models.
#
# There are two basic **methods for ensembling:**
#
# - Manually ensembling your individual models.
# - Using a model that ensembles for you.
# <a id="part-one"></a>
# ## Part 1: Manual Ensembling
#
# What makes an effective manual ensemble?
#
# - Different types of **models**.
# - Different combinations of **features**.
# - Different **tuning parameters**.
# 
#
# *Machine learning flowchart created by the [winner](https://github.com/ChenglongChen/Kaggle_CrowdFlower) of Kaggle's [CrowdFlower competition](https://www.kaggle.com/c/crowdflower-search-relevance)*.
# ### Comparing Manual Ensembling With a Single Model Approach
#
# **Advantages of manual ensembling:**
#
# - It increases predictive accuracy.
# - It's easy to get started.
#
# **Disadvantages of manual ensembling:**
#
# - It decreases interpretability.
# - It takes longer to train.
# - It takes longer to predict.
# - It is more complex to automate and maintain.
# - Small gains in accuracy may not be worth the added complexity.
# <a id="part-two"></a>
# ## Part 2: Bagging
#
# The primary weakness of **decision trees** is that they don't tend to have the best predictive accuracy. This is partially because of **high variance**, meaning that different splits in the training data can lead to very different trees.
#
# **Bagging** is a general-purpose procedure for reducing the variance of a machine learning method but is particularly useful for decision trees. Bagging is short for **bootstrap aggregation**, meaning the aggregation of bootstrap samples.
#
# A **bootstrap sample** is a random sample with replacement. So, it has the same size as the original sample but might duplicate some of the original observations.
# +
# Set a seed for reproducibility.
np.random.seed(1)
# Create an array of 1 through 20.
nums = np.arange(1, 21)
print nums
# Sample that array 20 times with replacement.
print np.random.choice(a=nums, size=20, replace=True)
# -
# **How does bagging work (for decision trees)?**
#
# 1. Grow B trees using B bootstrap samples from the training data.
# 2. Train each tree on its bootstrap sample and make predictions.
# 3. Combine the predictions:
# - Average the predictions for **regression trees**.
# - Take a vote for **classification trees**.
#
# Notes:
#
# - **Each bootstrap sample** should be the same size as the original training set. (It may contain repeated rows.)
# - **B** should be a large enough value that the error seems to have "stabilized".
# - The trees are **grown deep** so that they have low bias/high variance.
#
# Bagging increases predictive accuracy by **reducing the variance**, similar to how cross-validation reduces the variance associated with train/test split (for estimating out-of-sample error) by splitting many times an averaging the results.
# <a id="manual-bagged"></a>
# ## Manually Implementing Bagged Decision Trees (with B=10)
# +
# Read in and prepare the vehicle training data.
import pandas as pd
path = './data/vehicles_train.csv'
train = pd.read_csv(path)
train['vtype'] = train.vtype.map({'car':0, 'truck':1})
train
# +
# Set a seed for reproducibility.
np.random.seed(123)
# Create ten bootstrap samples (which will be used to select rows from the DataFrame).
samples = [np.random.choice(a=14, size=14, replace=True) for _ in range(1, 11)]
samples
# -
# Show the rows for the first decision tree.
train.iloc[samples[0], :]
# Read in and prepare the vehicle testing data.
path = './data/vehicles_test.csv'
test = pd.read_csv(path)
test['vtype'] = test.vtype.map({'car':0, 'truck':1})
test
# +
from sklearn.tree import DecisionTreeRegressor
# Grow each tree deep.
treereg = DecisionTreeRegressor(max_depth=None, random_state=123)
# List for storing predicted price from each tree:
predictions = []
# Define testing data.
X_test = test.iloc[:, 1:]
y_test = test.iloc[:, 0]
# Grow one tree for each bootstrap sample and make predictions on testing data.
for sample in samples:
X_train = train.iloc[sample, 1:]
y_train = train.iloc[sample, 0]
treereg.fit(X_train, y_train)
y_pred = treereg.predict(X_test)
predictions.append(y_pred)
# Convert predictions from list to NumPy array.
predictions = np.array(predictions)
predictions
# -
# Average predictions.
np.mean(predictions, axis=0)
# Calculate RMSE.
from sklearn import metrics
y_pred = np.mean(predictions, axis=0)
np.sqrt(metrics.mean_squared_error(y_test, y_pred))
# <a id="manual-sklearn"></a>
# ## Bagged Decision Trees in `scikit-learn` (with B=500)
# Define the training and testing sets.
X_train = train.iloc[:, 1:]
y_train = train.iloc[:, 0]
X_test = test.iloc[:, 1:]
y_test = test.iloc[:, 0]
# Instruct BaggingRegressor to use DecisionTreeRegressor as the "base estimator."
from sklearn.ensemble import BaggingRegressor
bagreg = BaggingRegressor(DecisionTreeRegressor(), n_estimators=500, bootstrap=True, oob_score=True, random_state=1)
# Fit and predict.
bagreg.fit(X_train, y_train)
y_pred = bagreg.predict(X_test)
y_pred
# Calculate RMSE.
np.sqrt(metrics.mean_squared_error(y_test, y_pred))
# <a id="oos-error"></a>
# ## Estimating Out-of-Sample Error
#
# For bagged models, out-of-sample error can be estimated without using **train/test split** or **cross-validation**!
#
# For each tree, the **unused observations** are called "out-of-bag" observations.
# Show the first bootstrap sample.
samples[0]
# Show the "in-bag" observations for each sample.
for sample in samples:
print set(sample)
# Show the "out-of-bag" observations for each sample.
for sample in samples:
print sorted(set(range(14)) - set(sample))
# **Calculating "out-of-bag error:"**
#
# 1. For each observation in the training data, predict its response value using **only** the trees in which that observation was out-of-bag. Average those predictions (for regression) or take a vote (for classification).
# 2. Compare all predictions to the actual response values in order to compute the out-of-bag error.
#
# When B is sufficiently large, the **out-of-bag error** is an accurate estimate of **out-of-sample error**.
# Compute the out-of-bag R-squared score (not MSE, unfortunately) for B=500.
bagreg.oob_score_
# ### Estimating Feature Importance
#
# Bagging increases **predictive accuracy** but decreases **model interpretability** because it's no longer possible to visualize the tree to understand the importance of each feature.
#
# However, we can still obtain an overall summary of **feature importance** from bagged models:
#
# - **Bagged regression trees:** Calculate the total amount that **MSE** decreases due to splits over a given feature, averaged over all trees
# - **Bagged classification trees:** Calculate the total amount that **Gini index** decreases due to splits over a given feature, averaged over all trees
# <a id="part-three"></a>
# ## Part 3: Random Forests
#
# Random Forests offer a **slight variation on bagged trees** with even better performance:
#
# - Exactly like bagging, we create an ensemble of decision trees using bootstrapped samples of the training set.
# - However, when building each tree, each time a split is considered, a **random sample of m features** is chosen as split candidates from the **full set of p features**. The split is only allowed to use **one of those m features**.
# - A new random sample of features is chosen for **every single tree at every single split**.
# - For **classification**, m is typically chosen to be the square root of p.
# - For **regression**, m is typically chosen to be somewhere between p/3 and p.
#
# What's the point?
#
# - Suppose there is **one very strong feature** in the data set. When using bagged trees, most of the trees will use that feature as the top split, resulting in an ensemble of similar trees that are **highly correlated**.
# - Averaging highly correlated quantities does not significantly reduce variance (which is the entire goal of bagging).
# - By randomly leaving out candidate features from each split, **random forests "decorrelate" the trees** to the extent that the averaging process can reduce the variance of the resulting model.
# - Another way of looking at it is that sometimes one or two strong features dominate every tree in bagging, resulting in essentially the same tree as every predictor. (This is what was meant when saying the trees could be highly correlated.) By using a subset of features to generate each tree, we get a wider variety of predictive trees that do not all use the same dominant features.
# <a id="part-four"></a>
# ## Part 4: Building and Tuning Decision Trees and Random Forests
#
# In this section, we will implement random forests in scikit-learn.
#
# - Major League Baseball player data from 1986-87: [data](https://github.com/justmarkham/DAT8/blob/master/data/hitters.csv), [data dictionary](https://cran.r-project.org/web/packages/ISLR/ISLR.pdf) (page 7)
# - Each observation represents a player.
# - **Goal:** Predict player salary.
# ### Preparing the Data
# +
# Read in the data.
path ='./data/hitters.csv'
hitters = pd.read_csv(path)
# Remove rows with missing values.
hitters.dropna(inplace=True)
# -
hitters.head()
# Encode categorical variables as integers.
hitters['League'] = pd.factorize(hitters.League)[0]
hitters['Division'] = pd.factorize(hitters.Division)[0]
hitters['NewLeague'] = pd.factorize(hitters.NewLeague)[0]
hitters.head()
# +
# Allow plots to appear in the notebook.
import matplotlib.pyplot as plt
# %matplotlib inline
# -
# Create a scatter plot of hits vs years, colored by salary
hitters.plot(kind='scatter', x='Years', y='Hits', c='Salary', colormap='jet', xlim=(0, 25), ylim=(0, 250));
# Define features: Exclude career statistics (which start with "C") and the response (salary).
feature_cols = hitters.columns[hitters.columns.str.startswith('C') == False].drop('Salary')
feature_cols
# Define X and y.
X = hitters[feature_cols]
y = hitters.Salary
# <a id="decision-tree"></a>
# ## Optional: Predicting Salary With a Decision Tree
#
# Let's first recall how we might predict salary using a single decision tree.
#
# We'll first find the best **max_depth** for a decision tree using cross-validation:
# +
# List of values to try for max_depth:
max_depth_range = range(1, 21)
# List to store the average RMSE for each value of max_depth:
RMSE_scores = []
# Use 10-fold cross-validation with each value of max_depth.
from sklearn.model_selection import cross_val_score
for depth in max_depth_range:
treereg = DecisionTreeRegressor(max_depth=depth, random_state=1)
MSE_scores = cross_val_score(treereg, X, y, cv=10, scoring='neg_mean_squared_error')
RMSE_scores.append(np.mean(np.sqrt(-MSE_scores)))
# -
# Plot max_depth (x-axis) versus RMSE (y-axis).
plt.plot(max_depth_range, RMSE_scores);
plt.xlabel('max_depth');
plt.ylabel('RMSE (lower is better)');
# Show the best RMSE and the corresponding max_depth.
sorted(zip(RMSE_scores, max_depth_range))[0]
# max_depth=2 was best, so fit a tree using that parameter.
treereg = DecisionTreeRegressor(max_depth=2, random_state=1)
treereg.fit(X, y)
# Compute feature importances.
pd.DataFrame({'feature':feature_cols, 'importance':treereg.feature_importances_}).sort_values(by='importance')
# <a id="random-forest-demo"></a>
# ## Predicting Salary With a Random Forest
#
# ### Fitting a Random Forest With the Best Parameters
from sklearn.ensemble import RandomForestRegressor
# max_features=5 is best and n_estimators=150 is sufficiently large.
rfreg = RandomForestRegressor(n_estimators=150, max_features=5, oob_score=True, random_state=1)
rfreg.fit(X, y)
# Compute feature importances.
pd.DataFrame({'feature':feature_cols, 'importance':rfreg.feature_importances_}).sort_values(by='importance')
# +
# Compute the out-of-bag R-squared score.
print(rfreg.oob_score_)
# Find the average RMSE.
scores = cross_val_score(rfreg, X, y, cv=10, scoring='neg_mean_squared_error')
np.mean(np.sqrt(-scores))
# -
# #### Reducing X to its Most Important Features
# Check the shape of X.
X.shape
# +
# Set a threshold for which features to include.
from sklearn.feature_selection import SelectFromModel
print SelectFromModel(rfreg, threshold='mean', prefit=True).transform(X).shape
print SelectFromModel(rfreg, threshold='median', prefit=True).transform(X).shape
# -
# Create a new feature matrix that only includes important features.
X_important = SelectFromModel(rfreg, threshold='mean', prefit=True).transform(X)
# +
# Check the RMSE for a random forest that only includes important features.
rfreg = RandomForestRegressor(n_estimators=150, max_features=3, random_state=1)
scores = cross_val_score(rfreg, X_important, y, cv=10, scoring='neg_mean_squared_error')
np.mean(np.sqrt(-scores))
# -
# In this case, the error decreased slightly. Often parameter tuning is required to achieve optimal results.
# <a id="comparing"></a>
# ## Comparing Random Forests With Decision Trees
#
# **Advantages of random forests:**
#
# - Their performance is competitive with the best supervised learning methods.
# - They provide a more reliable estimate of feature importance.
# - They allow you to estimate out-of-sample error without using train/test split or cross-validation.
#
# **Disadvantages of random forests:**
#
# - They are less interpretable.
# - They are slower to train.
# - They are slower to predict.
# 
#
# *Machine learning flowchart created by the [second-place finisher](http://blog.kaggle.com/2015/04/20/axa-winners-interview-learning-telematic-fingerprints-from-gps-data/) of Kaggle's [Driver Telematics competition](https://www.kaggle.com/c/axa-driver-telematics-analysis)*.
# <a id="tuning"></a>
# ## Optional: Tuning Individual Parameters
from sklearn.ensemble import RandomForestRegressor
rfreg = RandomForestRegressor()
rfreg
# ### Tuning n_estimators
#
# One important tuning parameter is **n_estimators**, which represents the number of trees that should be grown. This should be a large enough value that the error seems to have "stabilized."
# +
# List of values to try for n_estimators:
estimator_range = range(10, 1010, 100)
# List to store the average RMSE for each value of n_estimators:
RMSE_scores = []
# Use five-fold cross-validation with each value of n_estimators (Warning: Slow!).
for estimator in estimator_range:
rfreg = RandomForestRegressor(n_estimators=estimator, random_state=1)
MSE_scores = cross_val_score(rfreg, X, y, cv=5, scoring='neg_mean_squared_error')
RMSE_scores.append(np.mean(np.sqrt(-MSE_scores)))
# +
# Plot RMSE (y-axis) versus n_estimators (x-axis).
plt.plot(estimator_range, RMSE_scores);
plt.xlabel('n_estimators');
plt.ylabel('RMSE (lower is better)');
# -
# ### Tuning max_features
#
# The other important tuning parameter is **max_features**, which represents the number of features that should be considered at each split.
# +
# List of values to try for max_features:
feature_range = range(1, len(feature_cols)+1)
# List to store the average RMSE for each value of max_features:
RMSE_scores = []
# Use 10-fold cross-validation with each value of max_features (Warning: Super slow!).
for feature in feature_range:
rfreg = RandomForestRegressor(n_estimators=150, max_features=feature, random_state=1)
MSE_scores = cross_val_score(rfreg, X, y, cv=10, scoring='neg_mean_squared_error')
RMSE_scores.append(np.mean(np.sqrt(-MSE_scores)))
# +
# Plot max_features (x-axis) versus RMSE (y-axis).
plt.plot(feature_range, RMSE_scores);
plt.xlabel('max_features');
plt.ylabel('RMSE (lower is better)');
# -
# Show the best RMSE and the corresponding max_features.
sorted(zip(RMSE_scores, feature_range))[0]
# <a id="summary"></a>
# ## Summary
#
# **Which model is best?** The best classifier for a particular task is task-dependent. In many business cases, interpretability is more important than accuracy. So, decision trees may be preferred. In other cases, accuracy on unseen data might be paramount, in which case random forests would likely be better (since they typically overfit less).
#
# Remember that every model is a tradeoff between bias and variance. Ensemble models attempt to reduce overfitting by reducing variance but increasing bias (as compared to decision trees). By making the model more stable, we necessarily make it fit the training data less accurately. In some cases this is desired (particularly if we start with lots of overfitting), but for more simply structured data a simple decision tree might be best.
#
# ---
#
# **In this lesson:**
#
# - We looked at ensemble models.
#
# - We saw how decision trees could be extended using two ensemble techniques -- bagging and random forests.
#
# - We looked at methods of evaluating feature importance and tuning parameters.
| labs/lab9/ensembles_random_forests.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Mobility for resilience: population analysis
#
# This notebook shows the preliminary steps done using `mobilkit` to load raw HFLB data, determine the population estimates of each area and prepare the data for displacement and POI visit rates.
#
# We start loading raw HFLB data using the `mobilkit.loader` module.
# +
# %matplotlib inline
# %config Completer.use_jedi = False
import os
import sys
from copy import copy, deepcopy
from glob import glob
from collections import Counter
import pytz
from datetime import datetime
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec
from mpl_toolkits.axes_grid1 import make_axes_locatable
from pandas.plotting import register_matplotlib_converters
register_matplotlib_converters()
import numpy as np
import pandas as pd
import seaborn as sns
import geopandas as gpd
import contextily as ctx
import pyproj
from scipy import stats
from sklearn import cluster
import dask
from dask.distributed import Client
from dask import dataframe as dd
### import mobility libraries
import skmob
import mobilkit
sns.set_context("notebook", font_scale=1.5)
# -
dask.__version__ ### tested using Dask version 2020.12.0
# ## Load data
# ### Set up Dask
# * Notes:
# * Use **Dask** library for high-speed computation on edge computer
# * https://dask.org/
# * accumulates tasks and runs actual computation when ".compute()" is given
# * If cluster computing is available, using PySpark is recommended
# * Click the URL of the Dashboard below to monitor progress
client = Client(address="127.0.0.1:8786") ### choose number of cores to use
client
# ## Load raw data using `mobilkit` interface
# +
datapath = "../../data/"
outpath = "../../results/"
### define temporal cropping parameters (including these dates)
timezone = "America/Mexico_City"
startdate = "2017-09-04"
enddate = "2017-10-08"
nightendtime = "09:00:00"
nightstarttime = "18:00:00"
# How to translate the original columns in the mobilkit's nomenclature
colnames = {"id": "uid",
"gaid": "gaid",
"hw": "hw",
"lat": "lat",
"lon": "lng",
"accuracy": "acc",
"unixtime": "UTC",
"noise": "noise"
}
# Wehere raw data are stored
filepath = "/data/DataWB/sample/*.part"
ddf = mobilkit.loader.load_raw_files(filepath,
version="wb",
sep=",",
file_schema=colnames,
start_date=startdate,
stop_date=enddate,
timezone=timezone,
header=True,
minAcc=300.,
)
# -
# ### Quickly compute min/max of space-time
#
# Use the `mobilkit` and `skmob` column names notations.
dmin, dmax, lonmin, lonmax, latmin, latmax = dask.compute(ddf.UTC.min(),
ddf.UTC.max(),
ddf.lng.min(), ddf.lng.max(),
ddf.lat.min(), ddf.lat.max()
)
print(mobilkit.loader.fromunix2fulldate(dmin),
mobilkit.loader.fromunix2fulldate(dmax))
print(lonmin, lonmax, latmin, latmax)
boundary = (lonmin, latmin, lonmax, latmax)
mobilkit.viz.visualize_boundarymap(boundary)
# ### Sample of dataset (choose a very small fraction)
# %%time
ddf_sample = ddf.sample(frac=0.0001).compute()
len(ddf_sample)
mobilkit.viz.visualize_simpleplot(ddf_sample)
# ## Clean data
# * Some ideas on data cleaning:
# * **geographical boundary**; analyze data only within a specific area
# * **temporal boundary**; analyze data only within a specific timeframe
# * **Users' data quality**; select users with more than X datapoints, etc.
#
# ### Geographical boundary
### define boundary box: (min long, min lat, max long, max lat)
# ==== Parameters === #
bbox = (-106.3, 15.5, -86.3, 29.1)
# ddf_sc = ddf.map_partitions(data_preprocess.crop_spatial, bbox)
ddf_sc = ddf.map_partitions(mobilkit.loader.crop_spatial, bbox)
# ### Temporal boundary
#
# These computation gets done automatically when loading now.
#
# We only have to filter night hours.
# +
nightendtime = "09:00:00"
nightstarttime = "18:00:00"
ddf_tc2 = ddf_sc.map_partitions(mobilkit.loader.crop_time,
nightendtime,
nightstarttime,
timezone)
# -
# ### select users with sufficient data points
# * **users_totalXpoints** : select users with more than X data points throughout entire period
# * **users_Xdays** : select users with observations of more than X days
# * **users_Xavgps** : select users with more than X observations per day
# * **users_Xdays_Xavgps** : select users that satisfy both criteria
# +
# ==== Parameters === #
mindays = 3
avgpoints = 1
ddf = ddf.assign(uid=ddf["id"])
users_stats = mobilkit.stats.userStats(ddf).compute()
valid_users = set(users_stats[
(users_stats["avg"] > avgpoints)
& (users_stats["daysActive"] > mindays)
]["uid"].values)
ddf_clean = mobilkit.stats.filterUsersFromSet(ddf, valid_users)
# I do not have this col...
# ddf_clean_homework = ddf_clean[ddf_clean["hw"]=="HOMEWORK"]
# I keep only events during night
ddf_clean_homework = ddf_clean_homework[~ddf_clean_homework["datetime"].dt.hour.between(8,19)]
# -
# ## Home location estimation
#
# ### Estimation using Meanshift
# * took ~ 2 hours 15 minutes for entire dataset (mindays=1, avgpoints=0.1)
#
# We compute home location and we later split it into its latitude and longitude.
#
# ---
# **NOTE**
#
# When determining the home location of a user, please consider that some data providers, like _Cuebiq_, obfuscate/obscure/alter the coordinates of the points falling near the user's home location in order to preserve privacy.
#
# This means that you cannot locate the precise home of a user with a spatial resolution higher than the one used to obfuscate these data. If you are interested in the census area (or geohash) of the user's home alone and you are using a spatial tessellation with a spatial resolution wider than or equal to the one used to obfuscate the data, then this is of no concern.
#
# However, tasks such as stop-detection or POI visit rate computation may be affected by the noise added to data in the user's home location area. Please check if your data has such noise added and choose the spatial tessellation according to your use case.
#
# ---
# + tags=[]
id_home = ddf_clean_homework.groupby("uid").apply(mobilkit.spatial.meanshift)\
.compute()\
.reset_index()\
.rename(columns={0:"home"})
toc = datetime.now()
print("Number of IDs with estimated homes: ",len(id_home))
# + tags=[]
### save to csv file
id_home.to_csv("../data/"+"id_home_"+str(mindays)+"_"+str(avgpoints).replace(".","")+".csv")
# -
id_home["lon"] = id_home["home"].apply(lambda x : x[0])
id_home["lat"] = id_home["home"].apply(lambda x : x[1])
id_home = id_home.drop(columns=["home"])[["uid","lon","lat"]]
id_home.lon = id_home.lon.astype("float64")
id_home.lat = id_home.lat.astype("float64")
# Create a geodataframe for spatial queries
idhome_gdf = gpd.GeoDataFrame(id_home, geometry=gpd.points_from_xy(id_home.lon, id_home.lat))
# ## Compute administrative region for each ID
# ### manzana shape data (for only urban areas)
### load shape data
areas = ["09_Manzanas_INV2016_shp","17_Manzanas_INV2016_shp",
"21_Manzanas_INV2016_shp","29_Manzanas_INV2016_shp"]
manz_shp = gpd.GeoDataFrame()
for i,a in enumerate(areas):
manz_f = "data/spatial/manzanas_shapefiles/"+a+"/"
manz_shp1 = gpd.read_file(manz_f)
manz_shp = manz_shp.append(manz_shp1, ignore_index=True)
print("done",i)
manz_shp = manz_shp[["geometry","CVEGEO",'ENT','MUN','LOC','AGEB', 'MZA']]
manz_shp.head()
# ### By Entidad or Municipio stratification
adm2_f = datapath+"spatial/boundaries_shapefiles/mex_admbnda_adm2_govmex/"
adm2_shp = gpd.read_file(adm2_f)
adm2_shp.boundary.plot()
adm2_shp = adm2_shp[["ADM2_PCODE","geometry"]]
adm2_shp["ent"] = adm2_shp["ADM2_PCODE"].apply(lambda x : x[2:4])
adm2_shp["entmun"] = adm2_shp["ADM2_PCODE"].apply(lambda x : x[2:])
adm2_shp.head()
# ### Spatial join with manzana data
# * compute what geographical boundar each home location is in
id_manz = gpd.sjoin(idhome_gdf, manz_shp, how="inner", op='within')
id_manz["loc_code"] = id_manz["CVEGEO"].apply(lambda x : x[:9])
id_manz["ageb_code"] = id_manz["CVEGEO"].apply(lambda x : x[:13])
id_manz["mza_code"] = id_manz["CVEGEO"].apply(lambda x : x[:16])
id_manz = id_manz.drop(columns=["LOC","AGEB","MZA"])
# ### Spatial join with entidad/muncipio data
id_entmun = gpd.sjoin(idhome_gdf, adm2_shp, how="inner", op='within')
# ## Validation using census population data
# ### Population data for all levels
# +
poppath = datapath+"sociodemographic/populationdata/"
df_pop = pd.DataFrame()
for es in ["09","17","21","29"]:
pop = poppath+"resultados_ageb_urbana_"+es+"_cpv2010.csv"
df_pop1 = pd.read_csv(pop)[["entidad","mun","loc","ageb","mza","pobtot"]]
df_pop = df_pop.append(df_pop1, ignore_index=True)
df_pop["CVEGEO"] = df_pop.apply(lambda row: str(row["entidad"]).zfill(2)+
str(row["mun"]).zfill(3)+
str(row["loc"]).zfill(4)+
str(row["ageb"]).zfill(4)+
str(row["mza"]).zfill(3), axis=1)
# -
df_pop.head()
# ### Entidad level
ent_ids = id_entmun.groupby("ent").uid.count().reset_index()
ent_pop = df_pop[(df_pop["mun"]==0) & (df_pop["loc"]==0)
& (df_pop["ageb"]=="0000") & (df_pop["mza"]==0)][["entidad","pobtot"]]
ent_pop["ent"] = ent_pop["entidad"].apply(lambda x : str(x).zfill(2))
ent_ids_pop = ent_pop.merge(ent_ids, on="ent")
# ### Municipio level
mun_ids = id_entmun.groupby("entmun").uid.count().reset_index()
mun_pop = df_pop[(df_pop["mun"]!=0) & (df_pop["loc"]==0)
& (df_pop["ageb"]=="0000") & (df_pop["mza"]==0)][["CVEGEO","pobtot"]]
mun_pop["entmun"] = mun_pop["CVEGEO"].apply(lambda x : str(x)[:5])
mun_ids_pop = mun_pop.merge(mun_ids, on="entmun")
# ### Localidades level
loc_ids = id_manz.groupby("loc_code").uid.count().reset_index()
loc_pop = df_pop[(df_pop["mun"]!=0) & (df_pop["loc"]!=0)
& (df_pop["ageb"]=="0000") & (df_pop["mza"]==0)][["CVEGEO","pobtot"]]
loc_pop["loc_code"] = loc_pop["CVEGEO"].apply(lambda x : str(x)[:9])
loc_ids_pop = loc_pop.merge(loc_ids, on="loc_code")
# ### AGEB level
ageb_ids = id_manz.groupby("ageb_code").uid.count().reset_index()
ageb_pop = df_pop[(df_pop["mun"]!=0) & (df_pop["loc"]!=0)
& (df_pop["ageb"]!="0000") & (df_pop["mza"]==0)][["CVEGEO","pobtot"]]
ageb_pop["ageb_code"] = ageb_pop["CVEGEO"].apply(lambda x : str(x)[:13])
ageb_ids_pop = ageb_pop.merge(ageb_ids, on="ageb_code")
# ### Manzana level
mza_ids = id_manz.groupby("mza_code").uid.count().reset_index()
mza_pop = df_pop[(df_pop["mun"]!=0) & (df_pop["loc"]!=0)
& (df_pop["ageb"]!="0000") & (df_pop["mza"]!=0)][["CVEGEO","pobtot"]]
mza_pop["mza_code"] = mza_pop["CVEGEO"].apply(lambda x : str(x)[:17])
mza_ids_pop = mza_pop.merge(mza_ids, on="mza_code")
# ## Plot census population vs MP data
def plot_compare(df, ax, title):
df["logpop"] = np.log10(df["pobtot"])
df["loguser"] = np.log10(df["uid"])
df = df.replace([np.inf, -np.inf], np.nan).dropna()
# for col in set(df["color"].values):
# df_thiscol = df[df["color"]==col]
ax.scatter(df["logpop"].values, df["loguser"].values, color="b", s=15)
c1, i1, s1, p_value, std_err = stats.linregress(df["logpop"].values, df["loguser"].values)
ax.plot([0,np.max(df["logpop"])*1.1],[i1,i1+np.max(df["logpop"])*1.1*c1],
linestyle="-", color="gray")
ax.set_xlim(np.min(df["logpop"]),np.max(df["logpop"])*1.1)
ax.set_ylim(0,np.max(df["loguser"])*1.1)
ax.set_xlabel(r"$log_{10}$(Census population)", fontsize=14)
ax.set_ylabel(r"$log_{10}$(Unique users)", fontsize=14)
ax.annotate("Slope: "+str(c1)[:5]+"\n"+str(s1)[:5], #+utils.stars(p_value),
xy=(.1,0.7),
xycoords='axes fraction', color="k", fontsize=14)
ax.set_title(title, fontsize=16)
# +
fig = plt.figure(figsize=(10,8))
gs=GridSpec(2,2)
ax0 = fig.add_subplot(gs[0,0])
plot_compare(mun_ids_pop, ax0, "Municipio")
ax1 = fig.add_subplot(gs[0,1])
plot_compare(loc_ids_pop, ax1, "Localidades")
ax2 = fig.add_subplot(gs[1,0])
plot_compare(ageb_ids_pop, ax2, "AGEBs")
ax3 = fig.add_subplot(gs[1,1])
plot_compare(mza_ids_pop, ax3, "Manzanas")
plt.tight_layout()
# plt.savefig(outpath+"represent_manzana_eq.png",
# dpi=300, bbox_inches='tight', pad_inches=0.05)
plt.show()
# -
# ## Plot population on map
# +
mun_ids_pop["rate"] = mun_ids_pop["uid"]/mun_ids_pop["pobtot"]
mun_ids_pop["pcode"] = mun_ids_pop["entmun"].apply(lambda x : "MX"+str(x))
mun_ids_pop_shp = adm2_shp.merge(mun_ids_pop, on="entmun", how="right")
# -
fig,ax = plt.subplots(figsize=(10,10))
divider = make_axes_locatable(ax)
cax = divider.append_axes("right", size="5%", pad=0.1)
mun_ids_pop_shp.plot(ax=ax, column='rate', cmap='OrRd', legend=True,
cax=cax, legend_kwds={'label': "Sampling rate"}, alpha=0.65)
mun_ids_pop_shp.boundary.plot(ax=ax, color="k", linewidth=0.5)
| docs/examples/M4R_01_Dataloading_cleaning_validating.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# + [markdown] colab_type="text" id="6-w6JdXpymm5"
# # **Assignment 6** #
#
# **Delivery Instructions**: Similar to previous assignments. See this [**Canvas announcement**](https://njit.instructure.com/courses/11882/discussion_topics/42914) for more details.
#
#
# <br>
# <br>
#
# ---
#
# #### **Important Note**: If you want to follow the alternative track, as I explained in a previous discussions, you can skip questions marked with ^^. Please let me know that you do that !
#
# ----
#
# + [markdown] colab_type="text" id="-d604ucx7LtF"
# ---
#
#
# ### **Q1. Check BST validity** ###
#
#
# Recall the definition of a the Node class which can be used for implementing binary trees. Write a function that takes as input such a tree $T$, and outputs True if $T$ is a valid BST, or False otherwise. [Hint: Think recursion]
#
#
#
#
#
#
#
#
#
#
#
# + colab={} colab_type="code" id="5UMkl0gAtuU0"
# your implementation goes here
class Node:
def __init__(self,key):
self.key = key
self.lchild = None
self.rchild = None
# def checkBSTValidity(T):
# + [markdown] colab_type="text" id="duqXrslqqa3X"
# ---
#
#
# ### **Q2. Find the height of a Binary Tree**
#
# Write a function *BT_Height* that takes as input a binary tree and computes its height. [Hint: Again, think recursion]
#
# Side Note: If a BST is fully balanced then its height is exactly $\lceil \log_2 n \rceil$. So, the height computation allows you to check if a tree is fully balanced.
# + colab={} colab_type="code" id="gjsU_wuSqy4A"
# your implementation goes here
# def BT_Height(T):
# + [markdown] colab_type="text" id="c3ezTmqv0I0O"
# ---
#
#
# ### **Q3. Find the closest leaf** <br>
#
# Write a function *BT_ClosestLeaf* that takes as input a binary tree and computes the distance of the root to its closest leaf.
# + colab={} colab_type="code" id="OfsVWe5u7h-t"
# your code goes here
# def BT_ClosestLeaf(T):
# + [markdown] colab_type="text" id="drSvVq3aQKEU"
# ---
#
#
# ### **Q4^^**. Sorted array to BST
#
# In the lecture we briefly discussed that inserting keys in a random order, will give a balanced tree with high probability. However, it's likely that the tree will not be fully balanced. Suppose now that we have already a sorted array of elements $S$ and we want to convert it to a **fully** balanced search tree. Write a function that accomplishes that goal
#
#
#
#
#
#
# + colab={} colab_type="code" id="TCtaL0-7vKlm"
# def sortedToBST(S)
# output should be a Tree.
# + [markdown] colab_type="text" id="sl9VvPqlTm0v"
# ---
#
#
# ### **Q5. Find Max in BST**
#
# Write a function *BST_max* that takes as input a BST and returns the maximum key in it. This function should be iterative.
# + colab={} colab_type="code" id="jG1n6Pfaw3IG"
# def BST_max(T):
# + [markdown] colab_type="text" id="wbSfO5m0xT3I"
# ---
#
# ### **Q6^^**. Check Red-Black Tree Validity
#
# In the following cell, I give the definition of a class that can be used to build Red-Black Trees. The *color* attribute is assumed to be 1 or 0, where 1 means 'black' and 0 means 'red'.
# Write a function *checkRBTreeValidity* that takes as input a RB Tree $T$ and outputs True if $T$ satisfies all RB properties we discussed in the lecture, and false otherwise.
#
# **Note 1**: As we discussed in the lecture the 'None' children are considered as black nodes without keys.
#
# **Note 2**: Checking if a RB-Tree is a BST is also part of the question, but for it you can use Q1.
# + colab={} colab_type="code" id="1jfvfOf6xk1z"
class RBNode:
def __init__(self,key):
self.key = key
self.lchild = None
self.rchild = None
self.color = 1
# def checkRBValidity(T)
| notebooks/work/Assignment-6.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# + [markdown] slideshow={"slide_type": "skip"}
# ### Workshop Tutorial: Note that all slides have been optimized for a [RISE slideshow](https://rise.readthedocs.io)
# + slideshow={"slide_type": "skip"}
# Ignore warnings that distract from the tutorial
import warnings
warnings.simplefilter("ignore", category=FutureWarning)
# + [markdown] slideshow={"slide_type": "slide"}
# <div align='center' style='font-size:200%'>Validating Computational Models with</div>
# <div align='center'><img src="https://raw.githubusercontent.com/scidash/assets/master/logos/SciUnit/sci-unit-wide.png" width="50%"></div>
# <hr>
# <br>
# <div align='center' style='font-size:150%; line-height:80px;'>
# <NAME>. (Rick) Gerkin, PhD
# </div>
# <div align='center' style='font-size:100%; line-height:80px;'>Associate Research Professor, School of Life Sciences<br>
# Co-Director, <a href="http://iconlab.asu.edu">Laboratory for Informatics and Computation in Open Neuroscience</a><br>
# Arizona State University, Tempe, AZ USA
# </div>
# <hr>
# + [markdown] slideshow={"slide_type": "slide"}
# ### <i>[SciUnit](http://sciunit.scidash.org)</i> is a framework for validating scientific models by creating experimental-data-driven <i>unit tests</i>.
# + [markdown] slideshow={"slide_type": "fragment"}
# #### Conventionally, a unit test is <i>“a strict, written contract that the piece of code must satisfy</i>''
# + [markdown] slideshow={"slide_type": "fragment"}
# #### <i>SciUnit</i> extends this idea from generic computer programs to scientific models, making scientific model validation both formal and transparent.
# + [markdown] slideshow={"slide_type": "fragment"}
# #### The validity of a model is then represented by the collection of unit tests that it passes.
# + [markdown] slideshow={"slide_type": "fragment"}
# ### <i>[SciUnit](http://sciunit.scidash.org)</i> is a Python package. Let's install it, then make sure it can be imported.
# + slideshow={"slide_type": "fragment"}
# Installation of the `sciunit` package from PyPI
# !pip install -q sciunit
# Import the package
import sciunit
# + slideshow={"slide_type": "skip"}
# This code cell exists just to generate the mockup table a few cells below.
# Further down you will see that SciUnit can generate such tables from scores automatically!
from IPython.display import display, HTML
display(HTML("""
<style>
td.red {
background-color: #FF0000;
border: 1px solid black;
}
td.green {
background-color: #00FF00;
border: 1px solid black;
}
td.grey {
background-color: #AAAAAA;
border: 1px solid black;
}
th {
text-align: center;
border: 1px solid black;
}
table td, table th {
border: 10px solid black;
font-size: 250%;
}
</style>
"""))
# + [markdown] slideshow={"slide_type": "slide"}
# <div style='font-size:200%; text-align: center;'>Toy example: A brief history of cosmology</div><br>
# + [markdown] slideshow={"slide_type": "fragment"}
# <table>
# <tr style='background-color: #FFFFFF'>
# <td></td><th style='text-align: center'>Experimentalists</th>
# </tr>
# <tr>
# <th>Modelers</th><td><table style='border: 1px solid black'></td>
# <tr>
# <th></th><th>Babylonians</th><th>Brahe</th><th>Galileo</th><th>Le Verrier</th>
# </tr>
# <tr>
# <th>Ptolemy</th><td class='green'></td><td class='red'></td><td class='red'></td><td class='red'></td>
# </tr>
# <tr>
# <th>Copernicus</th><td class='green'></td><td class='red'></td><td class='red'></td><td class='red'></td>
# </tr>
# <tr>
# <th>Kepler</th><td class='green'></td><td style='background-color:#FF0000'></td><td class='grey'></td><td class='red'></td>
# </tr>
# <tr>
# <th>Newton</th><td class='green'></td><td class='green'></td><td class='green'></td><td class='red'></td>
# </tr>
# <tr>
# <th>Einstein</th><td class='green'></td><td class='green'></td><td class='green'></td><td class='green'></td>
# </tr>
# </table>
# </td>
# </tr>
# </table>
#
# <table style='border: 1px solid black'>
# <tr>
# <td class='green'>Pass</td><td class='red'>Fail</td><td class='grey'>Unclear</td>
# </tr>
# </table>
# + [markdown] slideshow={"slide_type": "slide"}
# ### Model validation goals:
# + [markdown] slideshow={"slide_type": "fragment"}
# #### - Generate one unit tests for each experimental datum (or stylized fact about data)
# + [markdown] slideshow={"slide_type": "fragment"}
# #### - Execute these tests against all models capable of taking them
# + [markdown] slideshow={"slide_type": "fragment"}
# #### - Programatically display the results as a “dashboard" of model validity
# - Optionally record and display non-boolean test results, test artifacts, etc.
# + [markdown] slideshow={"slide_type": "slide"}
# ### High-level workflow for validation:
# + [markdown] slideshow={"slide_type": "fragment"}
# ```python
# # Hypothetical examples of data-driven tests
# from cosmounit.tests import brahe_test, galileo_test, leverrier_test
#
# # Hypothetical examples of parameterized models
# from cosmounit.models import ptolemy_model, copernicus_model
#
# # Execute one test against one model and return a test score
# score = brahe_test.judge(copernicus_model)
# ```
#
# This is the only code-like cell of the tutorial that **doesn't** contain executable code, since it is a high-level abstraction. Don't worry, you'll be running real code just a few cells down!
# + [markdown] slideshow={"slide_type": "slide"}
# ### Q: How does a test “know" how to test a model?
# + [markdown] slideshow={"slide_type": "fragment"}
# ### A: Through guarantees that models provide to tests, called <i>“Capabilities"</i>.
# + [markdown] slideshow={"slide_type": "fragment"}
# [Code for **sciunit.capabilities** on GitHub](https://github.com/scidash/sciunit/tree/master/sciunit/capabilities.py)
# + [markdown] slideshow={"slide_type": "fragment"}
# ### Next we show an example of a <i>Capability</i> relevant to the cosmology case outlined above.
# + slideshow={"slide_type": "skip"}
# Some imports to make the code below run
from math import pi, sqrt, sin, cos, tan, atan
from datetime import datetime, timedelta
import numpy as np
# SymPy is needed because one of Kepler's equations
# is in implicit form and must be solved numerically!
from sympy import Symbol, solvers, sin as sin_
# + slideshow={"slide_type": "slide"}
class ProducesOrbitalPosition(sciunit.Capability):
"""
A model `capability`, i.e. a collection of methods that a test is allowed to invoke on a model.
These methods are unimplemented by design, and the model must implement them.
"""
def get_position(self, t: datetime) -> tuple:
"""Produce an orbital position from a time point
in polar coordinates.
Args:
t (datetime): The time point to examine, relative to perihelion
Returns:
tuple: A pair of (r, theta) coordinates in the oribtal plane
"""
raise NotImplementedError("")
@property
def perihelion(self) -> datetime:
"""Return the time of last perihelion"""
raise NotImplementedError("")
@property
def period(self) -> float:
"""Return the period of the orbit"""
raise NotImplementedError("")
@property
def eccentricity(self) -> float:
"""Return the eccentricity of the orbit"""
raise NotImplementedError("")
def get_x_y(self, t: datetime) -> tuple:
"""Produce an orbital position from a time point, but in cartesian coordinates.
This method does not require a model-specific implementation.
Thus, a generic implementation can be provided in advance."""
r, theta = self.get_position(t)
x, y = r*cos(theta), r*sin(theta)
return x, y
# + [markdown] slideshow={"slide_type": "slide"}
# ### <i>[SciUnit](http://sciunit.scidash.org)</i> (and domain specific libraries that build upon it) also define their own capabilities
# + slideshow={"slide_type": "fragment"}
# An extremely generic model capability
from sciunit.capabilities import ProducesNumber
# A specific model capability used in neurophysiology
#from neuronunit.capabilities import HasMembranePotential
# + [markdown] slideshow={"slide_type": "slide"}
# ### Now we can define a <i>model class</i> that implements this `ProducesOrbitalPosition` capability by inheritance.
# + [markdown] slideshow={"slide_type": "fragment"}
# ### All models are subclasses of `sciunit.Model` and typically one or more subclasses of `sciunit.Capability`.
# + slideshow={"slide_type": "slide"}
class BaseKeplerModel(sciunit.Model,
ProducesOrbitalPosition):
"""A sciunit model class corresponding to a Kepler-type model
of an object in the solar system. This model has the
`ProducesOrbitalPosition` capability by inheritance,
so it must implement all of the unimplemented methods of that capability"""
def get_position(self, t):
"""Implementation of polar coordinate position as a function of time"""
r, theta = self.heliocentric_distance(t), self.true_anomaly(t)
return r, theta
@property
def perihelion(self):
"""Implementation of time of last perihelion"""
return self.params['perihelion']
@property
def period(self):
"""Implementation of period of the orbit"""
return self.params['period']
@property
def eccentricity(self):
"""Implementation of orbital eccentricity (assuming elliptic orbit)"""
a, b = self.params['semimajor_axis'], self.params['semiminor_axis']
return sqrt(1 - (b/a)**2)
# + slideshow={"slide_type": "slide"}
class KeplerModel(BaseKeplerModel):
"""This 'full' model contains all of the methods required
to complete the implementation of the `ProducesOrbitalPosition` capability"""
def mean_anomaly(self, t):
"""How long into its period the object is at time `t`"""
time_since_perihelion = t - self.perihelion
return 2*pi*(time_since_perihelion % self.period)/self.period
def eccentric_anomaly(self, t):
"""How far the object has gone into its period at time `t`"""
E = Symbol('E')
M, e = self.mean_anomaly(t), self.eccentricity
expr = E - e*sin_(E) - M
return solvers.nsolve(expr, 0)
def true_anomaly(self, t):
"""Theta in a polar coordinate system at time `t`"""
e, E = self.eccentricity, self.eccentric_anomaly(t)
theta = 2*atan(sqrt(tan(E/2)**2 * (1+e)/(1-e)))
return theta
def heliocentric_distance(self, t):
"""R in a polar coordinate system at time `t`"""
a, e = self.params['semimajor_axis'], self.eccentricity
E = self.eccentric_anomaly(t)
return a*(1-e*cos(E))
# + [markdown] slideshow={"slide_type": "slide"}
# ### Now we can instantiate a <i>specific model</i> from this class, e.g. one representing the orbital path of Earth (according to Kepler)
# + slideshow={"slide_type": "fragment"}
# The quantities module to put dimensional units on values
import quantities as pq
# `earth_model` will be a specific instance of KeplerModel, with its own parameters
earth_model = KeplerModel(name = "Kepler's Earth Model",
semimajor_axis=149598023 * pq.km,
semiminor_axis=149577161 * pq.km,
period=timedelta(365, 22118), # Period of Earth's orbit
perihelion=datetime(2019, 1, 3, 0, 19), # Time and date of Earth's last perihelion
)
# + [markdown] slideshow={"slide_type": "fragment"}
# ### We can use this model to make specific predictions, for example the current distance between Earth and the sun.
# + slideshow={"slide_type": "fragment"}
# The time right now
t = datetime.now()
# Predicted distance from the sun, right now
r = earth_model.heliocentric_distance(t)
print("Heliocentric distance of Earth right now is predicted to be %s" % r.round(1))
# + [markdown] slideshow={"slide_type": "slide"}
# ### Now let's build a test class that we might use to validate (i.e. unit test to produce test scores) with this (and hopefully other) models
# + [markdown] slideshow={"slide_type": "fragment"}
# ### First, what kind of scores do we want our test to return?
# + slideshow={"slide_type": "fragment"}
# Several score types available in SciUnit
from sciunit.scores import BooleanScore, ZScore, RatioScore, PercentScore # etc., etc.
# + [markdown] slideshow={"slide_type": "fragment"}
# [Code for **sciunit.scores** on GitHub](https://github.com/scidash/sciunit/tree/master/sciunit/scores)
# + [markdown] slideshow={"slide_type": "slide"}
# ### Here's a first shot a test class for assessing the agreement between predicted and observed positions of orbiting objects. All test classes are subclasses of `sciunit.Test`.
# + slideshow={"slide_type": "fragment"}
class PositionTest(sciunit.Test):
"""A test of a planetary position at some specified time"""
# This test can only operate on models that implement
# the `ProducesOrbitalPosition` capability.
required_capabilities = (ProducesOrbitalPosition,)
score_type = BooleanScore # This test's 'judge' method will return a BooleanScore.
def generate_prediction(self, model):
"""Generate a prediction from a model"""
t = self.observation['t'] # Get the time point from the test's observation
x, y = model.get_x_y(t) # Get the predicted x, y coordinates from the model
return {'t': t, 'x': x, 'y': y} # Roll this into a model prediction dictionary
def compute_score(self, observation, prediction):
"""Compute a test score based on the agreement between
the observation (data) and prediction (model)"""
# Compare observation and prediction to get an error measure
delta_x = observation['x'] - prediction['x']
delta_y = observation['y'] - prediction['y']
error = np.sqrt(delta_x**2 + delta_y**2)
passing = bool(error < 1e5*pq.kilometer) # Turn this into a True/False score
score = self.score_type(passing) # Create a sciunit.Score object
score.set_raw(error) # Add some information about how this score was obtained
score.description = ("Passing score if the prediction is "
"within < 100,000 km of the observation") # Describe the scoring logic
return score
# + [markdown] slideshow={"slide_type": "slide"}
# ### We might want to include extra checks and constraints on observed data, test parameters, or other contingent testing logic.
# + slideshow={"slide_type": "fragment"}
class StricterPositionTest(PositionTest):
# Optional observation units to validate against
units = pq.meter
# Optional schema for the format of observed data
observation_schema = {'t': {'min': 0, 'required': True},
'x': {'units': True, 'required': True},
'y': {'units': True, 'required': True},
'phi': {'required': False}}
def validate_observation(self, observation):
"""Additional checks on the observation"""
assert isinstance(observation['t'], datetime)
return observation
# Optional schema for the format of test parameters
params_schema = {'rotate': {'required': False}}
# Optional schema for the format of default test parameters
default_params = {'rotate': False}
def compute_score(self, observation, prediction):
"""Optionally use additional information to compute model/data agreement"""
observation_rotated = observation.copy()
if 'phi' in observation:
# Project x and y values onto the plane defined by `phi`.
observation_rotated['x'] *= cos(observation['phi'])
observation_rotated['y'] *= cos(observation['phi'])
return super().compute_score(observation_rotated, prediction)
# + [markdown] slideshow={"slide_type": "slide"}
# ### Now we can instantiate a test. Each test instance is a combination of the test class, describing the testing logic and required capabilties, plus some <i>'observation'</i>, i.e. data.
# + slideshow={"slide_type": "fragment"}
# A single test instance, best on the test class `StricterPositionTest` combined with
# a specific set of observed data (a time and some x, y coordinates)
# N.B.: This data is made up for illustration purposes
earth_position_test_march = StricterPositionTest(name = "Earth Orbital Data on March 1st, 2019",
observation = {'t': datetime(2019, 3, 1),
'x': 7.905e7 * pq.km,
'y': 1.254e8 * pq.km})
# + [markdown] slideshow={"slide_type": "slide"}
# ### Finally, we can execute this one test against this one model
# + slideshow={"slide_type": "fragment"}
# Execute `earth_position_test` against `earth_model` and return a score
score = earth_position_test_march.judge(earth_model)
# Display the score
score
# + [markdown] slideshow={"slide_type": "fragment"}
# ### And we can get additional information about the test, including intermediate objects computed in order to generate a score.
# + slideshow={"slide_type": "fragment"}
# Describe the score in plain language
score.describe()
# + slideshow={"slide_type": "fragment"}
# What were the prediction and observation used to compute the score?
score.prediction, score.observation
# + slideshow={"slide_type": "fragment"}
# What was the raw error before the decision criterion was applied?
score.get_raw()
# + [markdown] slideshow={"slide_type": "slide"}
# ### We may want to bundle many such tests into a `TestSuite`. This suite may contain test from multiple classes, or simply tests which differ only in the observation (data) used to instantiate them.
# + slideshow={"slide_type": "fragment"}
# A new test for a new month: same test class, new observation (data)
# N.B. I deliberately picked "observed" values that will make the model fail this test
earth_position_test_april = StricterPositionTest(name = "Earth Orbital Data on April 1st, 2019",
observation = {'t': datetime(2019, 4, 1),
'x': 160000 * pq.km,
'y': 70000 * pq.km})
# A test suite built from both of the tests that we have instantiated
earth_position_suite = sciunit.TestSuite([earth_position_test_march,
earth_position_test_april],
name = 'Earth observations in Spring, 2019')
# + [markdown] slideshow={"slide_type": "fragment"}
# ### We can then test our model against this whole suite of tests
# + slideshow={"slide_type": "fragment"}
# Run the whole suite (two tests) against one model
scores = earth_position_suite.judge(earth_model)
# + [markdown] slideshow={"slide_type": "slide"}
# ### Rich HTML output is automatically produced when this score output is summarized
# + slideshow={"slide_type": "fragment"}
# Display the returned `scores` object
scores
# + [markdown] slideshow={"slide_type": "slide"}
# ### We can then expand this to multiple models
# + slideshow={"slide_type": "fragment"}
# Just like the Kepler model, but returning a random orbital angle
class RandomModel(KeplerModel):
def get_position(self, t):
r, theta = super().get_position(t)
return r, 2*pi*np.random.rand()
# + slideshow={"slide_type": "fragment"}
# A new model instance, using the same parameters but a different underlying model class
random_model = RandomModel(name = "Random Earth Model",
semimajor_axis=149598023 * pq.km,
semiminor_axis=149577161 * pq.km,
period=timedelta(365, 22118), # Period of Earth's orbit
perihelion=datetime(2019, 1, 3, 0, 19), # Time and date of Earth's last perihelion
)
# + slideshow={"slide_type": "slide"}
# Run the whole suite (two tests) against two models
scores = earth_position_suite.judge([earth_model, random_model])
# + slideshow={"slide_type": "fragment"}
# Display the returned `scores` object
scores
# + [markdown] slideshow={"slide_type": "slide"}
# ### Or extract just a slice:
# + slideshow={"slide_type": "fragment"}
# All the scores for just one model
scores[earth_model]
# + slideshow={"slide_type": "fragment"}
# All the scores for just one test
scores[earth_position_test_march]
# + [markdown] slideshow={"slide_type": "slide"}
# ### What about models that <i>can't</i> take a certain test? Some models aren't capable (even in principle) of doing what the test is asking of them.
# + slideshow={"slide_type": "fragment"}
# A simple model which has some capabilities,
# but not the ones needed for the orbital position test
class SimpleModel(sciunit.Model,
sciunit.capabilities.ProducesNumber):
pass
simple_model = SimpleModel()
# + slideshow={"slide_type": "fragment"}
# Run the whole suite (two tests) against two models
scores = earth_position_suite.judge([earth_model, random_model, simple_model])
# + [markdown] slideshow={"slide_type": "slide"}
# ### Incapable models don't fail, they get the equivalent of 'incomplete' grades
# + slideshow={"slide_type": "fragment"}
# Display the returned `scores` object
scores
# + [markdown] slideshow={"slide_type": "slide"}
# ### <i>[SciUnit](http://sciunit.scidash.org)</i> is in use in several multiscale modeling projects including:
# #### - [The Human Brain Project](https://www.humanbrainproject.eu/en/) (neurophysiology, neuroanatomy, neuroimaging)
# #### - [OpenWorm](http://openworm.org/) (biophysics, network dynamics, animal behavior)
# + [markdown] slideshow={"slide_type": "slide"}
# ### <i>[NeuronUnit](http://neuronunit.scidash.org)</i> is a reference implementation in the domain of neurophysiology of:
# #### - model classes
# #### - test classes
# #### - capability classes
# #### - tools for constructing tests from several public neurophysiology databases
# #### - tools for implementing capabilities from standard model exchange formats
# #### - tools for executing simulations underlying testing using popular simulators
# #### - test-driven model optimization
# + [markdown] slideshow={"slide_type": "slide"}
# ### <i>[SciDash](http://dash.scidash.org)</i> is a web application for creating, scheduling, and viewing the results of SciUnit tests without writing a single line of code.
# + [markdown] slideshow={"slide_type": "slide"}
# <hr>
# <div align='center' style='font-size:300%; line-height:30px;'>
# Links:
# </div>
# <table align='center' style='font-size:150%; line-height:30px;'>
# <tr>
# <td width='25%'><a href="http://sciunit.scidash.org"><img src="https://github.com/scidash/assets/blob/master/logos/SciUnit/sci-unit-wide.png?raw=true" width="50%"></a></td>
# <td width='25%'><a href="http://neuronunit.scidash.org"><img src="https://github.com/scidash/assets/blob/master/logos/neuronunit-logo.png?raw=trueg" width="50%"></a></td>
# </tr>
# <tr>
# <td width='25%'><a href="http://dash.scidash.org"><img src="https://github.com/scidash/assets/blob/master/logos/scidash_logo.png?raw=true" width="50%"></a></td>
# <td width='25%'><a href="http://metacell.us"><img src="http://science-marketplace.org/oc-content/uploads/6/599.png" width="35%"></a></td>
# </tr>
# </table>
# + [markdown] slideshow={"slide_type": "slide"}
# <hr>
# <div align='center' style='font-size:200%; line-height:30px;'>
# Funded by:
# </div><br>
# <table align='center' style='line-height:30px;'>
# <tr>
# <td width='25%'>R01DC018455 (NIDCD)</td>
# <td width='25%'><img src="https://upload.wikimedia.org/wikipedia/commons/thumb/c/cd/US-NIH-NIDCD-Logo.svg/1920px-US-NIH-NIDCD-Logo.svg.png" width="50%"></td>
# <td width='25%'>R01MH106674 (NIMH)</td>
# <td width='25%'><img src="https://upload.wikimedia.org/wikipedia/commons/a/a0/NIH-NIMH-logo-new.png" width="100%"></td>
# </tr>
# <tr>
# <td>R01EB021711 (NIBIB)</td>
# <td><img src="https://upload.wikimedia.org/wikipedia/commons/1/15/NIH_NIBIB_Vertical_Logo_2Color.jpg" width="50%"></td>
# <td>Human Brain Project</td>
# <td><img src="https://pbs.twimg.com/profile_images/660035391442042880/v7RkSosC_400x400.png" width="50%"></td>
# </tr>
# </table>
#
# ### Thanks also to <NAME>, <NAME>, <NAME>, and <NAME>
| docs/workshop-tutorial.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# + [markdown] slideshow={"slide_type": "slide"}
# # TALENT Course 11
# ## Learning from Data: Bayesian Methods and Machine Learning
# ### York, UK, June 10-28, 2019
# ### <NAME>, Chalmers University of Technology, Sweden
# + [markdown] slideshow={"slide_type": "-"}
# ## Bayesian Optimization
# Selected references
# * Paper: [Bayesian optimization in ab initio nuclear physics](https://iopscience.iop.org/article/10.1088/1361-6471/ab2b14) by <NAME>, <NAME> et al., Accepted for publication in J. Phys G, (2019)
# * Book: <NAME> (2012). Bayesian approach to global optimization: theory and applications. Kluwer Academic.
# * Software: E.g., [GPyOpt](https://sheffieldml.github.io/GPyOpt/) from Sheffield ML.
#
#
# + slideshow={"slide_type": "-"}
# %matplotlib inline
import numpy as np
import scipy as sp
from scipy.stats import multivariate_normal
import matplotlib.pyplot as plt
import GPy
import GPyOpt
# Not really needed, but nicer plots
import seaborn as sns
sns.set_style("darkgrid")
sns.set_context("talk")
# + [markdown] slideshow={"slide_type": "slide"}
# ### Optimization of expensive objective functions
# + [markdown] slideshow={"slide_type": "fragment"}
# Let us first state an inconvenient fact about optimization:
# + [markdown] slideshow={"slide_type": "subslide"}
# > Global minimization is almost always intractable. In practice, we have to resort to local minimization:
# + [markdown] slideshow={"slide_type": "subslide"}
# For $f:\;\mathbf{R}^D \to \mathbf{R}$, with $\theta \in \Theta \subset \mathbf{R}^D$ and possibly subject to constraints $c(\theta) \leq 0$
#
# Find point(s) $\theta_*$ for which
# $$
# f(\theta_*) \leq f(\theta),
# $$
# for all $\theta \in \Theta$ close to $\theta_*$.
# + [markdown] slideshow={"slide_type": "subslide"}
# Consider **expensive** objective functions, e.g.
# $$
# f(\theta) = \chi^2(\theta) \equiv \sum_{i=1}^N \frac{\left[ y_i^\mathrm{exp} - y_i^\mathrm{th}(\theta) \right]^2}{\sigma_i^2},
# $$
# where $y_i^\mathrm{th}(\theta)$ may be computationally costly to evaluate.
# + [markdown] slideshow={"slide_type": "subslide"}
# #### Example: Nuclear interactions from chiral EFT
# Fitting a nuclear interaction with 20-30 parameters (LECs) to nucleon-nucleon scattering data and possibly few-nucleon observables.
# * Each iteration requires the evaluation of ~6000 NN scattering observables (or phase shifts).
# * And the solution of the A=2 and A=3-body bound-state problem with three-body forces.
# * And/or various NNN scattering problems.
# This is certainly an example of an expensive objective function.
# + [markdown] slideshow={"slide_type": "subslide"}
# Much effort has been spent on this problem by various people. Our contribution has been to:
# 1. introduce modern optimization technology without need for derivatives (POUNDERS in [PETSc/Tao](https://www.mcs.anl.gov/petsc/index.html)).
# 1. implement derivative-based minimization with first- and second-order derivatives from automatic differentiation.
# + [markdown] slideshow={"slide_type": "subslide"}
# #### With POUNDERS
# Ekström et al, (2013)
# [](https://doi.org/10.1103/PhysRevLett.110.192502)
# + [markdown] slideshow={"slide_type": "subslide"}
# #### With POUNDERS (using scattering observables, i.e. including uncertainties)
# Ekström et al., (2015)
# [](https://doi.org/10.1088/0954-3899/42/3/034003)
# + [markdown] slideshow={"slide_type": "subslide"}
# #### Order-by-order with correlations and using automatic differentiation
# <NAME> al., (2016)
# [](https://doi.org/10.1103/PhysRevX.6.011019)
# + [markdown] slideshow={"slide_type": "slide"}
# ## Bayesian optimization
# + [markdown] slideshow={"slide_type": "-"}
# > An optimization algorithm for expensive black-box functions
# + [markdown] slideshow={"slide_type": "subslide"}
# There are two main components in this algorithm;
# 1. A prior probabilistic belief $p(f|D)$ for the objective function $f(\theta)$ given some data $D$. The prior is often a Gaussian process. This is updated in every iteration.
#
# 1. An acquisition function $\mathcal{A}(\theta|D)$ given some data $D$.
# This is a heuristic that balances exploration against exploitation and determines where to evaluate the objective function $f(\theta)$ next.
# + [markdown] slideshow={"slide_type": "subslide"}
# Pseudo-code for BayesOpt:
# 1. initial $\mathbf{\theta}^{(1)},\mathbf{\theta}^{(2)},\ldots \mathbf{\theta}^{(k)}$, where $k \geq 2$
# 1. evaluate the objective function $f(\mathbf{\theta})$ to obtain $y^{(i)}=f(\mathbf{\theta}^{(i)})$ for $i=1,\ldots,k$
# 1. initialize a data vector $\mathcal{D}_k = \left\{(\mathbf{\theta}^{(i)},y^{(i)})\right\}_{i=1}^k$
# 1. select a statistical model for $f(\mathbf{\theta})$
# 1. **for** {$n=k+1,k+2,\ldots$}
# 1. select $\mathbf{\theta}^{(n)}$ by optimizing the acquisition function
# 1. $\mathbf{\theta}^{(n)} = \underset{\mathbf{\theta}}{\text{arg max}}\, \mathcal{A}(\mathbf{\theta}|\mathcal{D}_{n-1})$
# 1. evaluate the objective function to obtain $y^{(n)}=f(\mathbf{\theta}^{(n)})$
# 1. augment the data vector $\mathcal{D}_n = \left\{\mathcal{D}_{n-1} , (\mathbf{\theta}^{(n)},y^{(n)})\right\}$
# 1. update the statistical model for $f(\mathbf{\theta})$
# 1. **end for**
#
# -
# Some remarks:
# * Use of a space-filling method such as LHS or Sobol for the initial $k$ evaluations.
# * Use of a gaussian process, or a Gaussian emulator, for the statistical model of $f(\theta)$.
# * The choice of aquisition function is the heart of BayesOpt. There are several possible choices; with different balance between exploration-exploitation.
# * Expected improvement
# * Lower confidence bound
# * The update of the statistical model is an $\mathcal{O}(n^3)$ cost (if using a GP).
# * The stopping criterion might be a fixed computational budget that limits the number of function evaluations that can be made.
# + [markdown] slideshow={"slide_type": "slide"}
# ## Acquisition functions
# -
# We will consider two different acquisition functions:
# * Lower Confidence Bound (LCB)
# * Expected Improvement (EI)
#
# Note that we abbreviate the notation below and write $\mathcal{A}(\mathbf{\theta}) \equiv \mathcal{A}(\mathbf{\theta}| D)$.
# + [markdown] slideshow={"slide_type": "subslide"}
# #### Lower Confidence Bound
# The lower confidence-bound acquisition function introduces an additional
# parameter $\beta$ that explicitly sets the level of exploration
# \$$
# \mathcal{A}(\mathbf{\theta})_{\rm LCB} = \beta \sigma(\mathbf{\theta}) - \mu(\mathbf{\theta}).
# $$
# The maximum of this acquisition function will occur for the maximum of
# the $\beta$-enlarged confidence envelope of the $\mathcal{GP}$. We
# use $\beta=2$, which is a very common setting. Larger values of
# $\beta$ leads to even more explorative BayesOpt algorithms.
#
# + [markdown] slideshow={"slide_type": "subslide"}
# #### Expected Improvement
# The expected improvement acquisition function is defined by the
# expectation value of the rectifier ${\rm max}(0,f_{\rm min} -
# f(\mathbf{\theta}))$, i.e. we reward any expected reduction of $f$ in
# proportion to the reduction $f_{\rm min} - f(\mathbf{\theta})$. This can be evaluated analytically
# $$
# \begin{align}
# \begin{split}
# \mathcal{A}_{\rm EI}({\mathbf{\theta}})= {}& \langle {\rm max}(0,f_{\rm min} - f(\mathbf{\theta})) \rangle = \int_{-\infty}^{\infty} {\rm max}(0,f_{\rm min}-f)\mathcal{N}(f(\mathbf{\theta})|\mu(\mathbf{\theta}),\sigma(\mathbf{\theta})^2)\,\, df(\mathbf{\theta}) = \\
# {}& \int_{-\infty}^{f_{\rm min}} (f_{\rm min} - f) \frac{1}{\sqrt{2\pi \sigma^2}}\exp\left[{-\frac{(f-\mu)^2}{2\sigma^2}}\right] \,\,df = \\
# {}& (f_{\rm min} - \mu)\Phi\left(\frac{f_{\rm min} - \mu}{\sigma}\right) + \sigma \phi\left(\frac{f_{\rm min} - \mu}{\sigma}\right) = \sigma \left[ z \Phi(z) + \phi(z) \right],
# \end{split}
# \end{align}
# $$
#
# + [markdown] slideshow={"slide_type": "-"}
# where
# $$
# \mathcal{N}(f(\mathbf{x})|\mu(\mathbf{\theta}),\sigma(\mathbf{\theta})^2)
# $$
# indicate the density function of the normal distribution, whereas the standard normal distribution and the cumulative
# distribution function are denoted
# $\phi$ and $\Phi$, respectively, and we dropped the explicit
# dependence on $\mathbf{\theta}$ in the third step.
# -
# In the last step we
# write the result in the standard normal variable $z=\frac{f_{\rm
# min}-\mu}{\sigma}$. BayesOpt will exploit regions of expected
# improvement when the term $z \Phi(z)$ dominates, while new, unknown
# regions will be explored when the second term $\phi(z)$ dominates. For
# the expected improvement acquisition function, the
# exploration-exploitation balance is entirely determined by the set of
# observed data $D_n$ and the $\mathcal{GP}$ kernel.
# + [markdown] slideshow={"slide_type": "subslide"}
# Note 1: Density function of the normal distribution:
# $\mathcal{N}(\theta|\mu,\sigma^2) =
# \frac{1}{\sqrt{2\pi}\sigma}\exp\left(
# -\frac{1}{2\sigma^2}(\theta-\mu)^2\right)$
#
# Note 2: Density function of the standard normal distribution: $\phi(z) \equiv \mathcal{N}(z|\mu=0,\sigma^2=1) = \frac{1}{\sqrt{2 \pi}}\exp\left( -\frac{1}{2}z^2\right)$
#
# Note 3: Cumulative distribution function of the standard normal: $\Phi(z) = \frac{1}{\sqrt{2\pi}} \int_{-\infty}^{z}\exp\left(-\frac{t^2}{2}\right)\, dt$
# + [markdown] slideshow={"slide_type": "slide"}
# ## Univariate example
# +
xmin = 0.
xmax = 1.
def Ftrue(x):
return np.sin(4*np.pi*x) + x**4
# + slideshow={"slide_type": "subslide"}
np.random.seed(123)
x0 = np.random.uniform(xmin,xmax)
res = sp.optimize.minimize(Ftrue,x0)
print(res)
# + slideshow={"slide_type": "subslide"}
X_domain = np.linspace(xmin,xmax,1000)
fig, ax = plt.subplots(1,1,figsize=(8,6))
ax.plot(X_domain,Ftrue(X_domain))
ax.plot(res.x[0],res.fun,'ro')
ax.set(xlabel=r'$x$',ylabel=r'$f(x)$');
# + slideshow={"slide_type": "subslide"}
# parameter bound(s)
bounds = [{'name': 'x_1', 'type': 'continuous', 'domain': (xmin,xmax)}]
# +
acquisition_type = 'EI'
#acquisition_type = 'LCB'
# Creates GPyOpt object with the model and aquisition function
myBopt = GPyOpt.methods.BayesianOptimization(\
f=Ftrue, # function to optimize
initial_design_numdata=1, # Start with two initial data
domain=bounds, # box-constraints of the problem
acquisition_type=acquisition_type, # Selects the acquisition type
exact_feval = True)
# + slideshow={"slide_type": "-"}
# Run the optimization
np.random.seed(123)
max_iter = 1 # evaluation budget
max_time = 60 # time budget
eps = 10e-6 # minimum allowed distance between the last two observations
# + slideshow={"slide_type": "subslide"}
for i in range(10):
myBopt.run_optimization(max_iter, max_time, eps)
myBopt.plot_acquisition()
# + slideshow={"slide_type": "subslide"}
myBopt.plot_convergence()
# + [markdown] slideshow={"slide_type": "slide"}
# ## Bivariate example
# -
# Next, we try a 2-dimensional example. In this case we minimize the Six-hump camel function
# $$
# f(\theta_1,\theta_2)=\left( 4−2.1 \theta_1^2 + \frac{\theta_1^4}{3}\right)\theta_1^2+\theta_1 \theta_2+\left(−4+4\theta_2^2\right)\theta_2^2,
# $$
# in $[−3,3]$, $[−2,2]$. This functions has two global minimum, at (0.0898,−0.7126) and (−0.0898,0.7126). The function is already pre-defined in `GPyOpt`. In this case we generate observations of the function perturbed with white noise of sd=0.1.
# + slideshow={"slide_type": "subslide"}
# create the object function
f_true = GPyOpt.objective_examples.experiments2d.sixhumpcamel()
f_sim = GPyOpt.objective_examples.experiments2d.sixhumpcamel(sd = 0.1)
bounds =[{'name': 'var_1', 'type': 'continuous', 'domain': f_true.bounds[0]},
{'name': 'var_2', 'type': 'continuous', 'domain': f_true.bounds[1]}]
f_true.plot()
# + slideshow={"slide_type": "subslide"}
myBopt2D = GPyOpt.methods.BayesianOptimization(f_sim.f,
domain=bounds,
model_type = 'GP',
acquisition_type='EI',
normalize_Y = True,
exact_feval = False)
# +
# runs the optimization for the three methods
max_iter = 40 # maximum time 40 iterations
max_time = 60 # maximum time 60 seconds
myBopt2D.run_optimization(max_iter,max_time,verbosity=False)
# + slideshow={"slide_type": "subslide"}
myBopt2D.plot_acquisition()
# -
myBopt2D.plot_convergence()
# ### Space-filling sampling
# 
# * Sobol sequence sampling in Python, e.g. with [sobol_seq](https://github.com/naught101/sobol_seq)
# * Latin Hypercube Sampling in Python, e.g. with [pyDOE](https://pythonhosted.org/pyDOE/index.html)
# * Mersenne-Twister is the core random number generator in Python / numpy
# ## Some concluding remarks
# from our paper [arXiv:1902.00941](https://arxiv.org/abs/1902.00941). Accepted for publication in J. Phys G, (2019)
# * **Prior knowledge/belief is everything!** Important to tailor the acquisition function and the GP kernel to the spatial structure of the objective function. Thus, the usefulness of BayesOpt hinge on the arbitrariness and uncertainty of a priori information. Complicated by the fact that we resort to BayesOpt when little is known about the objective function in the first place, since it is computationally expensive to evaluate.
# * In general, BayesOpt will never find a narrow minimum **nor be useful for extracting the exact location of any optimum**.
# * We find that the **acquisition function is more important** than the form of the GP-kernel.
# * BayesOpt would probably benefit from a prior that captures the **large-scale structure of the objective function**.
# * **High-dimensional parameter domains** are always challenging (subspace learning, dim reduction).
| topics/bayesian-methods-and-machine-learning/BayesOpt.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# + [markdown] slideshow={"slide_type": "slide"}
#
#
#
# # ECO 701: Microeconomic Theory, Fall 2017
#
# ## <NAME>
# + [markdown] slideshow={"slide_type": "slide"}
# **Office Hours: HW1504A
# After class, Tue, Wed 11-12pm and by appt.**
#
# <EMAIL>
#
# **Teaching Assistant:** <NAME>
# + [markdown] slideshow={"slide_type": "slide"}
# ## Textbook
# **Nicholson & Snyder, *Microeconomic Theory: Basic Principles and Extensions*.** 11th edition (10th or 12th acceptable).
# <img src="https://images-na.ssl-images-amazon.com/images/I/41pxoVIgGaL._SX398_BO1,204,203,200_.jpg" alt="Drawing" style="width: 300px;"/>
# + [markdown] slideshow={"slide_type": "slide"}
# ### Jupyter notebook materials
# - These lecture slides, problem sets and other handouts prepared as Jupyter notebooks
# + [markdown] slideshow={"slide_type": "fragment"}
# - Cells use markdown for text and math and python (or other language) code for interactive simulations and visualizations.
# + [markdown] slideshow={"slide_type": "subslide"}
# - Notebooks can be rendered in different formats. Depending on how you access, you may be viewing:
# - Interactive notebook (.ipynb) that can be viewed an modified on jupyter server on own computer or cloud. Interactive widgets work.
# - Static HTML or PDF rendering. Cannot edit and interactive widgets do not work or display.
# - Slideshow from notebook displays only pre-selected cells. May be static or interactive (alt-r)
# + [markdown] slideshow={"slide_type": "subslide"}
# - Promising but still evolving technology, so this is an experiment !
# - Please suggest ways to improve content and user experience.
# + [markdown] slideshow={"slide_type": "subslide"}
# ### The Eco 701 notebook library
# - class notebooks stored in a library on Microsoft's Azure Notebooks server, a free cloud server: [notebooks.azure.com/jhconning/libraries/eco701](https://notebooks.azure.com/jhconning/libraries/eco701)
# - Follow link create account/login to view notebooks/slideshows.
# - 'Clone' library to your own account if you wish to interact/modify notebooks or download to own machine if you have local jupyter notebooks and python installation.
#
# - [Eco 701 repository] on github also has content and will be used for issue tracking (i.e.your post corrections/suggestions welcomed here).
# + [markdown] slideshow={"slide_type": "fragment"}
# - You are encouraged but not required to use Jupyter notebooks interactively.
# - Many good intros for learning to use jupyter and python including [on Azure](https://notebooks.azure.com/Microsoft/libraries/samples/html/Introduction%20to%20Python.ipynb) and at the [Quantecon project](https://lectures.quantecon.org/py/)
# + [markdown] slideshow={"slide_type": "subslide"}
# - ### Blackboard or google classroom
# - for communications and grades
# + [markdown] slideshow={"slide_type": "slide"}
# # Course Grading
# - ## 25% Problem sets/participation
# - ## 45% higher of midterm or final
# - ## 30% lower of midterm or final
# - **Final:** TBA
# - **Midterm:** TBA
# + [markdown] slideshow={"slide_type": "fragment"}
# ### Problem sets
# - Usually 4 in the semester. ~ 2 weeks to complete
# - Can work in groups but you must write up your own answers.
# + [markdown] slideshow={"slide_type": "fragment"}
# There are just 12 lecture sessions (excluding midterm), so problem sets and outside reading are important.
# + [markdown] slideshow={"slide_type": "slide"}
# # What are the questions?
# + [markdown] slideshow={"slide_type": "slide"}
# ## How do individuals and societies allocate resources?
# ## What are the alternatives?
#
# + [markdown] slideshow={"slide_type": "fragment"}
# - Far more than the study of demand and supply choices in ‘markets’
# - how do agents (individuals, households, firms, groups) choose to associate and contract and the rules of the game they play by.
# - strategies, contracts, organizations, property rights, institutions and policy. Supply and demand decisions.
# - Judging outcomes: Conflict or cooperation? Efficient, equitable, just?
# + [markdown] slideshow={"slide_type": "slide"}
# ## Methods and Assumptions
# - Methodological individualism and instrumental rationality
# - Optimization subject to constraints and marginal analysis
# - Feedback, interactions and equilibrium
# - *Ceteribus paribus* and 'what-if' comparative statics
# - Modern challenges to behavioral and other assumptions
# - Theory and Evidence
# + [markdown] slideshow={"slide_type": "slide"}
# ## What is neo-classical economics ... and why bother with it?
#
# <NAME> ([8/28/12](https://krugman.blogs.nytimes.com/2012/08/28/neo-fights-slightly-wonkish-and-vague/?mcubz=0&_r=0)):
#
# >... maximization-with-equilibrium. We imagine an economy consisting of rational, self-interested players, and suppose that economic outcomes reflect a situation in which each player is doing the best he, she, or it can given the actions of all the other players. If nobody has market power, this comes down to the textbook picture of perfectly competitive markets with all the marginal whatevers equal.
# + [markdown] slideshow={"slide_type": "subslide"}
# >... Some economists really really believe that life is like this — and they have a significant impact on our discourse.
#
# > But the rest of us are well aware that this is nothing but a metaphor! [we take]... the maximization-and-equilibrium world as a starting point or baseline, which is then modified — but not too much — in the direction of realism.
#
# + [markdown] slideshow={"slide_type": "slide"}
# ## Mathematical Preliminaries
# + [markdown] slideshow={"slide_type": "slide"}
# ### (brief note on Jupyter notebooks)
#
# Jupyter notebooks are made up of cells that are either markdown cells or code cells. A Jupyter slideshow is typically created by marking many code cells to be 'skipped' in order to not clutter the presentation.
#
# I'd typically hide a code cell like the following, but will reveal it here to illustrate how we are importing additional python libraries to extend the standard python library. matplotlib and numpy are for plotting and matrix algebra.
# + slideshow={"slide_type": "-"}
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
# %matplotlib inline
# + [markdown] slideshow={"slide_type": "slide"}
# ## Calculus for Optimization
# + [markdown] slideshow={"slide_type": "fragment"}
# Cost function: $$C(q) = F + q^2$$
#
# Profit function:
# \begin{align}
# \Pi(q) & = P \cdot q - C(q) \\
# &= P\cdot q - A - q^2
# \end{align}
#
# + [markdown] slideshow={"slide_type": "fragment"}
# First-order necessary condition: $\frac{d\Pi}{dq} = P - 2q = 0$
#
# Solve for $q$: $q^* =\frac{P}{2} $
#
# Profit maximizing output level is independent of fixed cost $F$
# + slideshow={"slide_type": "skip"}
F = 10
P = 10
def C(q, F=F):
return F + q**2
def profit(q, P=P, F=F):
return P*q - C(q, F)
def opt(P, F):
return P/2, profit(P/2, P, F)
q = np.linspace(0,10,20)
# + slideshow={"slide_type": "slide"}
qe, pre = opt(P,F)
plt.figure(figsize=(12,5))
plt.plot(q, profit(q))
plt.scatter(qe,pre)
plt.plot([qe,qe],[0,pre],linestyle=':')
plt.gca().spines['bottom'].set_position('zero')
plt.gca().spines['right'].set_visible(False)
plt.gca().spines['top'].set_visible(False)
plt.xlabel(r'$q - output$');
# + [markdown] slideshow={"slide_type": "slide"}
# ### Next Lecture: [Constrained Optimization](01_Constrained_Optimization.ipynb)
| notebooks/micro/00_Introduction.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# + hide_input=false
# export
from nbdev.imports import *
from fastscript import *
# +
# default_exp export
# default_cls_lvl 3
# -
#hide
#not a dep but we need it for show_doc
from nbdev.showdoc import show_doc
# # Export to modules
#
# > The functions that transform notebooks in a library
# The most important function defined in this module is `notebooks2script`, so you may want to jump to it before scrolling though the rest, which explain the details behind the scenes of the conversion from notebooks to library. The main things to remember are:
# - put an `# export` flag on each cell you want exported
# - put an `# exports` flag (for export and show) on each cell you want exported with the source code shown in the docs
# - one cell should contain `# default_exp` flag followed by the name of the module (with points for submodules and without the py extension) everything should be exported in (if one specific cell needs to be exported in a different module, just indicate it after the `# export` flag: `# export special.module`)
# - all left members of an equality, functions and classes will be exported and variables that are not private will be put in the `__all__` automatically
# - to add something to `__all__` if it's not picked automatically, write an exported cell with something like `_all_ = ["my_name"]` (the single underscores are intentional)
# ## Basic foundations
# For bootstrapping `nbdev` we have a few basic foundations defined in `imports`, which we test a show here. First, a simple config file class, `Config` that read the content of your `settings.ini` file and make it accessible:
show_doc(Config, title_level=3)
cfg = Config.create("nbdev", user='fastai', path='..', tst_flags='tst', cfg_name='test_settings.ini')
cfg = Config(cfg_name='test_settings.ini')
test_eq(cfg.lib_name, 'nbdev')
test_eq(cfg.git_url, "https://github.com/fastai/nbdev/tree/master/")
test_eq(cfg.lib_path, Path.cwd().parent/'nbdev')
test_eq(cfg.nbs_path, Path.cwd())
test_eq(cfg.doc_path, Path.cwd().parent/'docs')
test_eq(cfg.custom_sidebar, 'False')
# We derive some useful variables to check what environment we're in:
if not os.environ.get("IN_TEST", None):
assert IN_NOTEBOOK
assert not IN_COLAB
assert IN_IPYTHON
# Then we have a few util functions.
show_doc(last_index)
test_eq(last_index(1, [1,2,1,3,1,4]), 4)
test_eq(last_index(2, [1,2,1,3,1,4]), 1)
test_eq(last_index(5, [1,2,1,3,1,4]), -1)
show_doc(compose)
f1 = lambda o,p=0: (o*2)+p
f2 = lambda o,p=1: (o+1)/p
test_eq(f2(f1(3)), compose(f1,f2)(3))
test_eq(f2(f1(3,p=3),p=3), compose(f1,f2)(3,p=3))
test_eq(f2(f1(3, 3), 3), compose(f1,f2)(3, 3))
show_doc(parallel)
# +
import time,random
def add_one(x, a=1):
time.sleep(random.random()/100)
return x+a
inp,exp = range(50),range(1,51)
test_eq(parallel(add_one, inp, n_workers=2), list(exp))
test_eq(parallel(add_one, inp, n_workers=0), list(exp))
test_eq(parallel(add_one, inp, n_workers=1, a=2), list(range(2,52)))
test_eq(parallel(add_one, inp, n_workers=0, a=2), list(range(2,52)))
# -
# ## Reading a notebook
# ### What's a notebook?
# A jupyter notebook is a json file behind the scenes. We can just read it with the json module, which will return a nested dictionary of dictionaries/lists of dictionaries, but there are some small differences between reading the json and using the tools from `nbformat` so we'll use this one.
#export
def read_nb(fname):
"Read the notebook in `fname`."
with open(Path(fname),'r', encoding='utf8') as f: return nbformat.reads(f.read(), as_version=4)
# `fname` can be a string or a pathlib object.
test_nb = read_nb('00_export.ipynb')
# The root has four keys: `cells` contains the cells of the notebook, `metadata` some stuff around the version of python used to execute the notebook, `nbformat` and `nbformat_minor` the version of nbformat.
test_nb.keys()
test_nb['metadata']
f"{test_nb['nbformat']}.{test_nb['nbformat_minor']}"
# The cells key then contains a list of cells. Each one is a new dictionary that contains entries like the type (code or markdown), the source (what is written in the cell) and the output (for code cells).
test_nb['cells'][0]
# ### Finding patterns
# The following functions are sued to catch the flags used in the code cells.
# export
def check_re(cell, pat, code_only=True):
"Check if `cell` contains a line with regex `pat`"
if code_only and cell['cell_type'] != 'code': return
if isinstance(pat, str): pat = re.compile(pat, re.IGNORECASE | re.MULTILINE)
return pat.search(cell['source'])
# `pat` can be a string or a compiled regex, if `code_only=True`, this function ignores markdown cells.
cell = test_nb['cells'][0].copy()
assert check_re(cell, '# export') is not None
assert check_re(cell, re.compile('# export')) is not None
assert check_re(cell, '# bla') is None
cell['cell_type'] = 'markdown'
assert check_re(cell, '# export') is None
assert check_re(cell, '# export', code_only=False) is not None
# export
_re_blank_export = re.compile(r"""
# Matches any line with #export or #exports without any module name:
^ # beginning of line (since re.MULTILINE is passed)
\s* # any number of whitespace
\#\s* # # then any number of whitespace
exports? # export or exports
\s* # any number of whitespace
$ # end of line (since re.MULTILINE is passed)
""", re.IGNORECASE | re.MULTILINE | re.VERBOSE)
# export
_re_mod_export = re.compile(r"""
# Matches any line with #export or #exports with a module name and catches it in group 1:
^ # beginning of line (since re.MULTILINE is passed)
\s* # any number of whitespace
\#\s* # # then any number of whitespace
exports? # export or exports
\s* # any number of whitespace
(\S+) # catch a group with any non-whitespace chars
\s* # any number of whitespace
$ # end of line (since re.MULTILINE is passed)
""", re.IGNORECASE | re.MULTILINE | re.VERBOSE)
# export
def is_export(cell, default):
"Check if `cell` is to be exported and returns the name of the module to export it if provided"
if check_re(cell, _re_blank_export):
if default is None:
print(f"This cell doesn't have an export destination and was ignored:\n{cell['source'][1]}")
return default
tst = check_re(cell, _re_mod_export)
return os.path.sep.join(tst.groups()[0].split('.')) if tst else None
# The cells to export are marked with an `#export` or `#exports` code, potentially with a module name where we want it exported. The default module is given in a cell of the form `#default_exp bla` inside the notebook (usually at the top), though in this function, it needs the be passed (the final script will read the whole notebook to find it).
# - a cell marked with `# export` or `# exports` will be exported to the defualt module
# - a cell marked with `# export special.module` or `# exports special.module` will be exported in special.module (located in `lib_name`/special/module.py)
cell = test_nb['cells'][0].copy()
test_eq(is_export(cell, 'export'), 'export')
cell['source'] = "# exports"
test_eq(is_export(cell, 'export'), 'export')
cell['source'] = "# export mod"
test_eq(is_export(cell, 'export'), 'mod')
cell['source'] = "# export mod.file"
test_eq(is_export(cell, 'export'), 'mod/file')
cell['source'] = "# expt mod.file"
assert is_export(cell, 'export') is None
# export
_re_default_exp = re.compile(r"""
# Matches any line with #default_exp with a module name and catches it in group 1:
^ # beginning of line (since re.MULTILINE is passed)
\s* # any number of whitespace
\#\s* # # then any number of whitespace
default_exp # export or exports
\s* # any number of whitespace
(\S+) # catch a group with any non-whitespace chars
\s* # any number of whitespace
$ # end of line (since re.MULTILINE is passed)
""", re.IGNORECASE | re.MULTILINE | re.VERBOSE)
# export
def find_default_export(cells):
"Find in `cells` the default export module."
for cell in cells:
tst = check_re(cell, _re_default_exp)
if tst: return tst.groups()[0]
# Stops at the first cell containing a `# default_exp` flag (if there are several) and returns the value behind. Returns `None` if there are no cell with that code.
test_eq(find_default_export(test_nb['cells']), 'export')
assert find_default_export(test_nb['cells'][2:]) is None
# ### Listing all exported objects
# The following functions make a list of everything that is exported to prepare a proper `__all__` for our exported module.
#export
_re_patch_func = re.compile(r"""
# Catches any function decorated with @patch, its name in group 1 and the patched class in group 2
@patch # At any place in the cell, something that begins with @patch
\s*def # Any number of whitespace (including a new line probably) followed by def
\s+ # One whitespace or more
([^\(\s]*) # Catch a group composed of anything but whitespace or an opening parenthesis (name of the function)
\s*\( # Any number of whitespace followed by an opening parenthesis
[^:]* # Any number of character different of : (the name of the first arg that is type-annotated)
:\s* # A column followed by any number of whitespace
(?: # Non-catching group with either
([^,\s\(\)]*) # a group composed of anything but a comma, a parenthesis or whitespace (name of the class)
| # or
(\([^\)]*\))) # a group composed of something between parenthesis (tuple of classes)
\s* # Any number of whitespace
(?:,|\)) # Non-catching group with either a comma or a closing parenthesis
""", re.VERBOSE)
#hide
tst = _re_patch_func.search("""
@patch
def func(obj:Class):""")
test_eq(tst.groups(), ("func", "Class", None))
tst = _re_patch_func.search("""
@patch
def func (obj:Class, a)""")
test_eq(tst.groups(), ("func", "Class", None))
tst = _re_patch_func.search("""
@patch
def func (obj:(Class1, Class2), a)""")
test_eq(tst.groups(), ("func", None, "(Class1, Class2)"))
#export
_re_typedispatch_func = re.compile(r"""
# Catches any function decorated with @typedispatch
(@typedispatch # At any place in the cell, catch a group with something that begins with @patch
\s*def # Any number of whitespace (including a new line probably) followed by def
\s+ # One whitespace or more
[^\(]* # Anything but whitespace or an opening parenthesis (name of the function)
\s*\( # Any number of whitespace followed by an opening parenthesis
[^\)]* # Any number of character different of )
\)\s*:) # A closing parenthesis followed by whitespace and :
""", re.VERBOSE)
#hide
assert _re_typedispatch_func.search("@typedispatch\ndef func(a, b):").groups() == ('@typedispatch\ndef func(a, b):',)
#export
_re_class_func_def = re.compile(r"""
# Catches any 0-indented function or class definition with its name in group 1
^ # Beginning of a line (since re.MULTILINE is passed)
(?:def|class) # Non-catching group for def or class
\s+ # One whitespace or more
([^\(\s]*) # Catching group with any character except an opening parenthesis or a whitespace (name)
\s* # Any number of whitespace
(?:\(|:) # Non-catching group with either an opening parenthesis or a : (classes don't need ())
""", re.MULTILINE | re.VERBOSE)
#hide
test_eq(_re_class_func_def.search("class Class:").groups(), ('Class',))
test_eq(_re_class_func_def.search("def func(a, b):").groups(), ('func',))
#export
_re_obj_def = re.compile(r"""
# Catches any 0-indented object definition (bla = thing) with its name in group 1
^ # Beginning of a line (since re.MULTILINE is passed)
([^=\s]*) # Catching group with any character except a whitespace or an equal sign
\s*= # Any number of whitespace followed by an =
""", re.MULTILINE | re.VERBOSE)
#hide
test_eq(_re_obj_def.search("a = 1").groups(), ('a',))
test_eq(_re_obj_def.search("a=1").groups(), ('a',))
# +
# export
def _not_private(n):
for t in n.split('.'):
if (t.startswith('_') and not t.startswith('__')) or t.startswith('@'): return False
return '\\' not in t and '^' not in t and '[' not in t
def export_names(code, func_only=False):
"Find the names of the objects, functions or classes defined in `code` that are exported."
#Format monkey-patches with @patch
def _f(gps):
nm, cls, t = gps.groups()
if cls is not None: return f"def {cls}.{nm}():"
return '\n'.join([f"def {c}.{nm}():" for c in re.split(', *', t[1:-1])])
code = _re_typedispatch_func.sub('', code)
code = _re_patch_func.sub(_f, code)
names = _re_class_func_def.findall(code)
if not func_only: names += _re_obj_def.findall(code)
return [n for n in names if _not_private(n)]
# -
# This function only picks the zero-indented objects on the left side of an =, functions or classes (we don't want the class methods for instance) and excludes private names (that begin with `_`) but no dunder names. It only returns func and class names (not the objects) when `func_only=True`.
#
# To work properly with fastai added python functionality, this function ignores function decorated with `@typedispatch` (since they are defined multiple times) and unwraps properly functions decorated with `@patch`.
# +
test_eq(export_names("def my_func(x):\n pass\nclass MyClass():"), ["my_func", "MyClass"])
#Indented funcs are ignored (funcs inside a class)
test_eq(export_names(" def my_func(x):\n pass\nclass MyClass():"), ["MyClass"])
#Private funcs are ignored, dunder are not
test_eq(export_names("def _my_func():\n pass\nclass MyClass():"), ["MyClass"])
test_eq(export_names("__version__ = 1:\n pass\nclass MyClass():"), ["MyClass", "__version__"])
#trailing spaces
test_eq(export_names("def my_func ():\n pass\nclass MyClass():"), ["my_func", "MyClass"])
#class without parenthesis
test_eq(export_names("def my_func ():\n pass\nclass MyClass:"), ["my_func", "MyClass"])
#object and funcs
test_eq(export_names("def my_func ():\n pass\ndefault_bla=[]:"), ["my_func", "default_bla"])
test_eq(export_names("def my_func ():\n pass\ndefault_bla=[]:", func_only=True), ["my_func"])
#Private objects are ignored
test_eq(export_names("def my_func ():\n pass\n_default_bla = []:"), ["my_func"])
#Objects with dots are privates if one part is private
test_eq(export_names("def my_func ():\n pass\ndefault.bla = []:"), ["my_func", "default.bla"])
test_eq(export_names("def my_func ():\n pass\ndefault._bla = []:"), ["my_func"])
#Monkey-path with @patch are properly renamed
test_eq(export_names("@patch\ndef my_func(x:Class):\n pass"), ["Class.my_func"])
test_eq(export_names("@patch\ndef my_func(x:Class):\n pass", func_only=True), ["Class.my_func"])
test_eq(export_names("some code\n@patch\ndef my_func(x:Class, y):\n pass"), ["Class.my_func"])
test_eq(export_names("some code\n@patch\ndef my_func(x:(Class1,Class2), y):\n pass"), ["Class1.my_func", "Class2.my_func"])
#Check delegates
test_eq(export_names("@delegates(keep=True)\nclass someClass:\n pass"), ["someClass"])
#Typedispatch decorated functions shouldn't be added
test_eq(export_names("@patch\ndef my_func(x:Class):\n pass\n@typedispatch\ndef func(x: TensorImage): pass"), ["Class.my_func"])
# +
#export
_re_all_def = re.compile(r"""
# Catches a cell with defines \_all\_ = [\*\*] and get that \*\* in group 1
^_all_ # Beginning of line (since re.MULTILINE is passed)
\s*=\s* # Any number of whitespace, =, any number of whitespace
\[ # Opening [
([^\n\]]*) # Catching group with anything except a ] or newline
\] # Closing ]
""", re.MULTILINE | re.VERBOSE)
#Same with __all__
_re__all__def = re.compile(r'^__all__\s*=\s*\[([^\]]*)\]', re.MULTILINE)
# -
# export
def extra_add(code):
"Catch adds to `__all__` required by a cell with `_all_=`"
if _re_all_def.search(code):
names = _re_all_def.search(code).groups()[0]
names = re.sub('\s*,\s*', ',', names)
names = names.replace('"', "'")
code = _re_all_def.sub('', code)
code = re.sub(r'([^\n]|^)\n*$', r'\1', code)
return names.split(','),code
return [],code
# Sometimes objects are not picked to be automatically added to the `__all__` of the module so you will need to add them manually. To do so, create an exported cell with the following code `_all_ = ["name"]` (the single underscores are intentional)>
test_eq(extra_add('_all_ = ["func", "func1", "func2"]'), (["'func'", "'func1'", "'func2'"],''))
test_eq(extra_add('_all_ = ["func", "func1" , "func2"]'), (["'func'", "'func1'", "'func2'"],''))
test_eq(extra_add("_all_ = ['func','func1', 'func2']\n"), (["'func'", "'func1'", "'func2'"],''))
test_eq(extra_add('code\n\n_all_ = ["func", "func1", "func2"]'), (["'func'", "'func1'", "'func2'"],'code'))
#export
def _add2add(fname, names, line_width=120):
if len(names) == 0: return
with open(fname, 'r', encoding='utf8') as f: text = f.read()
tw = TextWrapper(width=120, initial_indent='', subsequent_indent=' '*11, break_long_words=False)
re_all = _re__all__def.search(text)
start,end = re_all.start(),re_all.end()
text_all = tw.wrap(f"{text[start:end-1]}{'' if text[end-2]=='[' else ', '}{', '.join(names)}]")
with open(fname, 'w', encoding='utf8') as f: f.write(text[:start] + '\n'.join(text_all) + text[end:])
fname = 'test_add.txt'
with open(fname, 'w', encoding='utf8') as f: f.write("Bla\n__all__ = [my_file, MyClas]\nBli")
_add2add(fname, ['new_function'])
with open(fname, 'r', encoding='utf8') as f:
test_eq(f.read(), "Bla\n__all__ = [my_file, MyClas, new_function]\nBli")
_add2add(fname, [f'new_function{i}' for i in range(10)])
with open(fname, 'r', encoding='utf8') as f:
test_eq(f.read(), """Bla
__all__ = [my_file, MyClas, new_function, new_function0, new_function1, new_function2, new_function3, new_function4,
new_function5, new_function6, new_function7, new_function8, new_function9]
Bli""")
os.remove(fname)
# export
def relative_import(name, fname):
"Convert a module `name` to a name relative to `fname`"
mods = name.split('.')
splits = str(fname).split(os.path.sep)
if mods[0] not in splits: return name
i=len(splits)-1
while i>0 and splits[i] != mods[0]: i-=1
splits = splits[i:]
while len(mods)>0 and splits[0] == mods[0]: splits,mods = splits[1:],mods[1:]
return '.' * (len(splits)) + '.'.join(mods)
# When we say from
# ``` python
# from lib_name.module.submodule import bla
# ```
# in a notebook, it needs to be converted to something like
# ```
# from .module.submodule import bla
# ```
# or
# ```from .submodule import bla```
# depending on where we are. This function deals with those imports renaming.
test_eq(relative_import('nbdev.core', Path.cwd()/'nbdev'/'data.py'), '.core')
test_eq(relative_import('nbdev.core', Path('nbdev')/'vision'/'data.py'), '..core')
test_eq(relative_import('nbdev.vision.transform', Path('nbdev')/'vision'/'data.py'), '.transform')
test_eq(relative_import('nbdev.notebook.core', Path('nbdev')/'data'/'external.py'), '..notebook.core')
test_eq(relative_import('nbdev.vision', Path('nbdev')/'vision'/'learner.py'), '.')
#export
_re_import = ReLibName(r'^(\s*)from (LIB_NAME.\S*) import (.*)$')
# export
def _deal_import(code_lines, fname):
def _replace(m):
sp,mod,obj = m.groups()
return f"{sp}from {relative_import(mod, fname)} import {obj}"
return [_re_import.re.sub(_replace,line) for line in code_lines]
#hide
lines = ["from nbdev.core import *", "nothing to see", " from nbdev.vision import bla1, bla2", "from nbdev.vision import models"]
test_eq(_deal_import(lines, Path.cwd()/'nbdev'/'data.py'), [
"from .core import *", "nothing to see", " from .vision import bla1, bla2", "from .vision import models"
])
# ## Create the library
# ### Saving an index
# To be able to build back a correspondence between functions and the notebooks they are defined in, we need to store an index. It's done in the private module `_nbdev` inside your library, and the following function are used to define it.
#export
_re_patch_func = re.compile(r"""
# Catches any function decorated with @patch, its name in group 1 and the patched class in group 2
@patch # At any place in the cell, something that begins with @patch
\s*def # Any number of whitespace (including a new line probably) followed by def
\s+ # One whitespace or more
([^\(\s]*) # Catch a group composed of anything but whitespace or an opening parenthesis (name of the function)
\s*\( # Any number of whitespace followed by an opening parenthesis
[^:]* # Any number of character different of : (the name of the first arg that is type-annotated)
:\s* # A column followed by any number of whitespace
(?: # Non-catching group with either
([^,\s\(\)]*) # a group composed of anything but a comma, a parenthesis or whitespace (name of the class)
| # or
(\([^\)]*\))) # a group composed of something between parenthesis (tuple of classes)
\s* # Any number of whitespace
(?:,|\)) # Non-catching group with either a comma or a closing parenthesis
""", re.VERBOSE)
#export
def reset_nbdev_module():
"Create a skeletton for `_nbdev`"
fname = Config().lib_path/'_nbdev.py'
fname.parent.mkdir(parents=True, exist_ok=True)
with open(fname, 'w') as f:
f.write(f"#AUTOGENERATED BY NBDEV! DO NOT EDIT!")
f.write('\n\n__all__ = ["index", "modules", "custom_doc_links", "git_url"]')
f.write('\n\nindex = {}')
f.write('\n\nmodules = []')
f.write(f'\n\ngit_url = "{Config().git_url}"')
f.write('\n\ndef custom_doc_links(name): return None')
# export
class _EmptyModule():
def __init__(self): self.index,self.modules,self.git_url = {},[],""
def custom_doc_links(name): return None
# export
def get_nbdev_module():
"Reads `_nbdev`"
try:
spec = importlib.util.spec_from_file_location(f"{Config().lib_name}._nbdev", Config().lib_path/'_nbdev.py')
mod = importlib.util.module_from_spec(spec)
spec.loader.exec_module(mod)
return mod
except: return _EmptyModule()
#export
_re_index_idx = re.compile(r'index\s*=\s*{[^}]*}')
_re_index_mod = re.compile(r'modules\s*=\s*\[[^\]]*\]')
#export
def save_nbdev_module(mod):
"Save `mod` inside `_nbdev`"
fname = Config().lib_path/'_nbdev.py'
with open(fname, 'r') as f: code = f.read()
t = ',\n '.join([f'"{k}": "{v}"' for k,v in mod.index.items()])
code = _re_index_idx.sub("index = {"+ t +"}", code)
t = ',\n '.join([f'"{f}"' for f in mod.modules])
code = _re_index_mod.sub(f"modules = [{t}]", code)
with open(fname, 'w') as f: f.write(code)
#hide
ind,ind_bak = Config().lib_path/'_nbdev.py',Config().lib_path/'_nbdev.bak'
if ind.exists(): shutil.move(ind, ind_bak)
try:
reset_nbdev_module()
mod = get_nbdev_module()
test_eq(mod.index, {})
test_eq(mod.modules, [])
mod.index = {'foo':'bar'}
mod.modules.append('lala.bla')
save_nbdev_module(mod)
mod = get_nbdev_module()
test_eq(mod.index, {'foo':'bar'})
test_eq(mod.modules, ['lala.bla'])
finally:
if ind_bak.exists(): shutil.move(ind_bak, ind)
# ### Create the modules
# export
def create_mod_file(fname, nb_path):
"Create a module file for `fname`."
fname.parent.mkdir(parents=True, exist_ok=True)
with open(fname, 'w') as f:
f.write(f"#AUTOGENERATED! DO NOT EDIT! File to edit: dev/{nb_path.name} (unless otherwise specified).")
f.write('\n\n__all__ = []')
# A new module filename is created each time a notebook has a cell marked with `# default_exp`. In your collection of notebooks, you should only have one notebook that creates a given module since they are re-created each time you do a library build (to ensure the library is clean). Note that any file you create manually will never be overwritten (unless it has the same name as one of the modules defined in a `# default_exp` cell) so you are responsible to clean up those yourself.
#
# `nb_fname` is the notebook that contained the `# default_exp` cell.
#export
def _notebook2script(fname, silent=False, to_dict=None):
"Finds cells starting with `#export` and puts them into a new module"
if os.environ.get('IN_TEST',0): return # don't export if running tests
fname = Path(fname)
nb = read_nb(fname)
default = find_default_export(nb['cells'])
if default is not None:
default = os.path.sep.join(default.split('.'))
if to_dict is None: create_mod_file(Config().lib_path/f'{default}.py', fname)
mod = get_nbdev_module()
exports = [is_export(c, default) for c in nb['cells']]
cells = [(i,c,e) for i,(c,e) in enumerate(zip(nb['cells'],exports)) if e is not None]
for i,c,e in cells:
fname_out = Config().lib_path/f'{e}.py'
orig = ('#C' if e==default else f'#Comes from {fname.name}, c') + 'ell\n'
code = '\n\n' + orig + '\n'.join(_deal_import(c['source'].split('\n')[1:], fname_out))
# remove trailing spaces
names = export_names(code)
extra,code = extra_add(code)
if to_dict is None: _add2add(fname_out, [f"'{f}'" for f in names if '.' not in f and len(f) > 0] + extra)
mod.index.update({f: fname.name for f in names})
code = re.sub(r' +$', '', code, flags=re.MULTILINE)
if code != '\n\n' + orig[:-1]:
if to_dict is not None: to_dict[fname_out].append((i, fname, code))
else:
with open(fname_out, 'a', encoding='utf8') as f: f.write(code)
if f'{e}.py' not in mod.modules: mod.modules.append(f'{e}.py')
save_nbdev_module(mod)
if not silent: print(f"Converted {fname.name}.")
return to_dict
#hide
_notebook2script('00_export.ipynb')
#export
def add_init(path):
"Add `__init__.py` in all subdirs of `path` containing python files if it's not there already"
for p,d,f in os.walk(path):
for f_ in f:
if f_.endswith('.py'):
if not (Path(p)/'__init__.py').exists(): (Path(p)/'__init__.py').touch()
break
with tempfile.TemporaryDirectory() as d:
os.makedirs(Path(d)/'a', exist_ok=True)
(Path(d)/'a'/'f.py').touch()
os.makedirs(Path(d)/'a/b', exist_ok=True)
(Path(d)/'a'/'b'/'f.py').touch()
add_init(d)
assert not (Path(d)/'__init__.py').exists()
for e in [Path(d)/'a', Path(d)/'a/b']:
assert (e/'__init__.py').exists()
#export
def notebook2script(fname=None, silent=False, to_dict=False):
"Convert notebooks matching `fname` to modules"
# initial checks
if os.environ.get('IN_TEST',0): return # don't export if running tests
if fname is None:
reset_nbdev_module()
files = [f for f in Config().nbs_path.glob('*.ipynb') if not f.name.startswith('_')]
else: files = glob.glob(fname)
d = collections.defaultdict(list) if to_dict else None
for f in sorted(files): d = _notebook2script(f, silent=silent, to_dict=d)
if to_dict: return d
else: add_init(Config().lib_path)
# Finds cells starting with `#export` and puts them into the appropriate module. If `fname` is not specified, this will convert all notebook not beginning with an underscore in the `nb_folder` defined in `setting.ini`. Otherwise `fname` can be a single filename or a glob expression.
#
# `silent` makes the command not print any statement and `to_dict` is used internally to convert the library to a dictionary.
#hide
#export
#for tests only
class DocsTestClass:
def test(): pass
# ## Export -
#hide
notebook2script()
| nbs/00_export.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 2
# language: python
# name: python2
# ---
# The question to explore is the following: given Kepler observations, how many events of the following type are we likely to observe as single eclipse events?
#
# * EBs
# * BEBs
# * HEBs
#
# More specifically, given a period and depth range, how many of each do I predict?
from keputils import kicutils as kicu
stars = kicu.DATA # This is Q17 stellar table.
# OK, first, let's calculate the number of expected EBs. That is, assign each Kepler target star a binary companion according to the Raghavan (2010) distribution, and see what the eclipsing population looks like. Let's use tools from `vespa` to make this happen.
stars = stars.query('mass > 0') #require there to be a mass.
len(stars)
# +
from vespa.stars import Raghavan_BinaryPopulation
binpop = Raghavan_BinaryPopulation(M=stars.mass)
# -
binpop.stars.columns
# +
# %matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
# e.g.,
plt.hist(np.log10(binpop.orbpop.P.value), histtype='step', lw=3);
plt.figure()
plt.hist(binpop.orbpop.ecc, histtype='step', lw=3);
plt.figure()
binpop.orbpop.scatterplot(ms=0.05, rmax=1000);
# +
# Determine eclipse probabilities
import astropy.units as u
ecl_prob = ((binpop.stars.radius_A.values + binpop.stars.radius_B.values)*u.Rsun / binpop.orbpop.semimajor).decompose()
# -
sum(ecl_prob > 1) # These will need to be ignored later.
ok = ecl_prob < 1
# Rough estimate of numbers of systems with eclipsing orientation
ecl_prob[ok].sum()
# OK, how many that have periods less than 1 years?
kep_ok = (ok & (binpop.orbpop.P < 3*u.yr))
ecl_prob[kep_ok].sum()
# And, including binary fraction
fB = 0.4
fB * ecl_prob[kep_ok].sum()
# This is actually a bit low compared to the Kepler EB catalog haul of 2878 EBs. However, keep in mind that this is only looking at *binaries*, not considering triple systems that tend to have much closer pairs. So to my eye this is actually a pretty believable number. (Also note that this does not take eccentricity into account.) How many of these would have periods from 5 to 15 years?
minP = 5*u.yr; maxP = 15*u.yr
kep_long = ok & (binpop.orbpop.P > minP) & (binpop.orbpop.P < maxP)
fB * ecl_prob[kep_long].sum()
# This seems like a lot. Now keep in mind this is just the number with eclipsing *geometry*, not the number that would actually show up within the Kepler data, taking the window function into account. A quick hack at this would be that the probability for an eclipse to be within the Kepler window would be `4yr / P`.
# +
in_window = np.clip(4*u.yr / binpop.orbpop.P, 0, 1).decompose()
fB*(ecl_prob[kep_long] * in_window[kep_long]).sum()
# -
# OK, better, but this still seems like a lot. Perhaps I'm doing something wrong here? Accounting properly for eccentricity in the transit probability will only make this number larger. Of course, only a fraction of these would be plausibly planetary-like signals, but still, this seems like an overestimate, though not crazy.
| notebooks/predictions.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3.7.1 64-bit (conda)
# name: python37164bitcondaa00d8dddf2684238a29fd3466bf30d2e
# ---
from metaflow import Metaflow
selected_run = Metaflow().flows[0].latest_successful_run
import pandas
# + tags=[]
table_arr = []
for pid,pap in selected_run.data.processed_papers:
table_arr.append(dict(num_tables=len(pap.tables),paper_id = pid))
df = pandas.DataFrame(table_arr)
# -
import plotly.express as px
px.histogram(df,x='num_tables')
| notebooks/metaflow_res.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
# default_exp examples
# -
#hide
from nbdev.showdoc import *
# hide
import graphviz
def gv(s): return graphviz.Source('digraph G{ rankdir="LR"' + s + '; }')
# + active=""
# ---
# dummy: In diesem Vorspann stehen Variablen, die von Pandoc bzw. dem Template 'Eisvogel' genutzt werden
# title: "Jupyter Notebooks und LaTeX"
# author: <NAME>
# subject: "Jupyter Notebooks und LaTeX"
# keywords: [Markdown, FHDW, Abschlussarbeiten]
# toc-own-page: true
# titlepage: true
# header-right: "\\phantom{Ich will nichts sehen} "
# footer-left: "\\phantom{Ich will nichts sehen} "
# lang: "de"
# fontfamily: "lmodern"
# reference-section-title: "Quellen"
# ---
# -
# # Einleitung
# Dieses Dokument soll anhand einiger Beispiele die Möglichkeiten von Jupyter-Notebooks aufzeigen, Literate-Programming zu realisieren. Beim Literate-Programming wird der Quellcode und die dazu gehörende Dokumentation integriert in einem Dokument entwickelt und gepflegt. Der prinzipielle Ablauf ist folgender:
# 
# D.h. aus dem Jupyter-Notebook (.ipynb) wird im ersten Prozess über die Zwischenschritte Markdown und LaTeX am Ende ein PDF-Dokument. Im zweiten Prozess wird aus dem selben Jupyter-Notebook der lauffähige Python-Code erzeugt. Ermöglicht wird dies durch den Einsatz des Frameworks nbdev. nbdev ist in Python geschrieben, genauso wie die Datenanalyse-Software, die Sie im Rahmen dieser Veranstaltung erstellen sollen. Falls Sie eine Einführung in Python benötigen, so wäre z.B. das Buch von Kofler[^Kofler18] geeignet. Einen fundierten und unterhaltsamen Überblick über sog. NoSQL-Datenbanken bietet ein Vortrag von Fowler[^fowler13], der per Youtube verfügbar ist.
#
#
# [^Kofler18]: [@kofler_python_2018]
# [^fowler13]: [@fowler_introduction_2013]
# # Jupyter Notebook
# Jupyter Notebooks sind im Grunde JSON-Dateien, die mit Hilfe der Web-Anwendung Jupyter-notebook oder Jupyter-lab editiert werden. Ein Notebook besteht aus einer Abfolge von Zellen, die entweder Markdown-Text, (Python-)Quellcode oder Rohdaten enthalten. Diese Zellen können beliebig oft und in beliebiger Reihenfolge ausgeführt werden. Auf diese Weise können Code und Dokumentation in einem Dokument gepflegt und gespeichert werden. Das Framework `nbdev`[^fastai21] unterstützt dieses Vorgehen durch die Bereitstellung eines Vorgehensmodells und den dazu passenden Werkzeugen.
#
# [^fastai21]: [@fastai_welcome_2021]
# # Markdown
# In diesem Notebook sind verschiedene Beispiele für die Möglichkeiten zur Dokumentation von Programmcode zusammengestellt, die bei der Konvertierung des Notebooks nach LaTeX (und dann nach PDF) verwendet werden können.
# Im Prinzip steht die komplette Markdown-Syntax zur Verfügung, die von [Jupyter-Notebooks](https://jupyter-notebook.readthedocs.io/en/latest/examples/Notebook/Working%20With%20Markdown%20Cells.html) unterstützt wird. Über die hier gezeigten Beispiele könnte dieses [Cheat-Sheet](https://sqlbak.com/blog/jupyter-notebook-markdown-cheatsheet) helfen.
#
# - Listen (dies ist selbst eine solche)
# - internal references
# - Mathematische Formeln
# - weitere Blöcke
# - Bilder
# - Tabellen
# - Quellcode
# - Plots
# - Verweise und Fußnoten
# - Verschiedene Hinweisblöcke
#
#
#
# ## Listen
# Nicht nummerierte Liste siehe oben.
#
# ### Nummerierte Liste
# 1. Eins
# 2. Zwei
# 1. Zwei Unterpunkt eins
# 1. Zwei Unterpunkt zwei
# 1. Drei
#
#
# ## Bilder
# Ein einfaches Beipielbild von der Festplatte. Übliche Dateitypen sind .svg, .jpg und .png:
#
# 
# Graphviz ist ein Werkzeug, um Graphen zu erzeugen. Auch PlantUML basiert auf Graphviz und ist in Jupyter-Notebooks einsetzbar.
#hide_input
#title Training a machine learning model
#id training_loop
#alt The basic training loop
gv('''ordering=in
model[shape=box3d width=1 height=0.7]
inputs->model->results; weights->model; results->performance
performance->weights[constraint=false label=update]''')
# Wie hier zu sehen, werden von `nbdev2md` keine korrekten Bildunterschriften erzeugt. Daher sollte ein per graphviz erzeugtes Bild manuell eingebunden werden. Eventuell wird zu einem späteren Zeitpunkt eine entsprechende Funktionalität zur Verfügugng gestellt.
# ## Tabellen
# Für die Erzeugung von Tabellen gibt es verschiedene Möglichkeiten in Markdown selbst, aber auch mit \LaTeX. Hier einige Beispiele:
# ### Markdown
# Table: Preise und Vorteile diverser Früchte
#
# +---------------+---------------+--------------------+
# | Fruit | Price | Advantages |
# +===============+===============+====================+
# | Bananas | $1.34 | - built-in wrapper |
# | | | - bright color |
# +---------------+---------------+--------------------+
# | Oranges | $2.10 | - cures scurvy |
# | | | - tasty |
# +---------------+---------------+--------------------+
#
# Die obige Tabelle wird im Jupyter-Notebook nicht korrekt angezeigt, im PDF-Dokument aber sehr wohl, wenn vor und nach der Tabelle Leerzeilen eingefügt werden.
#
# Bei der unteren Tabellenform funktioiert beides:
#
# | Stretch/Untouched | ProbDistribution | Accuracy |
# | :- | :-: | -: |
# | linksbündig | zentriert | .843
#
# Table: Dies ist die Überschrift zur zweiten Tabelle. Wenn die Überschrift sehr lang sein sollte, kann sie sich auch über mehr als eine Zeile erstrecken.
#
# ### \LaTeX
#
# Es ist auch möglich Tabellen und andere Elemente in \LaTeX-Code einzufügen.
# \begin{tabular}{|l|r|}\hline
# Age & Frequency \\ \hline
# 18--25 & 15 \\
# 26--35 & 33 \\
# 36--45 & 22 \\ \hline
# \end{tabular}
# Hier das Beispiel einer Formel:
# + active=""
#
# $$f'(a) = \lim_{x \to a} \frac{f(x) - f(a)}{x-a}$$
#
# -
# Die Formel selbst sollte in einer eigenen "Raw"-Zelle stehen und in dieser oberhalb und unterhalb von einer Leerzeile umgeben sein. Dies ist erforderlich, um mögliche Probleme bei der Konvertierung zu vermeiden.
# # nbdev
#
# Für die nbdev-Werkzeuge werden die einzelnen Code-Zellen mit speziellen Kommenaren versehen, um nvdev zu signalisieren, wie der jeweilige Code-Block zu verarbeiten ist. Um zu sehen, was die unterschiedlichen Kommentare bewirken, sehen Sie sich bitte die aus diesem Notebook generierte PDF-Datei sowie die generierte Datei examples.py im Verzeichnis `nb2ltx` an.
#
# - `#export`: Zelle wird nicht angezeigt; Code wird von `nbdev` in die Moduldatei exportiert
# - `#exports`: Zelle und Ausgabe der Zelle werden angezeigt; Code wird von nbdev in die Moduldatei exportiert
#
# export
def nix():
return
# +
# exports
def wirdAngezeigt():
return 'Sie werden exportiert und angezeigt!'
print('Hi')
# -
# - `#hide`: Von der folgenden Zelle wird weder der Quellcode noch die Ausgabe angezeigt
# +
# hide
def verstecken():
return "Wir verstecken Sie..."
verstecken()
# -
# - `#hide_input`: Von dieser Zelle wird nicht der Quellcode, sondern nur die Ausgabe angezeigt:
#hide_input
360/2.7
print("Aufruf der Funktion 'verstecken()':")
verstecken()
# - `#sonstiger Kommentar` oder kein Kommentar: Zelle und auch das Ergebnis werden angezeigt
# dies ist ein Test...
wirdAngezeigt()
import sys
print('Zelle ohne Kommentar')
sys.getdefaultencoding()
# ## Markdown Tests
#
# ### Umlaute
#
# ... sind möglich!
# Umlauttest: öäüÄÜÖß
#
| 20_Examples.ipynb |
# +
import numpy as np
import matplotlib.pyplot as plt
from matplotlib import style
from scipy import linalg
from scipy.stats import multivariate_normal
try:
import probml_utils as pml
except ModuleNotFoundError:
# %pip install git+https://github.com/probml/probml-utils.git
import probml_utils as pml
mu_1 = np.array([[0.22], [0.45]])
mu_2 = np.array([[0.5], [0.5]])
mu_3 = np.array([[0.77], [0.55]])
Mu = np.array([mu_1, mu_2, mu_3])
Sigma1 = np.array([[0.011, -0.01], [-0.01, 0.018]])
Sigma2 = np.array([[0.018, 0.01], [0.01, 0.011]])
Sigma3 = Sigma1
Sigma = np.array([Sigma1, Sigma2, Sigma3])
mixmat = np.array([[0.5], [0.3], [0.2]])
def sigmaEllipse2D(mu, Sigma, level=3, npoints=128):
"""
SIGMAELLIPSE2D generates x,y-points which lie on the ellipse describing
a sigma level in the Gaussian density defined by mean and covariance.
Input:
MU [2 x 1] Mean of the Gaussian density
SIGMA [2 x 2] Covariance matrix of the Gaussian density
LEVEL Which sigma level curve to plot. Can take any positive value,
but common choices are 1, 2 or 3. Default = 3.
NPOINTS Number of points on the ellipse to generate. Default = 32.
Output:
XY [2 x npoints] matrix. First row holds x-coordinates, second
row holds the y-coordinates. First and last columns should
be the same point, to create a closed curve.
"""
phi = np.linspace(0, 2 * np.pi, npoints)
x = np.cos(phi)
y = np.sin(phi)
z = level * np.vstack((x, y))
xy = mu + linalg.sqrtm(Sigma).dot(z)
return xy
def plot_sigma_levels(mu, P):
xy_1 = sigmaEllipse2D(mu, P, 0.25)
xy_2 = sigmaEllipse2D(mu, P, 0.5)
xy_3 = sigmaEllipse2D(mu, P, 0.75)
xy_4 = sigmaEllipse2D(mu, P, 1)
xy_5 = sigmaEllipse2D(mu, P, 1.25)
xy_6 = sigmaEllipse2D(mu, P, 1.5)
plt.plot(xy_1[0], xy_1[1])
plt.plot(xy_2[0], xy_2[1])
plt.plot(xy_3[0], xy_3[1])
plt.plot(xy_4[0], xy_4[1])
plt.plot(xy_5[0], xy_5[1])
plt.plot(xy_6[0], xy_6[1])
plt.plot(mu[0], mu[1], "ro")
def plot_sigma_vector(Mu, Sigma):
n = len(Mu)
plt.figure(figsize=(12, 7))
for i in range(n):
plot_sigma_levels(Mu[i], Sigma[i])
plt.tight_layout()
pml.savefig("mixgaussSurface.pdf")
plt.show()
plot_sigma_vector(Mu, Sigma)
def plot_gaussian_mixture(Mu, Sigma, weights=None, x=None, y=None):
if x == None:
x = np.arange(0, 1, 0.01)
if y == None:
y = np.arange(-0.5, 1.2, 0.01)
if len(Mu) == len(Sigma) == len(weights):
pass
else:
print("Error: Mu, Sigma and weights must have the same dimension")
return
X, Y = np.meshgrid(x, y)
Pos = np.dstack((X, Y))
Z = 0
for i in range(len(Mu)):
Z = Z + weights[i] * multivariate_normal(Mu[i].ravel(), Sigma[i]).pdf(Pos)
fig = plt.figure(figsize=(12, 7))
ax = fig.gca(projection="3d")
ax.plot_surface(X, Y, Z, cmap="copper", lw=0.5, rstride=1, cstride=1)
ax.set_xlabel("X axis")
ax.set_ylabel("Y axis")
ax.set_zlabel("Z axis")
plt.tight_layout()
pml.savefig("mixgaussSurface.pdf")
plt.show()
weights = [0.5, 0.3, 0.2]
plot_gaussian_mixture(Mu, Sigma, weights=weights)
| notebooks/book1/03/gmm_plot_demo.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # OGGM-Edu - Jupyter notebooks to learn and teach about glaciers
# ## Authors
#
# - Author1 = {"name": "<NAME>", "affiliation": "University of Innsbruck", "email": "<EMAIL>", "orcid": "http://orcid.org/0000-0002-3211-506X"}
# - Author2 = {"name": "", "": "", "email": "", "orcid": ""}
# - Author3 = ...
# + [markdown] toc=true
# <h1>Table of Contents<span class="tocSkip"></span></h1>
# <div class="toc"><ul class="toc-item"><li><span><a href="#OGGM-Edu---Jupyter-notebooks-to-learn-and-teach-about-glaciers" data-toc-modified-id="OGGM-Edu---Jupyter-notebooks-to-learn-and-teach-about-glaciers-1"><span class="toc-item-num">1 </span>OGGM-Edu - Jupyter notebooks to learn and teach about glaciers</a></span><ul class="toc-item"><li><span><a href="#Authors" data-toc-modified-id="Authors-1.1"><span class="toc-item-num">1.1 </span>Authors</a></span></li><li><span><a href="#Purpose" data-toc-modified-id="Purpose-1.2"><span class="toc-item-num">1.2 </span>Purpose</a></span></li><li><span><a href="#Technical-contributions" data-toc-modified-id="Technical-contributions-1.3"><span class="toc-item-num">1.3 </span>Technical contributions</a></span></li><li><span><a href="#Methodology" data-toc-modified-id="Methodology-1.4"><span class="toc-item-num">1.4 </span>Methodology</a></span></li><li><span><a href="#Results" data-toc-modified-id="Results-1.5"><span class="toc-item-num">1.5 </span>Results</a></span></li><li><span><a href="#Funding" data-toc-modified-id="Funding-1.6"><span class="toc-item-num">1.6 </span>Funding</a></span></li><li><span><a href="#Keywords" data-toc-modified-id="Keywords-1.7"><span class="toc-item-num">1.7 </span>Keywords</a></span></li><li><span><a href="#Citation" data-toc-modified-id="Citation-1.8"><span class="toc-item-num">1.8 </span>Citation</a></span></li><li><span><a href="#Suggested-next-steps" data-toc-modified-id="Suggested-next-steps-1.9"><span class="toc-item-num">1.9 </span>Suggested next steps</a></span></li><li><span><a href="#Acknowledgements" data-toc-modified-id="Acknowledgements-1.10"><span class="toc-item-num">1.10 </span>Acknowledgements</a></span></li></ul></li><li><span><a href="#Setup" data-toc-modified-id="Setup-2"><span class="toc-item-num">2 </span>Setup</a></span><ul class="toc-item"><li><span><a href="#Library-import" data-toc-modified-id="Library-import-2.1"><span class="toc-item-num">2.1 </span>Library import</a></span></li></ul></li><li><span><a href="#Part-1:-idealized-glacier-experiments" data-toc-modified-id="Part-1:-idealized-glacier-experiments-3"><span class="toc-item-num">3 </span>Part 1: idealized glacier experiments</a></span><ul class="toc-item"><li><span><a href="#Glacier-flowlines" data-toc-modified-id="Glacier-flowlines-3.1"><span class="toc-item-num">3.1 </span>Glacier flowlines</a></span></li><li><span><a href="#Mass-balance" data-toc-modified-id="Mass-balance-3.2"><span class="toc-item-num">3.2 </span>Mass balance</a></span></li><li><span><a href="#Glacier-in-Equilibrium" data-toc-modified-id="Glacier-in-Equilibrium-3.3"><span class="toc-item-num">3.3 </span>Glacier in Equilibrium</a></span></li><li><span><a href="#Advancing-Glacier" data-toc-modified-id="Advancing-Glacier-3.4"><span class="toc-item-num">3.4 </span>Advancing Glacier</a></span></li><li><span><a href="#Retreating-Glacier" data-toc-modified-id="Retreating-Glacier-3.5"><span class="toc-item-num">3.5 </span>Retreating Glacier</a></span></li></ul></li><li><span><a href="#Part-2:-real-world-glacier-experiments" data-toc-modified-id="Part-2:-real-world-glacier-experiments-4"><span class="toc-item-num">4 </span>Part 2: real-world glacier experiments</a></span></li><li><span><a href="#References" data-toc-modified-id="References-5"><span class="toc-item-num">5 </span>References</a></span></li></ul></div>
# -
# ## Purpose
#
# OGGM-Edu (http://edu.oggm.org) is an educational platform providing instructors with tools that allow the demonstration of the governing principles of glacier behaviour. It offers online interactive apps and Jupyter notebooks that can be run in a browser via MyBinder or JupyterHub.
#
# This notebook demonstrates how an open source numerical glacier model ([OGGM](http://oggm.org)) can be used to tackle scientific and socially-relevant research questions in class assignments and student projects. It is built on two complementary numerical experiments:
# 1. the first section uses idealized glaciers (with controlled boundary conditions) to illustrate how climate and topography influence glacier behavior, and
# 2. the second section relies on realistic glaciers to illustrate how downstream freshwater resources will be affected by glacier change in the future.
#
# The notebook contains code sections that serve as templates, followed by research questions and suggestions that invite the student to re-run the experiment with updated simulation parameters. This notebook (as well as all other similar notebooks featured on the OGGM-Edu platform) is meant to be adapted by teachers to match the topics of a specific lecture or workshop. Interested readers will find more example notebooks [on OGGM-Edu](https://edu.oggm.org/en/latest/notebooks_index.html).
#
# OGGM-Edu's notebooks can help students to overcome barriers posed by numerical modelling and coding, in a fun, question-driven and societally relevant way.
#
#
# ## Technical contributions
#
# - teach about fundamental concepts in glaciology in a modern, fun and interactive way
# - a complex numerical model is used and abstracted (simplified) for teaching purposes
# - open and reproducible: the notebooks are all licensed with BSD3, we use openly available docker environments to run the notebooks
#
#
# ## Methodology
#
# The notebook relies on a number of standard packages of the scientific python ecosytem: numpy, scipy, xarray, pandas, etc. The main tool used for the modelling of glaciers is the Open Global Glacier Model (OGGM, http://oggm.org, https://docs.oggm.org). We also rely on a small number of helper functions (mostly to hide some of the OGGM internals to the learners) from the oggm-edu python package. For more details about OGGM-Edu, visit https://edu.oggm.org.
#
# ## Results
#
# The main outcome of this example notebook is a template, that can be used in glaciology workshops and classes. Example applications include a three-day workshop in Peru for university students without prior experience in glaciology ([repository](https://github.com/ehultee/CdeC-glaciologia), [more info](https://oggm.org/2019/12/06/OGGM-Edu-AGU/)) or the University of Michigan CLaSP 474 [Ice and Climate notebooks](https://github.com/skachuck/clasp474_w2021).
#
#
# ## Funding
#
# - Award1 = {"agency": "University of Innsbruck", "award_code": "Förderkreis 1669 – Wissen schafft Gesell schaft", "award_URL": "https://www.uibk.ac.at/foerderkreis1669"}
# - Award2 = {"agency": "Bundesministerium für Bildung und Forschung - BMBF", "award_code": "FKZ 01LS1602A", "award_URL": "https://www.bmbf.de"}
#
#
# ## Keywords
#
# keywords=["glaciers", "climate", "education", "python", "numerical model"]
#
# ## Citation
#
# <NAME>., <NAME>., <NAME>., <NAME>., <NAME>., <NAME>., Schuster, L.. OGGM-Edu - Jupyter notebooks to learn and teach about glaciers. Jupyter Notebook accessed 07.05.2021 at https://github.com/OGGM/EarthCube2021
#
# ## Suggested next steps
#
# Visit https://edu.oggm.org and try the other notebooks there!
#
# ## Acknowledgements
#
# Thanks to the OGGM and OGGM-Edu developpers, and all the open-source tools used in this notebook. Most notably: numpy, scipy, matplotlib, pandas, geopandas, xarray... Thanks to EarthCube for this opportunity.
# # Setup
#
# ## Library import
# +
# import oggm-edu helper package
import oggm_edu as edu
# Interactive plotting
import holoviews as hv
hv.extension('bokeh')
# import modules, constants and set plotting defaults
import matplotlib.pyplot as plt
plt.rcParams['figure.figsize'] = (9, 6) # Default plot size
# Scientific packages
import numpy as np
# Constants
from oggm import cfg
cfg.initialize_minimal()
# OGGM flowline model
from oggm.core.flowline import RectangularBedFlowline
# OGGM mass-balance model
from oggm.core.massbalance import LinearMassBalance
# There are several numerical implementations in OGGM core. We use the "FluxBasedModel"
from oggm.core.flowline import FluxBasedModel as FlowlineModel
# -
# # Part 1: idealized glacier experiments
# This part of the notebook shows how idealized glacier geometries can be used to explore the influence of a changing climate. For the glacier flow simulation the Open Global Glacier Model (OGGM, http://oggm.org, https://docs.oggm.org) is used.
#
# Goals of this part:
# - learn how to define an idealized flowline glacier
# - understand the concept of mass balance and in particular what the equilibrium line altitude (ELA) describes
# - understand the influence of glacier mass balance on the ELA
# - be able to explain glacier advance and retreat in response to a change in the ELA
# ## Glacier flowlines
# OGGM is a “flowline model”, which means that the glacier ice flow is assumed to happen along a representative “1.5D” flowline, as in the image below. “1.5D” here is used to emphasize that although glacier ice can flow only in one direction along the flowline, each point of the glacier has a geometrical width. This width means that flowline glaciers are able to match the observed area-elevation distribution of true glaciers, and can parametrize the changes in glacier width with thickness changes.
#
# <img src="https://docs.oggm.org/en/stable/_images/hef_flowline.jpg" width="60%">
# The first step for the experiment is now to define our idealized glacier geometry with:
# - linear glacier bed heights
# - widths with a trapezoidal shape at glacier top, starting from larger widths and decreasing until a certain point is reached
# - below this point constant widths
# This function could be integrated in OGGM Edu,
# I made this to separate the definition of the geometry from the definition of the mass balance,
# as it is kind of mixed in the function 'linear_mb_equilibrium' from the oggm_edu package
def define_widths_with_trapezoidal_shape_at_top(topw, bottomw, nx, nz, map_dx):
# accumulation area occupies a fraction NZ of the total glacier extent
acc_width = np.linspace(topw, bottomw, int(nx * nz))
# ablation area occupies a fraction 1 - NZ of the total glacier extent
abl_width = np.tile(bottomw, nx - len(acc_width))
# glacier widths profile
widths = np.hstack([acc_width, abl_width])
return widths
# +
# define horizontal resolution of the model:
# nx: number of grid points
# map_dx: grid point spacing in meters
nx = 200
map_dx = 200
# define glacier top and bottom altitudes in meters
top = 5000
bottom = 0
# create a linear bedrock profile from top to bottom
bed_h, surface_h = edu.define_linear_bed(top, bottom, nx)
# calculate the distance from the top to the bottom of the glacier in km
distance_along_glacier = edu.distance_along_glacier(nx, map_dx)
# glacier width at the top of the accumulation area: m
ACCW = 1000
# glacier width at the equilibrium line altitude: m
ELAW = 500
# fraction of vertical grid points occupied by accumulation area
NZ = 1 / 3
# create the widths with a
widths = define_widths_with_trapezoidal_shape_at_top(topw=ACCW,
bottomw=ELAW,
nx=nx,
nz=NZ,
map_dx=map_dx)
# plot the idealized glacier
edu.plot_glacier_3d(distance_along_glacier, bed_h, widths, nx);
# -
# Now we have defined the principle look of our glacier, the only thing left is now to define the shape of our cross-section. OGGM supports three different shapes rectangular, parabolic and trapezoidal. For our experiment we go with the rectangular one:
# +
# describe the widths in "grid points" for the model, based on grid point spacing map_dx
mwidths = np.zeros(nx) + widths / map_dx
# define the glacier flowline
init_flowline = RectangularBedFlowline(surface_h=surface_h,
bed_h=bed_h,
widths=mwidths,
map_dx=map_dx)
# -
# ## Mass balance
# The **mass balance** is the result of several processes that either add mass to the glacier (**accumulation**) or remove mass from the glacier (**ablation**). The following glacier graphics illustrate this relationship:
#
# - The left graphic represents a theoretical mass accumulation over the whole glacier depicted by the blue ice volume on top of the grey glacier body.
#
# - In the graphic in the middle a theoretical mass ablation is marked as red ice volume.
#
# - The graphic on the right shows the resulting mass balance with blue and red arrows in combination with the blue and red volume changes on top of the grey glacier body. In the central part of the glacier where the red line lies directly on the grey glacier body ablation and accumulation canceled each other out.
#
# *The following glacier graphics are taken from the [open glacier graphics](http://edu.oggm.org/en/latest/glacier_basics.html) on OGGM-Edu, made by <NAME>, [Atelier les Gros yeux](http://atelierlesgrosyeux.com/)*.
#
# <img src="https://raw.githubusercontent.com/OGGM/glacier-graphics/master/glacier_intro/png/glacier_03.png" width="33%" align="left">
# <img src="https://raw.githubusercontent.com/OGGM/glacier-graphics/master/glacier_intro/png/glacier_04.png" width="33%" align="left">
# <img src="https://raw.githubusercontent.com/OGGM/glacier-graphics/master/glacier_intro/png/glacier_05.png" width="33%" align="left">
# The rates of accumulation and ablation processes, summed over the glacier and over time, determine the *glacier mass balance*: $\dot{m}$, the change in total mass of snow and ice,
# $$\dot{m} = \text{accumulation} + \text{ablation}.$$
# Since accumulation and ablation generally vary with height, also the glacier mass balance is a function of elevation,
# $$\dot{m}(z) = \text{accumulation}(z) + \text{ablation}(z).$$
# Mass is continuously redistributed in a glacier: accumulated mass at the top of the glacier is transported downglacier. The driving force of this *ice flow* is gravity. Thus, the mass balance of a region on a glacier depends not only on the mass exchanges induced by accumulation and ablation, but also on the gravity driven transport of ice from the acccumulation area to the ablation area. The *ice flow* is indicated by the grey arrow in this figure:
#
# <img src="https://raw.githubusercontent.com/OGGM/glacier-graphics/master/glacier_intro/png/glacier_06.png" width="60%">
# The altitude where $\dot{m}(z) = 0$ is called the *equilibrium line altitude*, short ELA. Hence, the ELA is the altitude where accumulation processes and ablation processes balance each other - in theory. However, in reality the ELA does not exactly exist and can only be approximated.
# <img src="https://raw.githubusercontent.com/OGGM/glacier-graphics/master/glacier_intro/png/glacier_07.png" width="60%">
# We want to reproduce these processes in an experiment. For this purpose we start with defining a linear mass balance model of the form
# $$\dot{m}(z) = (z - ELA) \frac{d\dot{m}}{dz},$$
# with the mass balance gradient $\frac{d\dot{m}}{dz}$:
# +
# mass balance gradient with respect to elevation in mm w.e. m^-1 yr^-1
mb_grad = 7
# equilibrium line altitude: height where the glacier width first hits ELAW
ela = bed_h[np.where(widths==ELAW)[0][0]]
print('ELA: {:.2f} m'.format(ela))
# defining the mass balance model
mb_model = LinearMassBalance(ela, grad=mb_grad)
# -
# Now that we have all the ingredients to run the model, we just have to initialize it:
# The model requires the initial glacier bed, a mass balance model, and an initial time (the year y0)
model = FlowlineModel(init_flowline, mb_model=mb_model, y0=0., min_dt=0, cfl_number=0.01)
# ## Glacier in Equilibrium
# For a glacier to be in equilibrium, we require the specific mass balance (accumulation + ablation) to be zero averaged over a year on the glacier. But this doesn't mean that the mass-balance is zero everywhere! A very classic situation looks like the image below: positive mass-balance at the top (more accumulation, less ablation) and negative at the tongue (less accumulation, more ablation).
#
# <img src="https://raw.githubusercontent.com/OGGM/glacier-graphics/master/glacier_intro/png/glacier_05.png" width="60%">
# Let's run the model until our test glacier is in equilibrium:
model.run_until_equilibrium()
# Now, we use a linear accumulation and ablation function from the oggm-edu package for the calculation of the net mass balance (= glacier mass distribution without considering *ice flow*):
# +
# get the equilibrium surface height of our test glacier in equilibrium
initial = model.fls[0].surface_h
# accumulation and ablation balance each other
acc, acc_0 = edu.linear_accumulation(mb_grad, ela, initial, bed_h, mwidths)
abl, abl_0 = edu.linear_ablation(mb_grad, ela, initial, bed_h, mwidths, acc_0)
# -
# ``acc_0`` and ``abl_0`` are the accumulation and the ablation at the ELA, respectively - by construction, they should be equal:
print('Mass balance at the ELA: {:.2f} m w.e. yr^-1'.format(float(acc_0 - abl_0)))
# Now, we can define the glacier surface after accumulation and ablation, respectively.
# accumulation and ablation surfaces
acc_sfc = initial + acc
abl_sfc = initial + abl
# The mass balance is then just the sum of accumulation and ablation:
# net mass balance m w.e yr^-1
mb_we = acc + abl
# Near the terminus ablation may totally remove the ice, hence, we need to correct "negative" ice thickness to the glacier bed:
# mass balance surface corrected to the bed where ice thickness is negative
mb_sfc = edu.correct_to_bed(bed_h, initial + mb_we)
# The next figure shows the glacier surface after applying the net mass balance.
# plot the model glacier
fig, ax = plt.subplots(1, 1, figsize=(16, 9))
edu.intro_glacier_plot(ax, distance_along_glacier, bed_h, initial, [mb_sfc], ['net mass balance'], ela=[ela], plot_ela=True)
# Remember: In the graphic we visualised the glacier in equilibrium in red and in black the glacier surface after applying the mass balance after a cycle of accumulation and ablation. After that we did not include ice flow in our simulation.
# So the glacier is now in an imbalanced state, with more mass above the equilibrium line and less ice in the ablation zone than in the equilibrium state. This imbalance is compensated by a movement of ice from top to bottom, the ice flow. In an undisturbed climate the ice flow together with ablation and accumulation keep the glacier in a steady equilibrium state.
#
# Now we have set the scene to model glacier advance and retreat.
# ## Advancing Glacier
# More accumulation and/or less ablation leads to a larger accumulation and a smaller ablation area. Hence, the ELA decreases, as shown in this graphic:
#
# <img src="https://raw.githubusercontent.com/OGGM/glacier-graphics/master/glacier_intro/png/glacier_08.png" width="60%">
# To simulate a glacier advance, we will use the same glacier as before, but move the ELA downglacier:
# number of vertical grid points the ELA is shifted downglacier
downglacier = 10
# +
# Hey Patrick: can you sidestep the edu.linear_mb_equilibrium-function again? I think we would need it here.
#.... calculate the new glacier's equilibrium and the the new ELA
# -
print(*['{} ELA: {:.2f} m'.format(s, e) for s, e in zip(['Initial', 'Advance'], [ela, ela_adv])], sep='\n')
# +
# I am not sure if the mass balance plot with the grey glacier from the advance and retreat nb adds value.
# Maybe if we design it differently? I would go directly to the plot where we see the advanced glacier surface.
# -
# the glacier surface in equilibrium with the decreased ELA
advance_s = advance.fls[-1].surface_h
fig, ax = plt.subplots(1, 1, figsize=(16, 9))
edu.intro_glacier_plot(ax, distance_along_glacier, bed_h, initial, [advance_s], ['Advance'], ela=[ela, ela_adv], plot_ela=True)
# As expected the glacier model with the lower ELA reaches more downward in its equilibrium state than the initial glacier. This is also illustrated in the following graphic:
# <img src="https://raw.githubusercontent.com/OGGM/glacier-graphics/master/glacier_intro/png/glacier_09.png" width="60%">
# ## Retreating Glacier
# Maybe continue with 'Retreating' from advance_and_retreat notebook
# # Part 2: real-world glacier experiments
#
# In the previous steps we showed how to use OGGM to answer theoretical questions about glaciers, using idealized experiments. In the following section we will explain how you can use OGGM to explore real glaciers and investigate their role as water resources.
#
# You will learn about
# * How to set up the model and run it on a real world glacer
# * Running simulations using different climate scenarios
# * The concept of **peak water** and how to calculate it using the OGGM
#
# ## Glaciers as water resources
# First we have to import and set up OGGM along with some other useful packages
import salem
import geoviews as gv
import geoviews.tile_sources as gts
from oggm import cfg, utils, workflow, tasks, graphics
from oggm_edu import read_run_results, compute_climate_statistics
from matplotlib import pyplot as plt
import seaborn as sns
import xarray as xr
cfg.initialize(logging_level='WARNING')
cfg.PATHS['working_dir'] = utils.get_temp_dir(dirname='OGGMEarthCube')
# ### Define the glaciers to play with
# We are going to start with doing a simuilation of Hintereisferner in Austria. Some other possibilites are:
#
# - Shallap Glacier: RGI60-16.02207
# - Artesonraju: RGI60-16.02444 ([reference glacier](https://cluster.klima.uni-bremen.de/~github/crossval/1.1.2.dev45+g792ae9c/web/RGI60-16.02444.html))
# - Hintereisferner: RGI60-11.00897 ([reference glacier](https://cluster.klima.uni-bremen.de/~github/crossval/1.1.2.dev45+g792ae9c/web/RGI60-11.00897.html))
#
# And virtually any glacier you can find the RGI Id from, e.g. in the [GLIMS viewer](https://www.glims.org/maps/glims).
# Hintereisferner
rgi_id = 'RGI60-11.00897'
# ### Preparing the glacier data
#
# This can take up to a few minutes on the first call because the data has to downloaded:
# We pick the elevation-bands glaciers because they run a bit faster
base_url = 'https://cluster.klima.uni-bremen.de/~oggm/gdirs/oggm_v1.4/L3-L5_files/CRU/elev_bands/qc3/pcp2.5/no_match'
gdir = workflow.init_glacier_directories([rgi_id], from_prepro_level=5, prepro_border=80, prepro_base_url=base_url)[0]
# We can now take a first look at our glacier
sh = salem.transform_geopandas(gdir.read_shapefile('outlines'))
(gv.Polygons(sh).opts(fill_color=None) *
gts.tile_sources['EsriImagery'] * gts.tile_sources['StamenLabels']).opts(width=800, height=500, active_tools=['pan','wheel_zoom'])
# *Tip: You can use the mouse to pan and zoom in the map*
#
# ### "Commitment run"
# We are now ready to run our first simulation. This is a so called commitment run, which runs a simulation for 100 years with a constant climate based on the last 11 years.
# file identifier where the model output is saved
file_id = '_ct'
# We are using the task run_with_hydro to store hydrological outputs along with
# the usual glaciological outputs.
tasks.run_with_hydro(gdir, run_task=tasks.run_constant_climate, nyears=100, y0=2014, halfsize=5, store_monthly_hydro=True,
output_filesuffix=file_id);
# Then we can take a look at the output:
with xr.open_dataset(gdir.get_filepath('model_diagnostics', filesuffix=file_id)) as ds:
# The last step of hydrological output is NaN (we can't compute it for this year)
ds = ds.isel(time=slice(0, -1)).load()
# There are plenty of variables in this dataset! We can list them with:
ds
# For instance, we can plot the the volume and the length of the glacier
fig, axs = plt.subplots(nrows=2, figsize=(11, 7), sharex=True)
ds.volume_m3.plot(ax=axs[0]);
ds.length_m.plot(ax=axs[1]);
axs[0].set_xlabel('')
axs[0].set_title(f'{rgi_id}');
axs[1].set_xlabel('Years');
# The glacier length and volume decrease during the first ~40 years of the simulation - this is the **glacier retreat** phase. Afterwards, both length and volume oscillate around a more or less constant value indicating that the glacier has **reached equilibrium**.
#
# #### Annual runoff
# We can also take a look at some of the hydrological outputs computed by the OGGM. We start by creating a pandas DataFrame of all "1D" (annual) variables:
sel_vars = [v for v in ds.variables if 'month_2d' not in ds[v].dims]
df_annual = ds[sel_vars].to_dataframe()
# Then we can select the hydrological varialbes and sum them to get the total annual runoff:
# Select only the runoff variables
runoff_vars = ['melt_off_glacier', 'melt_on_glacier', 'liq_prcp_off_glacier', 'liq_prcp_on_glacier']
# Convert them to megatonnes (instead of kg)
df_runoff = df_annual[runoff_vars] * 1e-9
df_runoff.sum(axis=1).plot();
plt.ylabel('Mt');
plt.xlabel('Years')
plt.title(f'Total annual runoff for {rgi_id}');
# The hydrological variables are computed on the largest possible area that was covered by glacier ice in the simulation. This is equivalent to the runoff that would be measured at a fixed-gauge station at the glacier terminus.
#
# The total annual runoff consists of the following components:
# - melt off-glacier: snow melt on areas that are now glacier free (i.e. 0 in the year of largest glacier extent, in this example at the start of the simulation)
# - melt on-glacier: ice + seasonal snow melt on the glacier
# - liquid precipitaton on- and off-glacier (the latter being zero at the year of largest glacial extent, in this example at start of the simulation)
f, ax = plt.subplots(figsize=(10, 6));
df_runoff.plot.area(ax=ax, color=sns.color_palette("rocket")); plt.xlabel('Years'); plt.ylabel('Runoff (Mt)'); plt.title(rgi_id);
# Before we continue it is time to introduce the concept of **peak water** of [<NAME>](https://vaw.ethz.ch/personen/person-detail.html?persid=96677).
#
# Peak water is the point in time when glacier melt water supply reaches its maximum, i.e. when the maximum runoff occurs. After peak water, annual runoff sums from glaciers will be steadily decreasing, which might cause problems with water availability. [Here](https://www.nature.com/articles/s41558-017-0049-x) is a recently published paper of Huss's team on the occurence of peak water for glaciers worldwide.
# <br>
#
# <img src="https://media.springernature.com/full/springer-static/image/art%3A10.1038%2Fs41558-017-0049-x/MediaObjects/41558_2017_49_Fig1_HTML.jpg" width="60%">
#
# To get a first glimpse of **peak water** we can compute the annual change of the total runoff:
df_runoff.sum(axis=1).diff().plot()
plt.axhline(y=0, color='k', ls=':')
plt.ylabel('Runoff (Mt)')
plt.xlabel('Years')
plt.title('Annual total runoff change');
# So the glacier is losing mass in the retreat phase, then the mass is more or less constant in the equilibrium phase. This illustrates well that **glaciers in equilibrium are not net water resources**: in the course of the year they gain as much mass as they release. In this commitment run, Hintereisferner has already passed **peak water**: the total annual runoff is continously decreasing throughout the period.
# #### Monthly runoff
#
# The "2D" variables contain the same data but at monthly resolution, with the dimension (time, month). For example, runoff can be computed the
# same way:
#
# Select only the runoff variables and convert them to megatonnes (instead of kg)
monthly_runoff = ds['melt_off_glacier_monthly'] + ds['melt_on_glacier_monthly'] + ds['liq_prcp_off_glacier_monthly'] + ds['liq_prcp_on_glacier_monthly']
monthly_runoff *= 1e-9
monthly_runoff.clip(0).plot(cmap='Blues', cbar_kwargs={'label':'Mt'}); plt.xlabel('Months'); plt.ylabel('Years');
# But be aware, something is a bit wrong with this: the coordinates are hydrological months - let's make this better:
# +
# This should work in both hemispheres maybe?
ds_roll = ds.roll(month_2d=ds['calendar_month_2d'].data[0]-1, roll_coords=True)
ds_roll['month_2d'] = ds_roll['calendar_month_2d']
# Select only the runoff variables and convert them to megatonnes (instead of kg)
monthly_runoff = ds_roll['melt_off_glacier_monthly'] + ds_roll['melt_on_glacier_monthly'] + ds_roll['liq_prcp_off_glacier_monthly'] + ds_roll['liq_prcp_on_glacier_monthly']
monthly_runoff *= 1e-9
monthly_runoff.clip(0).plot(cmap='Blues', cbar_kwargs={'label':'Mt'}); plt.xlabel('Months'); plt.ylabel('Years');
# -
# As we can see, the runoff is approximately zero during the winter months, while relatively high during the summer months. This implies that the glacier is a source of water in the summer when it releases the water accumulated in the winter.
#
# The annual cycle changes as the glacier retreats:
monthly_runoff.sel(time=[0, 30, 99]).plot(hue='time');
plt.title('Annual cycle');
plt.xlabel('Month');
plt.ylabel('Runoff (Mt)');
# Not only does the total runoff during the summer months decrease as the simulation progresses, the month of maximum runoff is also shifted to earlier in the summer.
# ### CMIP5 projection runs
#
# You have now learned how to simulate and analyse a specific glacier under a constant climate. We will now take this a step further and simulate two different glaciers, located in different climatic regions, forced with CMIP5 climate projections.
#
# We begin by initializing the glacier directories:
# We keep Hintereisferner from earlier, but also add a new glacier
rgi_ids = [rgi_id, 'RGI60-15.02420']
gdirs = workflow.init_glacier_directories(rgi_ids, from_prepro_level=5, prepro_border=80, prepro_base_url=base_url)
# `gdirs` now contain two glaciers, one in Central Europe and one in the Eastern Himlayas:
gdirs
# We can take a quick look at the new glacier:
sh = salem.transform_geopandas(gdirs[1].read_shapefile('outlines'))
(gv.Polygons(sh).opts(fill_color=None) *
gts.tile_sources['EsriImagery'] * gts.tile_sources['StamenLabels']).opts(width=800, height=500, active_tools=['pan','wheel_zoom'])
# #### Climate downscaling
# Before we run our simulation we have to process the climate data for the glaicer i.e. downscale it: (This can take some time)
from oggm.shop import gcm_climate
bp = 'https://cluster.klima.uni-bremen.de/~oggm/cmip5-ng/pr/pr_mon_CCSM4_{}_r1i1p1_g025.nc'
bt = 'https://cluster.klima.uni-bremen.de/~oggm/cmip5-ng/tas/tas_mon_CCSM4_{}_r1i1p1_g025.nc'
for rcp in ['rcp26', 'rcp45', 'rcp60', 'rcp85']:
# Download the files
ft = utils.file_downloader(bt.format(rcp))
fp = utils.file_downloader(bp.format(rcp))
workflow.execute_entity_task(gcm_climate.process_cmip_data, gdirs,
# Name file to recognize it later
filesuffix='_CCSM4_{}'.format(rcp),
# temperature projections
fpath_temp=ft,
# precip projections
fpath_precip=fp,
);
# #### Projection run
# With the downscaling complete, we can run the forced simulations:
for rcp in ['rcp26', 'rcp45', 'rcp60', 'rcp85']:
rid = '_CCSM4_{}'.format(rcp)
workflow.execute_entity_task(tasks.run_with_hydro, gdirs,
run_task=tasks.run_from_climate_data, ys=2020,
# use gcm_data, not climate_historical
climate_filename='gcm_data',
# use the chosen scenario
climate_input_filesuffix=rid,
# this is important! Start from 2020 glacier
init_model_filesuffix='_historical',
# recognize the run for later
output_filesuffix=rid,
# add monthly diagnostics
store_monthly_hydro=True,
);
# Create the figure
f, ax = plt.subplots(figsize=(18, 7), sharex=True)
# Loop over all scenarios
for i, rcp in enumerate(['rcp26', 'rcp45', 'rcp60', 'rcp85']):
file_id = f'_CCSM4_{rcp}'
# Open the data, gdirs[0] correspond to Hintereisferner.
with xr.open_dataset(gdirs[0].get_filepath('model_diagnostics',
filesuffix=file_id)) as ds:
# Load the data into a dataframe
ds = ds.isel(time=slice(0, -1)).load()
# Select annual variables
sel_vars = [v for v in ds.variables if 'month_2d' not in ds[v].dims]
# And create a dataframe
df_annual = ds[sel_vars].to_dataframe()
# Select the variables relevant for runoff.
runoff_vars = ['melt_off_glacier', 'melt_on_glacier',
'liq_prcp_off_glacier', 'liq_prcp_on_glacier']
# Convert to mega tonnes instead of kg.
df_runoff = df_annual[runoff_vars].clip(0) * 1e-9
# Sum the variables each year "axis=1", take the 11 year rolling mean
# and plot it.
df_runoff.sum(axis=1).rolling(window=11).mean().plot(ax=ax, label=rcp,
color=sns.color_palette("rocket")[i],
)
ax.set_ylabel('Annual runoff (Mt)')
ax.set_xlabel('Year')
plt.title(rgi_id)
plt.legend();
# For Hintereisferner, runoff continues to decrease throughout the 21st-century for all scenarios, indicating that **peak water** has already been reached sometime in the past. This is the case for many European glaciers. What about our unnamed glacier in the Himalayas?
# Create the figure
f, ax = plt.subplots(figsize=(18, 7), sharex=True)
# Loop over all scenarios
for i, rcp in enumerate(['rcp26', 'rcp45', 'rcp60', 'rcp85']):
file_id = f'_CCSM4_{rcp}'
# Open the data, gdirs[1] correspond to the unnamed glacier.
with xr.open_dataset(gdirs[1].get_filepath('model_diagnostics',
filesuffix=file_id)) as ds:
# Load the data into a dataframe
ds = ds.isel(time=slice(0, -1)).load()
# Select annual variables
sel_vars = [v for v in ds.variables if 'month_2d' not in ds[v].dims]
# And create a dataframe
df_annual = ds[sel_vars].to_dataframe()
# Select the variables relevant for runoff.
runoff_vars = ['melt_off_glacier', 'melt_on_glacier',
'liq_prcp_off_glacier', 'liq_prcp_on_glacier']
# Convert to mega tonnes instead of kg.
df_runoff = df_annual[runoff_vars].clip(0) * 1e-9
# Sum the variables each year "axis=1", take the 11 year rolling mean
# and plot it.
df_runoff.sum(axis=1).rolling(window=11).mean().plot(ax=ax, label=rcp,
color=sns.color_palette("rocket")[i],
)
ax.set_ylabel('Annual runoff (Mt)')
ax.set_xlabel('Year')
plt.title(rgi_id)
plt.legend();
# Unlike for Hintereisferner, these projections indicate that the annual runoff will increase in all the scenarios for the first half of the century. The higher RCP scenarios can reach **peak water** later in the century, since the excess melt can continue to increase. For the lower RCP scenarios on the other hand, the glacier might be approaching a new equilibirum, which reduces the runoff earlier in the century ([Rounce et. al., 2020](https://www.frontiersin.org/articles/10.3389/feart.2019.00331/full)). After **peak water** is reached (RCP2.6: ~2055, RCP8.5: ~2070 in these projections), the annual runoff begin to decrease. This decrease occurs because the shrinking glacier is no longer able to support the high levels of melt.
# ## Another projection run with temperature bias?
# To inlcude something about how temperature bias affect the size of the glacier and the meltwater output.
# # References
# List relevant references.
#
# 1. Notebook sharing guidelines from reproducible-science-curriculum: https://reproducible-science-curriculum.github.io/publication-RR-Jupyter/
# 2. Guide for developing shareable notebooks by <NAME>, SDSC: https://github.com/kevincoakley/sharing-jupyter-notebooks/raw/master/Jupyter-Notebooks-Sharing-Recommendations.pdf
# 3. Guide for sharing notebooks by <NAME>, SDSC: https://zonca.dev/2020/09/how-to-share-jupyter-notebooks.html
# 4. Jupyter Notebook Best Practices: https://towardsdatascience.com/jupyter-notebook-best-practices-f430a6ba8c69
# 5. Introduction to Jupyter templates nbextension: https://towardsdatascience.com/stop-copy-pasting-notebooks-embrace-jupyter-templates-6bd7b6c00b94
# 5.1. Table of Contents (Toc2) readthedocs: https://jupyter-contrib-nbextensions.readthedocs.io/en/latest/nbextensions/toc2/README.html
# 5.2. Steps to install toc2: https://stackoverflow.com/questions/23435723/installing-ipython-notebook-table-of-contents
# 6. Rule A, <NAME>, <NAME>, <NAME>, <NAME>, et al. (2019) Ten simple rules for writing and sharing computational analyses in Jupyter Notebooks. PLOS Computational Biology 15(7): e1007007. https://doi.org/10.1371/journal.pcbi.1007007. Supplementary materials: example notebooks (https://github.com/jupyter-guide/ten-rules-jupyter) and tutorial (https://github.com/ISMB-ECCB-2019-Tutorial-AM4/reproducible-computational-workflows)
# 7. Languages supported by Jupyter kernels: https://github.com/jupyter/jupyter/wiki/Jupyter-kernels
# 8. EarthCube notebooks presented at EC Annual Meeting 2020: https://www.earthcube.org/notebooks
# 9. Manage your Python Virtual Environment with Conda: https://towardsdatascience.com/manage-your-python-virtual-environment-with-conda-a0d2934d5195
# 10. Venv - Creation of Virtual Environments: https://docs.python.org/3/library/venv.html
| FM_01_OGGM-Edu_learn_and_teach_about_glaciers.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# + [markdown] papermill={} tags=[]
# <img width="10%" alt="Naas" src="https://landen.imgix.net/jtci2pxwjczr/assets/5ice39g4.png?w=160"/>
# + [markdown] papermill={} tags=[]
# # CCXT - Predict Bitcoin from Binance
# <a href="https://app.naas.ai/user-redirect/naas/downloader?url=https://raw.githubusercontent.com/jupyter-naas/awesome-notebooks/master/CCXT/CCXT_Predict_Bitcoin_from_Binance.ipynb" target="_parent"><img src="https://naasai-public.s3.eu-west-3.amazonaws.com/open_in_naas.svg"/></a>
# + [markdown] papermill={} tags=[]
# **Tags:** #ccxt #bitcoin #trading #investors #ai #analytics #plotly
# + [markdown] papermill={} tags=[]
# **Author:** [<NAME>](https://www.linkedin.com/in/ACoAAAJHE7sB5OxuKHuzguZ9L6lfDHqw--cdnJg/)
# + [markdown] papermill={} tags=[]
# ## Input
# + [markdown] papermill={} tags=[]
# ### Install package
# + papermill={} tags=[]
# !pip install ccxt --user
# + [markdown] papermill={} tags=[]
# ### Import libraries
# + papermill={} tags=[]
import naas
import ccxt
import pandas as pd
from datetime import datetime
from naas_drivers import plotly, prediction
# + [markdown] papermill={} tags=[]
# ### Setup Binance
# 👉 <a href='https://www.binance.com/en/support/faq/360002502072'>How to create API ?</a>
# + papermill={} tags=[]
binance_api = ""
binance_secret = ""
# + [markdown] papermill={} tags=[]
# ### Variables
# + papermill={} tags=[]
symbol = 'BTC/USDT'
limit = 200
timeframe = '1d'
# + [markdown] papermill={} tags=[]
# ## Model
# + [markdown] papermill={} tags=[]
# ### Get data
# + papermill={} tags=[]
binance = ccxt.binance({
'apiKey': binance_api,
'secret': binance_secret
})
data = binance.fetch_ohlcv(symbol=symbol,
limit=limit,
timeframe=timeframe)
# + [markdown] papermill={} tags=[]
# ### Mapping of the candlestick plot
# + papermill={} tags=[]
df = pd.DataFrame(data, columns=["Date","Open","High","Low","Close","Volume"])
df['Date'] = [datetime.fromtimestamp(float(time)/1000) for time in df['Date']]
# + [markdown] papermill={} tags=[]
# ### Attribute the candlesticks variables
# + papermill={} tags=[]
chart_candlestick = plotly.candlestick(df,
label_x="Date",
label_open="Open",
label_high="High",
label_low="Low",
label_close="Close"
)
# + papermill={} tags=[]
df[f"MA{20}"] = df.Close.rolling(
20
).mean()
df[f"MA{50}"] = df.Close.rolling(
50
).mean()
# + [markdown] papermill={} tags=[]
# ### Get the prediction for the stock plot
# + papermill={} tags=[]
pr = prediction.get(dataset=df)
chart_stock = plotly.stock(pr, kind="linechart")
# + [markdown] papermill={} tags=[]
# ## Output
# + [markdown] papermill={} tags=[]
# ### Display bitcoin plot prediction by changing resolution
# + papermill={} tags=[]
chart_stock.update_layout(
autosize=True,
width=1300,
height=800,
)
| CCXT/CCXT_Predict_Bitcoin_from_Binance.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: OceanParcels
# language: python
# name: oceanparcels
# ---
# check to make sure that between two very different runs that the same cross sections have the same number of data points:
import xarray as xr
# +
file = '/ocean/rbeutel/MOAD/analysis-becca/Ariane/JDF_salish/14sep17/ariane_positions_quantitative.nc'
dayrun = xr.open_dataset(file)
file = '/ocean/rbeutel/MOAD/analysis-becca/Ariane/salish_manydays/rosario_forward_01dec19/ariane_positions_quantitative.nc'
monthrun = xr.open_dataset(file)
# -
#admiralty in the day run
section = 2
lons = dayrun.final_lon[(dayrun.final_section==section)]
len(lons)
#admiralty in the month run
section = 4
lons = monthrun.final_lon[(monthrun.final_section==section)]
len(lons)
# ok well clearly not, which sucks but does make sense - maybe they're the same between all month runs?
file = '/ocean/rbeutel/MOAD/analysis-becca/Ariane/salish_manydays/haro_backward_01mar19/ariane_positions_quantitative.nc'
monthrun2 = xr.open_dataset(file)
section = 2
lons = monthrun2.final_lon[(monthrun2.final_section==section)]
len(lons)
# NOooooooooooo! <br>
# fack - i guess we have to figure out a way to make your code more efficient without exporting cross section information
| Ariane/CSlengthCheck.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# + [markdown] _uuid="5ffb21374c7cf4b98e7239045ef9bf312effee25"
# # Two Sigma Financial News Competition Official Getting Started Kernel
# ## Introduction
# In this competition you will predict how stocks will change based on the market state and news articles. You will loop through a long series of trading days; for each day, you'll receive an updated state of the market, and a series of news articles which were published since the last trading day, along with impacted stocks and sentiment analysis. You'll use this information to predict whether each stock will have increased or decreased ten trading days into the future. Once you make these predictions, you can move on to the next trading day.
#
# This competition is different from most Kaggle Competitions in that:
# * You can only submit from Kaggle Kernels, and you may not use other data sources, GPU, or internet access.
# * This is a **two-stage competition**. In Stage One you can edit your Kernels and improve your model, where Public Leaderboard scores are based on their predictions relative to past market data. At the beginning of Stage Two, your Kernels are locked, and we will re-run your Kernels over the next six months, scoring them based on their predictions relative to live data as those six months unfold.
# * You must use our custom **`kaggle.competitions.twosigmanews`** Python module. The purpose of this module is to control the flow of information to ensure that you are not using future data to make predictions for the current trading day.
#
# ## In this Starter Kernel, we'll show how to use the **`twosigmanews`** module to get the training data, get test features and make predictions, and write the submission file.
# ## TL;DR: End-to-End Usage Example
# ```
# from kaggle.competitions import twosigmanews
# env = twosigmanews.make_env()
#
# (market_train_df, news_train_df) = env.get_training_data()
# train_my_model(market_train_df, news_train_df)
#
# for (market_obs_df, news_obs_df, predictions_template_df) in env.get_prediction_days():
# predictions_df = make_my_predictions(market_obs_df, news_obs_df, predictions_template_df)
# env.predict(predictions_df)
#
# env.write_submission_file()
# ```
# Note that `train_my_model` and `make_my_predictions` are functions you need to write for the above example to work.
# + _uuid="406332e61223c255f105c6832c3f1e2cafe736f1"
import pandas as pd
import gc
import re
import numpy as np
# + _uuid="8f2839f25d086af736a60e9eeb907d3b93b6e0e5" _cell_guid="b1076dfc-b9ad-4769-8c92-a6c4dae69d19"
from kaggle.competitions import twosigmanews
# You can only call make_env() once, so don't lose it!
env = twosigmanews.make_env()
# + [markdown] _uuid="6034b46fce8c9d55d403de32e7cebe8cb9fef96d"
# ## **`get_training_data`** function
#
# Returns the training data DataFrames as a tuple of:
# * `market_train_df`: DataFrame with market training data
# * `news_train_df`: DataFrame with news training data
#
# These DataFrames contain all market and news data from February 2007 to December 2016. See the [competition's Data tab](https://www.kaggle.com/c/two-sigma-financial-news/data) for more information on what columns are included in each DataFrame.
# + _uuid="c20fa6deeac9d374c98774abd90bdc76b023ee63"
(market_train_df, news_train_df) = env.get_training_data()
# + _uuid="e1cf10a54aea81e0a1c0daf025303bc8027f7d1b"
market_train_df.shape
# + _uuid="6811a1a76f08b2a029543cf73bcdf4dfca7dc362"
market_train_df.head()
# + _uuid="84b5a58f67ebded82e6aabc66ca36411e6db35a9"
market_train_df.tail()
# + _uuid="8e6dfdbf3645bcd3faac47a8dc65f2c849fb5cee"
market_train_df.describe()
# + _uuid="594b1400c8381d7b2ca73ac0b6387ee4eae77d80"
news_train_df.head()
# + _uuid="cd415199355b95491f24da873cb8729554b4d484"
news_train_df.tail()
# + _uuid="72c258fef51fef895ace138c6db9c4b574218118"
def add_id(df, id_name):
df[id_name] = df.index.astype("int32") + 1
# + [markdown] _uuid="f20433ce55874ca1f3911388fb393b2a0c983d0d"
# ## compress dtypes
# + _uuid="7619634c75e379754e5ff9040ed5e95e69de88a6"
def compress_dtypes(news_df):
for col, dtype in zip(news_df.columns, news_df.dtypes):
if dtype == np.dtype('float64'):
news_df[col] = news_df[col].astype("float32")
if dtype == np.dtype('int64'):
news_df[col] = news_df[col].astype("int32")
# + _uuid="825d53080701eccab3ea485ce37a1fc560aac6e7"
compress_dtypes(news_train_df)
# + _uuid="8ffa863b9fee32a7210db7d96596e5f00c1f67e2"
news_train_df.dtypes
# + _uuid="1f8507eddcbc2071176d0d67ef1132f5a00bb75a"
news_train_df.tail()
# + [markdown] _uuid="fca895c4a419b9d3da2a96ed8d3d9c14f0400ae2"
# # add necessary info
# + _uuid="5ed8c68effb926be50e957d7242154bc20af9d60"
MARKET_ID = "id"
NEWS_ID = "news_id"
# + _uuid="f34d3deb1f68a8b10bbcdfed4fd2fef5d41936fa"
def add_ids(market_df, news_df):
add_id(market_df, MARKET_ID)
add_id(news_df, NEWS_ID)
# + _uuid="89139d560625100568105a010c0ab526e14629e9"
add_ids(market_train_df, news_train_df)
# + _uuid="a45100a8c21c7df0323cd5c14237df9a06f7eada"
market_train_df["id"].max()
# + _uuid="924546812bba2d2e87717aaeed9561828cb87d81"
news_train_df["news_id"].max()
# + _uuid="114b92ab945af7e7a9a2a5ecac04b66d107b147b"
market_train_df[:1]
# + _uuid="6eab5568b7dc38e7747cfb26aa34a53b41408c46"
def add_confidence(df):
# TODO change confidence by return proportion
df["confidence"] = df["returnsOpenNextMktres10"] >= 0
# + _uuid="4eb8986296d80c473396e9d4fe2446c05bf12909"
add_confidence(market_train_df)
# + _uuid="80900248fee7c8d2921f9c6fd6f867f2f4ee0df8"
market_train_df[:10]
# + _uuid="e88510d7e3285b89b71dca26c38440a7b28f8c8b"
market_train_df[:1]
# + _uuid="2b79a8ed42b9bd009242e1eead01401aaed0e236"
market_train_df.shape
# + _uuid="886048391800881466a6903a756aa5c63840c2fe"
market_train_df.id.tail()
# + [markdown] _uuid="1f227d0dcdf63a72bc01661dcbc02e3d2239c539"
# # full fill missing values
# + _uuid="b9cc769275d23b94219c2575640cc406989a1856"
market_train_df.isnull().sum(axis=0)
# + [markdown] _uuid="7faf7e24c9a1cbba1da44db2251186211abffe1f"
# returnsClosePrevMktres1 , returnsOpenPrevMktres1 returnsClosePrevMktres10 and returnsOpenPrevMktres10 aren't used here for this model, I ignore them
# + _uuid="be943d9b985e3a72b80baf68890e0a6f12a857a6"
news_train_df.isnull().sum(axis=0)
# + _uuid="1edf18230734333c3f6e338d0ca446c15a7dd6c1"
# empty string check
for col, dtype in zip(news_train_df.columns, news_train_df.dtypes):
if dtype == np.dtype('O'):
n_empty = (news_train_df[col]=="").sum()
print("empty value in {}: {}".format(col, n_empty))
# + _uuid="753af2f2f3dc30c34d05f4a92cdfb17e97eb8d98"
news_train_df.headlineTag.value_counts()
# + [markdown] _uuid="50ba81d1066127d61a931532e2e3c978f155d832"
# It seems headlineTag values are categorical values. Therefore, I convert the column into categorical values.
# + _uuid="4ca457a4279add111198f3ec6674041b70b1ef84"
def fill_missing_value_news_df(news_df):
news_df.headlineTag.replace("", "UNKNONWN", inplace=True)
# + _uuid="9827ee392ff5d3e60b2abe5981a147c0a12fed11"
fill_missing_value_news_df(news_df=news_train_df)
# + _uuid="e93124b6e41a4939a88a4a771efd4e59bf3534fc"
def to_category_news_df(news_df):
news_df.headlineTag = news_df.headlineTag.astype('category')
# + _uuid="e1669c400aeb2cde32df426cfe4d133a4554a30d"
to_category_news_df(news_train_df)
# + _uuid="4c3b1ce3340731b93fe279210d32f02284773889"
news_train_df.dtypes
# + [markdown] _uuid="f6d2aa535f025c04dcd0011689413b5198458c47"
# # Feature Extraction
# + [markdown] _uuid="3249ca64ec5da85922415d33ec3865021e013582"
# ## news
# + _uuid="3ba68a0442eb9b814e1f7a4d231e265ecede9942"
categorical_features = ["provider", "subjects", "audiences", "headlineTag"]
# + _uuid="d8b85f5b54e7aa318ee9db49ef2e951af85047e2"
def encode_categorical_fields(news_df):
categories = []
for cat_column in categorical_features:
categories.append(news_df[cat_column].cat.categories)
news_df[cat_column] = news_df[cat_column].cat.codes
return categories
# + _uuid="825b768e0d073e19bf281b2689ee2371c035ce7a"
news_categories = encode_categorical_fields(news_train_df)
# + _uuid="4318eda9c289d66f5ba1bb01cb89936f46c64780"
news_categories
# + [markdown] _uuid="2d554e2024277d27fe68476aec92620450e0667a"
# ### headline
# + _uuid="ed2f24d2610453a08c1105187f10c5e1cb60182d"
#from gensim.sklearn_api import D2VTransformer
# + _uuid="b6467837031a8b32e7a2cffc0908f316227e5a5d"
RANDOM_SEED = 10
# + _uuid="9502447f2ea8e3e24a70cf02449b799cfc73ae39"
#head_line_d2vec_model = D2VTransformer(min_count=5, size=50, workers=2, seed=RANDOM_SEED)
# + _uuid="22d594a3b6957c08b098aa5f7e7e3f5d899317d8"
# # %%time
# # more sophisticated cleaning
# head_line_d2vec_feature = head_line_d2vec_model.fit_transform([text.split() for text in news_train_df.headline.tolist()])
# + _uuid="ea6456dc43e40a79ed292eb69cbe3b78ff8e2272"
#head_line_d2vec_feature[:10]
# + _uuid="527513b3befae151e610ba8714718622d3762af4"
import joblib
# + _uuid="621012497ff3fc61da43e8f0ed2deba4d3aad678"
#HEADLINE_DOC2VEC_MODEL = "./headline_doc2vec_model.pickle"
#joblib.dump(head_line_d2vec_model, HEADLINE_DOC2VEC_MODEL)
#del head_line_d2vec_model
# + _uuid="c1edf52e0335e99c2d6021656f8861eaf04b3118"
gc.collect()
# + _uuid="3d3cc3868bb334c5918fd3277272e1e03392414a"
import fastText
# + _uuid="4b4423419fe5eb783a1160f1ccb018a59ddde9e6"
FASTTEXT_MODEL_PATH = "./fasttext_headline.model"
from pathlib import Path
TEMP_HEAD_LINE_FILE = Path("./headline.txt")
news_train_df.headline.to_csv(TEMP_HEAD_LINE_FILE, index=False, encoding="utf-8")
# + _uuid="2785e760244f76507c99610ba6976864315fbe0a"
# %%time
head_line_fastText_model = fastText.train_unsupervised(str(TEMP_HEAD_LINE_FILE), dim=50)
# + _uuid="98a0e91cc19265d4ed2792bbca35f9f2cccce499"
TEMP_HEAD_LINE_FILE.unlink()
# + _uuid="4bfa5c77e840ea71622740061405cd64621bd76a"
def extract_headline_fastText(news_df, fastText_model):
feature = news_df.headline.apply(fastText_model.get_sentence_vector)
return np.vstack(feature).astype("float16")
# + _uuid="f160b4096e3ae344a5885c1fc563269d1c344a03"
# %%time
head_line_fastText_feature = extract_headline_fastText(news_train_df, head_line_fastText_model)
# + _uuid="4aba534f452d0c32f054a8493bb3147b11e0f347"
head_line_fastText_feature.shape
# + _uuid="f646907ef1baf8d7602b0a5f1f1f367406786509"
head_line_fastText_model.save_model(FASTTEXT_MODEL_PATH)
# + _uuid="a79b2e2dfa1ab37459f9e967c09881ccc3c78fd2"
del head_line_fastText_model
# + _uuid="0f2897a65d4c02108206b0bb629198ba3228be34"
gc.collect()
# + _uuid="faa3b5bfcae7686b9a129ad92d876d4569e2501b"
NEWS_FEATURE_SAVE_FILE = "news_features.npz"
# + _uuid="4b3adbce6ad24df75135bad960e8cff8bc78ac6c"
np.savez_compressed(NEWS_FEATURE_SAVE_FILE, headline_fastText=head_line_fastText_feature)
# + _uuid="56e65bb91f34363ef82c9cf4f0e9ed4a7ad36e7a"
del head_line_fastText_feature
# + _uuid="4c95896efa5ce1225f677ea54d4dd703f094236a"
gc.collect()
# + [markdown] _uuid="c4448e59ee2d9c8e2938921d5b86748c486005e0"
# # remove unnecc
# + _uuid="eeebb99198b5c7e84928cbd2e55f6d684c0380dd"
def remove_unnecessary_columns(market_df, news_df):
#market_df.drop(["returnsOpenNextMktres10", "universe"], axis=1, inplace=True)
news_df.drop(['time', 'sourceId', 'sourceTimestamp', 'headline'], axis=1, inplace=True)
# + _uuid="c3d94c82c76e8635b8c75f9a475be81398f46a49"
def remove_unnecessary_columns_train(market_df, news_df):
market_df.drop(["returnsOpenNextMktres10", "universe"], axis=1, inplace=True)
remove_unnecessary_columns(market_df, news_df)
# + _uuid="dca92881831c520fdccfc9baca75d67d4aaaf1fc"
remove_unnecessary_columns_train(market_train_df, news_train_df)
# + _uuid="eb14c1835eda945f63fecf1a9b81d55d9d887966"
gc.collect()
# + [markdown] _uuid="9a3ea0ffe20f1f014e7f1daedaf28ed22728f1fa"
# # link data and news
# + [markdown] _uuid="fae5b40023b00649db5f161e1daf9cd06aefd7c4"
# ## check assecName links
# + _uuid="a89c2e2340de394b7c946b335f8d741cf12f8124"
MAX_DAY_DIFF = 3
MULTIPLE_CODES_PATTERN = re.compile(r"[{}'']")
import itertools
def link_data_and_news(market_df, news_df):
assetCodes_in_markests = market_df.assetCode.unique()
print("assetCodes pattern in markets: {}".format(len(assetCodes_in_markests)))
assetCodes_in_news = news_df.assetCodes.unique()
assetCodes_in_news_size = len(assetCodes_in_news)
print("assetCodes pattern in news: {}".format(assetCodes_in_news_size))
parse_multiple_codes = lambda codes: re.sub(r"[{}'']", "", str(codes)).split(", ")
parsed_assetCodes_in_news = [parse_multiple_codes(str(codes)) for codes in assetCodes_in_news]
# len(max(parsed_assetCodes_in_news, key=lambda x: len(x)))
all_assetCode_type_in_news = list(set(itertools.chain.from_iterable(assetCodes_in_news)))
# check linking
links_assetCodes = [[[raw_codes, market_assetCode] for parsed_codes, raw_codes in zip(parsed_assetCodes_in_news, assetCodes_in_news) if str(market_assetCode) in parsed_codes] for market_assetCode in assetCodes_in_markests]
links_assetCodes = list(itertools.chain.from_iterable(links_assetCodes))
print("links for assetCodes: {}".format(len(links_assetCodes)))
links_assetCodes = pd.DataFrame(links_assetCodes, columns=["newsAssetCodes", "marketAssetCode"], dtype='category')
## check date linking
news_df["firstCreatedDate"] = news_df.firstCreated.dt.date
market_df["date"] = market_df.time.dt.date
working_dates = news_df.firstCreatedDate.unique().astype(np.datetime64)
working_dates.sort()
market_dates = market_df.date.unique().astype(np.datetime64)
market_dates.sort()
def find_prev_date(date):
for diff_day in range(1, MAX_DAY_DIFF + 1):
prev_date = date - np.timedelta64(diff_day, 'D')
if len(np.searchsorted(working_dates, prev_date)) > 0:
return prev_date
return None
prev_news_days_for_market_day = np.apply_along_axis(arr=market_dates, func1d=find_prev_date, axis=0)
date_df = pd.DataFrame(columns=["date", "prevDate"])
date_df.date = market_dates
date_df.prevDate = prev_news_days_for_market_day
market_df.date = market_df.date.astype(np.datetime64)
market_df = market_df.merge(date_df, left_on="date", right_on="date")
market_df[:10]
del date_df
gc.collect()
## merge assetCodes links
market_df = market_df.merge(links_assetCodes, left_on="assetCode", right_on="marketAssetCode")
market_df[:10]
market_df.drop(["marketAssetCode"], axis=1, inplace=True)
del links_assetCodes
gc.collect()
## merge market and news
news_df.firstCreatedDate = news_df.firstCreatedDate.astype(np.datetime64)
market_df_today_news = market_df.merge(news_df, left_on=["newsAssetCodes", "date"],
right_on=["assetCodes", "firstCreatedDate"])
# remove news after market obs
market_df_today_news = market_df_today_news[market_df_today_news["time"] > market_df_today_news["firstCreated"]]
market_df_today_news.shape
market_df_today_news.sort_values(by=["firstCreated"], inplace=True)
# only leave latest news
market_df_today_news.drop_duplicates(subset=["id"], keep="last", inplace=True)
gc.collect()
market_df_prev_day_news = market_df.merge(news_df, left_on=["newsAssetCodes", "prevDate"],
right_on=["assetCodes", "firstCreatedDate"])
market_df_prev_day_news.sort_values(by=["firstCreated"], inplace=True)
# only leave latest news
market_df_prev_day_news.drop_duplicates(subset=["id"], keep="last", inplace=True)
del market_df
del news_df
gc.collect()
market_df = pd.concat([market_df_prev_day_news, market_df_today_news]).sort_values(["firstCreated"])
del market_df_prev_day_news
del market_df_today_news
gc.collect()
market_df.drop_duplicates(subset=["id"], keep="last", inplace=True)
market_df.drop(["assetCode", "date", "prevDate", "newsAssetCodes", "assetName_x", "assetCodes", "assetName_y",
"firstCreated", "firstCreatedDate"], axis=1, inplace=True)
gc.collect()
print("linking done")
return market_df
# + _uuid="8e76f174025e6eec29af76ca5951b924450fa113"
# %%time
market_train_df = link_data_and_news(market_train_df, news_train_df)
# + _uuid="711af28ca4f465dde6eb89839fadcc2f73c69c3b"
del news_train_df
# + _uuid="99f4ce43c07e663dc9ee02d6ea9f97e6c2830e7f"
gc.collect()
# + _uuid="2c5dc84d3aab78b2eff2bc5f42cff0de398b89ca"
market_train_df.columns
# + _uuid="9fd16beb215172715b8cad3f83aba53ec0fe2d86"
market_train_df.columns
# + _uuid="7567021eb00d534d4e3e2f14de8121a929b13a9d"
market_train_df.sort_values(by=["time"], inplace=True)
# + [markdown] _uuid="6a70033b0c1436ee5d5b494e45f71f712ed621a3"
# # convert into trainable form
# + _uuid="e6420db679f041bca746e5113581bf003b2468da"
def to_Y(train_df):
return np.asarray(train_df.confidence)
# + _uuid="64a69e94abdf77c6abaa920315630b06e8596bac"
train_Y = to_Y(train_df=market_train_df)
# + _uuid="987cc3852c103816d1643fa3447c61351eae0665"
market_train_df.drop(["confidence"], axis=1, inplace=True)
# + _uuid="cb2bddbfce8fa0c6b889608ee7fe33976fc0057b"
def to_X(df, news_features, news_feature_names):
market_obs_ids = df.id
news_obs_ids = df.news_id
market_obs_times = df.time
df.drop(["id", "news_id", "time"], axis=1, inplace=True)
X = df.values.astype("float32")
feature_names = df.columns.tolist()
feature_names.extend(news_feature_names)
del df
gc.collect()
row_indices = [market_id - 1 for market_id in news_obs_ids.tolist()]
news_features = news_features[row_indices]
X = np.hstack([X, news_features])
del news_features
return X, market_obs_ids, news_obs_ids, market_obs_times, feature_names
# + _uuid="952584ef2328fcefd1e665ff613dac702954188b"
news_features = [ np.load("news_features.npz")["headline_fastText"] ]
# + _uuid="57ae006f83f9637b10c3059e40bf6e39d2355843"
news_feature_names = [ "headline_fastText"]
# + _uuid="13b41850e0cd07debddb7202dd051b7f1a63084d"
news_feature_names = [["{}_{}".format(name, i) for i in range(feature.shape[1])]for feature, name
in zip(news_features, news_feature_names)]
# + _uuid="9425179f3cdf13e6c20bd36fefc6d6e8bc19f1f1"
news_feature_names = itertools.chain.from_iterable(news_feature_names)
# + _uuid="0f9776382129935e9dc7eff05ff36e46983c3192"
news_features = np.hstack(news_features)
# + _uuid="1a37457dc9e1387372ed095e885cb6dc62d3975d"
gc.collect()
# + _uuid="be84cdd01daa23fdaea59b62ea1786345ac66d96"
# %%time
X, market_train_obs_ids, news_train_obs_ids, market_train_obs_times, feature_names = to_X(
market_train_df, news_features, news_feature_names
)
# + _uuid="32ea841c3ce6d3603551712517428594f4993cf5"
del news_features
# + _uuid="e00d4939d9f8a9accce0ae7eff520c839a61add0"
gc.collect()
# + _uuid="e954736227df542ebc8ca6348522818f0ceabe5b"
type(feature_names[0])
# + _uuid="8b68b849d7d9659e026136b8b28f66fa28facc20"
len(feature_names)
# + [markdown] _uuid="fea4c47d148463d38fa42265a4310288cbe00711"
# # create validation data
# + [markdown] _uuid="a8d91a96dcb5f53f71315bdfd6ad1b382bfc3d97"
# # train model
# + _uuid="785ecb08eff9d35a272ac3828b94158403eaac84"
import lightgbm as lgb
# + _uuid="9bd3978f632e017af9cb38dd05a0eae075056ea0"
train_size = X.shape[0] // 5 * 4
# + _uuid="203bf713c4c67747436125f9d0874e9a16fcb5a5"
train_size
# + _uuid="b568cf7b68ce5dca6c6b32dd2828fa46bd00307b"
X, valid_X, train_Y, valid_Y = (X[range(train_size)], X[train_size:],
train_Y[:train_size], train_Y[train_size:])
# + _uuid="930b7141417cf48a83f7bf86f972460ab175d5ab"
X.shape
# + _uuid="afa312be8a550338a2c4c1b650c59b0eb8a7a2bc"
valid_X.shape
# + _uuid="d9ff4ab79743da65af05170980406865abe02d27"
feature_names
# + _uuid="71902be335f59766bde60509075eb7e3ec0fd6aa"
X = lgb.Dataset(X, label=train_Y, feature_name=feature_names, categorical_feature=categorical_features, free_raw_data=False)
# + _uuid="4c0ec14ee3bf375e634326aee7ca5b32615adf85"
valid_X = X.create_valid(valid_X, label=valid_Y)
# + _uuid="645d18a5ae50cd55ed2150ff359b0ae62925a715"
gc.collect()
# + [markdown] _uuid="95bcd7a2b6b7cf792f495c551679d35617f86191"
# ## train
# + _uuid="ccc4269d9a7597086432c1d271ee12ecda8a37c4"
hyper_params = {"objective": "binary", "boosting":"gbdt", "num_iterations": 100,
"learning_rate": 0.02, "num_leaves": 31, "num_threads": 2,
"seed": RANDOM_SEED, "early_stopping_round": 10
}
# + _uuid="2c71b981163912b3872358aacb3ee834369fde87"
model = lgb.train(params=hyper_params, train_set=X, valid_sets=[valid_X])
# + _uuid="27c4d5b112572723879ddfdbb1e2dbf82993df81"
for feature, imp in zip(model.feature_name(), model.feature_importance()):
print("{}: {}".format(feature, imp))
# + _uuid="fa1a786d0a21d036a7c57d1f70ab680c9b908eb1"
del X
# + _uuid="96cbbb9bad765408e6b910de6bfe378c18e6bfca"
del valid_X
# + _uuid="ee386c015378bc51496e09cb94b3464b03f1ce82"
gc.collect()
# + _uuid="024c9c31cb541f723b26574697113125d3963f48"
import plotly.plotly as plotly
# + _uuid="f99b4f083974ee07e23b30cb203228598306ee73"
import seaborn as sns
# + _uuid="0e2be438374f2c3265f475cd99c2b80dd99bf728"
import plotly.graph_objs as go
# + _uuid="f7915c7f5f3838dbfc905693728b50b0b761c1c3"
# bar_data = [go.Bar(x=X.feature_name, y=model.feature_importance())]
# plotly.iplot(bar_data, filename="feature_importance")
# + _uuid="997999e0151db21da197c293988f94cc418276d0"
sns.set()
# + _uuid="b454872aef2ee7e7b7be36d92c68cab2e73b3ec5"
sns.set_context("notebook")
# + _uuid="0586227abb28de92dd564f4138e607db6a5a0ed0"
import matplotlib.pyplot as plt
# + _uuid="111299cbb7bd8954cc7e587ef7249456d93c78bf"
# %matplotlib inline
# + _uuid="4b6ff2f30b2312a64cfccc4718ec5aa39437e0d8"
sns.barplot(x=model.feature_name(), y=model.feature_importance(),
ax=plt.subplots(figsize=(20, 10))[1])
# + [markdown] _uuid="840aa03b49d675953f080e4069f79f435282bb43"
# ## `get_prediction_days` function
#
# Generator which loops through each "prediction day" (trading day) and provides all market and news observations which occurred since the last data you've received. Once you call **`predict`** to make your future predictions, you can continue on to the next prediction day.
#
# Yields:
# * While there are more prediction day(s) and `predict` was called successfully since the last yield, yields a tuple of:
# * `market_observations_df`: DataFrame with market observations for the next prediction day.
# * `news_observations_df`: DataFrame with news observations for the next prediction day.
# * `predictions_template_df`: DataFrame with `assetCode` and `confidenceValue` columns, prefilled with `confidenceValue = 0`, to be filled in and passed back to the `predict` function.
# * If `predict` has not been called since the last yield, yields `None`.
# + [markdown] _uuid="ba72731adf652d6011652e906d8b340d6572904e"
# ### **`predict`** function
# Stores your predictions for the current prediction day. Expects the same format as you saw in `predictions_template_df` returned from `get_prediction_days`.
#
# Args:
# * `predictions_df`: DataFrame which must have the following columns:
# * `assetCode`: The market asset.
# * `confidenceValue`: Your confidence whether the asset will increase or decrease in 10 trading days. All values must be in the range `[-1.0, 1.0]`.
#
# The `predictions_df` you send **must** contain the exact set of rows which were given to you in the `predictions_template_df` returned from `get_prediction_days`. The `predict` function does not validate this, but if you are missing any `assetCode`s or add any extraneous `assetCode`s, then your submission will fail.
# + [markdown] _uuid="9cd8317a5e52180b592ee2abc1d2177214642a3c"
# Let's make random predictions for the first day:
# + _uuid="7198d2c094989edce3c6bc95f8c2ccc24eb6f2ed"
from pandas.api.types import CategoricalDtype
# + _uuid="f527a922bcce560d1223279dfb670709b6241a45"
def to_category_type(df, category_columns, categories_list):
for col, categories in zip(category_columns, categories_list):
cat_type = CategoricalDtype(categories=categories)
df[col] = df[col].astype(cat_type)
# + _uuid="b5eedd02895e609c0f1b8da3bbf90f903dabcc62"
headline_fastText_model = fastText.load_model(FASTTEXT_MODEL_PATH)
# + _uuid="5178dfaf62d67e73e903be19a36a6032bc02ac2c"
def extract_features(news_df):
return extract_headline_fastText(news_df, headline_fastText_model)
# + _uuid="b65d553f5ddc0ca729b5c35754597515c6e53552"
def make_predictions(market_obs_df, news_obs_df, predictions_df):
add_ids(market_obs_df, news_obs_df)
fill_missing_value_news_df(news_obs_df)
to_category_type(news_obs_df, category_columns=categorical_features,
categories_list= news_categories)
encode_categorical_fields(news_df=news_obs_df)
news_features = extract_features(news_df=news_obs_df)
remove_unnecessary_columns(market_obs_df, news_obs_df)
market_obs_df = link_data_and_news(market_obs_df, news_obs_df)
X, market_train_obs_ids, news_train_obs_ids, market_train_obs_times, feature_names = to_X(market_obs_df, news_features, news_feature_names)
predictions_df.confidenceValue[[market_id - 1 for market_id in market_train_obs_ids]] = model.predict(X) * 2 - 1
# + _uuid="64bfaca64180059bbf18a35e06664a948cfe3811"
days = env.get_prediction_days()
# + _uuid="1e8e841e6af4f54af8d8f85db861d83d7beaaceb"
# random prediction for debug
# def make_random_predictions(predictions_df):
# predictions_df.confidenceValue = 2.0 * np.random.rand(len(predictions_df)) - 1.0
# make_random_predictions(predictions_template_df)
# env.predict(predictions_template_df)
# + [markdown] _uuid="8056b881707072c379ad2e89b9c59c3c041a2ab7"
# ## Main Loop
# Let's loop through all the days and make our random predictions. The `days` generator (returned from `get_prediction_days`) will simply stop returning values once you've reached the end.
# + _uuid="5c111bb2494b9a4dd1a39bbec833e7f484adbca4"
from tqdm import tqdm
# + _uuid="ef60bc52a8a228e5a2ce18e4bd416f1f1f25aeae"
# %time
for (market_obs_df, news_obs_df, predictions_template_df) in tqdm(days):
make_predictions(market_obs_df, news_obs_df, predictions_template_df)
env.predict(predictions_template_df)
print('Done!')
# + [markdown] _uuid="7c8fbcca87c7f6abc53e86408417bf12ce21bb7f"
# ## **`write_submission_file`** function
#
# Writes your predictions to a CSV file (`submission.csv`) in the current working directory.
# + _uuid="2c8ed34ffb2c47c6e124530ec798c0b4eb01ddd5"
env.write_submission_file()
# + _uuid="d38aa8a67cad3f0c105db7e764ec9b805db39ceb"
# We've got a submission file!
import os
print([filename for filename in os.listdir('.') if '.csv' in filename])
# + [markdown] _uuid="f464f37885ffa763a2592e2867d74685f75be506"
# As indicated by the helper message, calling `write_submission_file` on its own does **not** make a submission to the competition. It merely tells the module to write the `submission.csv` file as part of the Kernel's output. To make a submission to the competition, you'll have to **Commit** your Kernel and find the generated `submission.csv` file in that Kernel Version's Output tab (note this is _outside_ of the Kernel Editor), then click "Submit to Competition". When we re-run your Kernel during Stage Two, we will run the Kernel Version (generated when you hit "Commit") linked to your chosen Submission.
# + [markdown] _uuid="2e3a267ea3149403c49ff59515a1a669ca2d1f9f"
# ## Restart the Kernel to run your code again
# In order to combat cheating, you are only allowed to call `make_env` or iterate through `get_prediction_days` once per Kernel run. However, while you're iterating on your model it's reasonable to try something out, change the model a bit, and try it again. Unfortunately, if you try to simply re-run the code, or even refresh the browser page, you'll still be running on the same Kernel execution session you had been running before, and the `twosigmanews` module will still throw errors. To get around this, you need to explicitly restart your Kernel execution session, which you can do by pressing the Restart button in the Kernel Editor's bottom Console tab:
# 
| not_final_kernels/baseline-fasttext-model-for-two-sigma.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Bipolar field
from konfoo import Index, Byteorder, Bipolar, Bipolar2, Bipolar4
# ## Item
# Item type of the `field` class.
Bipolar.item_type
# Checks if the `field` class is a `bit` field.
Bipolar.is_bit()
# Checks if the `field` class is a `boolean` field.
Bipolar.is_bool()
# Checks if the `field` class is a `decimal` number field.
Bipolar.is_decimal()
# Checks if the `field` class is a `floating point` number field.
Bipolar.is_float()
# Checks if the `field` class is a `pointer` field.
Bipolar.is_pointer()
# Checks if the `field` class is a `stream` field.
Bipolar.is_stream()
# Checks if the `field` class is a `string` field.
Bipolar.is_string()
# ## Field
bipolar = Bipolar(bits_integer=2, bit_size=16, align_to=None, byte_order='auto')
bipolar = Bipolar(2, 16)
# ### Field view
bipolar
str(bipolar)
repr(bipolar)
# ### Field name
bipolar.name
# ### Field index
bipolar.index
# Byte `index` of the `field` within the `byte stream`.
bipolar.index.byte
# Bit offset relative to the byte `index` of the `field` within the `byte stream`.
bipolar.index.bit
# Absolute address of the `field` within the `data source`.
bipolar.index.address
# Base address of the `byte stream` within the `data source`.
bipolar.index.base_address
# Indexes the `field` and returns the `index` after the `field`.
bipolar.index_field(index=Index())
# ### Field alignment
bipolar.alignment
# Byte size of the `field group` which the `field` is *aligned* to.
bipolar.alignment.byte_size
# Bit offset of the `field` within its *aligned* `field group`.
bipolar.alignment.bit_offset
# ### Field size
bipolar.bit_size
# ### Field byte order
bipolar.byte_order
bipolar.byte_order.value
bipolar.byte_order.name
bipolar.byte_order = 'auto'
bipolar.byte_order = Byteorder.auto
# ### Field value
# Checks if the decimal `field` is signed or unsigned.
bipolar.signed
# Maximal decimal `field` value.
bipolar.max()
# Minimal decimal `field` value.
bipolar.min()
# Returns the bipolar `field` value as a floating point number.
bipolar.value
# Returns the decimal `field` value *aligned* to its `field group` as a number of bytes.
bytes(bipolar)
bytes(bipolar).hex()
# Returns the decimal `field` value as an integer number.
int(bipolar)
# Returns the decimal `field` value as an floating point number.
float(bipolar)
# Returns the decimal `field` value as a lowercase hexadecimal string prefixed with `0x`.
hex(bipolar)
# Returns the decimal `field` value as a binary string prefixed with `0b`.
bin(bipolar)
# Returns the decimal `field` value as an octal string prefixed with `0o`.
oct(bipolar)
# Returns the decimal `field` value as a boolean value.
bool(bipolar)
# Returns the decimal `field` value as a signed integer number.
bipolar.as_signed()
# Returns the decimal `field` value as an unsigned integer number.
bipolar.as_unsigned()
# ### Field metadata
# Returns the ``meatadata`` of the ``field`` as an ordered dictionary.
bipolar.describe()
# ### Deserialize
bipolar.deserialize(bytes.fromhex('0100'), byte_order='little')
bipolar.value
bytes(bipolar)
bytes(bipolar).hex()
int(bipolar)
float(bipolar)
hex(bipolar)
bin(bipolar)
oct(bipolar)
bool(bipolar)
# ### Serialize
buffer = bytearray()
bipolar.value = -1
bipolar.value = -1.0
bipolar.value = -0x1
bipolar.value = -0b1
bipolar.value = -0o1
bipolar.value = True
bipolar.value = -1.0
bipolar.serialize(buffer, byte_order='little')
buffer.hex()
bytes(bipolar).hex()
| notebooks/fields/Bipolar field.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # This Notebook Simulates and Animates Milling About
# ## Required Imports
# +
# %load_ext autoreload
# %autoreload 2
import math
import numpy as np
from millingabout import Fish
from interaction import Interaction
from environment import Environment
from channel import Channel
from observer import Observer
from dynamics import Dynamics
from utils import generate_distortion, generate_fish, run_simulation
# -
# ## Simulation of Milling About
#
# Change parameters here, e.g. number of fish or initializations.
# +
from events import Homing
run_time = 90 # in seconds
num_fish = 25
arena_size = np.array([1780, 1780, 1170])
arena_center = arena_size / 2.0
initial_spread = 2000
fish_pos = initial_spread * np.random.rand(num_fish, 3) + arena_center - initial_spread / 2.0
fish_vel = np.zeros((num_fish, 3))
fish_phi = math.pi * np.random.rand(num_fish, 1)
fish_vphi = np.zeros((num_fish, 1))
clock_freqs = 1
verbose = False
distortion = generate_distortion(type='none', magnitude=130, n=math.ceil(arena_size[0]/10)+1, show=False)
environment = Environment(
arena_size=arena_size,
node_pos=fish_pos,
node_vel=fish_vel,
node_phi=fish_phi,
node_vphi=fish_vphi,
distortion=distortion,
prob_type='binary',
conn_thres=3000,
conn_drop=1,
noise_magnitude=10,
verbose=verbose
)
interaction = Interaction(environment, verbose=verbose)
channel = Channel(environment)
dynamics = Dynamics(environment, clock_freq=clock_freqs)
fish = generate_fish(
n=num_fish,
channel=channel,
interaction=interaction,
dynamics=dynamics,
target_dist=130*1.75,
lim_neighbors=[2,3],
neighbor_weights=1.0,
fish_max_speeds=130,
clock_freqs=clock_freqs,
verbose=verbose
)
channel.set_nodes(fish)
observer = Observer(fish=fish, environment=environment, channel=channel)
missing_aircraft = Homing()
for i in range(1, run_time):
observer.instruct(event=missing_aircraft, rel_clock=i, pos=arena_center, fish_all=True)
run_simulation(fish=fish, observer=observer, run_time=run_time, dark=False, white_axis=False, no_legend=True)
# -
# ## Prepare Data for Animation
# +
# Get fish data from observer
data = np.zeros((6, run_time, num_fish+2))
data[0, :, :-2] = np.transpose(np.array(observer.x))
data[1, :, :-2] = np.transpose(np.array(observer.y))
data[2, :, :-2] = np.transpose(np.array(observer.z))
data[3, :, :-2] = np.transpose(np.array(observer.vx))
data[4, :, :-2] = np.transpose(np.array(observer.vy))
data[5, :, :-2] = np.transpose(np.array(observer.vz))
# Add center
data[0, :, -2] = 1780/2
data[1, :, -2] = 1780/2
data[2, :, -2] = 1170/2+45
data[3, :, -2] = 0
data[4, :, -2] = 0
data[5, :, -2] = -1
data[0, :, -1] = 1780/2
data[1, :, -1] = 1780/2
data[2, :, -1] = 1170/2-45
data[3, :, -1] = 0
data[4, :, -1] = 0
data[5, :, -1] = 1
# -
# ## Save Data
np.save('millingabout', data)
# ## Animate Simulated Data
#
# Change the speed-up factor of the animation in the variable `speed`.
# +
# Imports
import ipyvolume as ipv
from ipyvolume.moviemaker import MovieMaker
import ipywidgets as widgets
import ipywebrtc as webrtc
import matplotlib.cm as cm
import time
# Data handling
x, y, z, vx, vy, vz = data
speed = 10 # speed up animation 10 times
# Colors
v = np.sqrt(x**2 + y**2 + z**2)
v -= v.min(); v /= v.max();
colors = np.array([cm.Blues(k) for k in v])
colors[:, -2:, :] = cm.Reds(0.5) # center is red
# Figure
fig = ipv.figure()
ipv.xlim(0, 1780)
ipv.ylim(0, 1780)
ipv.zlim(0, 1170)
ipv.style.use('dark')
quiver = ipv.quiver(x, y, z, vx, vy, vz, size=10, color=colors[:,:,:3])
ipv.animation_control(quiver, interval=1000/speed)
ipv.show()
# -
# ## Save Animation as html
ipv.save('millingabout.html')
# !open 'millingabout.html'
| BlueSim/millingabout.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + id="nkKDOxwPQnDy"
from pycocotools.coco import COCO
# + id="VqWZ6x5oSrAF"
captions_ds = "/content/captions_train2017.json"
coco_captions = COCO(captions_ds)
instances_ds = "/content/instances_train2017.json"
coco_instances = COCO(instances_ds)
# + id="IgHclrDpXKyj"
categories = coco_instances.loadCats(coco_instances.getCatIds()) # Prendo tutte le categorie
categories_ids = [cat["id"] for cat in categories]
categories_names = [cat["name"] for cat in categories]
print(categories_ids)
print(len(categories_ids))
print(categories_names)
print(len(categories_names))
supercategories_names = [cat["supercategory"] for cat in categories]
print(supercategories_names)
print(len(supercategories_names))
print(set(supercategories_names))
# + id="MjkaU6lPXbaP"
# !mkdir "./supercategories"
# + id="gihlHzomXc_J"
for sup in set(supercategories_names):
f = open("./supercategories/" +sup + ".txt","w+")
f.close()
# + id="B0FxDaraXkfn"
for cat_id, cat_name, supercat_name in zip(categories_ids, categories_names, supercategories_names) :
print("CATEGORIA : ")
print(cat_id)
print(cat_name)
print("SUPER CATEGORIA : ")
print(supercat_name)
print("*******")
images = coco_instances.getImgIds(catIds = cat_id)
for img in images :
annIds = coco_captions.getAnnIds(imgIds=img)
#print(annIds)
anns = coco_captions.loadAnns(annIds)
f = open("./supercategories/" +supercat_name + ".txt","a")
f.write(anns[2]['caption'] +"\n")
f.close()
| coco_dataset/Split_COCO_supercategories.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Image Manipulation with skimage
# This example builds a simple UI for performing basic image manipulation with [scikit-image](http://scikit-image.org/).
# +
# Stdlib imports
from io import BytesIO
# Third-party libraries
from IPython.display import Image
from ipywidgets import interact, interactive, fixed
import matplotlib as mpl
from skimage import data, filters, io, img_as_float
import numpy as np
# -
# Let's load an image from scikit-image's collection, stored in the `data` module. These come back as regular numpy arrays:
i = img_as_float(data.coffee())
i.shape
# Let's make a little utility function for displaying Numpy arrays with the IPython display protocol:
def arr2img(arr):
"""Display a 2- or 3-d numpy array as an image."""
if arr.ndim == 2:
format, cmap = 'png', mpl.cm.gray
elif arr.ndim == 3:
format, cmap = 'jpg', None
else:
raise ValueError("Only 2- or 3-d arrays can be displayed as images.")
# Don't let matplotlib autoscale the color range so we can control overall luminosity
vmax = 255 if arr.dtype == 'uint8' else 1.0
with BytesIO() as buffer:
mpl.image.imsave(buffer, arr, format=format, cmap=cmap, vmin=0, vmax=vmax)
out = buffer.getvalue()
return Image(out)
arr2img(i)
# Now, let's create a simple "image editor" function, that allows us to blur the image or change its color balance:
def edit_image(image, sigma=0.1, R=1.0, G=1.0, B=1.0):
new_image = filters.gaussian(image, sigma=sigma, multichannel=True)
new_image[:,:,0] = R*new_image[:,:,0]
new_image[:,:,1] = G*new_image[:,:,1]
new_image[:,:,2] = B*new_image[:,:,2]
return arr2img(new_image)
# We can call this function manually and get a new image. For example, let's do a little blurring and remove all the red from the image:
edit_image(i, sigma=2, R=1)
# But it's a lot easier to explore what this function does by controlling each parameter interactively and getting immediate visual feedback. IPython's `ipywidgets` package lets us do that with a minimal amount of code:
lims = (0.0,1.0,0.01)
interact(edit_image, image=fixed(i), sigma=(0.0,10.0,0.1), R=lims, G=lims, B=lims);
# # Browsing the scikit-image gallery, and editing grayscale and jpg images
#
# The coffee cup isn't the only image that ships with scikit-image, the `data` module has others. Let's make a quick interactive explorer for this:
# +
def choose_img(name):
# Let's store the result in the global `img` that we can then use in our image editor below
global img
img = getattr(data, name)()
return arr2img(img)
# Skip 'load' and 'lena', two functions that don't actually return images
interact(choose_img, name=sorted(set(data.__all__)-{'lena', 'load'}));
# -
# And now, let's update our editor to cope correctly with grayscale and color images, since some images in the scikit-image collection are grayscale. For these, we ignore the red (R) and blue (B) channels, and treat 'G' as 'Grayscale':
# +
lims = (0.0, 1.0, 0.01)
def edit_image(image, sigma, R, G, B):
new_image = filters.gaussian(image, sigma=sigma, multichannel=True)
if new_image.ndim == 3:
new_image[:,:,0] = R*new_image[:,:,0]
new_image[:,:,1] = G*new_image[:,:,1]
new_image[:,:,2] = B*new_image[:,:,2]
else:
new_image = G*new_image
return arr2img(new_image)
interact(edit_image, image=fixed(img), sigma=(0.0, 10.0, 0.1),
R=lims, G=lims, B=lims);
# -
| demos/interactive_image.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + [markdown] id="AtWSVIVcV4j6" colab_type="text"
# # Celcius to Farenheit equation
# + [markdown] colab_type="text" id="F8YVA_634OFk"
# $$ f = c \times 1.8 + 32 $$
# + [markdown] id="Nl3Ho_drWD-t" colab_type="text"
# # Import TensorFlow 2.x.
# + colab_type="code" id="-ZMgCvSRFqxE" colab={}
try:
# %tensorflow_version 2.x
except Exception:
pass
import tensorflow as tf
import tensorflow.keras.layers as layers
import tensorflow.keras.models as models
import numpy as np
np.random.seed(7)
import matplotlib.pyplot as plot
print(tf.__version__)
# + [markdown] id="BS2p8F70WISp" colab_type="text"
# # Compute Farenheit using Celcius.
# + id="uHuT5KfSU6Gy" colab_type="code" colab={}
def celsius_to_fahrenheit(celsius_value):
fahrenheit_value = celsius_value * 1.8 + 32
return(fahrenheit_value)
# + [markdown] id="0nmpmaxSWQlb" colab_type="text"
# # Generate dataset for converting Celcius to Farenheit.
# + id="tQlqUK-BWSn0" colab_type="code" colab={}
def generate_dataset(number_of_samples=100):
celsius_values = []
fahrenheit_values = []
value_range = number_of_samples
for sample in range(number_of_samples):
celsius_value = np.random.randint(-1*value_range, +1*value_range)
fahrenheit_value = celsius_to_fahrenheit(celsius_value)
celsius_values.append(celsius_value)
fahrenheit_values.append(fahrenheit_value)
return(celsius_values, fahrenheit_values)
# + id="qi0BRjepi9e_" colab_type="code" colab={}
number_of_samples = 100
# + colab_type="code" id="gg4pn6aI1vms" colab={}
celsius_values, fahrenheit_values = generate_dataset(number_of_samples)
for index, celsius_value in enumerate(celsius_values):
print("{} degrees Celsius = {} degrees Fahrenheit".format(celsius_value, fahrenheit_values[index]))
# + [markdown] id="o7nHcURZWgR0" colab_type="text"
# # Create artificial neural network model.
# + colab_type="code" id="pRllo2HLfXiu" colab={}
model = models.Sequential(name='model')
model.add(layers.Dense(units=1, input_shape=[1], name='dense_layer'))
model.summary()
# + [markdown] id="N_AcNn6ZWvdq" colab_type="text"
# # Create the optimizer.
# + id="_vkNG0zxRLgj" colab_type="code" colab={}
from tensorflow.keras.optimizers import Adam
learning_rate = 0.2
optimizer = Adam(learning_rate=learning_rate)
# + [markdown] id="A8-yJCSyW5YC" colab_type="text"
# # Compute the mean squared loss.
# + colab_type="code" id="m8YQN1H41L-Y" colab={}
def compute_mean_squared_loss(y_true, y_pred):
y_true = tf.cast(y_true, y_pred.dtype)
loss = tf.math.reduce_mean(tf.math.squared_difference (y_true, y_pred), axis=-1)
print('y_true -', y_true.numpy())
print('y_pred -', y_pred.numpy())
print('MSE -', loss.numpy())
return(loss)
# + id="JqTyK431rJlQ" colab_type="code" colab={}
maximum_iterations = 300
# + id="twi6jID6n4pe" colab_type="code" colab={}
iteration = 0
while iteration < maximum_iterations:
iteration = iteration + 1
print('******************************************************************************************')
print('iteration', iteration)
print("model weights - {}".format(model.get_layer(index=-1).get_weights()))
index = np.random.randint(0, number_of_samples)
input_celsius_sample, true_fahrenheit_sample = celsius_values[index], fahrenheit_values[index]
print('celsius value -', input_celsius_sample)
print('fahrenheit value -', true_fahrenheit_sample)
with tf.GradientTape(persistent=True, watch_accessed_variables=False) as tape:
tape.watch(model.trainable_variables)
input_celsius = tf.expand_dims(input_celsius_sample, -1)
true_fahrenheit = tf.expand_dims(true_fahrenheit_sample, -1)
predicted_fahrenheit = model(input_celsius, training=True)
loss = compute_mean_squared_loss(true_fahrenheit, predicted_fahrenheit[0])
gradients = tape.gradient(loss, model.trainable_variables)
print('gradients -', gradients[0].numpy(), gradients[1].numpy())
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
| Backpropagation/LinearRegression.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 2
# language: python
# name: python2
# ---
# +
from numpy import *
from numpy.random import *
import matplotlib.pyplot as plt
import matplotlib.cm as cm
from mpl_toolkits.basemap import Basemap
from PlotFuncs import *
from LabFuncs import *
from Params import *
from HaloFuncs import *
from scipy.stats import norm
import pandas
# Galpy
from galpy.orbit import Orbit
from galpy.potential import MWPotential2014
from mpl_toolkits.mplot3d import Axes3D
from astropy import units
from skimage import measure
import cmocean
# Set plot rc params
plt.rcParams['axes.linewidth'] = 2.5
plt.rc('text', usetex=True)
plt.rc('font', family='serif')
# # Candidate
df = pandas.read_csv('../data/GAIA_SDSS_Shards.csv')
names = df.group_id.unique()
num_cands = size(names)
fig,ax = MySquarePlot('Time [Myr]','Distance [kpc]')
n_ex = 5
cols = cm.Spectral(linspace(0,1,num_cands))
sig_sun = zeros(shape=num_cands)
for i in range(0,num_cands):
Cand = df.loc[df['group_id'] ==names[i]]
orb_env,rsun,sig_sun[i],t = StreamOrbit(Cand,T_Myr=20.0)
plt.fill_between(t,orb_env[0,:],y2=orb_env[3,:],color=cols[i,:],alpha=0.25,edgecolor=None)
plt.fill_between(t,orb_env[2,:],y2=orb_env[1,:],color=cols[i,:],alpha=0.5,edgecolor=None)
#plt.plot(t,orb_env[0,:],'--',lw=3,color=cols[i,:])
#plt.plot(t,orb_env[1,:],'-',lw=3,color=cols[i,:])
#plt.plot(t,orb_env[2,:],'-',lw=3,color=cols[i,:])
#plt.plot(t,orb_env[3,:],'--',lw=3,color=cols[i,:])
print names[i],sig_sun[i]
plt.xlim([t[0],t[-1]])
plt.ylim([0.0,16.0])
plt.plot([t[0],t[-1]],[1.0,1.0],'k-',)
plt.fill_between([t[0],t[-1]],[1.0,1.0],y2=0.0,lw=3,edgecolor='k',color='lightgray',zorder=-1)
plt.show()
# +
import cmocean
fig,ax = MySquarePlot('time','distance')
plt.fill_between(t,orb_env[0,:],y2=orb_env[3,:],color='ForestGreen',alpha=0.25,edgecolor=None)
plt.fill_between(t,orb_env[2,:],y2=orb_env[1,:],color='ForestGreen',alpha=0.5,edgecolor=None)
plt.plot(t,orb_env[0,:],'g--',lw=3)
plt.plot(t,orb_env[1,:],'g-',lw=3)
plt.plot(t,orb_env[2,:],'g-',lw=3)
plt.plot(t,orb_env[3,:],'g--',lw=3)
plt.plot([-10.0,10.0],[1.0,1.0],'k-')
plt.show()
# +
# Getting local
df = pandas.read_csv('../data/GAIA-SDSS.csv')
rmin = 1.0
T_Myr = 10.0
nt = 100
nstars = size(df,0)
# orbits
kpc = units.kpc
kms = units.km/units.s
deg = units.deg
Gyr = units.Gyr
ts = linspace(0.0,T_Myr*units.Myr,nt/2)
t_tot = append(ts,-ts)
rsun = zeros(shape=nt)
rsunmin = zeros(shape=nstars)
vlocal = zeros(shape=(nstars,3))
osun1x,osun1y,osun1z = Sun[0],Sun[1],Sun[2]
osun2x,osun2y,osun2z = Sun[0],Sun[1],Sun[2]
for i in range(0,nstars):
R = df.GalR[i]
vR = df.GalRVel[i]
vT = df.GalphiVel[i]
z = df.Galz[i]
vz = df.GalzVel[i]
phi = df.Galphi[i]*180/pi
# -t
o1 = Orbit(vxvv=[R*kpc,vR*kms,vT*kms,z*kpc,vz*kms,phi*deg]).flip()
o1.integrate(ts,MWPotential2014)
# +t
o2 = Orbit(vxvv=[R*kpc,vR*kms,vT*kms,z*kpc,vz*kms,phi*deg])
o2.integrate(ts,MWPotential2014)
rsun[0:nt/2] = flipud(sqrt((o1.x(ts)-osun1x)**2.0+(o1.y(ts)-osun1y)**2.0+(o1.z(ts)-osun1z)**2.0))
rsun[nt/2:] = (sqrt((o2.x(ts)-osun2x)**2.0+(o2.y(ts)-osun2y)**2.0+(o2.z(ts)-osun2z)**2.0))
imin = argmin(rsun)
rsunmin[i] = rsun[imin]
imin = argmin(rsun)
if imin>=nt/2:
vlocal[i,:] = array([o2.vR(ts[imin-nt/2]),o2.vT(ts[imin-nt/2]),o2.vz(ts[imin-nt/2])])
else:
vlocal[i,:] = array([o1.vR(ts[imin]),o1.vT(ts[imin]),o1.vz(ts[imin])])
# +
df_local1 = df.loc[rsunmin<1.0]
df_local1 = df_local1.reset_index()
print 100*shape(df_local1)[0]/(1.0*nstars)
df_local1.to_csv('../data/Gaia-SDSS_local_1kpc.csv',float_format='%.8f',index=False)
df_local2 = df.loc[rsunmin<2.0]
df_local2 = df_local2.reset_index()
print 100*shape(df_local2)[0]/(1.0*nstars)
df_local2.to_csv('../data/Gaia-SDSS_local_2kpc.csv',float_format='%.8f',index=False)
df_local3 = df.loc[rsunmin<0.5]
df_local3 = df_local3.reset_index()
print 100*shape(df_local3)[0]/(1.0*nstars)
df_local3.to_csv('../data/Gaia-SDSS_local_0.5kpc.csv',float_format='%.8f',index=False)
# +
xlab1 = r"$v_r$ [km s$^{-1}$]"
xlab2 = r"$v_\phi$ [km s$^{-1}$]"
xlab3 = r"$v_z$ [km s$^{-1}$]"
ylab1 = r"$f_{\rm gal}(v)$ [km$^{-1}$ s]"
ylab = r"$f(v_{\rm x})$ [km$^{-1}$ s]"
fig,ax1,ax2,ax3=MyTriplePlot(xlab1,ylab,xlab2,'',xlab3,'',wspace=0.0)
col0 = 'k'
col1 = 'Crimson'
col2 = 'Blue'
col3 = 'Green'
# ax1.hist(df.GalRVel,bins='fd',color=col0,label = 'All',normed=True,alpha=0.3)
# ax2.hist(df.GalphiVel,bins='fd',color=col0,normed=True,alpha=0.3)
# ax3.hist(df.GalzVel,bins='fd',color=col0,normed=True,alpha=0.3)
# ax1.hist(df_local2.GalRVel,bins='fd',color=col2,label='in 2 kpc',normed=True,alpha=0.3)
# ax2.hist(df_local2.GalphiVel,bins='fd',color=col2,normed=True,alpha=0.3)
# ax3.hist(df_local2.GalzVel,bins='fd',color=col2,normed=True,alpha=0.3)
ax1.hist(df_local1.GalRVel,bins='fd',color=col1,label='in 1 kpc',normed=True,alpha=0.3)
ax2.hist(df_local1.GalphiVel,bins='fd',color=col1,normed=True,alpha=0.3)
ax3.hist(df_local1.GalzVel,bins='fd',color=col1,normed=True,alpha=0.3)
ax1.hist(vlocal[rsunmin<1,0],bins='fd',color=col1,label='vel in 0.5 kpc',normed=True,histtype='step',lw=3)
ax2.hist(vlocal[rsunmin<1,1],bins='fd',color=col1,normed=True,histtype='step',lw=3)
ax3.hist(vlocal[rsunmin<1,2],bins='fd',color=col1,normed=True,histtype='step',lw=3)
# ax1.hist(df_local3.GalRVel,bins='fd',color=col3,label='in 0.5 kpc',normed=True,alpha=0.3)
# ax2.hist(df_local3.GalphiVel,bins='fd',color=col3,normed=True,alpha=0.3)
# ax3.hist(df_local3.GalzVel,bins='fd',color=col3,normed=True,alpha=0.3)
# ax1.hist(vlocal[rsunmin<0.5,0],bins='fd',color=col3,label='vel in 0.5 kpc',normed=True,histtype='step',lw=3)
# ax2.hist(vlocal[rsunmin<0.5,1],bins='fd',color=col3,normed=True,histtype='step',lw=3)
# ax3.hist(vlocal[rsunmin<0.5,2],bins='fd',color=col3,normed=True,histtype='step',lw=3)
leg = ax1.legend()
ax2.set_yticklabels([])
ax3.set_yticklabels([])
ax1.set_ylim([0.0,0.005])
ax2.set_ylim([0.0,0.005])
ax3.set_ylim([0.0,0.005])
plt.show()
# +
from copy import copy
rlab = r'$\log_{10}(J_R/[\textrm{km s}^{-1}\,\textrm{kpc}])$'
plab = '$J_\phi$ [km s$^{-1}$ kpc]'
zlab = r'$\log_{10}(J_z/[\textrm{km s}^{-1}\,\textrm{kpc}])$'
Elab = r'$E$ [$10^5$ km$^2$ s$^{-2}$]'
Emax = -0.5
Emin = -2.0
jrmin = 1.0
jrmax = 10000.0
jpmin = -4900.0
jpmax = 4900.0
jzmin = 1.0
jzmax = 5000.0
gsize = 50
df_S = pandas.read_csv('../data/GAIA_SDSS_Shards.csv')
fig,ax1,ax2,ax3 = MyTriplePlot(rlab,Elab,plab,'',zlab,'',wspace=0.0,lfs=40)
cmap = cmocean.cm.matter
cmap = copy(plt.get_cmap(cmap))
cmap.set_under('white', 1.0)
df1 = df.loc[rsunmin<2]
pltname = 'Actions-local2'
plt.gcf().text(0.14,0.8,r'$r_{\rm min}<2$ kpc',fontsize=35)
# df1 = df.loc[rsunmin<1]
# pltname = 'Actions-local1'
# plt.gcf().text(0.14,0.8,r'$r_{\rm min}<1$ kpc',fontsize=35)
# df1 = df.loc[rsunmin<0.5]
# pltname = 'Actions-local0.5'
# plt.gcf().text(0.14,0.8,r'$r_{\rm min}<0.5$ kpc',fontsize=35)
###
eta = 100*shape(df1)[0]*1.0/(1.0*shape(df)[0])
plt.gcf().text(0.14,0.72,'('+r'{:.1f}'.format(eta)+'\%) ',fontsize=35)
E1 = (df1.E/1e5).as_matrix()
Jr = (df1.JR).as_matrix()
Jp = (df1.Jphi).as_matrix()
Jz = (df1.Jz).as_matrix()
# Plot halo stars
ax1.hexbin(log10(Jr),E1,extent=(log10(jrmin),log10(jrmax),Emin,Emax), gridsize=gsize,cmap=cmap,vmin=0.01,linewidths=0.0)
ax1.hexbin(log10(Jr),E1,extent=(log10(jrmin),log10(jrmax),Emin,Emax), gridsize=gsize,cmap=cmap,vmin=0.01,linewidths=0.0)
ax1.hexbin(log10(Jr),E1,extent=(log10(jrmin),log10(jrmax),Emin,Emax), gridsize=gsize,cmap=cmap,vmin=0.01,linewidths=0.0)
ax1.hexbin(log10(Jr),E1,extent=(log10(jrmin),log10(jrmax),Emin,Emax), gridsize=gsize,cmap=cmap,vmin=0.01,linewidths=0.0)
ax2.hexbin(Jp,E1,extent=(jpmin,jpmax,Emin,Emax), gridsize=gsize,cmap=cmap,vmin=0.01,linewidths=0.0)
ax2.hexbin(Jp,E1,extent=(jpmin,jpmax,Emin,Emax), gridsize=gsize,cmap=cmap,vmin=0.01,linewidths=0.0)
ax2.hexbin(Jp,E1,extent=(jpmin,jpmax,Emin,Emax), gridsize=gsize,cmap=cmap,vmin=0.01,linewidths=0.0)
ax2.hexbin(Jp,E1,extent=(jpmin,jpmax,Emin,Emax), gridsize=gsize,cmap=cmap,vmin=0.01,linewidths=0.0)
ax3.hexbin(log10(Jz),E1,extent=(log10(jzmin),log10(jzmax),Emin,Emax), gridsize=gsize,cmap=cmap,vmin=0.01,linewidths=0.0)
ax3.hexbin(log10(Jz),E1,extent=(log10(jzmin),log10(jzmax),Emin,Emax), gridsize=gsize,cmap=cmap,vmin=0.01,linewidths=0.0)
ax3.hexbin(log10(Jz),E1,extent=(log10(jzmin),log10(jzmax),Emin,Emax), gridsize=gsize,cmap=cmap,vmin=0.01,linewidths=0.0)
ax3.hexbin(log10(Jz),E1,extent=(log10(jzmin),log10(jzmax),Emin,Emax), gridsize=gsize,cmap=cmap,vmin=0.01,linewidths=0.0)
ax2.set_yticklabels([])
ax3.set_yticklabels([])
# Plot shards
Examples = names[:]
n_ex = size(Examples)
col_ex = flipud(cm.Greens(linspace(0,1,n_ex+40)))
points = zeros(shape=(size(x),2))
for i in range(0,n_ex):
namei = Examples[i]
Cand = df_S.loc[df_S['group_id'] == namei]
Cand0 = df1.loc[around(df1.ra,8).isin(Cand.ra)]
e0 = (Cand0.E/1e5).as_matrix()
jr = (Cand0.JR).as_matrix()
jp = (Cand0.Jphi).as_matrix()
jz = (Cand0.Jz).as_matrix()
ax1.plot(log10(jr),e0,'.',color=col_ex[i,:],markersize=8)
ax2.plot(jp,e0,'.',color=col_ex[i,:],markersize=8)
ax3.plot(log10(jz),e0,'.',color=col_ex[i,:],markersize=8)
ax1.set_ylim([Emin,Emax])
ax2.set_ylim([Emin,Emax])
ax3.set_ylim([Emin,Emax])
# Save
plt.show()
fig.savefig('../plots/'+pltname+'.pdf',bbox_inches='tight')
fig.savefig('../plots/plots_png/'+pltname+'.png',bbox_inches='tight')
# -
| code/Plot_orbitdistances.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# !dir /w
# !pwd
import pandas as pd
sample1 = pd.read_excel('./files/sample_1.xls', skipfooter = 2, header=1 , usecols='A:C' )
sample1
sample1.describe()
sample1[['입국객수']]
sample1[['입국객수','성별','국적코드']]
sample1[['기준년월']] = '2019-11'
sample1
sample1['성별'] == '남성'
sample1[(sample1['성별'] == '남성')]
sample1[(sample1['입국객수'] > 150000) & (sample1['성별'] ==\
'남성')]
sample1
sample1['국적코드'].isin(['A01', 'A18'])
# # 엑셀 로드
# # 국적코드가 A31, A18 인것 & 여성인것
sample2 = pd.read_excel('./files/sample_1.xls',\
skipfooter = 2, header=1 , usecols='A:C' )
sample2
| test_first.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
import pandas as pd
import numpy as np
# df=pd.read_csv('./SMSSpamCollection',sep='\t', header=None,na_filter=False,names=['class','text'])
# df['class'] = df["class"].astype('category')
# df['true_label'] = df['class'].cat.codes
# np.random.seed(1234)
# msk = np.random.rand(len(df)) < 0.66
# train_df = df[msk]
# test_df = df[~msk]
# true_labels = test_df['true_label'].tolist()
# train_df.to_pickle("train_df")
# test_df.to_pickle("test_df")
# -
train_df = pd.read_pickle("train_df")
# train_df.head()
train_df.groupby("class").agg({"text": np.count_nonzero})
# +
test_df = pd.read_pickle("test_df")
true_labels = test_df['true_label'].tolist()
test_df.groupby("class").agg({"text": np.count_nonzero})
# +
from gensim.parsing.preprocessing import STOPWORDS
import gensim.matutils as gm
from gensim.models.keyedvectors import KeyedVectors
# Load pretrained model (since intermediate data is not included, the model cannot be refined with additional data)
model = KeyedVectors.load_word2vec_format('../../../snorkel/tutorials/glove_w2v.txt', binary=False) # C binary format
wordvec_unavailable= set()
def write_to_file(wordvec_unavailable):
with open("wordvec_unavailable.txt","w") as f:
for word in wordvec_unavailable:
f.write(word+"\n")
def preprocess(tokens):
btw_words = [word for word in tokens if word not in STOPWORDS]
btw_words = [word for word in btw_words if word.isalpha()]
return btw_words
def get_word_vectors(btw_words): # returns vector of embeddings of words
word_vectors= []
for word in btw_words:
try:
word_v = np.array(model[word])
word_v = word_v.reshape(len(word_v),1)
#print(word_v.shape)
word_vectors.append(model[word])
except:
wordvec_unavailable.add(word)
return word_vectors
def get_similarity(word_vectors,target_word): # sent(list of word vecs) to word similarity
similarity = 0
target_word_vector = 0
try:
target_word_vector = model[target_word]
except:
wordvec_unavailable.add(target_word+" t")
return similarity
target_word_sparse = gm.any2sparse(target_word_vector,eps=1e-09)
for wv in word_vectors:
wv_sparse = gm.any2sparse(wv, eps=1e-09)
similarity = max(similarity,gm.cossim(wv_sparse,target_word_sparse))
return similarity
# +
def read_words(words_file):
return [line for line in open(words_file, 'r') ]
words = read_words("blacklist.txt")
spam = [word.strip('-_\n/') for word in words]
spam = [word.replace('-',' ') for word in spam]
print(len(spam))
# l1 = []
# l2 = []
# l3 = []
# for i,w in enumerate(spam):
# if(i%3==0):
# l1.append(w)
# elif(i%3==1):
# l2.append(w)
# else:
# l3.append(w)
l1 = set()
l2 = set()
l3 = set()
for i,w in enumerate(spam):
if(i%3==0):
l1.add(w)
elif(i%3==1):
l2.add(w)
else:
l3.add(w)
print(len(l1),len(l2),len(l3))
# +
####### Discrete ##########
# Helper function to get last name
import re
def ltp(x):
return '(' + '|'.join(x) + ')'
# def l1words(c):
# return (1,1) if re.search(ltp(l1), c['text'], flags=re.I) else (0,0)
# def l2words(c):
# return (1,1) if re.search(ltp(l2), c['text'], flags=re.I) else (0,0)
# def l3words(c):
# return (1,1) if re.search(ltp(l3), c['text'], flags=re.I) else (0,0)
# notFree = ['you','toll','your','call','meet','talk','freez']
# def notFreeSpam(c):
# return (-1,1) if re.search('(free.*'+ltp(notFree)+')|('+ltp(notFree)+'.*free)',\
# flags=re.I) else (0,0)
def l1words(c):
return (1,1) if len(l1.intersection(c['text'].split())) > 0 else (0,0)
def l2words(c):
return (1,1) if len(l2.intersection(c['text'].split())) > 0 else (0,0)
def l3words(c):
return (1,1) if len(l3.intersection(c['text'].split())) > 0 else (0,0)
notFree1 = {'toll','Toll','freely','call','meet','talk','feedback'}
def notFreeSpam(c):
return (-1,1) if 'free' in c['text'].split() and len(notFree.intersection(c['text'].split()))>0 else (0,0)
notFree2 = {'not free','you are','when','wen'}
def notFreeSpam2(c):
return (-1,1) if 'free' in c['text'].split() and re.search(ltp(notFree2),c['text'], flags= re.I) else (0,0)
person1 = {'I','i','u','you','ur','your','our','we','us','you\'re,'}
person2 = {'He','he','She','she','they','They','Them','them','their','Their'}
def personWords(c):
return (-1,1) if 'free' in c['text'].split() and len(person1.intersection(c['text'].split()))>0 else (0,0)
def secondPersonWords(c):
return (-1,1) if 'free' in c['text'].split() and len(person2.intersection(c['text'].split()))>0 else (0,0)
def noOfCapChars(c):
return (1,1) if (sum(1 for ch in c['text'] if ch.isupper()) > 6) else (0,0)
LFs = [
l1words,l2words,l3words,noOfCapChars,notFreeSpam,notFreeSpam2,personWords,secondPersonWords
]
LF_l = [1,1,1,1,-1,-1,-1,-1]
print(len(LFs),len(LF_l))
# +
##### Continuous ################
def l1words(c):
sc = 0
word_vectors = get_word_vectors(c['text'].split())
l1 = ['free','credit','cheap','apply','buy','attention','shop','sex','soon','now','spam']
for w in l1:
sc=max(sc,get_similarity(word_vectors,w))
return (1,sc)
def l2words(c):
sc = 0
l2 = ['gift','click','new','online','discount','earn','miss','hesitate','exclusive','urgent']
word_vectors = get_word_vectors(c['text'].split())
for w in l2:
sc=max(sc,get_similarity(word_vectors,w))
return (1,sc)
def l3words(c):
sc = 0
l3 = ['cash','refund','insurance','money','guaranteed','save','win','teen','weight','hair']
word_vectors = get_word_vectors(c['text'].split())
for w in l3:
sc=max(sc,get_similarity(word_vectors,w))
return (1,sc)
def notFreeSpam(c):
sc = 0
notFree = ['not','when','call','meet','talk','feedback','toll']
word_vectors = get_word_vectors(c['text'].split())
for w in notFree:
sc=max(sc,get_similarity(word_vectors,w))
return (1,sc)
def notFreeSpam2(c):
sc = 0
notFree2 = ['not free','you are','when']
word_vectors = get_word_vectors(c['text'].split())
for w in notFree2:
sc=max(sc,get_similarity(word_vectors,w))
return (1,sc)
def personWords(c):
sc = 0
notFree2 = ['I','you','your','we','us']
word_vectors = get_word_vectors(c['text'].split())
for w in person1:
sc=max(sc,get_similarity(word_vectors,w))
return (-1,sc)
return (-1,1) if 'free' in c['text'].split() and re.search(ltp(notFree2),c['text'], flags= re.I) else (0,0)
def secondPersonWords(c):
sc = 0
notFree2 = ['he','she','they','them','their']
word_vectors = get_word_vectors(c['text'].split())
for w in person1:
sc=max(sc,get_similarity(word_vectors,w))
return (-1,sc)
def noOfCapChars(c):
l = sum(1 for ch in c['text'] if ch.isupper())
return (1,l/150)
LFs = [
l1words,l2words,l3words,noOfCapChars,notFreeSpam,notFreeSpam2,personWords,secondPersonWords
]
LF_l = [1,1,1,1,-1,-1,-1,-1]
print(len(LFs),len(LF_l))
# +
''' output:
[[[L_x1],[S_x1]],
[[L_x2],[S_x2]],
......
......
]
'''
def get_L_S_Tensor(df,msg):
L_S = []
print('labelling ',msg,' data')
for i in range(len(df.index)):
L_S_ci=[]
L=[]
S=[]
P_ik = []
for LF in LFs:
# print(i,LF.__name__)
# print(df.iloc[i]['text'])
l,s = LF(df.iloc[i])
L.append(l)
S.append((s+1)/2) #to scale scores in [0,1]
L_S_ci.append(L)
L_S_ci.append(S)
L_S.append(L_S_ci)
if(i%250==0 and i!=0):
print(str(i)+'data points labelled in',(time.time() - start_time)/60,'mins')
return L_S
# +
# import matplotlib.pyplot as plt
import time
import numpy as np
start_time = time.time()
lt = time.localtime()
print("started at: {}-{}-{}, {}:{}:{}".format(lt.tm_mday,lt.tm_mon,lt.tm_year,lt.tm_hour,lt.tm_min,lt.tm_sec))
test_L_S = get_L_S_Tensor(test_df,'regex test')
np.save("test_L_S_discrete",np.array(test_L_S))
train_L_S = get_L_S_Tensor(train_df,'regex train')
np.save("train_L_S_discrete",np.array(train_L_S))
# test_L_S = get_L_S_Tensor(test_df,'regex test')
# np.save("test_L_S_smooth",np.array(test_L_S))
# train_L_S = get_L_S_Tensor(train_df,'regex train')
# np.save("train_L_S_smooth",np.array(train_L_S))
print("--- %s seconds ---" % (time.time() - start_time))
# test_L_S = get_L_S_Tensor(test_cands)
# pkl.dump(test_L_S,open("test_L_S.p","wb"))
# +
LF_l = [1,1,1,1,-1,-1,-1,-1]
def merge(a,b):
c = []
for i in range(len(a)):
ci = []
ci_l = a[i,0,:].tolist()+b[i,0,:].tolist()
ci_s = a[i,1,:].tolist()+b[i,1,:].tolist()
ci.append(ci_l)
ci.append(ci_s)
c.append(ci)
return c
import numpy as np
test_L_S_s = np.load("test_L_S_smooth.npy")
train_L_S_s = np.load("train_L_S_smooth.npy")
test_L_S_d = np.load("test_L_S_discrete.npy")
train_L_S_d = np.load("train_L_S_discrete.npy")
test_L_S = np.array(merge(test_L_S_d,test_L_S_s))
train_L_S = np.array(merge(train_L_S_d,train_L_S_s))
dev_L_S = test_L_S
gold_labels_dev = true_labels
LF_l = LF_l + LF_l
print(len(LF_l))
NoOfLFs= len(LF_l)
NoOfClasses = 2
# LF_names = [lf.__name__ for lf in LFs] + ['s'+lf.__name__ for lf in LFs]
# print(len(LF_names))
print(test_L_S.shape,train_L_S.shape)
# +
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrix
from collections import defaultdict
from sklearn.metrics import accuracy_score
from sklearn.metrics import precision_recall_fscore_support
from sklearn.metrics import precision_recall_curve
from sklearn.metrics import average_precision_score
from sklearn.metrics import roc_auc_score
def draw2DArray(a):
fig = plt.figure(figsize=(6, 3.2))
ax = fig.add_subplot(111)
ax.set_title('colorMap')
plt.imshow(np.array(a))
ax.set_aspect('equal')
cax = fig.add_axes([0.12, 0.1, 0.78, 0.8])
cax.get_xaxis().set_visible(False)
cax.get_yaxis().set_visible(False)
cax.patch.set_alpha(0)
cax.set_frame_on(False)
plt.colorbar(orientation='vertical')
plt.show()
def report2dict(cr):
# Parse rows
tmp = list()
for row in cr.split("\n"):
parsed_row = [x for x in row.split(" ") if len(x) > 0]
if len(parsed_row) > 0:
tmp.append(parsed_row)
# Store in dictionary
measures = tmp[0]
D_class_data = defaultdict(dict)
for row in tmp[1:]:
class_label = row[0]
for j, m in enumerate(measures):
D_class_data[class_label][m.strip()] = float(row[j + 1].strip())
return pd.DataFrame(D_class_data).T
def predictAndPrint(pl):
print("acc",accuracy_score(true_labels,pl))
# print(precision_recall_fscore_support(true_labels,pl,average='macro'))
print(confusion_matrix(true_labels,pl))
# draw2DArray(confusion_matrix(gold_labels_dev,pl))
return report2dict(classification_report(true_labels, pl))# target_names=class_names))
def drawPRcurve(y_test,y_score,it_no):
fig = plt.figure()
splt = fig.add_subplot(111)
precision, recall, _ = precision_recall_curve(y_test, y_score,pos_label=1)
splt.step(recall, precision, color='b', alpha=0.2,
where='post')
splt.fill_between(recall, precision, step='post', alpha=0.2,
color='b')
average_precision = average_precision_score(y_test, y_score)
plt.xlabel('Recall')
plt.ylabel('Precision')
plt.ylim([0.0, 1.05])
plt.xlim([0.0, 1.05])
plt.title('{0:d} Precision-Recall curve: AP={1:0.2f}'.format(it_no,
average_precision))
# -
import numpy as np
test_L_S = np.load("test_L_S_discrete.npy")
train_L_S = np.load("train_L_S_discrete.npy")
dev_L_S = test_L_S
gold_labels_dev = true_labels
print(test_L_S.shape,train_L_S.shape)
# LF_names= [lf.__name__ for lf in LFs]
# +
import numpy as np
test_L_S = np.load("test_L_S_smooth.npy")
train_L_S = np.load("train_L_S_smooth.npy")
dev_L_S = test_L_S
gold_labels_dev = true_labels
print(test_L_S.shape,train_L_S.shape)
# LF_names= ['s'+lf.__name__ for lf in LFs]
# +
#call this only once for a kernel startup
from __future__ import absolute_import, division, print_function
import tensorflow as tf
# BATCH_SIZE = 32
seed = 12
# -
LF_l = [1,1,1,1,-1,-1,-1,-1]
NoOfLFs= len(LF_l)
NoOfClasses = 2
print(len(LF_l))
# +
def train(lr,ep,th,af,batch_size=32,LF_acc=None,LF_rec=None,pcl=np.array([-1,1],dtype=np.float64),norm=True,\
smooth=True,penalty=0,p3k=3,alp=1,Gamma=1.0,debug=True):
## lr : learning rate
## ep : no of epochs
## th : thetas initializer
## af : alphas initializer
## penalty : {1,2,3} use one of the three penalties, 0: no-penalty
## p3k : parameter for penalty-3
## smooth : flag if smooth lfs are used
## make sure smooth/discrete LF data is loaded into train_L_S and test_L_S
## pcl : all possible class labels = [-1,1] for binary,
## np.arange(0,NoOfClasses) for multiclass
## alp : alpha parameter (to set a max value for alpha)
## norm : use normalization or not
## Gamma : penalty tuning parameter
BATCH_SIZE = batch_size
tf.reset_default_graph()
seed = 12
with tf.Graph().as_default():
train_dataset = tf.data.Dataset.from_tensor_slices(train_L_S).batch(BATCH_SIZE)
dev_dataset = tf.data.Dataset.from_tensor_slices(dev_L_S).batch(len(dev_L_S))
# test_dataset = tf.data.Dataset.from_tensor_slices(test_L_S).batch(len(test_L_S))
iterator = tf.data.Iterator.from_structure(train_dataset.output_types,
train_dataset.output_shapes)
next_element = iterator.get_next()
train_init_op = iterator.make_initializer(train_dataset)
dev_init_op = iterator.make_initializer(dev_dataset)
# test_in`it_op = iterator.make_initializer(test_dataset)
next_element = iterator.get_next()
# print("next_element",next_element)
alphas = tf.get_variable('alphas', [NoOfLFs],\
initializer=af,\
dtype=tf.float64)
thetas = tf.get_variable('thetas',[1,NoOfLFs],\
initializer=th,\
dtype=tf.float64)
# print("thetas",thetas)
k = tf.convert_to_tensor(LF_l, dtype=tf.float64)
g = tf.convert_to_tensor(Gamma, dtype=tf.float64)
if(penalty in [4,5,6]):
LF_a = tf.convert_to_tensor(LF_acc, dtype=tf.float64)
if(penalty == 6):
LF_r = tf.convert_to_tensor(LF_rec, dtype=tf.float64)
if(debug):
print("k",k)
l,s = tf.unstack(next_element,axis=1)
# print(alphas)
if(debug):
print("s",s)
print("l",l)
# print(s.graph)
if(smooth):
s_ = tf.maximum(tf.subtract(s,tf.minimum(alphas,alp)), 0)
if(debug):
print("s_",s_)
def iskequalsy(v,s):
out = tf.where(tf.equal(v,s),tf.ones_like(v),-tf.ones_like(v))
if(debug):
print("out",out)
return out
if(smooth):
pout = tf.map_fn(lambda c: l*c*s_ ,pcl,name="pout")
else:
pout = tf.map_fn(lambda c: l*c ,pcl,name="pout")
if(debug):
print("pout",pout)
t_pout = tf.map_fn(lambda x: tf.matmul(x,thetas,transpose_b=True),pout,\
name="t_pout")
if(debug):
print("t_pout",t_pout)
t = tf.squeeze(thetas)
if(debug):
print("t",t)
def ints(y):
ky = iskequalsy(k,y)
if(debug):
print("ky",ky)
out1 = alphas+((tf.exp((t*ky*(1-alphas)))-1)/(t*ky))
if(debug):
print("intsy",out1)
return out1
if(smooth):
#smooth normalizer
zy = tf.map_fn(lambda y: tf.reduce_prod(1+ints(y),axis=0),\
pcl,name="zy")
else:
#discrete normalizer
zy = tf.map_fn(lambda y: tf.reduce_prod(1+tf.exp(t*iskequalsy(k,y)),axis=0),\
pcl,name="zy")
### for precision and recall t_pout
def pr_t_pout(j):
Lj = tf.map_fn(lambda li : tf.gather(li,j),l)
if(debug):
print("sft Lj",Lj)
kj = tf.gather(k,j)
if(debug):
print("sft kj",kj)
indices = tf.where(tf.equal(Lj,kj))
if(debug):
print("sft indices",indices)
li_lij_eq_kj = tf.gather(l,tf.squeeze(indices,1))
if(smooth):
si_lij_eq_kj = tf.gather(s_,tf.squeeze(indices,1))
if(debug):
print("sft l_ij_eq_kj",li_lij_eq_kj)
if(smooth):
prec_z = tf.reduce_sum(tf.map_fn(lambda y: tf.reduce_prod(1+ints(y),axis=0),\
pcl,name="prec_zy"))
else:
prec_z = tf.reduce_sum(tf.map_fn(lambda y: tf.reduce_prod(1+tf.exp(t*iskequalsy(k,y)),axis=0),\
pcl,name="prec_zy"))
if(debug):
print("prec_z",prec_z)
if(smooth):
prec_t_pout = (tf.matmul(li_lij_eq_kj*si_lij_eq_kj*kj, thetas,transpose_b=True))/prec_z
else:
prec_t_pout = (tf.matmul(li_lij_eq_kj*kj, thetas,transpose_b=True))/prec_z
if(debug):
print("prec_t_pout",prec_t_pout)
return prec_t_pout
def softplus_p(j):
aj = tf.gather(LF_a,j)
if(debug):
print("sft aj",aj)
f_p = tf.reduce_sum(aj - pr_t_pout(j))
if(debug):
print("f_p",f_p)
sft_p = tf.nn.softplus(f_p,name="sft_p")
if(debug):
print("sft_p",sft_p)
return sft_p
def softplus_r(j):
rj = tf.gather(LF_r,j)
if(debug):
print("sft aj",rj)
f_r = tf.reduce_sum( pr_t_pout(j) - rj)
if(debug):
print("f_r",f_r)
sft_r = tf.nn.softplus(f_r,name="sft_r")
if(debug):
print("sft_r",sft_r)
return sft_r
# logsft = tf.map_fn(lambda j: tf.log(softplus(j)),np.arange(NoOfLFs),\
# dtype=tf.float64)
# sft = tf.map_fn(lambda j: softplus(j),np.arange(NoOfLFs),\
# dtype=tf.float64)
#
# zy = tf.map_fn(lambda y: tf.reduce_prod(1+ints(y),axis=0),\
# np.array(NoOfClasses,dtype=np.float64))
if(debug):
print("zy",zy)
logz = tf.log(tf.reduce_sum(zy,axis=0),name="logz")
if(debug):
print("logz",logz)
tf.summary.scalar('logz', logz)
lsp = tf.reduce_logsumexp(t_pout,axis=0)
if(debug):
print("lsp",lsp)
tf.summary.scalar('lsp', tf.reduce_sum(lsp))
if(not norm):
print("unnormlized loss")
loss = tf.negative(tf.reduce_sum(lsp ))
elif(penalty == 1):
print("penalty1")
loss = tf.negative(tf.reduce_sum(lsp - logz )) \
+(g*tf.reduce_sum(tf.maximum(tf.zeros_like(thetas),-thetas)))
elif(penalty == 2):
print("penalty2")
loss = tf.negative(tf.reduce_sum(lsp - logz )) \
-(g*tf.minimum( tf.reduce_min(thetas),0.0))
elif(penalty == 3):
print("penalty3")
loss = tf.negative(tf.reduce_sum(lsp - logz )) \
+(g*tf.reduce_sum(tf.log(1+tf.exp(-thetas-pk))))
elif(penalty == 4):
print("precision penalty")
loss = tf.negative(tf.reduce_sum(lsp - logz )) \
+ (g*tf.reduce_sum(tf.map_fn(lambda j: softplus_p(j),np.arange(NoOfLFs),\
dtype=tf.float64)))
elif(penalty == 5):
print("precision log(softplus) penalty")
loss = tf.negative(tf.reduce_sum(lsp - logz )) \
+ (g*tf.reduce_sum(tf.map_fn(lambda j: tf.log(softplus_p(j)),np.arange(NoOfLFs),\
dtype=tf.float64)))
elif(penalty == 6):
print("precision and recall penalty")
loss = tf.negative(tf.reduce_sum(lsp - logz )) \
+ (g*tf.reduce_sum(tf.map_fn(lambda j: softplus_p(j),np.arange(NoOfLFs),\
dtype=tf.float64))) \
+ (g*tf.reduce_sum(tf.map_fn(lambda j: softplus_r(j),np.arange(NoOfLFs),\
dtype=tf.float64)))
else:
print("normalized loss")
loss = tf.negative(tf.reduce_sum(lsp - logz ))
if(debug):
print("loss",loss)
tf.summary.scalar('loss', loss)
# tf.summary.histogram('thetas', t)
# tf.summary.histogram('alphas', alphas)
# print("normloss",normloss)
marginals = tf.nn.softmax(t_pout,axis=0)
if(debug):
print("marginals",marginals)
predict = tf.argmax(marginals,axis=0)
# pre = tf.metrics.precision(labels,predict)
# rec = tf.metrics.recall(labels,predict)
# print("loss",loss)
# print("nls_",nls_)
# global_step = tf.Variable(0, trainable=False,dtype=tf.float64)
# starter_learning_rate = 1.0
# learning_rate = tf.train.exponential_decay(starter_learning_rate, global_step,
# 10, 0.96, staircase=True)
# train_step = tf.train.AdamOptimizer(learning_rate).minimize(normloss, global_step=global_step)
# train_step = tf.train.AdamOptimizer(0.001).minimize(normloss)
# reg_losses = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
# reg_constant = 5.0 # Choose an appropriate one.
# totalloss = normloss + reg_constant * sum(reg_losses)
train_step = tf.train.AdamOptimizer(lr).minimize(loss)
# train_step = tf.train.AdagradOptimizer(0.01).minimize(normloss)
# train_step = tf.train.MomentumOptimizer(0.01,0.2).minimize(normloss)
# train_step = tf.train.GradientDescentOptimizer(0.1).minimize(normloss)
summary_merged = tf.summary.merge_all()
train_writer = tf.summary.FileWriter('./summary/train',
tf.get_default_graph())
test_writer = tf.summary.FileWriter('./summary/test')
init_g = tf.global_variables_initializer()
init_l = tf.local_variables_initializer()
with tf.Session() as sess:
sess.run(init_g)
sess.run(init_l)
# Initialize an iterator over the training dataset.
for en in range(ep):
sess.run(train_init_op)
tl = 0
try:
it = 0
while True:
sm,_,ls,t = sess.run([summary_merged,train_step,loss,thetas])
# print(t)
# print(tl)
train_writer.add_summary(sm, it)
# if(ls<1e-5):
# break
tl = tl + ls
it = it + 1
except tf.errors.OutOfRangeError:
pass
print(en,"loss",tl)
print("dev set")
sess.run(dev_init_op)
sm,a,t,m,pl = sess.run([summary_merged,alphas,thetas,marginals,predict])
test_writer.add_summary(sm, en)
print(a)
print(t)
unique, counts = np.unique(pl, return_counts=True)
print(dict(zip(unique, counts)))
print("acc",accuracy_score(gold_labels_dev,pl))
print(precision_recall_fscore_support(np.array(gold_labels_dev),np.array(pl),average="binary"))
print()
# print("test set")
# sess.run(test_init_op)
# a,t,m,pl = sess.run([alphas,thetas,marginals,predict])
# unique, counts = np.unique(pl, return_counts=True)
# print(dict(zip(unique, counts)))
# print("acc",accuracy_score(gold_labels_test,pl))
# print(precision_recall_fscore_support(np.array(gold_labels_test),np.array(pl),average="binary"))
# print()
# # Initialize an iterator over the validation dataset.
# sess.run(dev_init_op)
# a,t,m,pl = sess.run([alphas,thetas,marginals,predict])
# print(a)
# print(t)
# unique, counts = np.unique(pl, return_counts=True)
# print(dict(zip(unique, counts)))
# print("acc",accuracy_score(true_labels,pl))
# # predictAndPrint(pl)
# print(precision_recall_fscore_support(np.array(true_labels),np.array(pl),average="binary"))
# cf = confusion_matrix(true_labels,pl)
# print(cf)
return pl
# +
from sklearn.metrics import accuracy_score
from sklearn.metrics import recall_score
from sklearn.metrics import precision_score
import numpy as np
def get_LF_rec(L_S,true_labels):
#L_S : a numpy array of [NoOfDataPoints,2,NoOfLFs]
#true_labels : numpy array [NoOfDataPoints]
true_l = [-1 if x==0 else x for x in true_labels]
unique, counts = np.unique(true_l, return_counts=True)
print(dict(zip(unique, counts)))
# take only labels
L_S = L_S[:,0,:]
#L_S shape [NoOfDataPoints,NoOfLFs]
LF_rec = []
for i in range(L_S.shape[1]):
# print(accuracy_score(L_S[:,i],tl,normalize=False),accuracy_score(L_S[:,i],tl))
LF_labels = [LF_l[i] if x==LF_l[i] else 0 for x in L_S[:,i]]
tl = [LF_l[i] if x==LF_l[i] else 0 for x in true_l]
LF_rec.append(recall_score(LF_labels,tl,pos_label=LF_l[i],average='binary'))
# unique, counts = np.unique(L_S[:,i], return_counts=True)
# print(i,dict(zip(unique, counts)))
# print(precision_score(L_S[:,i],tl,labels=[LF_l[i]],average='macro'))
# LF_acc.append(precision_score(L_S[:,i],tl,labels=[LF_l[i]],average='macro'))
return np.array(LF_rec)
get_LF_rec(dev_L_S,gold_labels_dev)
# +
from sklearn.metrics import accuracy_score
from sklearn.metrics import precision_score
import numpy as np
def get_LF_acc(L_S,true_labels):
#L_S : a numpy array of [NoOfDataPoints,2,NoOfLFs]
#true_labels : numpy array [NoOfDataPoints]
tl = [-1 if x==0 else x for x in true_labels]
unique, counts = np.unique(tl, return_counts=True)
print(dict(zip(unique, counts)))
# take only labels
L_S = L_S[:,0,:]
#L_S shape [NoOfDataPoints,NoOfLFs]
LF_acc = []
for i in range(L_S.shape[1]):
# print(accuracy_score(L_S[:,i],tl,normalize=False),accuracy_score(L_S[:,i],tl))
LF_acc.append(accuracy_score(L_S[:,i],tl))
# unique, counts = np.unique(L_S[:,i], return_counts=True)
# print(i,dict(zip(unique, counts)))
# print(precision_score(L_S[:,i],tl,labels=[LF_l[i]],average='macro'))
# LF_acc.append(precision_score(L_S[:,i],tl,labels=[LF_l[i]],average='macro'))
return np.array(LF_acc)
get_LF_acc(dev_L_S,gold_labels_dev)
# +
rec = np.array([0.22666667, 0.1953602 , 0.30890052, 0.55192878, 0.44444444,\
1. , 0.55 , 1. ])
acc = np.array([0.04540598, 0.08547009, 0.06303419, 0.09935897, 0.0042735 ,\
0.00053419, 0.00587607, 0.00106838])
### smooth LFs with acc on discrete LFs
for b in [512,1024,2048]:
for i in np.linspace(0,1,11):
print("batch-size:",b,"alpha-init:",i)
train(0.1/len(train_L_S),5,batch_size = b, th = tf.truncated_normal_initializer(1,0.1,seed),\
af = tf.truncated_normal_initializer(i,0.001,seed),\
LF_acc = acc ,LF_rec = rec,\
pcl=np.array([-1,1],dtype=np.float64),\
norm=True,smooth=True,penalty=6,debug=False)
# -
for b in [512,1024,2048]:
for i in np.linspace(0,1,11):
print("batch-size:",b,"alpha-init:",i)
train(0.001,5,batch_size = b, th = tf.truncated_normal_initializer(1,0.1,seed),\
af = tf.truncated_normal_initializer(0,0.001,seed),\
LF_acc = get_LF_acc(dev_L_S,gold_labels_dev) ,pcl=np.array([-1,1],dtype=np.float64),\
norm=True,smooth=True,penalty=4)
for b in [32,64,128,512,1024,2048]:
for i in np.linspace(0,1,11):
print("batch-size:",b,"alpha-init:",i)
train(0.1/len(train_L_S),5,batch_size = b, th = tf.truncated_normal_initializer(1,0.1,seed),\
af = tf.truncated_normal_initializer(0,0.001,seed),\
LF_acc = get_LF_acc(dev_L_S,gold_labels_dev) ,pcl=np.array([-1,1],dtype=np.float64),\
norm=True,smooth=True,penalty=4)
for b in [32,64,128,512,1024,2048]:
print("batch-size:",b)
train(0.1/len(train_L_S),5,batch_size = b, th = tf.truncated_normal_initializer(1,0.1,seed),\
af = tf.truncated_normal_initializer(0,0.001,seed),\
LF_acc = get_LF_acc(dev_L_S,gold_labels_dev) ,pcl=np.array([-1,1],dtype=np.float64),\
norm=True,smooth=False,penalty=4)
for b in [32,64,128,512,1024,2048]:
print("batch-size:",b)
train(0.01,5,batch_size = b, th = tf.truncated_normal_initializer(1,0.1,seed),\
af = tf.truncated_normal_initializer(0,0.001,seed),\
LF_acc = get_LF_acc(dev_L_S,gold_labels_dev) ,pcl=np.array([-1,1],dtype=np.float64),\
norm=True,smooth=False,penalty=4)
# +
import scipy.sparse as sp
import _pickle as pkl
# L_train = pkl.load(open("train_L_S_discrete.p","rb"))
# L_train = sp.csr_matrix(L_train)
# L_gold = pkl.load(open("gold_discrete.p","rb"))
# print(np.array(L_gold).shape)
# L_gold = sp.csr_matrix(L_gold)
L_train = np.load("train_L_S_discrete.npy")
L_train = L_train[:,0,:].astype(int)
print(np.array(L_train).shape)
L_train = sp.csr_matrix(L_train)
L_gold = np.load("test_L_S_discrete.npy")
L_gold = L_gold[:,0,:].astype(int)
print(np.array(L_gold).shape)
L_gold = sp.csr_matrix(L_gold)
from snorkel.learning import GenerativeModel
import time
import datetime
gen_model = GenerativeModel()
start_time = time.time()
lt = time.localtime()
print("started at: {}-{}-{}, {}:{}:{}".format(lt.tm_mday,lt.tm_mon,lt.tm_year,lt.tm_hour,lt.tm_min,lt.tm_sec))
gen_model.train(L_train, epochs = 100, cardinality=2)
# gen_model.train(L_train, epochs=100, decay=0.95, step_size=0.1 / L_train.shape[0], reg_param=1e-6)
print("trained in ",str(datetime.timedelta(seconds=time.time() - start_time)))
# +
# 5 LFs
import numpy as np
dev_marginals = gen_model.marginals(L_gold)
dev_marginals = np.array(dev_marginals)
print(dev_marginals.shape)
# GenLabels = np.argmax(dev_marginals,axis=1)
GenLabels = np.array([1 if m > 0.5 else 0 for m in dev_marginals])
print(GenLabels.shape)
print(precision_recall_fscore_support(np.array(true_labels),GenLabels,average="binary"))
# +
# 8 discrete LFs
import numpy as np
dev_marginals = gen_model.marginals(L_gold)
dev_marginals = np.array(dev_marginals)
print(dev_marginals.shape)
# GenLabels = np.argmax(dev_marginals,axis=1)
GenLabels = np.array([1 if m > 0.5 else 0 for m in dev_marginals])
print(GenLabels.shape)
print(precision_recall_fscore_support(np.array(true_labels),GenLabels,average="binary"))
| smsspamcollection/SMS-SPAM-precision_constraints-r-befrecpen.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# %cd /Users/idawatibustan/Dev/shopee_data_science
# %env PROJECT_PATH /Users/idawatibustan/Dev/shopee_data_science
# +
from datetime import datetime
import pandas as pd
from model.heuristic.fashion_heuristic import load_library, run_fashion_heuristic
from utils.envs import *
# -
fashion_val = pd.read_csv(fashion_val_repo)
fashion_val.head()
# +
fashion_library = load_library('model/heuristic/fashion_library_20190316.json')
fashion_profile = fashion_library.get('primary')
fashion_profile_secondary = fashion_library.get('secondary')
fashion_max_length = fashion_library.get('length')
# +
start_time = datetime.now()
fashion_val_pred = run_fashion_heuristic(
fashion_val,
fashion_profile,
fashion_profile_secondary,
fashion_max_length
)
duration = datetime.now() - start_time
print(duration)
fashion_val_pred.head()
# +
# format answer for submission
fashion_val_submission = pd.DataFrame(columns=['id', 'tagging'])
for feature in fashion_profile.keys():
temp = pd.DataFrame()
temp['id'] = fashion_val_pred['itemid'].map(str)+"_"+feature
temp['tagging'] = fashion_val_pred[feature]
if len(fashion_val_submission) == 0:
fashion_val_submission = temp
else:
fashion_val_submission = fashion_val_submission.append(temp, ignore_index=True)
print(feature, len(fashion_val_submission))
fashion_val_submission.info()
# -
fashion_val_submission.head()
# +
import os
outpath = 'output/result'
filename = 'fashion_info_val_submission_'+str(datetime.now().date()).replace('-', '')+'.csv'
print(os.path.join(outpath,filename))
fashion_val_submission.to_csv(os.path.join(outpath,filename))
# -
| notebooks/ida/fashion_heuristics_run_and_export.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
# imports
import category_encoders as ce
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
from sklearn import metrics
from sklearn.ensemble import RandomForestRegressor, ExtraTreesClassifier
from sklearn.feature_selection import SelectKBest, chi2
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.linear_model import LinearRegression, LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsRegressor
from sklearn.neural_network import MLPRegressor
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.pipeline import make_pipeline
from sklearn.tree import DecisionTreeRegressor
from sklearn.svm import SVR
from sklearn.utils import shuffle
# graphing imports
import chart_studio
from chart_studio.plotly import plot, iplot
import plotly as py
import plotly.tools as tls
import plotly.express as px
import plotly.graph_objects as go
from plotly.subplots import make_subplots
# -
# # Data Exploration
# load in dataset
df = pd.read_csv('MLB-Stats.csv')
print(df.shape)
df.head()
df = df.copy()
# check for any missing data
df.isnull().sum()
# change column names from abbreviations to full names to help with domain knowledge
df = df.rename(columns={'G': 'Games_Played', 'AB': 'At_bats', 'R': 'Runs', 'H': 'Hits',
'2B': 'Doubles', '3B': 'Triples', 'HR': 'Home_Runs', 'SB': 'Stolen_Base',
'BB': 'Walk', 'SO': 'Strikeouts', 'IBB': 'Intentional_Walk', 'HBP': 'Hit_By_Pitch',
'SH': 'Sacrifice_Bunt', 'SF': 'Sacrifice_Fly', 'PA': 'Plate_Appearance'})
df.columns
# data exploration
df.describe().T
# # Feature Engineering
# batting average - hits divided by total at-bats
df['Batting_Average'] = df['Hits'] / df['At_bats']
# how frequently a batter reaches base per plate appearance
# times on base include hits, walks and hit-by-pitches
df['On_Base_Percentage'] = (df['Hits'] + df['Walk'] + df['Hit_By_Pitch']) / df['Plate_Appearance']
# slugging percentage = (1B + 2Bx2 + 3Bx3 + HRx4)/AB
df['Slugging_Percentage'] = ((df['Hits'] - df['Doubles'] - df['Triples'] - df['Home_Runs']) +
(df['Doubles'] * 2) + (df['Triples'] * 3) + (df['Home_Runs'] * 4)) / df['At_bats']
# on-base plus slugging = on-base percentage + slugging percentage
df['On_Base_Plus_Slugging'] = df['On_Base_Percentage'] + df['Slugging_Percentage']
# walks as a percentage of plate appearances
df['Walk_Percentage'] = df['Walk'] / df['Plate_Appearance']
# strikeouts as a percentage of at bats
df['Strikeout_Percentage'] = df['Strikeouts'] / df['At_bats']
# walk to strikeout ratio
df['Walks_To_Strikeouts'] = df['Walk'] / df['Strikeouts']
df['Walks_To_Strikeouts'] = df['Walks_To_Strikeouts'].replace([np.inf, -np.inf], 0)
# player value
# df['Player_Value'] = (df['On_Base_Plus_Slugging'] / df['salary']) * 1000000
df['Player_Value'] = df['salary'] / df['On_Base_Plus_Slugging']
# any null values after feature engineering?
df.isnull().sum()
# a look before dropping null values
print(df.shape)
df.head()
# drop null and infinite values
df = df.replace([np.inf, -np.inf], np.nan)
df = df.dropna()
print(df.shape)
df.head()
# getting oldest season for a player
year = df[['playerID', 'Season']]
year = year.rename(columns={'Season': 'Oldest_Season'})
year = year.sort_values('playerID').groupby('playerID').min()
year.head(10)
# merging oldest season
df = df.merge(year, how='inner', on='playerID')
# determining years in the league
df['Years_In_League'] = df['Season'] - df['Oldest_Season']
print(df.shape)
df.head()
# how stats are changing from season to season?
# the average weight of players has increased from 187 in 1985 to 212 in 2016
# the average salary of players has increased from 479k in 1985 to 4.49m in 2016
df.groupby('Season').mean()
# get the sum of each teams salaries for each season
df.groupby(['Season', 'Team']).sum()
# average salary by year for all field players
avg_salary = pd.DataFrame(df['salary'].groupby(df['Season']).mean().astype(int))
avg_salary.columns = ['Avg_Salary']
avg_salary.tail()
# merge average salary data
df = df.merge(avg_salary, how='inner', on='Season')
df.head()
# get correlations of each features in dataset
corrmat = df.corr()
top_corr_features = corrmat.index
plt.figure(figsize=(20,20))
#plot heat map
g=sns.heatmap(df[top_corr_features].corr(),annot=True,cmap="RdYlGn")
# mean absolute error
errors = df['Avg_Salary'] - df['salary']
mean_absolute_error = errors.abs().mean()
print(f"""If we just guessed a player's salary to be the average salary of a player
in that season it would be off by an average of ${mean_absolute_error:,.0f}""")
df.columns
# features
features = [
'Season',
'Games_Played',
'At_bats',
'Runs',
'Hits',
'Doubles',
'Home_Runs',
'RBI',
'Walk',
'Strikeouts',
'Intentional_Walk',
'Plate_Appearance',
'On_Base_Percentage',
'Batting_Average',
'Slugging_Percentage',
'On_Base_Plus_Slugging',
'Walk_Percentage',
'Strikeout_Percentage',
'Walks_To_Strikeouts',
'Years_In_League',
'League',
'teamID']
# +
# shuffle data
df = shuffle(df)
# drop target
y = df.pop('salary')
X = df[features]
# train test split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.25, random_state=42)
X_train.shape, X_val.shape, X_test.shape, y_train.shape, y_val.shape, y_test.shape
# +
pipeline = make_pipeline(
ce.OneHotEncoder(use_cat_names=True),
StandardScaler(),
DecisionTreeRegressor())
# Fit on train
pipeline.fit(X_train, y_train)
y_pred = pipeline.predict(X_test)
print('Mean Absolute Error:', metrics.mean_absolute_error(y_test, y_pred))
print('R^2', metrics.r2_score(y_test, y_pred))
# +
pipeline = make_pipeline(
ce.OneHotEncoder(use_cat_names=True),
StandardScaler(),
KNeighborsRegressor())
# Fit on train
pipeline.fit(X_train, y_train)
y_pred = pipeline.predict(X_test)
print('Mean Absolute Error:', metrics.mean_absolute_error(y_test, y_pred))
print('R^2:', metrics.r2_score(y_test, y_pred))
# +
pipeline = make_pipeline(
ce.OneHotEncoder(use_cat_names=True),
StandardScaler(),
RandomForestRegressor())
# Fit on train
pipeline.fit(X_train, y_train)
y_pred = pipeline.predict(X_test)
print('Mean Absolute Error:', metrics.mean_absolute_error(y_test, y_pred))
print('R^2:', metrics.r2_score(y_test, y_pred))
| .ipynb_checkpoints/MLB-Salary-Prediction-checkpoint.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Regresion lineal y minimos cuadrados
#
# Encontrar relaciones entre variables (atributos) para hacer predicciones.
# En un grafica de dispersion de puntos se puede ver una tendencia
#
#
# Definicion de recta y regresion lineal simple:
#
# Regresion lineal multiple
# Se usan hiperplanos multidimensionales dependiendo de la cantidad de variables
#
# Cada dimension representa readlidad de variables de forma vectorial en forma de matrices en que cada columna representa una variable
#
# 
#
# $Y=XW$
#
# En esto se usan las GPU que estan optimizadas para estos procesos
#
# ### Metodo de cuadrados ordinarios
#
# En este metodo se usa el error que es la distancia entre el punto y la recta.
# Para esto se usa una funcion de coste =
# media(Y_{r}-Y_{e)
#
# Error cuadratico medio media((Yr-Ye)^2)
#
# <b>Minimo error cuadratico medio: </b>
# W=(X^t-X)^-1*X^tY
#
# Este metodo es costoso computacionalmente de orden O(x^2)
#
#
import numpy as np #Calculo numerico y matricial
import matplotlib.pyplot as plt #Visualizacion grafica
from sklearn.datasets import load_boston
#Cargar libreria
boston=load_boston()
boston
print(boston.DESCR)
# Formula minimizar el valor cuadratico medio (MCO): $\beta = (X^{T}X)^{-1}X^{T}Y$
#
# +
#Datapoint = zona de boston
#Con numero medio de habitaciones predecir valor vivienda
X=np.array(boston.data[:, 5])
Y=np.array(boston.target)
plt.scatter(X, Y, alpha=0.5)
#Añadir columna de 1 para termino independeinte
X=np.array([np.ones(506), X]).T
print(X)
B=np.linalg.inv(X.T @X) @X.T @Y #Escribir formula @ es multiplicacion matricial
plt.plot([4,9],[B[0]+B[1]*4, B[0]+B[1]*9], c='red')
plt.show()
# -
B
| Theory/Regresion lineal y minimos cuadrados.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# + [markdown] slideshow={"slide_type": "slide"}
#
# # <center>Example slide show</center>
# #### _<center>(NBIS Python course)</center>_
#
# + [markdown] slideshow={"slide_type": "fragment"}
#
# ### _<NAME>_
#
# + [markdown] slideshow={"slide_type": "skip"}
# Notes:
#
# http://www.slideviper.oquanta.info/tutorial/slideshow_tutorial_slides.html
# + [markdown] slideshow={"slide_type": "slide"}
# # General overview:
# # + Item 1
# # + Item 2
# # + Item 3
# + [markdown] slideshow={"slide_type": "subslide"}
# ### CRISPRs!
#
# # + Clustered
# # + Regularly Interspaced ~~Palindromic~~ Repeats
# - separated by short (30bp) bits of non-coding DNA (spacers)
# - derives in microbes from exposures to a bacteriophage virus or plasmid
# - the process being guided by two highly conserved enzymes, Cas 1 and 2.
# - 24 to 48 bp, with dyad symetry but not truly palindromic
# # + are contained in 40% of the sequenced bacterial genomes and 90% of sequenced archaea
# # + New spacers added _always_ at the leader sequence end (thus it provides a mechanism for evolutionary studies in prokariotes).
# # + Pairs with Cas9 nuclease can be RNA guided for precise genome editing. (Yay UmU!)
# # + The most common microbial defense system. Co-evolution bacteria-viruses.
# + slideshow={"slide_type": "fragment"}
print("Hello World!")
# + [markdown] slideshow={"slide_type": "fragment"}
# 
# + [markdown] slideshow={"slide_type": "subslide"}
# 
# + jupyter={"outputs_hidden": true}
| day1/jupyter_slides.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .r
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# ---
# + [markdown] colab_type="text" id="view-in-github"
# [View in Colaboratory](https://colab.research.google.com/github/adowaconan/Deep_learning_fMRI/blob/master/Cole_et_al_2017_CNN_3D_fMRI.ipynb)
# + [markdown] colab_type="text" id="NF3wIy3TqjiA"
# 1. N = 2001
# 2. CNN predict age using pre-processed and raw T1-weighted MRI data
# 3. sample of [monozygotic](https://www.google.es/search?q=monozygotic&oq=monozygotic&aqs=chrome..69i57&sourceid=chrome&ie=UTF-8) and [dizygotic](https://www.google.es/search?q=dizygotic&oq=dizygotic&aqs=chrome..69i57&sourceid=chrome&ie=UTF-8) female twins, N = 62
# 4. test-related and multi-center reliablity of two samples, N = 20: within-scanner and N = 11: between-scanner
#
# + [markdown] colab_type="text" id="aPuwqUX5rgut"
# 1. predict chronological age in healthy individuals using mahcine learning (**Dosenbach et al, 2010; Franke et al, 2010**)
# 2. deep learning offers several practical advantages for high-dimensional prediction tasks, that should enable the learning of both physiologically-related representations and latent relationships (**Plis et al, 2014**)
# + [markdown] colab_type="text" id="QMMZzNqeskGL"
# # Dataset
# 1. T1-weighted MRI scans
# 2. male = 1016, female = 985
# 3. mean age = 36.95 $\pm$ 18.12, 18-92
# 4. 14 publicly-available sources
# 5. 1.5T or 3T starndard sequences
# 6. heirtability assessment sample, UK Adult Twin Registry, N = 62, all female
# 7. within-scanner reliability sample, days apart between scans
# 8. between-scanner reliability sample, ICL, adcademic medical center amsterdam, days aprt between scans
# + [markdown] colab_type="text" id="t1oWNMAzto13"
# # Preprocessing
# 1. Cole et al, 2017 a, bc
# 2. volumetric maps for use as feature in the anaylis
# 3. Grey matter and white matter images were analyzed together, to generate a whole-brain predicted age, as well as age predictions for each tissue
# 4. SPM12 were used to segment raw T1 images according to tissue classification (grey matter, white matter, r cerebrospinal fluid)
# 5. thorough visual quality control was conducted to ensure accuracy of segmentation and any motion-corrupted images were excluded
# 6. MNI152
# 7. normalization use DARTEL for non-linear registration and resampling included modulation and 4mm smoothing, which was applied independently to images from all the datasets, resulting in normalized maps with voxelwise correspondence for all participants
# + [markdown] colab_type="text" id="hIq8UB1Uu9t9"
# 1. 3D convolutions (Ji et al, 2013)
# 2. 3D convolutions for Alzheimer's disease classification (**Panyan and Montana, 2015*; Sarraf and Tofighi, 106**), brain lesion segmentation (**Kamnitsas et al, 2016**), and skull stripping (**Kleesiek et al, 2016**)
# + [markdown] colab_type="text" id="q6yoK3R_xBhj"
# # Model proposed in the paper:
# + colab={"base_uri": "https://localhost:8080/", "height": 35} colab_type="code" id="-kT8RlpyqCll" outputId="4db5e06d-ef75-446f-8a0f-9895b67a1ddf"
import keras
from keras import backend as K
from keras.models import Sequential,Model
from keras import regularizers
from keras.layers import Dense, Dropout, Flatten,LeakyReLU,Input
from keras.layers import Conv3D, AveragePooling3D,Reshape,Flatten
from keras.layers import Conv3DTranspose,Activation
from keras.layers import BatchNormalization,MaxPooling3D
import numpy as np
# + colab={"base_uri": "https://localhost:8080/", "height": 1126} colab_type="code" id="IYam1QY5xhN9" outputId="04c01d13-5896-4460-d831-b1dbdce91643"
inputs = Input(shape=(121,145,121,1),batch_shape=(None,182,218,182,1),name='input',dtype='float32')
conv1 = Conv3D(8,kernel_size=(3,3,3),strides=1,activation='relu',name='layer1_1')(inputs)
conv1 = Conv3D(8,kernel_size=(3,3,3),strides=1,name='layer1_2')(conv1)
conv1 = BatchNormalization(name='layer1_3')(conv1)
conv1 = Activation('relu',name='layer1_4')(conv1)
conv1 = MaxPooling3D(pool_size=(2,2,2),strides=(2,2,2),name='layer1_5')(conv1)
conv2 = Conv3D(16,kernel_size=(3,3,3),strides=1,activation='relu',name='layer2_1')(conv1)
conv2 = Conv3D(16,kernel_size=(3,3,3),strides=1,name='layer2_2')(conv2)
conv2 = BatchNormalization(name='layer2_3')(conv2)
conv2 = Activation('relu',name='layer2_4')(conv2)
conv2 = MaxPooling3D(pool_size=(2,2,2),strides=(2,2,2),name='layer2_5')(conv2)
conv3 = Conv3D(32,kernel_size=(3,3,3),strides=1,activation='relu',name='layer3_1')(conv2)
conv3 = Conv3D(32,kernel_size=(3,3,3),strides=1,name='layer3_2')(conv3)
conv3 = BatchNormalization(name='layer3_3')(conv3)
conv3 = Activation('relu',name='layer3_4')(conv3)
conv3 = MaxPooling3D(pool_size=(2,2,2),strides=(2,2,2),name='layer3_5')(conv3)
conv4 = Conv3D(64,kernel_size=(3,3,3),strides=1,activation='relu',name='layer4_1')(conv3)
conv4 = Conv3D(64,kernel_size=(3,3,3),strides=1,name='layer4_2')(conv4)
conv4 = BatchNormalization(name='layer4_3')(conv4)
conv4 = Activation('relu',name='layer4_4')(conv4)
conv4 = MaxPooling3D(pool_size=(2,2,2),strides=(2,2,2),name='layer4_5')(conv4)
conv5 = Conv3D(128,kernel_size=(3,3,3),strides=1,activation='relu',name='layer5_1')(conv4)
conv5 = Conv3D(128,kernel_size=(3,3,3),strides=1,name='layer5_2')(conv5)
conv5 = BatchNormalization(name='layer5_3')(conv5)
conv5 = Activation('relu',name='layer5_4')(conv5)
conv5 = MaxPooling3D(pool_size=(2,2,2),strides=(2,2,2),name='layer5_5')(conv5)
conv5 = Flatten(name='flatten')(conv5)
dense = Dense(1,activation='relu',name='output')(conv5)
model = Model(inputs,dense)
model.summary()
# + [markdown] colab_type="text" id="kLbZE_umxmsM"
# # Data augmentation:
#
# At the training phase, all datasets were agumented by generating additional artificial training images to **prevent model over-fitting**. The data augmentation strategy consisted of performing translation ($\pm$ 10 pixels) and rotation ($\pm$ 40 degrees), and [was found empirically to yield better performance compared to no data augmentation](https://medium.com/stanford-ai-for-healthcare/dont-just-scan-this-deep-learning-techniques-for-mri-52610e9b7a85)
#
# + [markdown] colab_type="text" id="a2qbBbj_zrzJ"
# # Training procedure:
#
# ## BAHC data
# 1. train-1601, validation-200, and test-200
#
# ## Heritability analysis
# 1. model pretrained by the BAHC, and transfer to this dataset due to the small sample size (N = 62)
# 2. heritability estimation was performed using [*structural equation modeling*](http://nbviewer.jupyter.org/gist/JohnGriffiths/8478146)
# 3. The importance of invidual variance components is assessed by dropping components sequentially from the set of nested models: (genetic, common envirionmental, unique environmental) -> (genetic and unique) -> (unique) (**Akaike, 1974; Rijsdijk and Sham, 2002**)
#
#
# ## Reliability analysis
# 1. model pretrained by the BAHC and transfer to this dataset (N = 20, 11)
# + colab={} colab_type="code" id="kp44RqqXzS4x"
import pandas as pd
# + colab={"base_uri": "https://localhost:8080/", "height": 295} colab_type="code" id="xWaC46Pe2Ii0" outputId="7b09738b-aa05-4960-d7c6-8d1fabe6aec1"
df = """Input_data MAE_(years) r R2 RMSE
GM 4.16 0.96 0.92 5.31
WM 5.14 0.94 0.88 6.54
GM+WM 4.34 0.96 0.91 5.67
Raw 4.65 0.94 0.88 6.46
GM 4.66 0.95 0.89 6.01
WM 5.88 0.92 0.84 7.25
GM+WM 4.41 0.96 0.91 5.43
Raw 11.81 0.57 0.32 15.10"""
df = df.split('\n')
temp = {}
for ii,item in enumerate(df[0].split(' ')):
temp[item] = [line.split(' ') [ii] for line in df[1:]]
temp = pd.DataFrame(temp)
temp['Method'] = np.concatenate([['CNN']*4,['GPR']*4])
temp
# + [markdown] colab_type="text" id="c0ZZOVC44g-L"
# # Figure 3
# # Figure 4 - transfer learning - within
# # Figure 5 - transfer learning - between
# + colab={} colab_type="code" id="ygX9D-B92KVX"
| Cole_et_al_2017_CNN_3D_fMRI.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3.8.11 64-bit
# name: python3
# ---
# ## FCS Lab 1 Submission Report
# * Name of Student(s): <NAME>
# * Student ID(s): 1004555
import datetime
print("Execution time:", datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%d %H:%M:%S"))
# ### Part I: Shift Cipher for printable input
# !python3 ex1.py -i sherlock_short.txt -o sherlock_short.en -k 42 -m e
# !cat sherlock_short.en
# !python3 ex1.py -i sherlock_short.en -o sherlock_short.de.txt -k 42 -m d
# !cat sherlock_short.de.txt
# Expected output:
# ```
# Mr. <NAME>, who was usually very late in the mornings, save upon those not infrequent occasions when he was up all night, was seated at the breakfast table.
# ```
# ### Part II: Shift Cipher for binary input
# !python3 ex2.py -i sherlock_short.txt -o sherlock_short.en.bin -k 42 -m e
# !cat sherlock_short.en.bin
# !python3 ex2.py -i sherlock_short.en.bin -o sherlock_short.de.txt -k 42 -m d
# !cat sherlock_short.de.txt
# Expected output:
# ```
# Mr. <NAME>, who was usually very late in the mornings, save upon those not infrequent occasions when he was up all night, was seated at the breakfast table.
# ```
# ### Part III: Break Shift Cipher of flag
# Fill this in!
# The binary flag file is a PNG file (with key: 246).
# Smart deduction can be conducted via inspecting the file headers and the "spacings" between the first few bytes.
# File Signature Database Link: https://filesignatures.net/
# Alternatively, a bruteforce method would also be viable.
# !file flag flag.png
# Expected output:
#
# You'll know it's correct when you see it...
| labs/lab1/report.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
class RelativeTmx(object):
def __init__(self, arr=None):
self.arr = []
def emptyObj(self):
return self.arr == []
def insert(self, e):
return self.arr.insert(0, e)
def lenght(self):
return len(self.arr)
def values(self):
return self.arr
class Utils:
def __init__(self, x=0):
self.x = x
def f(self, x):
self.x = x
return self.x
def g(self, x):
self.x = (pow(x,2))
return self.x
@staticmethod
def calculate_E(f, g):
return f-g
class InterestUtils:
def __init__(self, r, t):
self.r = r
self.t = t
def getSimpleInterest(self):
return float((1+(self.r * self.t)/100))
def getCompoundInterest(self):
return float(pow((1+ (self.r / 100)), self.t))
functions = Utils()
rtmx = RelativeTmx()
for i in range(0, 18):
values = InterestUtils(7.5333, i)
x = functions.calculate_E(values.getCompoundInterest(),values.getSimpleInterest())
rtmx.insert(x)
df = pd.Series(list(rtmx.values()))
T = np.linspace(0, df, 100)
plt.subplots( figsize=(18,6))
plt.plot(T, functions.f(T))
plt.plot(T, functions.g(T))
plt.axhline(df.max(), color='red', linestyle='dashed', linewidth=1.5, label="max")
plt.axhline(df.median(), color='blue', linestyle='dashed', linewidth=1.5, label="avg")
plt.fill_between(df, functions.g(df), functions.f(df), color = "grey",alpha = 0.4, hatch = '|')
# -
plt.subplots( figsize=(18,6))
plt.axhline(df.median(), color='red', linestyle='dashed', linewidth=1, label="avg difference")
plt.plot(df,"o")
| relativeTmax.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # 鸢尾花示例
import os
import sys
def create_folder(name):
try:
os.makedirs(name)
print(f'{name} has created!')
except:
print(f'{name} has existed!')
file_path = os.path.abspath('..')
data_path = os.path.join(file_path, 'data_python_basic_ml')
part_path = os.path.join(data_path, '1-introduction')
create_folder(part_path)
# ## 库、数据导入
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import mglearn
from sklearn.datasets import load_iris
iris_dataset = load_iris()
# iris_dataset是一个bunch对象，与字典相似，包含键和值
iris_dataset.keys()
# ## 划分训练集和测试集
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
iris_dataset['data'], iris_dataset['target'], random_state = 0)
X_train.shape
# ## 在构建模型之前，需要先观察数据
# +
# 利用X_train中的数据创建df
# 利用iris_dateset.feature_names中的字符串对数据列进行标记
iris_dataframe = pd.DataFrame(X_train, columns = iris_dataset.feature_names)
# 利用DataFrame创建散点图矩阵，按照y_train着色
grr = pd.pandas.plotting.scatter_matrix(iris_dataframe, c = y_train, figsize = (15, 15), marker = 'o',
hist_kwds = {'bins': 20}, s =60, alpha = 0.8, cmap = mglearn.cm3)
plt.show()
# +
# pic_name = os.path.join(part_path, 'iris_data_distribution.jpg')
# plt.savefig(pic_name)
# -
# ## K临近算法 KNN
from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier(n_neighbors = 1)
knn.fit(X_train, y_train)
X_new = np.array([[5, 2.9, 1, 0.2]])
prediction = knn.predict(X_new)
print(f'prediction: {prediction}')
iris_dataset['target_names'][prediction]
# ## 评估模型
y_pred = knn.predict(X_test)
# ### 使用np.mean计算准确度
np.mean(y_pred == y_test)
y_pred == y_test
# ### 使用knn的score计算精度
knn.score(X_test, y_test)
| basic_ml-1.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python [conda root]
# language: python
# name: conda-root-py
# ---
# ## Perceptron algorithm in plain Python
#
# The perceptron is a simple supervised machine learning algorithm and one of the earliest **neural network** architectures. It was introduced by Rosenblatt in the late 1950s. A perceptron represents a **binary linear classifier** that maps a set of training examples (of $d$ dimensional input vectors) onto binary output values using a $d-1$ dimensional hyperplane.
#
# The perceptron as follows.
#
# **Given:**
# - dataset $\{(\boldsymbol{x}^{(1)}, y^{(1)}), ..., (\boldsymbol{x}^{(m)}, y^{(m)})\}$
# - with $\boldsymbol{x}^{(i)}$ being a $d-$dimensional vector $\boldsymbol{x}^i = (x^{(i)}_1, ..., x^{(i)}_d)$
# - $y^{(i)}$ being a binary target variable, $y^{(i)} \in \{0,1\}$
#
# The perceptron is a very simple neural network:
# - it has a real-valued weight vector $\boldsymbol{w}= (w^{(1)}, ..., w^{(d)})$
# - it has a real-valued bias $b$
# - it uses the Heaviside step function as its activation function
#
# * * *
# A perceptron is trained using **gradient descent**. The training algorithm has different steps. In the beginning (step 0) the model parameters are initialized. The other steps (see below) are repeated for a specified number of training iterations or until the parameters have converged.
#
# **Step 0: ** Initialize the weight vector and bias with zeros (or small random values).
# * * *
#
# **Step 1: ** Compute a linear combination of the input features and weights. This can be done in one step for all training examples, using vectorization and broadcasting:
# $\boldsymbol{a} = \boldsymbol{X} \cdot \boldsymbol{w} + b$
#
# where $\boldsymbol{X}$ is a matrix of shape $(n_{samples}, n_{features})$ that holds all training examples, and $\cdot$ denotes the dot product.
# * * *
#
# **Step 2: ** Apply the Heaviside function, which returns binary values:
#
# $\hat{y}^{(i)} = 1 \, if \, a^{(i)} \geq 0, \, else \, 0$
# * * *
#
# ** Step 3: ** Compute the weight updates using the perceptron learning rule
#
# \begin{equation}
# \Delta \boldsymbol{w} = \eta \, \boldsymbol{X}^T \cdot \big(\boldsymbol{\hat{y}} - \boldsymbol{y} \big)
# \end{equation}
# $$ \Delta b = \eta \, \big(\boldsymbol{\hat{y}} - \boldsymbol{y} \big) $$
#
# where $\eta$ is the learning rate.
# * * *
#
# ** Step 4: ** Update the weights and bias
#
# \begin{equation}
# \boldsymbol{w} = \boldsymbol{w} + \Delta \boldsymbol{w}
# \end{equation}
#
# $$
# b = b + \Delta b
# $$
# +
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs
from sklearn.model_selection import train_test_split
np.random.seed(123)
% matplotlib inline
# -
# ## Dataset
X, y = make_blobs(n_samples=1000, centers=2)
fig = plt.figure(figsize=(8,6))
plt.scatter(X[:,0], X[:,1], c=y)
plt.title("Dataset")
plt.xlabel("First feature")
plt.ylabel("Second feature")
plt.show()
# +
y_true = y[:, np.newaxis]
X_train, X_test, y_train, y_test = train_test_split(X, y_true)
print(f'Shape X_train: {X_train.shape}')
print(f'Shape y_train: {y_train.shape})')
print(f'Shape X_test: {X_test.shape}')
print(f'Shape y_test: {y_test.shape}')
# -
# ## Perceptron model class
class Perceptron():
def __init__(self):
pass
def train(self, X, y, learning_rate=0.05, n_iters=100):
n_samples, n_features = X.shape
# Step 0: Initialize the parameters
self.weights = np.zeros((n_features,1))
self.bias = 0
for i in range(n_iters):
# Step 1: Compute the activation
a = np.dot(X, self.weights) + self.bias
# Step 2: Compute the output
y_predict = self.step_function(a)
# Step 3: Compute weight updates
delta_w = learning_rate * np.dot(X.T, (y - y_predict))
delta_b = learning_rate * np.sum(y - y_predict)
# Step 4: Update the parameters
self.weights += delta_w
self.bias += delta_b
return self.weights, self.bias
def step_function(self, x):
return np.array([1 if elem >= 0 else 0 for elem in x])[:, np.newaxis]
def predict(self, X):
a = np.dot(X, self.weights) + self.bias
return self.step_function(a)
# ## Initialization and training the model
p = Perceptron()
w_trained, b_trained = p.train(X_train, y_train,learning_rate=0.05, n_iters=500)
# ## Testing
# +
y_p_train = p.predict(X_train)
y_p_test = p.predict(X_test)
print(f"training accuracy: {100 - np.mean(np.abs(y_p_train - y_train)) * 100}%")
print(f"test accuracy: {100 - np.mean(np.abs(y_p_test - y_test)) * 100}%")
# -
# ## Visualize decision boundary
def plot_hyperplane(X, y, weights, bias):
"""
Plots the dataset and the estimated decision hyperplane
"""
slope = - weights[0]/weights[1]
intercept = - bias/weights[1]
x_hyperplane = np.linspace(-10,10,10)
y_hyperplane = slope * x_hyperplane + intercept
fig = plt.figure(figsize=(8,6))
plt.scatter(X[:,0], X[:,1], c=y)
plt.plot(x_hyperplane, y_hyperplane, '-')
plt.title("Dataset and fitted decision hyperplane")
plt.xlabel("First feature")
plt.ylabel("Second feature")
plt.show()
plot_hyperplane(X, y, w_trained, b_trained)
| perceptron.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# + [markdown] deletable=true editable=true
# # Working with Bag of Words
#
# -------------------------------------
#
# In this example, we will download and preprocess the ham/spam text data. We will then use a one-hot-encoding to make a bag of words set of features to use in logistic regression.
#
# We will use these one-hot-vectors for logistic regression to predict if a text is spam or ham.
#
# We start by loading the necessary libraries.
# + deletable=true editable=true
import tensorflow as tf
import matplotlib.pyplot as plt
import os
import numpy as np
import csv
import string
import requests
import io
from zipfile import ZipFile
from tensorflow.contrib import learn
from tensorflow.python.framework import ops
ops.reset_default_graph()
# + [markdown] deletable=true editable=true
# We start a computation graph session.
# + deletable=true editable=true
# Start a graph session
sess = tf.Session()
# + [markdown] deletable=true editable=true
# Check if data was downloaded, otherwise download it and save for future use
# + deletable=true editable=true
save_file_name = os.path.join('temp','temp_spam_data.csv')
# Create directory if it doesn't exist
if not os.path.exists('temp'):
os.makedirs('temp')
if os.path.isfile(save_file_name):
text_data = []
with open(save_file_name, 'r') as temp_output_file:
reader = csv.reader(temp_output_file)
for row in reader:
text_data.append(row)
else:
zip_url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00228/smsspamcollection.zip'
r = requests.get(zip_url)
z = ZipFile(io.BytesIO(r.content))
file = z.read('SMSSpamCollection')
# Format Data
text_data = file.decode()
text_data = text_data.encode('ascii',errors='ignore')
text_data = text_data.decode().split('\n')
text_data = [x.split('\t') for x in text_data if len(x)>=1]
# And write to csv
with open(save_file_name, 'w') as temp_output_file:
writer = csv.writer(temp_output_file)
writer.writerows(text_data)
texts = [x[1] for x in text_data]
target = [x[0] for x in text_data]
# + [markdown] deletable=true editable=true
# To reduce the potential vocabulary size, we normalize the text. To do this, we remove the influence of capitalization and numbers in the text.
# + deletable=true editable=true
# Relabel 'spam' as 1, 'ham' as 0
target = [1 if x=='spam' else 0 for x in target]
# Normalize text
# Lower case
texts = [x.lower() for x in texts]
# Remove punctuation
texts = [''.join(c for c in x if c not in string.punctuation) for x in texts]
# Remove numbers
texts = [''.join(c for c in x if c not in '0123456789') for x in texts]
# Trim extra whitespace
texts = [' '.join(x.split()) for x in texts]
# + [markdown] deletable=true editable=true
# To determine a good sentence length to pad/crop at, we plot a histogram of text lengths (in words).
# + deletable=true editable=true
# %matplotlib inline
# Plot histogram of text lengths
text_lengths = [len(x.split()) for x in texts]
text_lengths = [x for x in text_lengths if x < 50]
plt.hist(text_lengths, bins=25)
plt.title('Histogram of # of Words in Texts')
plt.show()
# + [markdown] deletable=true editable=true
# We crop/pad all texts to be 25 words long. We also will filter out any words that do not appear at least 3 times.
# + deletable=true editable=true
# Choose max text word length at 25
sentence_size = 25
min_word_freq = 3
# + [markdown] deletable=true editable=true
# TensorFlow has a built in text processing function called `VocabularyProcessor()`. We use this function to process the texts.
# + deletable=true editable=true
# Setup vocabulary processor
vocab_processor = learn.preprocessing.VocabularyProcessor(sentence_size, min_frequency=min_word_freq)
# Have to fit transform to get length of unique words.
vocab_processor.transform(texts)
embedding_size = len([x for x in vocab_processor.transform(texts)])
# + [markdown] deletable=true editable=true
# To test our logistic model (predicting spam/ham), we split the texts into a train and test set.
# + deletable=true editable=true
# Split up data set into train/test
train_indices = np.random.choice(len(texts), round(len(texts)*0.8), replace=False)
test_indices = np.array(list(set(range(len(texts))) - set(train_indices)))
texts_train = [x for ix, x in enumerate(texts) if ix in train_indices]
texts_test = [x for ix, x in enumerate(texts) if ix in test_indices]
target_train = [x for ix, x in enumerate(target) if ix in train_indices]
target_test = [x for ix, x in enumerate(target) if ix in test_indices]
# + [markdown] deletable=true editable=true
# For one-hot-encoding, we setup an identity matrix for the TensorFlow embedding lookup.
#
# We also create the variables and placeholders for the logistic regression we will perform.
# + deletable=true editable=true
# Setup Index Matrix for one-hot-encoding
identity_mat = tf.diag(tf.ones(shape=[embedding_size]))
# Create variables for logistic regression
A = tf.Variable(tf.random_normal(shape=[embedding_size,1]))
b = tf.Variable(tf.random_normal(shape=[1,1]))
# Initialize placeholders
x_data = tf.placeholder(shape=[sentence_size], dtype=tf.int32)
y_target = tf.placeholder(shape=[1, 1], dtype=tf.float32)
# + [markdown] deletable=true editable=true
# Next, we create the text-word embedding lookup with the prior identity matrix.
#
# Our logistic regression will use the counts of the words as the input. The counts are created by summing the embedding output across the rows.
#
# Then we declare the logistic regression operations. Note that we do not wrap the logistic operations in the sigmoid function because this will be done in the loss function later on.
# + deletable=true editable=true
# Text-Vocab Embedding
x_embed = tf.nn.embedding_lookup(identity_mat, x_data)
x_col_sums = tf.reduce_sum(x_embed, 0)
# Declare model operations
x_col_sums_2D = tf.expand_dims(x_col_sums, 0)
model_output = tf.add(tf.matmul(x_col_sums_2D, A), b)
# + [markdown] deletable=true editable=true
# Now we declare our loss function (which has the sigmoid built in), prediction operations, optimizer, and initialize the variables.
# + deletable=true editable=true
# Declare loss function (Cross Entropy loss)
loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=model_output, labels=y_target))
# Prediction operation
prediction = tf.sigmoid(model_output)
# Declare optimizer
my_opt = tf.train.GradientDescentOptimizer(0.001)
train_step = my_opt.minimize(loss)
# Intitialize Variables
init = tf.global_variables_initializer()
sess.run(init)
# + [markdown] deletable=true editable=true
# Now we loop through the iterations and fit the logistic regression on wether or not the text is spam or ham.
# + deletable=true editable=true
# Start Logistic Regression
print('Starting Training Over {} Sentences.'.format(len(texts_train)))
loss_vec = []
train_acc_all = []
train_acc_avg = []
for ix, t in enumerate(vocab_processor.fit_transform(texts_train)):
y_data = [[target_train[ix]]]
sess.run(train_step, feed_dict={x_data: t, y_target: y_data})
temp_loss = sess.run(loss, feed_dict={x_data: t, y_target: y_data})
loss_vec.append(temp_loss)
if (ix+1)%10==0:
print('Training Observation #' + str(ix+1) + ': Loss = ' + str(temp_loss))
# Keep trailing average of past 50 observations accuracy
# Get prediction of single observation
[[temp_pred]] = sess.run(prediction, feed_dict={x_data:t, y_target:y_data})
# Get True/False if prediction is accurate
train_acc_temp = target_train[ix]==np.round(temp_pred)
train_acc_all.append(train_acc_temp)
if len(train_acc_all) >= 50:
train_acc_avg.append(np.mean(train_acc_all[-50:]))
# + [markdown] deletable=true editable=true
# Now that we have a logistic model, we can evaluate the accuracy on the test dataset.
# + deletable=true editable=true
# Get test set accuracy
print('Getting Test Set Accuracy For {} Sentences.'.format(len(texts_test)))
test_acc_all = []
for ix, t in enumerate(vocab_processor.fit_transform(texts_test)):
y_data = [[target_test[ix]]]
if (ix+1)%50==0:
print('Test Observation #' + str(ix+1))
# Keep trailing average of past 50 observations accuracy
# Get prediction of single observation
[[temp_pred]] = sess.run(prediction, feed_dict={x_data:t, y_target:y_data})
# Get True/False if prediction is accurate
test_acc_temp = target_test[ix]==np.round(temp_pred)
test_acc_all.append(test_acc_temp)
print('\nOverall Test Accuracy: {}'.format(np.mean(test_acc_all)))
# + [markdown] deletable=true editable=true
# Let's look at the training accuracy over all the iterations.
# + deletable=true editable=true
# %matplotlib inline
# Plot training accuracy over time
plt.plot(range(len(train_acc_avg)), train_acc_avg, 'k-', label='Train Accuracy')
plt.title('Avg Training Acc Over Past 50 Iterations')
plt.xlabel('Iterations')
plt.ylabel('Training Accuracy')
plt.show()
# -
# It is worthwhile to mention the motivation of limiting the sentence (or text) size. In this example we limited the text size to 25 words. This is a common practice with bag of words because it limits the effect of text length on the prediction. You can imagine that if we find a word, “meeting” for example, that is predictive of a text being ham (not spam), then a spam message might get through by putting in many occurrences of that word at the end. In fact, this is a common problem with imbalanced target data. Imbalanced data might occur in this situation, since spam may be hard to find and ham may be easy to find. Because of this fact, our vocabulary that we create might be heavily skewed toward words represented in the ham part of our data (more ham means more words are represented in ham than spam). If we allow unlimited length of texts, then spammers might take advantage of this and create very long texts, which have a higher probability of triggering non-spam word factors in our logistic model.
#
# In the next section, we attempt to tackle this problem in a better way using the frequency of word occurrence to determine the values of the word embeddings.
| 07_Natural_Language_Processing/02_Working_with_Bag_of_Words/02_bag_of_words.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python3
# name: python3
# ---
# # 6. Monte Carlo Intro
# In this section we are going to be discussing another technique for solving MDP's, known as **Monte Carlo**. In the last section, you may have noticed something a bit odd; we have talked about how RL is all about learning from experience and playing games. Yet, in none of our dynamic programming algorithms did we actually play the game. We had a full model of the environment, which included all of the state transition probabilities. You may wonder: is it reasonable to assume that we would have that type of information in a real life environment? For board games, perhaps. But, what about self driving cars?
#
# The way that we manipulated our dynamic programming algorithms required us to put an agent into a state. That may not always be possible, especially when talking about self driving cars, or even video games. A video game starts in the state that it decides-you can't choose any state you want. This is another instance of having god mode capabilities, so it is not always realistic to assume that that is always possible. In this section, we will be playing the game and learning purely from experience.
#
# ## 1.2 Monte Carlo Methods
# Monte Carlo is a rather poorly defined term. Usually, it refers to any algorithm that involves a significantly random component. With Monte Carlo Methods in RL, the random component is the _**return**_. Recall that what we are always looking for is the expected return given that you are in state $s$. With MC, instead of calculating the true expected value of G (which requires probability distributions), we instead calculate its sample mean.
#
# In order for this to work, we need to assume that we are doing episodic tasks only. The reason is because an episode has to terminate before we can calculate any of the returns. This also means that MC methods are _not_ fully online algorithms. We don't do an update after every action, but rather after every episode.
#
# The methods that we use in the Monte Carlo section should be somewhat reminiscent of the multi armed bandit problem. With the multi armed bandit problem, we were always averaging the reward after every action. With MDP's we are always averaging the return. One way to think of Monte Carlo, is that _every state_ is a _separate multi-armed bandit problem_. What we are trying to do is learn to behave optimally for all of the multi armed bandit problems, all at once. In this section, we are again going to follow the same pattern that we did in the DP section. We will start by looking at the _**prediction problem**_ (_find the value given the policy_), and then look at the _**control problem**_ (_finding the optimal policy_).
# ---
#
# # 2.0 Monte Carlo Policy Evaluation
# We are now going to solve the prediction problem using Monte Carlo Estimation. Recall that the definition of the value function is that it is the expected value of the future return, given that the current state is $s$:
#
# $$V_\pi(s) = E \big[G(t) \mid S_t = s\big]$$
#
# We know that we can estimate any expected value simply by adding up samples and dividing by the total number of samples:
#
# $$\bar{V}_\pi(s) = \frac{1}{N} \sum_{i =1}^N G_{i,s}$$
#
# Where above, $i$ is indexing the episode, and $s$ is indexing the state. The question now, is how do we get these sample returns.
#
# ## 2.1 How do we generate $G$?
# In order to get these sample returns, we need to play many episodes to generate them! For every episode that we play, we will have a sequence of states and rewards. And from the rewards, we can calculate the returns by definition, which is just the sum of all future rewards:
#
# $$G(t) = r(t+1) + \gamma * G(t+1)$$
#
# Notice how, to actually implement this in code, it would be very useful to loop through the states in reverse order, since $G$ depends only on future values. Once we have done this for many episodes, we will have multiple lists of $s$'s and $G$'s. We can then take the sample mean.
#
# ## 2.2 Mutliple Visits to $s$
# One interesting question that comes up is, what if you see the same state more than once in an episode? For instance if you see state $s$ at $t=1$ and $t=3$? What is the return for state $s$? Should we use $G(1)$ or $G(3)$? There are two answers to this question, and surprisingly they both lead to the same answer.
#
# **First Visit Monte Carlo**<br>
# The first method is called _first visit monte carlo_. That means that you would only count the return for time $t=1$.
#
# **Every Visit Monte Carlo**<br>
# The second method is called _every visit monte carlo_. That means that you would calculate the return for every time you visited the state $s$, and all of them would contribute to the sample mean; i.e. use both $t=1$ and $t=3$ as samples.
#
# Surprisingly, it has been proven that both lead to the same answer.
#
# ## 2.3 First-Visit MC Pseudocode
# Let's now look at some pseudocode for first visit monte carlo prediction.
#
# ```
# def first_visit_monte_carlo_prediction(pi, N):
# V = random initialization
# all returns = {} # default = []
# do N times:
# states, returns = play_episode
# for s, g in zip(states, returns):
# if not seen s in this episode yet:
# all_returns[s].append(g)
# V(s) = sample_mean(all_returns[s])
# return V
# ```
#
# In the above pseudocode we can see the following:
# > * The input is a policy, and the number of samples we want to generate
# * We initialize $V$ randomly, and we create a dictionary to store our returns, with a default value being an empty list
# * We loop N times. Inside the loop we generate an episode by playing the game.
# * Next, we loop through the state sequence and return sequence. We only include the return if this the first time we have seen this state in this episode since this is first visit MC.
# * If so, we add this return to our list of returns for this state.
# * Next, we update V(s) to be the sample mean of all the returns we have collected for this state.
# * At the end, we return $V$.
#
# ## 2.4 Sample Mean
# One thing that you may have noticed for the pseudocode, is that it requires us to store all of the returns that we get for each state so that the sample mean can be calculated. But, if you recall from our section on the multi armed bandit, there are more efficient ways to calculate the mean, such as calculating it from the previous mean. There are also techniques for nonstationary problems, like using a moving average. So, all of the techniques we have learned already still apply here.
#
# Another thing that we should notice about the MCM, is that because we are calculating the sample mean, all of the same rules of probability apply. That means that the confidence interval is approximately Gaussian, and the variance if the original variance of the data, divided by the number of samples collected:
#
# $$\text{Variance of Estimate} = \frac{\text{variance of RV}}{N}$$
#
# Therefore, we are going to more confident in data that has more samples, but it grows slowly with respect to the number of samples.
#
# ## 2.5 Calculating Returns from Rewards
# For full clarity, we will also quickly go over how to calculate the returns from the rewards in pseudocode.
#
# ```
# # Calculating State and Reward Sequences
# s = grid.current_state()
# states_and_rewards = [(s, 0)]
# while not game_over:
# a = policy(s)
# r = grid.move(a)
# s = grid.current_state()
# states_and_rewards.append((s, r))
#
# # Calculating the Returns
# G = 0
# states_and_returns = []
# for s, r in reverse(states_and_rewards):
# states_and_returns.append((s, G))
# G = r + gamma*G
# states_and_returns.reverse()
# ```
#
# The above pseudocode shows two main steps:
# 1. Calculating State and Reward Sequences. This is just playing the game, and keeping a log of all the states and rewards that we get, in the order we get them. Notice, this is a list of tuples. Also, first award is assumed to be 0. We do not get any reward simply for arriving at the start state.
# 2. Calculating the Returns. We start with empty list, and then loop through the states and rewards in reverse order. In the first order of this loop, the state s represents the terminal state and G will be 0. Next we update G. Notice how, on the first iteration of the loop, this includes the reward for the terminal state. Once the loop is done, we reverse the list of states and returns, since we want it to be in the order that we visited the states.
#
# ## 2.6 Note on MC
# One final thing to note about MC. Recall that one of the disadvantages of DP is that we have to loop through the entire set of states on every iteration, and that this is bad for most practical scenarios in which there are a large number of states. Notice how MC only updates the value for states that we actually visit. That means even if the state space is large, if we only ever visit a small subset of states, then it doesn't matter.
#
# Also notice, we don't even need to know what the states are! We can simply discover them by playing the game. So, there are some advantages to MC in situations where doing full exact calculations is infeasible.
# ---
#
# # 3.0 Monte Carlo Policy Evaluation in Code
# We are now going to implement Monte Carlo for finding the State-Value function in code.
#
# +
import numpy as np
from common import standard_grid, negative_grid, print_policy, print_values
SMALL_ENOUGH = 10e-4
GAMMA = 0.9
ALL_POSSIBLE_ACTIONS = ('U', 'D', 'L', 'R')
# NOTE: This is only policy evaluation, NOT optimization
def play_game(grid, policy):
"""Returns a list of states and corresponding returns"""
# Reset game to start at a random position. We need to do this, because given our
# current deterministic policy (we take upper left path all the way to goal state, and
# for any state not in that path, to go all the way to losing state. Since MC only
# calculates values for states that are actually visited, and if we only started at the
# prescribed start state, there will be some states that we never visit. So we need this
# little hack at the beginning of play game, that allows us to start the game at any
# state. This is called the exploring starts method.
start_states = list(grid.actions.keys())
start_idx = np.random.choice(len(start_states))
grid.set_state(start_states[start_idx])
# Play the game -> goal is to make a list of all states we have visited, and all rewards
# we have received
s = grid.current_state()
states_and_rewards = [(s, 0)] # list of tuples of (state, reward)
while not grid.game_over():
a = policy[s]
r = grid.move(a)
s = grid.current_state()
states_and_rewards.append((s, r))
# Calculate the returns by working backward from the terminal state. We visit each state
# in reverse, and recursively calculate the return.
G = 0
states_and_returns = []
first = True
for s, r in reversed(states_and_rewards):
# The value of the terminal state is 0 by definition. We should ignore the first state
# we encounter, and ignore the last G, which is meaningless since it doesn't
# correspond to any move.
if first:
first = False
else:
states_and_returns.append((s, G))
G = r + GAMMA * G
states_and_returns.reverse() # we want it in the order of state visited
return states_and_returns
if __name__ == '__main__':
# use the standard grid again (0 for every step) so that we can compare
# to iterative policy evaluation
grid = standard_grid()
# print rewards
print("rewards:")
print_values(grid.rewards, grid)
# state -> action
policy = {
(2, 0): 'U',
(1, 0): 'U',
(0, 0): 'R',
(0, 1): 'R',
(0, 2): 'R',
(1, 2): 'R',
(2, 1): 'R',
(2, 2): 'R',
(2, 3): 'U',
}
# Initialize V(s) and returns
V = {}
returns = {}
states = grid.all_states()
for s in states:
if s in grid.actions:
returns[s] = []
else:
# terminal state or state we can't get to otherwise
V[s] = 0
# ------ Monte Carlo Loop ------
# Plays the games and gets the states and returns list.
for t in range(100):
# Generate an episode using pi. Create set to keep track of all the states that we
# have seen, since we only want to add a return if it is the first time we have seen
# the state in this episode.
states_and_returns = play_game(grid, policy)
seen_states = set()
# Loop through all states and returns.
for s, G in states_and_returns:
# Check if we have already seen s, called "first-visit: MC policy evaluation
if s not in seen_states:
returns[s].append(G)
V[s] = np.mean(returns[s]) # Recalculate V(s) because we have new sample return
seen_states.add(s)
print("values:")
print_values(V, grid)
print("policy:")
print_policy(policy, grid)
# -
# ---
#
# # 4.0 Policy Evaluation in Windy Grid World
# We are now going to use MC predicton algorithm to find $V$, but this time we will be in windy gridworld and will be using a slightly different policy. One thing that you may have noticed with the last script is that MC wasn't really needed since the returns were deterministic. This was because the two probability distributions that we are interested in- $\pi(a \mid s)$ and $p(s,a \mid s',r)$- were both _deterministic_.
#
# In windy gridworld the state transitions are not deterministic, so we will have a source of randomness, and hence a need for MC. Also, the policy will be different. In particular, this policy is always going to try and win; in other words, travel to the goal state. We will see that even though this policy is to go to the goal state, not all values will end up positive, since in windy gridworld the wind can still end up pushing you into the losing state. So on average, the return for that state is negative.
# +
import numpy as np
from common import standard_grid, negative_grid, print_policy, print_values
SMALL_ENOUGH = 10e-4
GAMMA = 0.9
ALL_POSSIBLE_ACTIONS = ('U', 'D', 'L', 'R')
def random_action(a):
# 0.5 probability of performing chosen action
# 0.5/3 probability of doing some action a' != a
p = np.random.random()
if p < 0.5:
return a
else:
tmp = list(ALL_POSSIBLE_ACTIONS)
tmp.remove(a)
return np.random.choice(tmp)
def play_game(grid, policy):
"""Returns a list of states and corresponding returns"""
# Reset game to start at a random position. We need to do this, because given our
# current deterministic policy (we take upper left path all the way to goal state, and
# for any state not in that path, to go all the way to losing state. Since MC only
# calculates values for states that are actually visited, and if we only started at the
# prescribed start state, there will be some states that we never visit. So we need this
# little hack at the beginning of play game, that allows us to start the game at any
# state. This is called the exploring starts method.
start_states = list(grid.actions.keys())
start_idx = np.random.choice(len(start_states))
grid.set_state(start_states[start_idx])
# Play the game -> goal is to make a list of all states we have visited, and all rewards
# we have received
s = grid.current_state()
states_and_rewards = [(s, 0)] # list of tuples of (state, reward)
while not grid.game_over():
a = policy[s]
a = random_action(a) # ----- THIS IS THE UPDATE FOR WINDY GRIDWORLD -----
r = grid.move(a)
s = grid.current_state()
states_and_rewards.append((s, r))
# Calculate the returns by working backward from the terminal state. We visit each state
# in reverse, and recursively calculate the return.
G = 0
states_and_returns = []
first = True
for s, r in reversed(states_and_rewards):
# The value of the terminal state is 0 by definition. We should ignore the first state
# we encounter, and ignore the last G, which is meaningless since it doesn't
# correspond to any move.
if first:
first = False
else:
states_and_returns.append((s, G))
G = r + GAMMA * G
states_and_returns.reverse() # we want it in the order of state visited
return states_and_returns
if __name__ == '__main__':
grid = standard_grid()
# print rewards
print("rewards:")
print_values(grid.rewards, grid)
# state -> action
# found by policy_iteration_random on standard_grid
# MC method won't get exactly this, but should be close
# values:
# ---------------------------
# 0.43| 0.56| 0.72| 0.00|
# ---------------------------
# 0.33| 0.00| 0.21| 0.00|
# ---------------------------
# 0.25| 0.18| 0.11| -0.17|
# policy:
# ---------------------------
# R | R | R | |
# ---------------------------
# U | | U | |
# ---------------------------
# U | L | U | L |
# ----- This policy has changed from the previous example! -----
policy = {
(2, 0): 'U',
(1, 0): 'U',
(0, 0): 'R',
(0, 1): 'R',
(0, 2): 'R',
(1, 2): 'U',
(2, 1): 'L',
(2, 2): 'U',
(2, 3): 'L',
}
# Everything else from here down is the same. The Monte Carlo algorithm doesn't change
# becasue the fact that we are taking averages already takes into account any
# randomness both in the policy and in the state transitions.
# initialize V(s) and returns
V = {}
returns = {} # dictionary of state -> list of returns we've received
states = grid.all_states()
for s in states:
if s in grid.actions:
returns[s] = []
else:
# terminal state or state we can't otherwise get to
V[s] = 0
# repeat until convergence
for t in range(5000):
# generate an episode using pi
states_and_returns = play_game(grid, policy)
seen_states = set()
for s, G in states_and_returns:
# check if we have already seen s
# called "first-visit" MC policy evaluation
if s not in seen_states:
returns[s].append(G)
V[s] = np.mean(returns[s])
seen_states.add(s)
print("values:")
print_values(V, grid)
print("policy:")
print_policy(policy, grid)
# -
# ---
#
# # 5.0 Monte Carlo Control
# If you recall, the pattern that we are generally trying to follow is:
#
# > First look at how to solve the _prediction problem_, which finding the value function given a policy. We then want to look at how to solve the _control problem_, which is how to find the optimal policy.
#
# We are now going to go about finding the optimal policy using MC.
#
# ## 5.1 MC for Control Problem
# When we first try and do this, you will see that we come across a big problem. That is, we only have $V(s)$ for a given policy, but we don't know what actions will lead to a better $V(s)$ because we can't do a look ahead search. With MC, all we are able to do is play an episode straight through and use the returns as samples. The key to using MC for the control problem then, is to find $Q(s,a)$, since $Q$ is indexed by both $s$ and $a$, and we can choose the argmax over $a$ to find the best policy:
#
# $$argmax_a\big( Q(s,a)\big)$$
#
# ## 5.2 MC for $Q(s,a)$
# So, how exactly do we use MC to find $Q$? The process is nearly the same as we used to find $V$, except that instead of just returning tuples of states and returns, (s, G), we will return triples of states, actions, and returns, (s, a, G).
#
# We can quickly see how this may be problematic. Recall that the number of values we need to store grows quadratically with the state set size and action set size. With $V(s)$ we only need $\mid S \mid$ different estimates. With $Q(s,a)$ we need $\mid S \mid * \mid A \mid$ different estimates. That means that we have a lot more values to approximate, and we need to do many more steps of MC in order to get a good answer.
#
# There is another problem with trying to estimate $Q$, which goes back to our explore/exploit dilemma. If we have a fixed policy, then every $Q(s,a)$ will only have samples for _one_ action. That means, out of the total $\mid S \mid * \mid A \mid$ values we need to fill in, we will only be able to fill in $\frac{1}{\mid A \mid}$ of those values.
#
# The way to fix this, as we discussed earlier, is using the exploring starts method. In this case, we now randomly choose an initial state and an initial action. Thereafter we follow the policy. So, the answer that we get is $Q_\pi(s,a)$. This is consistent with our defintion of $Q$:
#
# $$Q_\pi(s,a) = E_\pi \big[G(t) \mid S_t = s, A_t=a\big]$$
#
# ## 5.3 Back to Control Problem
# Let's now return to the control problem. If you think carefully, you'll realize that we already know the answer to this problem. We discussed earlier how the method that we always used to find an optimal policy is generalized policy iteration, where we alternate between policy evaluation and policy improvement. For policy evaulation, we just discussed it-we will simply use MC to get an estimate for $Q$. The policy improvement step is the same as always, we just take the argmax over the actions from $Q$:
#
# $$\pi(s) = argmax_a Q(s,a)$$
#
# ## 5.4 Problem with MC
# One issue with this as we have already discussed, is that because we need to find $Q$ over all states and all actions, this can take a very long time using sampling. We again have a problem where there is an iterative algorithm inside an iterative algorithm.
#
# The solution to this is to take the same approach that we do with value iteration. Instead of doing a fresh MC policy evaluation on each round, where it would take a long time to collect samples, we instead update the same $Q$ and do policy improvement after every single episode. This means that on every iteration of the outer loop we generate only one episode, use that episode to improve our estimate of $Q$, and then immediately do the policy improvement step.
#
# ## 5.5 Pseudocode
# We can now look at this in pseudocode to solidify this idea:
#
# ```
# Q = random, pi = random
#
# while True:
# s, a = randomly select from S and A # Exploring starts method
#
# # Generate an episode from this starting position, following current policy
# # Receive a list of triply containing states, actions, and returns
# states_actions_returns = play_game(start=(s,a))
#
# # Policy Evaluation Step
# for s,a,G in states_actions_returns:
# returns(s,a).append(G)
#
# # Recalculate Q as average of all returns for this state action pair
# Q(s,a) = average(returns(s,a))
#
# # Policy improvement step
# for s in states:
# pi(s) = argmax[a] { Q(s,a) }
# ```
#
# # 5.6 One more problem
# There is one more subtle problem with this algorithm; Recall that if we take an action that results in us bumping into a wall, we end up in the same state as before. So, if we follow this policy we will never end up in a terminal state and therefore never finish the episode. To avoid this problem, we can introduce a hack: if we end up in the same state after doing an action, this will give us a reward of -100 and end the episode.
#
# ## 5.7 MC
# It is interesting that this method converges, even though the returns that we average for $Q$ are for different policies. Intuitively, $Q$ has to converge, since if it is suboptimal, then the policy will change, and that will in turn cause $Q$ to change. We can only achieve stability when both the value and policy to converge to the optimal value and optimal policy. Interestingly, this have never been formally proven.
# ---
#
# # 6. Monte Carlo Control in Code
# We are now going to use Monte Carlo exploring starts to solve the control problem, aka find the optimal policy and the optimal value function.
# +
import matplotlib.pyplot as plt
GAMMA = 0.9
ALL_POSSIBLE_ACTIONS = ('U', 'D', 'L', 'R')
def play_game(grid, policy):
# Reset game to start at a random position. We need to do this, because given our
# current deterministic policy (we take upper left path all the way to goal state, and
# for any state not in that path, to go all the way to losing state. Since MC only
# calculates values for states that are actually visited, and if we only started at the
# prescribed start state, there will be some states that we never visit. So we need this
# little hack at the beginning of play game, that allows us to start the game at any
# state. This is called the exploring starts method.
start_states = list(grid.actions.keys())
start_idx = np.random.choice(len(start_states))
grid.set_state(start_states[start_idx])
s = grid.current_state()
a = np.random.choice(ALL_POSSIBLE_ACTIONS) # first action is uniformly random
# Be aware of the timing. Each triple is s(t), a(t), r(t) but r(t) results
# from taking action a(t-1) from s(t-1) and landing in s(t)
states_actions_rewards = [(s, a, 0)]
seen_states = set()
while True:
old_s = grid.current_state()
r = grid.move(a)
s = grid.current_state()
if s in seen_states:
# Hack so that we don't end up in infinitely long episode, bumping into wall
states_actions_rewards.append((s, None, -100))
break
elif grid.game_over():
states_actions_rewards.append((s, None, r))
break
else:
a = policy[s]
states_actions_rewards.append((s, a, r))
seen_states.add(s)
# calculate the returns by working backwards from the terminal state,
# NOW ADDING IN ACTIONS
G = 0
states_actions_returns = []
first = True
for s, a, r in reversed(states_actions_rewards):
# the value of the terminal state is 0 by definition
# we should ignore the first state we encounter
# and ignore the last G, which is meaningless since it doesn't correspond to any move
if first:
first = False
else:
states_actions_returns.append((s, a, G))
G = r + GAMMA*G
states_actions_returns.reverse() # we want it to be in order of state visited
return states_actions_returns
# Function to do max and argmax from a dictionary (what we are using to store Q)
def max_dict(d):
# returns the argmax (key) and max (value) from a dictionary
# put this into a function since we are using it so often
max_key = None
max_val = float('-inf')
for k, v in d.items():
if v > max_val:
max_val = v
max_key = k
return max_key, max_val
if __name__ == '__main__':
# Try the negative grid too, to see if agent will learn to go past the "bad spot"
# in order to minimize number of steps
grid = negative_grid(step_cost=-0.9)
# Print rewards
print("rewards:")
print_values(grid.rewards, grid)
# state -> action
# initialize a random policy
policy = {}
for s in grid.actions.keys():
policy[s] = np.random.choice(ALL_POSSIBLE_ACTIONS)
# initialize Q(s,a) and returns
Q = {}
returns = {} # dictionary of state -> list of returns we've received
states = grid.all_states()
for s in states:
if s in grid.actions: # not a terminal state
Q[s] = {}
for a in ALL_POSSIBLE_ACTIONS:
Q[s][a] = 0 # needs to be initialized to something so we can argmax it
returns[(s,a)] = []
else:
# terminal state or state we can't otherwise get to
pass
# Main Loop - repeat until convergence
deltas = [] # For debugging purposes
for t in range(2000):
if t % 100 == 0:
print(t)
# Generate an episode using pi. Play a game, get states, actions, and returns triples
biggest_change = 0
states_actions_returns = play_game(grid, policy)
seen_state_action_pairs = set() # Create set to store state-actions pairs we have seen
# Loop through all state action pairs in episode, update their returns list, and
# update Q
for s, a, G in states_actions_returns:
# check if we have already seen s
# called "first-visit" MC policy evaluation
sa = (s, a)
if sa not in seen_state_action_pairs:
old_q = Q[s][a]
returns[sa].append(G)
Q[s][a] = np.mean(returns[sa])
biggest_change = max(biggest_change, np.abs(old_q - Q[s][a]))
seen_state_action_pairs.add(sa)
deltas.append(biggest_change)
# ---- Policy Improvement Step ---- update policy
for s in policy.keys():
policy[s] = max_dict(Q[s])[0]
plt.plot(deltas)
plt.show()
print("final policy:")
print_policy(policy, grid)
# find V
V = {}
for s, Qs in Q.items():
V[s] = max_dict(Q[s])[1]
print("final values:")
print_values(V, grid)
# -
# ---
#
# # 7. Monte Carlo Control _without_ Exploring Starts
# Recall that one of the disadvantages of the method we just looked at, is that we need to use exploring starts. We talked about how that may be infeasible for any game we are not playing in "God-mode". For example, think of a self driving car; it wouldn't be possible to enumerate all of the possible edge cases that the car may find itself in. And even if you could, it would take a lot of work to put the car in those exact states. So, we will now look at how we could use MC for control, _without_ using exploring starts.
#
# Earlier, we briefly touched upon the fact that all techniques we learning for the multi armed bandit problem are applicable here. In particular, we don't want to follow the _greedy_ policy, but the _espilon-greedy_ policy instead (or any other method that allows for more exploration).
#
# The modifications to the code should be fairly simple. All we need to do is remove exploring starts (always start at official starting position), and change the policy to sometimes be random (in portion where we play the game, instead of just following the greedy policy, we will have a small probability $\epsilon$ of doing a random action).
#
# ## 7.2 Epsilon-Soft
# Note, in some sources you will see an algorithm called epsilon-soft. This looks a little bit different, but essentially does the same thing. The idea is that epsilon is used to ensure that every action has the possibility of being selected. We state this as:
#
# > The probability of $a$ given $s$ is greater than or equal to $\epsilon$ divided by the number of possible actions.
#
# $$\pi(a \mid s) \geq \frac{\epsilon}{\mid A(s)\mid} , \forall a \in A(s)$$
#
# But, we also use epsilon to decide whether or not we are going to explore. So, we can write this in total as:
#
# $$a^* = argmax_aQ(s,a)$$
# $$\pi(s \mid a) = 1 - \epsilon + \frac{\epsilon}{\mid A(s)\mid} \; if \; a = a^*$$
# $$\pi(s \mid a) = \frac{\epsilon}{\mid A(s)\mid} \; if \; a \neq a^*$$
#
# From now on we will just refer to this as epsilon greedy.
#
# ## 7.3 How often will we reach off-policy states?
# It is interesting to think about how often we will reach off-policy states. For a state that is $K$ steps away from the start state, we would need to be in exploration mode on each step, and chose the necessary states to get to the target state. So in total, that is:
#
# $$p \geq \Big(\frac{\epsilon}{\mid A(s)\mid}\Big)^K$$
#
# You can imagine that this is a very small number, so for states that are very far off from the policies trajectory, you will need to do many iterations of MC for the value to be accurate for those states.
# ---
#
# # 8. MC Control _without_ Exploring Starts in code
# +
def random_action(a, eps=0.1):
# choose given a with probability 1 - eps + eps/4
# choose some other a' != a with probability eps/4
p = np.random.random()
# if p < (1 - eps + eps/len(ALL_POSSIBLE_ACTIONS)):
# return a
# else:
# tmp = list(ALL_POSSIBLE_ACTIONS)
# tmp.remove(a)
# return np.random.choice(tmp)
#
# this is equivalent to the above
if p < (1 - eps):
return a
else:
return np.random.choice(ALL_POSSIBLE_ACTIONS)
def play_game(grid, policy):
# returns a list of states and corresponding returns
# in this version we will NOT use "exploring starts" method
# instead we will explore using an epsilon-soft policy
s = (2, 0)
grid.set_state(s)
a = random_action(policy[s])
# be aware of the timing
# each triple is s(t), a(t), r(t)
# but r(t) results from taking action a(t-1) from s(t-1) and landing in s(t)
states_actions_rewards = [(s, a, 0)]
while True:
r = grid.move(a)
s = grid.current_state()
if grid.game_over():
states_actions_rewards.append((s, None, r))
break
else:
# HERE WE HAVE ADDED EPSILON GREEDY POLICY
a = random_action(policy[s]) # the next state is stochastic
states_actions_rewards.append((s, a, r))
# calculate the returns by working backwards from the terminal state
G = 0
states_actions_returns = []
first = True
for s, a, r in reversed(states_actions_rewards):
# the value of the terminal state is 0 by definition
# we should ignore the first state we encounter
# and ignore the last G, which is meaningless since it doesn't correspond to any move
if first:
first = False
else:
states_actions_returns.append((s, a, G))
G = r + GAMMA*G
states_actions_returns.reverse() # we want it to be in order of state visited
return states_actions_returns
if __name__ == '__main__':
# use the standard grid again (0 for every step) so that we can compare
# to iterative policy evaluation
# grid = standard_grid()
# try the negative grid too, to see if agent will learn to go past the "bad spot"
# in order to minimize number of steps
grid = negative_grid(step_cost=-0.1)
# print rewards
print("rewards:")
print_values(grid.rewards, grid)
# state -> action
# initialize a random policy
policy = {}
for s in grid.actions.keys():
policy[s] = np.random.choice(ALL_POSSIBLE_ACTIONS)
# initialize Q(s,a) and returns
Q = {}
returns = {} # dictionary of state -> list of returns we've received
states = grid.all_states()
for s in states:
if s in grid.actions: # not a terminal state
Q[s] = {}
for a in ALL_POSSIBLE_ACTIONS:
Q[s][a] = 0
returns[(s,a)] = []
else:
# terminal state or state we can't otherwise get to
pass
# repeat until convergence
deltas = []
for t in range(5000):
if t % 1000 == 0:
print(t)
# generate an episode using pi
biggest_change = 0
states_actions_returns = play_game(grid, policy)
# calculate Q(s,a)
seen_state_action_pairs = set()
for s, a, G in states_actions_returns:
# check if we have already seen s
# called "first-visit" MC policy evaluation
sa = (s, a)
if sa not in seen_state_action_pairs:
old_q = Q[s][a]
returns[sa].append(G)
Q[s][a] = np.mean(returns[sa])
biggest_change = max(biggest_change, np.abs(old_q - Q[s][a]))
seen_state_action_pairs.add(sa)
deltas.append(biggest_change)
# calculate new policy pi(s) = argmax[a]{ Q(s,a) }
for s in policy.keys():
a, _ = max_dict(Q[s])
policy[s] = a
plt.plot(deltas)
plt.show()
# find the optimal state-value function
# V(s) = max[a]{ Q(s,a) }
V = {}
for s in policy.keys():
V[s] = max_dict(Q[s])[1]
print("final values:")
print_values(V, grid)
print("final policy:")
print_policy(policy, grid)
# -
# ---
#
# # 9. Summary
# Let's take a brief moment to summarize everything we have learned about in this section. This section was all about MC methods. In the last section on Dynamic programming, we made a rather weird assumption that we _knew_ all of the state transition probabilities and never actually played the game. Hence, we were never able to learn from experience, as you would expect a reinforcement learning agent to do.
#
# We followed our usual pattern of first looking at the prediction problem and then looking a the control problem. The main technique that we used with Monte Carlo is that the Value function is the expected return given a state:
#
# $$V_\pi(s) = \Big[G(t) \mid S_t=s\Big]$$
#
# We know from probability theory that the expected value of something can be approximated by its sample mean:
#
# $$\bar{V}_\pi(s) = \frac{1}{N} \sum_{i=1}^N G_{i,s}$$
#
# In order to use Monte Carlo, we needed to generate episodes, and calculate the returns for each episode. This gave a list of pairs of states and returns. We then average these returns to find the value for each state.
#
# Recall, there are two methods for average the returns: **first visit** and **every visit**. While these have both been proven to converge to the same result, we use first visit because it is simpler.
#
# ## 9.1 MC vs. DP
# We saw that MC can be more efficient than DP because we don't need to loop through the entire state space. Because of this, we may never get the full value function, however it may not matter if many of those states may never be reached, or only be reached very rarely. In other words, the more we visit a state, the more accurate the value will be for that state. Since the MC method results in each state being visited a different number of times depending on the policy, we used the exploring starts technique in order to make sure we had adequate data for each state.
#
# ## 9.2 MC Control
# We then looked at the control problem. The difference with MC is that we now need to use $Q$ instead of $V$, so that we can take the argmax of $Q$ over all of the actions. This is required since we can't do the same kind of look ahead search with MC, as we did with DP. We then saw that we can continue to use the idea of policy iteration that we had used in the DP section. Recall, this is where we alternate between policy evaluation and policy improvement. We talked about the fact that MC has one major disadvantage here: it needs many samples in order to be accurate, and it has to be inside of a loop, which makes it very inefficient. We ended up taking the same approach here as we did with value iteration; we only did one update for evaluation per iteration. What is surprising is that it converges even though the samples are not all for the same policy! Note, it never has been formally proven to converge.
#
# One of the disadvantages of the control solution we looked at was that we needed to use the exploring starts method in order to get a full measurement of $Q$. We saw that it is not necessary to use exploring starts, if we use epsilon greedy instead. This is because epsilon greedy allows us to continually explore all of the states in the state space. We learned that all of the techniques we learned about in the multi armed bandit still apply here. In fact, MDPs are like having different multi armed bandit problems at each state.
| AI/01-Reinforcement_Learning-06-Monte-Carlo.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
import numpy as np
from numpy import log, exp, sqrt
from scipy.stats import gamma as Gamma_Distribution
from scipy.special import psi
from scipy.special import gamma as Gamma_Function
# ## Exercise 4.1
# simulate some data
n, k = 500, 3
beta = np.arange(k) + 0.5
X = np.random.rand(n, k)
mu = X.dot(beta)
p = np.random.rand(n)
y = - mu * np.log(1 - p)
# plt.figure()
# plt.hist(y,n/20)
# plt.show()
def logL(beta, X, y):
u = X.dot(beta)
l = - (y/u) - log(u)
return l.sum()
def myqnewton(f, x0, B, searchmeth = 3,stepmeth = "bt" ,maxit = 10000, maxstep = 10000,tol = 1/100000,\
eps = np.spacing(1),eps0 =1.0, eps1 = 1.e-12, all_x = False):
'''
maxit, maxstep, tol,eps0, eps1 = 10000, 10000, 1/10000,1.0,1.e-12
f: object function and jacobian
B: inversed Hessian matrix
x0: initial value
all_x: if we collect x value for plotting
'''
x = x0
if all_x:
x_list = [x0]
A = f(x)
_is_there_jacobian = (type(A) is tuple) and (len(A) == 2)
if _is_there_jacobian:
print('Jacobian was provided by user!')
fx0,g0 = f(x)
else:
print('Jacobian was not provided by user!')
fx0 = f(x)
try:
g0 = jacobian(f,x)
except NameError:
print("jacobian function Not in scope!\n Using identity matrix as jacobian matrix")
g0 = np.identity(k)
else:
print("jacobian function In scope!")
if np.all(np.abs(g0) < eps): # similar to np.all(g0<eps)
print("abs(g0)< eps...")
return x
print("Solving nonlinear equations by using {} search method and {} step method".format(search_methods[searchmeth-1].capitalize(), stepmeth))
print("Start iteration......")
for it in range(maxit):
d = -np.dot(B, g0) # search direction, initial d
# https://github.com/randall-romero/CompEcon-python/blob/master/compecon/optimize.py
if (np.inner(d, g0) / (np.inner(d, d))) < eps1: # must go uphill
B = -np.identity(k) / np.maximum(abs(fx0), 1) # otherwise use
d = g0 / np.maximum(np.abs(fx0), 1) # steepest ascent
# optimize search step length
s, fx = optstep(stepmeth ,f, x, fx0, g0, d, maxstep)
if fx <= fx0:
warnings.warn('Iterations stuck in qnewton')
#return x
# reset Hessian and d.
B = -np.identity(k) / np.maximum(abs(fx0), 1) # otherwise use
d = g0.T / np.maximum(abs(fx0), 1) # steepest ascent
s, fx = optstep("bt" ,f, x, fx0, g0, d, maxstep)
if errcode:
warnings.warn('Cannot find suitable step in qnewton')
# return x
# reset to 1 and fx0
s, fx = 1, fx0
# update d and x
d *= s
x = x + d
# keep record of x sequence in list
if all_x:
x_list.append(x.copy())
if np.any(np.isnan(x) | np.isinf(x)):
raise ValueError('NaNs or Infs encountered')
# update fx and g again
if _is_there_jacobian:
#print('Jacobian was provided by user!')
fx,g = f(x)
else:
print('Jacobian was not provided by user!')
fx = f(x)
try:
g = jacobian(f,x)
except NameError:
print("jacobian function Not in scope!\n Using identity matrix as jacobian matrix")
g = np.identity(k)
else:
print("jacobian function In scope!")
# Test convergence using Marquardt's criteria and gradient test
if ((fx - fx0) / (abs(fx) + eps0) < tol and
np.all(np.abs(d) / (np.abs(x) + eps0) < tol)) or\
np.all(np.abs(g) < eps):
print("Meet the tol. x: ", x)
#break
if all_x:
return x, x_list
else:
return x
# Update inverse Hessian
u = g - g0 # change in Jacobian
ud = np.inner(u, d)
# pick a search method
#print("Please specify one search method: 1:steepest ascen;2: DFP;3:BFGS")
if np.all(np.abs(ud) < eps):
B = -np.identity(k) / np.maximum(abs(fx0), 1) # otherwise use
else:
if searchmeth == 1 and np.abs(ud) < eps: # steepest ascent
B = -np.identity(k) / np.maximum(abs(fx), 1)
elif searchmeth == 2: # DFP
v = B.dot(u)
B += np.outer(d, d) / ud - np.outer(v, v) / np.inner(u, v)
elif searchmeth == 3: # BFGS
w = d - B.dot(u)
wd = np.outer(w, d)
B += ((wd + wd.T) - (np.inner(u, w) * np.outer(d, d)) / ud) / ud
# Update iteration
fx0 = fx
g0 = g
print("finish {}th iteration...".format(it))
# end of iteration if exceed the maxit
if it >= maxit:
warnings.warn('Maximum iterations exceeded in qnewton')
return x
L = OP(logL, np.ones(k),X, y)
beta_hat = myqnewton(logL, np.ones(k),X, y)
print('Looking for the maximum likelihood: beta = ', beta_hat)
def dlogL(beta, X, y):
u = X.dot(beta)
temp = ((y - u) / u ** 2)
dl = temp[:, np.newaxis] * X
return dl.sum(0)
# ## Exercise 4.2
# +
# simulate some data
n = 500
a = 5.0
b = 2.0
x_data = Gamma_Distribution.rvs(a, scale=1/b, size=n)
Y1 = x_data.mean()
Y2 = exp(log(x_data).mean())
b_hat = lambda a0: a0 / Y1
def dlogL(theta):
return log(theta) - log(Y1 / Y2) - psi(theta)
a0 = 1.1 # initial guess
estimator = NLP(dlogL, a0, print=True, all_x=True)
# estimator = MCP(dlogL, 0, np.inf, a0, print=True, all_x=True)
a_hat = estimator.zero()
print(estimator.x_sequence)
print(b_hat(estimator.x_sequence))
y1y2 = np.linspace(1.1, 3, 48)
dlogL2 = lambda theta, y12: log(theta) - log(y12) - psi(theta)
ttheta = np.array([NLP(dlogL2, a0, k).zero() for k in y1y2])
plt.figure()
plt.plot(y1y2, ttheta)
plt.xlabel('Y1 / Y2')
plt.ylabel('theta1')
plt.show()
# Solve it using the MLE object
def logL(theta, x):
n = x.size
a, b = theta
return n*a*log(b) + (a-1)*log(x).sum() - b*x.sum() - n*log(Gamma_Function(a))
mle = MLE(logL, np.ones(2), x_data)
mle.estimate()
print('theta1 = {:.4f}, theta1 = {:.4f}'.format(*mle.beta))
print('Estimated Covariance = \n', mle.Sigma)
print('Confidence intervals\n', mle.ci())
# -
# ## Exercise 4.3
# +
treasury_tau = np.array([0.25, 0.5, 1, 2, 3, 5, 7, 10, 30])
treasury_r = np.array(
[[4.44, 4.49, 4.51, 4.63, 4.63, 4.62, 4.82, 4.77, 5.23],
[4.45, 4.48, 4.49, 4.61, 4.61, 4.60, 4.84, 4.74, 5.16],
[4.37, 4.49, 4.53, 4.66, 4.66, 4.65, 4.86, 4.76, 5.18],
[4.47, 4.47, 4.51, 4.57, 4.57, 4.57, 4.74, 4.68, 5.14]])
def Z(r, t, k, a, s):
gamma = sqrt(k **2 + 2 * s ** 2)
egt = exp(gamma * t) - 1
numA = 2 * gamma * exp((gamma + k) * t / 2)
numB = 2*egt
den = (gamma + k) * egt + 2 * gamma
expA = 2 * k * a / (s ** 2)
A = (numA / den) ** expA
B = numB / den
Z = A * exp(-B * r)
return Z
def ss(x, r, tau):
k, a, s = x
resid = r + 100 * log(Z(r / 100, tau, k, a, s)) / tau
return -(resid ** 2).sum()
def ss2(x, r, tau):
tmp = lambda x: ss(x, r, tau)
return jacobian(tmp, x)[0]
x0 = np.array([0.51, 0.05, 0.12])
hola = MCP(ss2, np.zeros(3), np.ones(3), x0, treasury_r[0], treasury_tau)
x = hola.zero(print=True)
print(x)
objective = OP(ss, x0, treasury_r[0], treasury_tau)
objective.qnewton(print=True, all_x=True)
print(objective.x)
print(objective.fnorm)
# -
| Exercise04.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Advanced Machine Learning - programming assignment 2
# **Please fill in:**
# * <NAME> (4279662)
# * <NAME> (6324363)
# * <NAME> (6970877)
# ## Implementing the PC algorithm
# In this assignment, you will complete an implementation of the PC algorithm. After that, you will use it to discover causal relations in a data set.
import numpy as np
import itertools
import graphviz # conda install python-graphviz
# The graphviz can draw graphs to different file formats, or show them directly in the notebook. We will use numpy arrays to represent graphs. The following function converts such an array to a graph in graphviz format.
def graph_to_graphviz(G, node_names):
n = G.shape[0]
d = graphviz.Digraph(engine='circo') #'neato')
for node_name in node_names:
d.node(node_name)
for x in range(n):
for y in range(n):
if x == y:
continue
if G[x,y] and not G[y,x]:
d.edge(node_names[x], node_names[y])
elif x < y and G[x,y] and G[y,x]:
d.edge(node_names[x], node_names[y], dir='none')
return d
# Demonstration of graph_to_graphviz:
node_names = ['X', 'Y', 'Z', 'W']
G1 = np.zeros((4,4), dtype=bool)
G1[0,1] = G1[2,1] = True # two directed edges
G1[2,3] = G1[3,2] = True # an undirected edge
d = graph_to_graphviz(G1, node_names)
d # must be final line of code block to be displayed
# Here is a function that performs the PC algorithm. Add the missing code for phase 2, and implement phases 3 and 4.
def PC_algorithm(n, independence_tester):
# PHASE I: Initialization
# The matrix G represents a graph as follows:
# - For all x, G[x,x] == False
# - G[x,y] == False and G[y,x] == False: no edge between x and y
# - G[x,y] == True and G[y,x] == True: undirected edge x --- y
# - G[x,y] == True and G[y,x] == False: directed edge x --> y
G = np.logical_not(np.eye(n, dtype=bool))
# PHASE II: Skeleton search
# Note: Adj(X) in the slides means: all nodes adjacent to X in the current graph G
sepset = dict()
for k in range(n-1):
for x in range(n):
for y in range(n):
if not G[x,y]:
continue
# Try all subsets S of Adj(x) \ {y} with |S|=k,
# until an independence is found.
# Hint: use itertools.combinations
# Your code here
# G[x,y] is true here , this means that y is adjacent to x
# for all S subset of adjacent nodes to x not including y, with size of S: |S|=k
l = [i for i in range(n) if (i != y and i != x)] # range n excluding y and x since adj to x
Set = itertools.combinations(l,k) # all combinations of length k
for S in Set:
indep = independence_tester.test_independence(x, y, S)
if indep:
print("independence found: {0} and {1} given {2}".format(x,y,S))
G[x,y] = G[y,x] = False
S_mask = np.zeros(n, dtype=bool)
np.put(S_mask, S, True)
sepset[frozenset([x,y])] = S_mask
break
# Do we need to continue with smaller k? ....
max_S_size = np.sum(G, axis=0) - 1
if np.all(max_S_size < k + 1):
break
# PHASE III: Orient v-structures
# Something to watch out for:
# If the data are not faithful to any graph, the algorithm may end up trying
# to orient a single edge in two different ways. You can choose either
# orientation if this happens.
# Your code here
# for two not adjacent nodes connected to a third node
# check if this third node is in the sepset of the two
# not connected nodes. When the third node is not in
# the sepset, the two first nodes collide in the third.
for x in range(n-1):
for y in range(x,n):
# if x and y not adjacent
if G[x,y] == G[y,x] == False and x != y:
for z in range(n):
# when z is adjacent to x and to y
if G[x,z] == False and G[z,x] == False:
continue
if G[y,z] == False and G[z,y] == False:
continue
# unordered when atleast one edge is undirected
if not (G[x,z]==G[z,x]==True or G[y,z]==G[z,y]==True):
continue
# if z not in sepset({x,y}):
if not sepset[frozenset([x,y])][z]:
# orient edges
G[z,x] = G[z,y] = False
# Not implemented "Something to watch out for" I do not understand when this exactly would happen...
# PHASE IV: Orientation rules
# Your code here
# no extra v-structures, no cycles
# undirected edges
for x in range(n-1):
for y in range(x,n):
# if x and y adjacent and undirected
if not(G[x,y] == G[y,x] == True and x != y):
continue
# x and y adjacent and undirected
print(x,y)
'''
rule 1: When a node has an incoming edge and an undirected edge
then the undirected edge becomes a directed outgoing edge.
rule 2: When two nodes are connected by an undirected edge and
have a directed chain connecting them via a third node
then the undirected edge becomes a directed edge with the same direction as the chain.
rule 3: When two nodes are connected by an undirected edge and
one node has two incoming edges that 'relate' to the 'other' node
then the undirected edge becomes a directed edge directed at the node with incoming edges.
'''
return G
# ## Testing the PC implementation
#
# To verify that the algorithm is working correctly, we will feed it output from an /oracle/ instead of conditional independence test results from a data set. The oracle knows what the true graph is, and mimics the conditional independence test results that we would get for data that is Markov and faithful to that graph. In this situation, PC should be able to recover the Markov equivalence class of the true graph.
# +
def is_d_connected_dfs(mB, pos, w, S, vis):
# Made modifications to deal with CPDAGs as input
#print("At ", pos)
(v, dir) = pos
if v == w:
return True
if (dir == 0 and not S[v]) or (dir == 1 and S[v]):
# traverse backward (dir=0) along an arrow
next_vs_mask = np.logical_and(mB[v,:], np.logical_not(vis[:,0]))
if dir == 1:
# we can't continue on an undirected path in case dir == 1 and S[v])
next_vs_mask = np.logical_and(next_vs_mask, np.logical_not(mB[:,v]))
tmp = np.logical_or(vis[:,0], next_vs_mask)
vis[:,0] = tmp
for next_v in np.nonzero(next_vs_mask)[0]:
if is_d_connected_dfs(mB, (next_v, 0), w, S, vis):
return True
if not S[v]:
# traverse forward (dir=1) along an arrow
next_vs_mask = np.logical_and(mB[:,v], np.logical_not(vis[:,1]))
next_vs_mask = np.logical_and(next_vs_mask, np.logical_not(mB[v,:]))
vis[:,1] = np.logical_or(vis[:,1], next_vs_mask)
for next_v in np.nonzero(next_vs_mask)[0]:
if is_d_connected_dfs(mB, (next_v, 1), w, S, vis):
return True
return False
def is_d_separated(G, v, w, S):
if S[v] or S[w]:
return True
mB = G.T
d = mB.shape[0]
# vis[v,0]: reachable by path ending in tail
# vis[v,1]: reachable by path ending in head
vis = np.zeros((d,2), dtype=bool)
pos = (v,0)
vis[pos] = True
is_d_connected_dfs(mB, pos, w, S, vis)
if vis[w,0] or vis[w,1]:
return False
return True
class IndependenceOracle:
def __init__(self, true_G):
self.G = true_G
self.n = true_G.shape[0]
def test_independence(self, x, y, S):
S_mask = np.zeros(self.n, dtype=bool)
#S_mask[S] = True
np.put(S_mask, S, True)
return is_d_separated(self.G, x, y, S_mask)
# -
# We will compare the output of PC to the oracle's true graph for the graph G1 we saw before, and for several other graphs. (You can add more tests to help chase down any bugs.)
oracle = IndependenceOracle(G1)
G = PC_algorithm(4, oracle)
print("CORRECT" if np.all(G == G1) else "INCORRECT")
graph_to_graphviz(G, node_names)
G2 = np.zeros((4,4), dtype=bool)
G2[0,2] = G2[1,2] = G2[2,3] = True
graph_to_graphviz(G2, node_names)
oracle = IndependenceOracle(G2)
G = PC_algorithm(4, oracle)
print("CORRECT" if np.all(G == G2) else "INCORRECT")
graph_to_graphviz(G, node_names)
G3 = np.zeros((4,4), dtype=bool)
G3[0,2] = G3[1,2] = G3[1,3] = G3[2,3] = True
graph_to_graphviz(G3, node_names)
oracle = IndependenceOracle(G3)
G = PC_algorithm(4, oracle)
print("CORRECT" if np.all(G == G3) else "INCORRECT")
graph_to_graphviz(G, node_names)
G4 = np.logical_not(np.eye(4, dtype=bool))
G4[0,1] = G4[1,0] = False
G4[3,0] = G4[3,1] = G4[3,2] = False
graph_to_graphviz(G4, node_names)
oracle = IndependenceOracle(G4)
G = PC_algorithm(4, oracle)
print("CORRECT" if np.all(G == G4) else "INCORRECT")
graph_to_graphviz(G, node_names)
# ## Running PC on data
# This part of the assignment will appear soon.
| Assignments/AML_assignment2_part_a.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: 'Python 3.8.10 64-bit (''MMCD'': conda)'
# language: python
# name: python3
# ---
# # Contrastive Learning for the Muller-Brown Potential
# +
import numpy as np
from functions import *
from sys import exit
import sys
import argparse
from scipy.interpolate import BSpline
from scipy import optimize
import matplotlib as mpl
from matplotlib import cm
from functions import *
#pathfinding
import sys
import os as os
d = os.path.abspath('')
tremcdir = d[:-7] + "/output/"
sys.path.append(tremcdir)
#sys.path.append("/home/gridsan/dingxq/my_package_on_github/CLCG")
#plotting functions
import matplotlib as mpl
from matplotlib import cm
import matplotlib.pyplot as plt
# -
# First, import all the functions as nessesary, and set up proper pathes. Load and visualize the data, a range.pkl file essentially only explains the range of the data, but we can visualize the Muller-Brown potential as a contour plot as well.
# +
with open(tremcdir + "range.pkl", 'rb') as file_handle:
data = pickle.load(file_handle)
x1_min, x1_max = data['x1_min'], data['x1_max']
x2_min, x2_max = data['x2_min'], data['x2_max']
Z = data['U']
plt.contour(Z, levels = 20)
plt.show()
print(data['x1_min'], data['x1_max'], data['x2_min'], data['x2_max'])
#Z is essentially a grid, where Z[0][2] gives the value at (0, 2), but
#normalized with respect to x1 and x2
# -
# Generate samples from uniform distributions with range $x_{\_max}$ and $x_{\_max}$ as defined below. Alpha is a constant that has the physical interpretation of being $\alpha = \frac{1}{k_b T}$. Also, we can visiual the distribution of $\vec{x}$ to be a uniform distribution with specified range.
# +
alpha = 0.05
num_samples = 30
x1 = np.random.rand(num_samples)*(x1_max - x1_min) + x1_min
x2 = np.random.rand(num_samples)*(x2_max - x2_min) + x2_min
x = np.vstack([x1, x2]).T
plt.clf()
plt.scatter(x1, x2)
plt.show()
# -
# We are attempting to learn the Muller-Brown potential function $U(\vec{x})$, where $\vec{x}$ is the position of a particle. For Boltzmann Statistics, $P(\vec{x}) \propto e^{-U(\vec{x})} = \frac{e^{-U(\vec{x})}}{\sum e^{-U(\vec{x})}}$. Maximum likelihood estimation or contrastive learning can be used to learn the parameters of the distribution, in other words, an approximation of $U(x)$. However, contrastive learning is much more efficient since it can simply estimate the partition function.
#
# A question is how to parameterize $U(x)$. While $U(x)$ could be parameterized by a neural network, neural networks are not convex functions, so optimization might be non-trivial. $U(x)$ can be also parameterized by a cublic spline.
# ## How to Use Cublic Splines and Design Matricies
# Source: http://publish.illinois.edu/liangf/files/2016/05/Note_splines.pdf
#
# A cubic spline is a function with $n$ knots. The knots are equally spaced points on the range $[a, b]$, and they are:
#
# $a < \xi_1 < \xi_2 < ... < \xi_n < b$.
#
# The spline function:
#
# $$g(x) = ax^3 + bx^2 + cx + d, x \in [\xi_{i}, \xi_{i+1}]$$
#
# And $g$ is continous up to the second derivative.
#
# To represent $g$, with $n$ knots, it may appear that we need $4 \cdot n$ parameters, since there is a value of $a$, $b$, $c$, $d$ for each of the knots. However, considering that $g$ is continuous to the second derivative, then there are three constraints for each of the knots. With four variables and three equations, there is actually only one degree of freedom for each of the knots. $4(n+1) -3n = n+4$ free parameters.
#
# From above we are assuming a cublic spline with one knot has only has two intervals, thats whey there are $m + 4$ free parameters.
# ## Function Space and Basis Functions
# Functions themselves can be though of vectors since they satisfy the constraint for vector spaces, and this is true of cubic functions as well: Assume that $g_1(x)$ and $g_2(x)$ are cubic splines. $a \cdot g_1(x) + b \cdot g_2(x)$ is also a cubic spline. Therefore cublic splines span a function space, of dimensions $(m+4)$.
#
# What are the basis functions for this function space?
#
# Consider that $g(x) = ax + bx^2 + cx^3 + d$ Then g(x) is a linear combination of $x$, $x^2$, $x^3$, and $1$. Then the basis functions for the first interval:
#
# $$h_0(x) = 1$$
# $$h_1(x) = x$$
# $$h_2(x) = x^2$$
# $$h_3(x) = x^3$$
# $$h_{i+3} =(x-\xi_i)^3_+, \ i \in \{1, 2, ..., m\}$$
#
# The term $$h_{i+3} =(x-\xi_i)^3_+$$ is a bit tricky to derive, but consider that:
#
# So a cubic spline $f(x) = \beta_0 + \sum \limits_{i=1}^{m+3} \beta_j \cdot h_j(x)$
#
#
#
#
# ## Design Matrix
# Source: https://www.uio.no/studier/emner/matnat/ifi/nedlagte-emner/INF-MAT5340/v05/undervisningsmateriale/kap2-new.pdf
# A design matrix is in the form
#
# $$y = \bf{X} \beta$$
#
# Where $y$ is a vector of predicted outputs, $\bf{X}$ is a design matrix, and $\beta$ is a vector of the model's coefficients.
#
# It is possible to rewrite a b-spline as a matrix vector product.
def compute_cubic_spline_basis(x, extent = (x1_min, x1_max, x2_min, x2_max)):
x1_min, x1_max, x2_min, x2_max = extent
## degree of spline
k = 3
## knots of cubic spline
t1 = np.linspace(x1_min, x1_max, 10)
t2 = np.linspace(x2_min, x2_max, 10)
## number of basis along each dimension
n1 = len(t1) - 2 + k + 1
n2 = len(t2) - 2 + k + 1
## preappend and append knots
t1 = np.concatenate(
(np.array([x1_min for i in range(k)]),
t1,
np.array([x1_max for i in range(k)])
))
t2 = np.concatenate(
(np.array([x2_min for i in range(k)]),
t2,
np.array([x2_max for i in range(k)])
))
spl1_list = []
for i in range(n1):
c1 = np.zeros(n1)
c1[i] = 1.0
spl1_list.append(BSpline(t1, c1, k, extrapolate = False))
spl2_list = []
for i in range(n2):
c2 = np.zeros(n2)
c2[i] = 1.0
spl2_list.append(BSpline(t2, c2, k, extrapolate = False))
x1, x2 = x[:, 0], x[:, 1]
y1 = np.array([spl1(x1) for spl1 in spl1_list]).T
y2 = np.array([spl2(x2) for spl2 in spl2_list]).T
y = np.matmul(y1[:,:,np.newaxis], y2[:, np.newaxis, :])
y = y.reshape(x1.shape[0], -1)
return y
def bs(x, knots, boundary_knots, degree = 3, intercept = False):
knots = np.concatenate([knots, boundary_knots])
knots.sort()
augmented_knots = np.concatenate([np.array([boundary_knots[0] for i in range(degree + 1)]),
knots,
np.array([boundary_knots[1] for i in range(degree + 1)])])
num_of_basis = len(augmented_knots) - 2*(degree + 1) + degree + 1
spl_list = []
for i in range(num_of_basis):
coeff = np.zeros(num_of_basis)
coeff[i] = 1.0
spl = BSpline(augmented_knots, coeff, degree, extrapolate = False)
spl_list.append(spl)
design_matrix = np.array([spl(x) for spl in spl_list]).T
## if the intercept is Fales, drop the first basis term, which is often
## referred as the "intercept". Note that np.sum(design_matrix, -1) = 1.
## see https://cran.r-project.org/web/packages/crs/vignettes/spline_primer.pdf
if intercept is False:
design_matrix = design_matrix[:, 1:]
return design_matrix
def compute_design_matrix(x, x1_knots, x2_knots, x1_boundary_knots, x2_boundary_knots):
x1_design_matrix = bs(x[:,0], x1_knots, x1_boundary_knots)
x2_design_matrix = bs(x[:,1], x2_knots, x2_boundary_knots)
x_design_matrix = x1_design_matrix[:,:,np.newaxis] * x2_design_matrix[:,np.newaxis,:]
x_design_matrix = x_design_matrix.reshape([x_design_matrix.shape[0], -1])
return x_design_matrix
# # Contrastive Learning
# Recall $P(\vec{x}) \propto e^{-U(\vec{x})}$. We now have a form for $U(\vec{x})$, so we can learn $P(\vec{x})$ to optimize for the parameters of $U(\vec{x})$. Here, $X_p$ is a set of observations from the true distribution, and $X_q$ is a set of observations from the noise distribution.
#
# Below the samples are initialized, and the knots for the splines are calculated.
# +
## samples from p
with open(tremcdir + 'TREMC/x_record_alpha_{:.3f}.pkl'.format(alpha), 'rb') as file_handle:
data = pickle.load(file_handle)
xp = data['x_record'][:, -1, :]
num_samples_p = xp.shape[0]
## samples from q
## these samples are from a "uniform" noise distribution
num_samples_q = num_samples_p
x1_q = np.random.rand(num_samples_q)*(x1_max - x1_min) + x1_min
x2_q = np.random.rand(num_samples_q)*(x2_max - x2_min) + x2_min
xq = np.vstack([x1_q, x2_q]).T
x1_knots = np.linspace(x1_min, x1_max, num = 10, endpoint = False)[1:]
x2_knots = np.linspace(x2_min, x2_max, num = 10, endpoint = False)[1:]
x1_boundary_knots = np.array([x1_min, x1_max])
x2_boundary_knots = np.array([x2_min, x2_max])
xp_design_matrix = compute_design_matrix(xp, x1_knots, x2_knots, x1_boundary_knots, x2_boundary_knots)
xq_design_matrix = compute_design_matrix(xq, x1_knots, x2_knots, x1_boundary_knots, x2_boundary_knots)
# -
print(xp_design_matrix)
print(np.shape(xp_design_matrix))
# We can visualize the distribution of $X_p$ and $X_q$. Below, $X_q$ has 50,000 points but we plot 1000 of them.
plt.clf()
plt.scatter(x1_q[1:5000], x2_q[1:5000], s=1)
plt.show()
plt.clf()
plt.scatter(xp[:, 0], xp[:, 1], s=1)
plt.show()
# A quick note on the notation: logq_xp is $\log q(x_p)$.
# +
theta = np.random.randn(xp_design_matrix.shape[-1])
F = np.zeros(1)
def compute_loss_and_grad(thetas, regularization='L1'):
theta = thetas[0:xp_design_matrix.shape[-1]]
F = thetas[-1]
up_xp = np.matmul(xp_design_matrix, theta)
logp_xp = -(up_xp - F)
logq_xp = np.ones_like(logp_xp)*np.log(1/((x1_max - x1_min)*(x2_max - x2_min)))
up_xq = np.matmul(xq_design_matrix, theta)
logp_xq = -(up_xq - F)
logq_xq = np.ones_like(logp_xq)*np.log(1/((x1_max - x1_min)*(x2_max - x2_min)))
nu = num_samples_q / num_samples_p
G_xp = logp_xp - logq_xp
G_xq = logp_xq - logq_xq
h_xp = 1./(1. + nu*np.exp(-G_xp))
h_xq = 1./(1. + nu*np.exp(-G_xq))
if regularization == None:
loss = -(np.mean(np.log(h_xp)) + nu*np.mean(np.log(1-h_xq)))
elif regularization == 'L1':
loss = -(np.mean(np.log(h_xp)) + nu*np.mean(np.log(1-h_xq))) + 0.001*theta
else: #regularization == 'L2':
loss = -(np.mean(np.log(h_xp)) + nu*np.mean(np.log(1-h_xq))) + np.linalg.norm(theta)**2
dl_dtheta = -(np.mean((1 - h_xp)[:, np.newaxis]*(-xp_design_matrix), 0) +
nu*np.mean(-h_xq[:, np.newaxis]*(-xq_design_matrix), 0))
dl_dF = -(np.mean(1 - h_xp) + nu*np.mean(-h_xq))
return loss, np.concatenate([dl_dtheta, np.array([dl_dF])])
thetas_init = np.concatenate([theta, F])
loss, grad = compute_loss_and_grad(thetas_init)
thetas, f, d = optimize.fmin_l_bfgs_b(compute_loss_and_grad,
thetas_init,
iprint = 1000)
# factr = 10)
theta = thetas[0:xp_design_matrix.shape[-1]]
F = thetas[-1]
x_grid = generate_grid(x1_min, x1_max, x2_min, x2_max, size = 100)
x_grid_design_matrix = compute_design_matrix(x_grid, x1_knots, x2_knots, x1_boundary_knots, x2_boundary_knots)
up = np.matmul(x_grid_design_matrix, theta)
up = up.reshape(100, 100)
up = up.T
fig, axes = plt.subplots()
plt.contourf(up, levels = 30, extent = (x1_min, x1_max, x2_min, x2_max), cmap = cm.viridis_r)
plt.xlabel(r"$x_1$", fontsize = 24)
plt.ylabel(r"$x_2$", fontsize = 24)
plt.tick_params(which='both', bottom=False, top=False, right = False, left = False, labelbottom=False, labelleft=False)
plt.colorbar()
plt.tight_layout()
axes.set_aspect('equal')
plt.show()
# +
thetas_init = np.concatenate([theta, F])
loss, grad = compute_loss_and_grad(thetas_init)
thetas, f, d = optimize.fmin_l_bfgs_b(compute_loss_and_grad,
thetas_init,
iprint = 1)
# factr = 10)
theta = thetas[0:xp_design_matrix.shape[-1]]
F = thetas[-1]
x_grid = generate_grid(x1_min, x1_max, x2_min, x2_max, size = 100)
x_grid_design_matrix = compute_design_matrix(x_grid, x1_knots, x2_knots, x1_boundary_knots, x2_boundary_knots)
up = np.matmul(x_grid_design_matrix, theta)
up = up.reshape(100, 100)
up = up.T
fig, axes = plt.subplots()
plt.contourf(up, levels = 30, extent = (x1_min, x1_max, x2_min, x2_max), cmap = cm.viridis_r)
plt.xlabel(r"$x_1$", fontsize = 24)
plt.ylabel(r"$x_2$", fontsize = 24)
plt.tick_params(which='both', bottom=False, top=False, right = False, left = False, labelbottom=False, labelleft=False)
plt.colorbar()
plt.tight_layout()
axes.set_aspect('equal')
plt.show()
# -
# # Sampling with TREMC
| MullerPotential/script/constrastive_learning_tutorial.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
import warnings
warnings.filterwarnings('ignore')
from report import analysis
# -
# # Ridge Regression
#analysis("example-data/cpu")
analysis("Sanajoon", skiprows=15)
#analysis("data-3bb4e2af-bf0a-4b78-b8b2-f9dbd1df35b3 (copy)/cpu")
| notebooks/ridge_benchmarking/Open Blas (Alex)-NUMEXPR_NUM_THREADS=1_.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# ## Load the BINANA module
#
# This notebook was tested in Jupyter Notebook 5.7.8. It did not work when tested in Jupyter Lab. We have confirmed that similar usage works in HTML/JavaScript web pages.
# + language="html"
# <script type="module">
# window.binana = undefined
# import * as bnana from './binana.js';
# window.binana = bnana;
# </script>
# -
# ## Define a JavaScript function to output formatted results
# + language="javascript"
#
# window.output = function(element, txt) {
# element.html("<pre style='font-size:80%;'>" + txt + "</pre>");
# };
# -
# ## Define ligand PDBQT text
# + language="javascript"
#
# window.ligPDBTxt = `REMARK 8 active torsions:
# REMARK status: ('A' for Active; 'I' for Inactive)
# REMARK 1 A between atoms: C4_1 and C5_2
# REMARK 2 A between atoms: C4_1 and N1_7
# REMARK 3 A between atoms: C4_1 and O6_5
# REMARK 4 A between atoms: C5_2 and N1_6
# REMARK 5 A between atoms: C7_4 and N1_6
# REMARK 6 A between atoms: C7_4 and C1_8
# REMARK 7 A between atoms: N1_6 and C6_14
# REMARK 8 A between atoms: N1_7 and C2_9
# ROOT
# HETATM 1 C5 CHT A 1 16.376 2.063 7.151 1.00 6.35 0.308 C
# ENDROOT
# BRANCH 1 2
# HETATM 2 N1 CHT A 1 15.723 3.326 7.619 1.00 6.17 -0.006 N
# HETATM 3 C6 CHT A 1 15.386 3.121 9.043 1.00 5.88 0.283 C
# BRANCH 2 4
# HETATM 4 C6 CHT A 1 14.451 3.555 6.881 1.00 0.00 0.248 A
# HETATM 5 C7 CHT A 1 14.179 3.052 5.671 1.00 0.00 0.066 A
# HETATM 6 C8 CHT A 1 12.835 3.506 5.294 1.00 0.00 0.029 A
# HETATM 7 C9 CHT A 1 12.365 4.258 6.295 1.00 0.00 0.144 A
# HETATM 8 O2 CHT A 1 13.332 4.389 7.437 1.00 0.00 -0.300 OA
# ENDBRANCH 2 4
# BRANCH 2 9
# HETATM 9 C7 CHT A 1 16.663 4.518 7.461 1.00 4.71 0.358 C
# BRANCH 9 10
# HETATM 10 C1 CHT A 1 17.243 5.230 8.677 1.00 0.00 0.200 C
# HETATM 11 O4 CHT A 1 16.818 5.027 9.728 1.00 0.00 -0.647 OA
# HETATM 12 O3 CHT A 1 18.046 6.106 8.908 1.00 0.00 -0.647 OA
# ENDBRANCH 9 10
# ENDBRANCH 2 9
# ENDBRANCH 1 2
# BRANCH 1 13
# HETATM 13 C4 CHT A 1 17.023 2.039 5.749 1.00 7.51 0.354 C
# BRANCH 13 14
# HETATM 14 N1 CHT A 1 17.117 0.715 5.182 1.00 0.00 0.004 N
# HETATM 15 H2 CHT A 1 16.240 0.227 5.182 1.00 0.00 0.289 HD
# HETATM 16 H1 CHT A 1 17.432 0.801 4.195 1.00 0.00 0.289 HD
# BRANCH 14 17
# HETATM 17 C2 CHT A 1 18.204 -0.049 5.920 1.00 0.00 0.247 A
# HETATM 18 O1 CHT A 1 19.656 0.045 5.545 1.00 0.00 -0.300 OA
# HETATM 19 C5 CHT A 1 20.217 -0.885 6.582 1.00 0.00 0.144 A
# HETATM 20 C4 CHT A 1 19.280 -1.403 7.384 1.00 0.00 0.029 A
# HETATM 21 C3 CHT A 1 17.983 -0.864 6.957 1.00 0.00 0.066 A
# ENDBRANCH 14 17
# ENDBRANCH 13 14
# BRANCH 13 22
# HETATM 22 O6 CHT A 1 18.398 2.270 5.897 1.00 8.52 -0.368 OA
# HETATM 23 HO6 CHT A 1 18.813 2.276 5.007 1.00 0.00 0.212 HD
# ENDBRANCH 13 22
# ENDBRANCH 1 13
# TORSDOF 8`;
# -
# ## Define protein PDBQT text
# + language="javascript"
#
# window.recepPDBTxt = `ATOM 1 N ASP A 40 23.366 -3.399 14.662 1.00 15.25 -0.326 NA
# ATOM 2 CA ASP A 40 22.530 -2.226 14.843 1.00 15.81 0.200 C
# ATOM 3 C ASP A 40 23.197 -1.095 14.078 1.00 15.68 0.243 C
# ATOM 4 O ASP A 40 24.256 -0.613 14.476 1.00 15.64 -0.271 OA
# ATOM 5 CB ASP A 40 22.432 -1.893 16.332 1.00 15.92 0.149 C
# ATOM 6 CG ASP A 40 21.603 -0.652 16.619 1.00 16.79 0.175 C
# ATOM 7 OD1 ASP A 40 21.101 0.007 15.681 1.00 17.82 -0.648 OA
# ATOM 8 OD2 ASP A 40 21.413 -0.255 17.786 1.00 19.39 -0.648 OA
# ATOM 9 H ASP A 40 24.353 -3.311 14.877 1.00 0.00 0.180 HD
# ATOM 10 N VAL A 41 22.581 -0.683 12.973 1.00 15.78 -0.346 N
# ATOM 11 CA VAL A 41 23.169 0.349 12.110 1.00 15.92 0.180 C
# ATOM 12 C VAL A 41 23.137 1.720 12.785 1.00 16.19 0.241 C
# ATOM 13 O VAL A 41 23.963 2.596 12.486 1.00 16.57 -0.271 OA
# ATOM 14 CB VAL A 41 22.514 0.374 10.712 1.00 15.84 0.009 C
# ATOM 15 CG1 VAL A 41 23.234 1.342 9.761 1.00 15.67 0.012 C
# ATOM 16 CG2 VAL A 41 22.531 -1.022 10.096 1.00 16.11 0.012 C
# ATOM 17 H VAL A 41 21.709 -1.109 12.695 1.00 0.00 0.163 HD
# ATOM 18 N GLY A 42 22.202 1.885 13.713 1.00 15.88 -0.351 N
# ATOM 19 CA GLY A 42 22.136 3.082 14.535 1.00 15.70 0.225 C
# ATOM 20 C GLY A 42 20.886 3.924 14.379 1.00 15.32 0.236 C
# ATOM 21 O GLY A 42 20.671 4.848 15.172 1.00 15.23 -0.272 OA
# ATOM 22 H GLY A 42 21.603 1.109 13.966 1.00 0.00 0.163 HD
# ATOM 23 N TRP A 43 20.067 3.630 13.366 1.00 14.72 -0.346 N
# ATOM 24 CA TRP A 43 18.778 4.311 13.226 1.00 14.44 0.181 C
# ATOM 25 C TRP A 43 17.932 3.984 14.459 1.00 14.06 0.241 C
# ATOM 26 O TRP A 43 18.069 2.906 15.035 1.00 14.14 -0.271 OA
# ATOM 27 CB TRP A 43 18.028 3.887 11.955 1.00 14.50 0.075 C
# ATOM 28 CG TRP A 43 18.852 3.543 10.764 1.00 14.78 -0.028 A
# ATOM 29 CD1 TRP A 43 19.772 4.326 10.159 1.00 14.91 0.096 A
# ATOM 30 CD2 TRP A 43 18.860 2.280 10.050 1.00 14.20 -0.002 A
# ATOM 31 NE1 TRP A 43 20.356 3.632 9.123 1.00 14.90 -0.365 N
# ATOM 32 CE2 TRP A 43 19.833 2.360 9.011 1.00 14.43 0.042 A
# ATOM 33 CE3 TRP A 43 18.124 1.077 10.178 1.00 14.13 0.014 A
# ATOM 34 CZ2 TRP A 43 20.063 1.286 8.142 1.00 14.63 0.030 A
# ATOM 35 CZ3 TRP A 43 18.350 -0.008 9.313 1.00 14.56 0.001 A
# ATOM 36 CH2 TRP A 43 19.316 0.106 8.298 1.00 14.58 0.002 A
# ATOM 37 H TRP A 43 20.294 2.873 12.738 1.00 0.00 0.163 HD
# ATOM 38 HE1 TRP A 43 21.179 4.024 8.621 1.00 0.00 0.165 HD
# ATOM 39 N THR A 44 17.062 4.907 14.857 1.00 13.58 -0.344 N
# ATOM 40 CA THR A 44 16.229 4.697 16.050 1.00 13.07 0.205 C
# ATOM 41 C THR A 44 15.366 3.431 15.946 1.00 12.89 0.243 C
# ATOM 42 O THR A 44 15.203 2.719 16.929 1.00 12.25 -0.271 OA
# ATOM 43 CB THR A 44 15.358 5.934 16.326 1.00 13.11 0.146 C
# ATOM 44 OG1 THR A 44 16.191 7.100 16.371 1.00 12.54 -0.393 OA
# ATOM 45 CG2 THR A 44 14.740 5.865 17.735 1.00 13.56 0.042 C
# ATOM 46 H THR A 44 16.968 5.767 14.327 1.00 0.00 0.163 HD
# ATOM 47 HG1 THR A 44 16.365 7.406 15.487 1.00 0.00 0.210 HD
# ATOM 48 N ASP A 45 14.834 3.144 14.756 1.00 12.67 -0.345 N
# ATOM 49 CA ASP A 45 13.958 1.979 14.592 1.00 12.87 0.186 C
# ATOM 50 C ASP A 45 14.693 0.650 14.775 1.00 13.06 0.241 C
# ATOM 51 O ASP A 45 14.203 -0.233 15.477 1.00 13.06 -0.271 OA
# ATOM 52 CB ASP A 45 13.196 2.016 13.235 1.00 13.01 0.147 C
# ATOM 53 CG ASP A 45 14.042 1.759 11.988 1.00 13.25 0.175 C
# ATOM 54 OD1 ASP A 45 15.013 2.526 11.815 1.00 14.05 -0.648 OA
# ATOM 55 OD2 ASP A 45 13.740 0.837 11.196 1.00 13.00 -0.648 OA
# ATOM 56 H ASP A 45 15.036 3.719 13.950 1.00 0.00 0.163 HD
# ATOM 57 N ILE A 46 15.868 0.512 14.158 1.00 13.12 -0.346 N
# ATOM 58 CA ILE A 46 16.648 -0.722 14.301 1.00 13.55 0.180 C
# ATOM 59 C ILE A 46 17.199 -0.860 15.723 1.00 13.70 0.241 C
# ATOM 60 O ILE A 46 17.346 -1.969 16.223 1.00 13.30 -0.271 OA
# ATOM 61 CB ILE A 46 17.763 -0.847 13.206 1.00 13.63 0.013 C
# ATOM 62 CG1 ILE A 46 18.452 -2.215 13.258 1.00 13.94 0.002 C
# ATOM 63 CG2 ILE A 46 18.797 0.261 13.335 1.00 14.03 0.012 C
# ATOM 64 CD1 ILE A 46 17.523 -3.407 13.070 1.00 13.44 0.005 C
# ATOM 65 H ILE A 46 16.218 1.256 13.569 1.00 0.00 0.163 HD
# ATOM 66 N THR A 47 17.474 0.267 16.384 1.00 14.15 -0.344 N
# ATOM 67 CA THR A 47 17.887 0.227 17.788 1.00 14.72 0.205 C
# ATOM 68 C THR A 47 16.727 -0.263 18.660 1.00 14.48 0.243 C
# ATOM 69 O THR A 47 16.931 -1.016 19.615 1.00 14.70 -0.271 OA
# ATOM 70 CB THR A 47 18.408 1.604 18.247 1.00 14.88 0.146 C
# ATOM 71 OG1 THR A 47 19.530 1.978 17.436 1.00 15.66 -0.393 OA
# ATOM 72 CG2 THR A 47 19.022 1.523 19.646 1.00 16.13 0.042 C
# ATOM 73 H THR A 47 17.394 1.166 15.925 1.00 0.00 0.163 HD
# ATOM 74 HG1 THR A 47 20.171 1.276 17.456 1.00 0.00 0.210 HD
# ATOM 75 N ALA A 48 15.515 0.167 18.315 1.00 14.28 -0.346 N
# ATOM 76 CA ALA A 48 14.303 -0.202 19.046 1.00 14.12 0.172 C
# ATOM 77 C ALA A 48 13.950 -1.678 18.886 1.00 13.83 0.240 C
# ATOM 78 O ALA A 48 13.683 -2.357 19.877 1.00 13.54 -0.271 OA
# ATOM 79 CB ALA A 48 13.129 0.678 18.618 1.00 14.05 0.042 C
# ATOM 80 H ALA A 48 15.423 0.801 17.531 1.00 0.00 0.163 HD
# ATOM 81 N THR A 49 13.951 -2.172 17.648 1.00 13.66 -0.345 N
# ATOM 82 CA THR A 49 13.629 -3.581 17.402 1.00 13.40 0.190 C
# ATOM 83 C THR A 49 14.694 -4.504 17.988 1.00 13.28 0.222 C
# ATOM 84 O THR A 49 14.371 -5.555 18.535 1.00 13.49 -0.287 OA
# ATOM 85 CB THR A 49 13.441 -3.883 15.900 1.00 13.46 0.144 C
# ATOM 86 OG1 THR A 49 14.556 -3.379 15.153 1.00 13.38 -0.393 OA
# ATOM 87 CG2 THR A 49 12.238 -3.145 15.346 1.00 13.62 0.042 C
# ATOM 88 H THR A 49 14.157 -1.564 16.866 1.00 0.00 0.163 HD
# ATOM 89 HG1 THR A 49 14.546 -2.434 15.199 1.00 0.00 0.210 HD
# ATOM 90 N GLY A 88 17.040 -5.422 10.405 1.00 12.46 -0.333 NA
# ATOM 91 CA GLY A 88 16.804 -4.172 9.687 1.00 12.42 0.225 C
# ATOM 92 C GLY A 88 16.909 -4.259 8.184 1.00 12.27 0.215 C
# ATOM 93 O GLY A 88 17.363 -3.303 7.556 1.00 12.16 -0.287 OA
# ATOM 94 H GLY A 88 17.987 -5.765 10.479 1.00 0.00 0.180 HD
# ATOM 95 N TRP A 90 15.564 -3.624 5.029 1.00 12.20 -0.326 NA
# ATOM 96 CA TRP A 90 14.502 -2.864 4.372 1.00 12.40 0.195 C
# ATOM 97 C TRP A 90 14.476 -3.199 2.875 1.00 12.75 0.242 C
# ATOM 98 O TRP A 90 15.493 -3.151 2.174 1.00 13.02 -0.271 OA
# ATOM 99 CB TRP A 90 14.718 -1.367 4.573 1.00 12.16 0.077 C
# ATOM 100 CG TRP A 90 14.277 -0.849 5.935 1.00 11.70 -0.028 A
# ATOM 101 CD1 TRP A 90 15.070 -0.651 7.015 1.00 11.86 0.096 A
# ATOM 102 CD2 TRP A 90 12.935 -0.486 6.377 1.00 12.11 -0.002 A
# ATOM 103 NE1 TRP A 90 14.322 -0.196 8.083 1.00 11.22 -0.365 N
# ATOM 104 CE2 TRP A 90 12.995 -0.100 7.753 1.00 11.58 0.042 A
# ATOM 105 CE3 TRP A 90 11.664 -0.452 5.762 1.00 12.22 0.014 A
# ATOM 106 CZ2 TRP A 90 11.867 0.303 8.478 1.00 11.72 0.030 A
# ATOM 107 CZ3 TRP A 90 10.522 -0.035 6.478 1.00 11.86 0.001 A
# ATOM 108 CH2 TRP A 90 10.627 0.353 7.827 1.00 11.69 0.002 A
# ATOM 109 H TRP A 90 16.500 -3.228 5.095 1.00 0.00 0.180 HD
# ATOM 110 HE1 TRP A 90 14.655 -0.008 9.037 1.00 0.00 0.165 HD
# ATOM 111 N MET A 91 13.288 -3.554 2.389 1.00 13.09 -0.346 N
# ATOM 112 CA MET A 91 13.056 -3.901 0.997 1.00 13.24 0.177 C
# ATOM 113 C MET A 91 11.899 -3.053 0.465 1.00 13.24 0.243 C
# ATOM 114 O MET A 91 10.902 -2.887 1.164 1.00 13.54 -0.271 OA
# ATOM 115 CB MET A 91 12.752 -5.398 0.858 1.00 13.31 0.045 C
# ATOM 116 CG MET A 91 13.889 -6.315 1.325 1.00 14.49 0.076 C
# ATOM 117 SD MET A 91 15.369 -6.218 0.294 1.00 15.59 -0.173 SA
# ATOM 118 CE MET A 91 14.916 -7.321 -1.041 1.00 16.54 0.089 C
# ATOM 119 H MET A 91 12.484 -3.598 3.016 1.00 0.00 0.163 HD
# ATOM 120 N PRO A 92 11.985 -2.553 -0.771 1.00 13.31 -0.337 N
# ATOM 121 CA PRO A 92 12.964 -2.988 -1.772 1.00 13.27 0.179 C
# ATOM 122 C PRO A 92 14.346 -2.294 -1.822 1.00 13.10 0.241 C
# ATOM 123 O PRO A 92 15.187 -2.715 -2.602 1.00 12.78 -0.271 OA
# ATOM 124 CB PRO A 92 12.229 -2.707 -3.080 1.00 13.32 0.037 C
# ATOM 125 CG PRO A 92 11.445 -1.452 -2.784 1.00 13.37 0.022 C
# ATOM 126 CD PRO A 92 11.080 -1.519 -1.310 1.00 13.30 0.127 C
# ATOM 127 N THR A 93 14.665 -1.240 -1.077 1.00 13.14 -0.344 N
# ATOM 128 CA THR A 93 15.904 -0.503 -1.373 1.00 13.15 0.205 C
# ATOM 129 C THR A 93 17.214 -1.240 -1.093 1.00 13.41 0.243 C
# ATOM 130 O THR A 93 18.231 -0.857 -1.689 1.00 13.68 -0.271 OA
# ATOM 131 CB THR A 93 15.853 0.835 -0.661 1.00 12.81 0.146 C
# ATOM 132 OG1 THR A 93 15.589 0.602 0.721 1.00 12.43 -0.393 OA
# ATOM 133 CG2 THR A 93 14.783 1.692 -1.378 1.00 12.91 0.042 C
# ATOM 134 H THR A 93 14.063 -0.836 -0.375 1.00 0.00 0.163 HD
# ATOM 135 HG1 THR A 93 16.413 0.539 1.229 1.00 0.00 0.210 HD
# ATOM 136 N LYS A 94 17.186 -2.333 -0.311 1.00 13.91 -0.347 N
# ATOM 137 CA LYS A 94 18.430 -3.076 -0.092 1.00 14.19 0.162 C
# ATOM 138 C LYS A 94 18.718 -4.139 -1.030 1.00 14.32 0.219 C
# ATOM 139 O LYS A 94 19.695 -4.858 -0.825 1.00 14.35 -0.287 OA
# ATOM 140 CB LYS A 94 18.294 -3.889 1.138 1.00 0.00 0.033 C
# ATOM 141 CG LYS A 94 18.731 -2.873 2.065 1.00 0.00 0.004 C
# ATOM 142 CD LYS A 94 18.597 -3.520 3.332 1.00 0.00 0.027 C
# ATOM 143 CE LYS A 94 18.768 -2.336 4.134 1.00 0.00 0.229 C
# ATOM 144 NZ LYS A 94 18.930 -2.951 5.358 1.00 0.00 -0.079 N
# ATOM 145 H LYS A 94 16.341 -2.663 0.188 1.00 0.00 0.163 HD
# ATOM 146 HZ1 LYS A 94 18.102 -3.274 5.843 1.00 0.00 0.274 HD
# ATOM 147 HZ2 LYS A 94 19.613 -3.692 5.269 1.00 0.00 0.274 HD
# ATOM 148 HZ3 LYS A 94 19.331 -2.252 5.977 1.00 0.00 0.274 HD
# ATOM 149 N LEU A 114 8.111 -6.486 9.691 1.00 12.35 -0.328 NA
# ATOM 150 CA LEU A 114 7.316 -5.252 9.629 1.00 11.61 0.177 C
# ATOM 151 C LEU A 114 6.731 -5.002 8.242 1.00 11.30 0.220 C
# ATOM 152 O LEU A 114 7.458 -4.994 7.244 1.00 10.95 -0.287 OA
# ATOM 153 CB LEU A 114 8.136 -4.028 10.079 1.00 11.79 0.038 C
# ATOM 154 CG LEU A 114 7.343 -2.710 10.162 1.00 11.19 -0.020 C
# ATOM 155 CD1 LEU A 114 6.399 -2.729 11.361 1.00 11.81 0.009 C
# ATOM 156 CD2 LEU A 114 8.291 -1.514 10.220 1.00 11.64 0.009 C
# ATOM 157 H LEU A 114 8.559 -6.809 8.844 1.00 0.00 0.180 HD
# ATOM 158 N GLY A 116 3.931 -2.315 5.960 1.00 9.85 -0.332 NA
# ATOM 159 CA GLY A 116 3.287 -0.999 5.932 1.00 9.60 0.241 C
# ATOM 160 C GLY A 116 4.183 0.158 6.288 1.00 9.85 0.237 C
# ATOM 161 O GLY A 116 3.757 1.287 6.463 1.00 9.67 -0.272 OA
# ATOM 162 H GLY A 116 4.157 -2.755 5.076 1.00 0.00 0.180 HD
# ATOM 163 N ALA A 117 5.465 -0.095 6.369 1.00 9.43 -0.347 N
# ATOM 164 CA ALA A 117 6.400 0.972 6.488 1.00 9.61 0.172 C
# ATOM 165 C ALA A 117 6.764 1.450 5.080 1.00 9.59 0.240 C
# ATOM 166 O ALA A 117 6.680 0.701 4.106 1.00 9.45 -0.271 OA
# ATOM 167 CB ALA A 117 7.545 0.353 7.198 1.00 9.53 0.042 C
# ATOM 168 H ALA A 117 5.800 -1.018 6.144 1.00 0.00 0.163 HD
# ATOM 169 N LYS A 118 7.055 2.741 4.970 1.00 9.92 -0.346 N
# ATOM 170 CA LYS A 118 7.014 3.486 3.722 1.00 9.68 0.176 C
# ATOM 171 C LYS A 118 7.838 4.751 3.874 1.00 9.08 0.240 C
# ATOM 172 O LYS A 118 7.817 5.367 4.944 1.00 8.87 -0.271 OA
# ATOM 173 CB LYS A 118 5.544 3.795 3.317 1.00 10.07 0.035 C
# ATOM 174 CG LYS A 118 4.652 4.446 4.405 1.00 11.88 0.004 C
# ATOM 175 CD LYS A 118 4.097 5.851 4.088 1.00 15.78 0.027 C
# ATOM 176 CE LYS A 118 5.113 7.010 4.110 1.00 17.52 0.229 C
# ATOM 177 NZ LYS A 118 5.813 7.122 5.402 1.00 19.32 -0.079 N
# ATOM 178 H LYS A 118 7.240 3.259 5.820 1.00 0.00 0.163 HD
# ATOM 179 HZ1 LYS A 118 6.491 6.364 5.479 1.00 0.00 0.274 HD
# ATOM 180 HZ2 LYS A 118 6.350 7.980 5.469 1.00 0.00 0.274 HD
# ATOM 181 HZ3 LYS A 118 5.185 7.084 6.193 1.00 0.00 0.274 HD
# ATOM 182 N GLY A 119 8.457 5.215 2.797 1.00 8.22 -0.351 N
# ATOM 183 CA GLY A 119 9.061 6.528 2.736 1.00 7.98 0.225 C
# ATOM 184 C GLY A 119 9.867 6.728 1.468 1.00 8.26 0.236 C
# ATOM 185 O GLY A 119 9.973 5.818 0.662 1.00 8.10 -0.272 OA
# ATOM 186 H GLY A 119 8.483 4.677 1.931 1.00 0.00 0.163 HD
# ATOM 187 N THR A 120 10.466 7.880 1.245 1.00 8.66 -0.344 N
# ATOM 188 CA THR A 120 11.225 8.115 0.031 1.00 9.18 0.205 C
# ATOM 189 C THR A 120 12.042 9.380 0.302 1.00 9.49 0.243 C
# ATOM 190 O THR A 120 12.297 9.711 1.470 1.00 9.35 -0.271 OA
# ATOM 191 CB THR A 120 10.256 8.056 -1.205 1.00 9.02 0.146 C
# ATOM 192 OG1 THR A 120 10.933 8.229 -2.416 1.00 9.63 -0.393 OA
# ATOM 193 CG2 THR A 120 9.048 9.002 -1.172 1.00 8.63 0.042 C
# ATOM 194 H THR A 120 10.595 8.555 1.989 1.00 0.00 0.163 HD
# ATOM 195 HG1 THR A 120 10.295 8.230 -3.115 1.00 0.00 0.210 HD
# ATOM 196 N LEU A 121 12.404 10.131 -0.741 1.00 10.01 -0.346 N
# ATOM 197 CA LEU A 121 12.752 11.533 -0.558 1.00 10.62 0.177 C
# ATOM 198 C LEU A 121 11.499 12.279 -0.068 1.00 10.95 0.241 C
# ATOM 199 O LEU A 121 10.398 12.075 -0.578 1.00 11.41 -0.271 OA
# ATOM 200 CB LEU A 121 13.317 12.169 -1.842 1.00 10.89 0.038 C
# ATOM 201 CG LEU A 121 14.734 11.686 -2.226 1.00 10.87 -0.020 C
# ATOM 202 CD1 LEU A 121 15.183 12.340 -3.537 1.00 11.50 0.009 C
# ATOM 203 CD2 LEU A 121 15.780 11.983 -1.137 1.00 11.42 0.009 C
# ATOM 204 H LEU A 121 12.110 9.811 -1.656 1.00 0.00 0.163 HD
# ATOM 205 N ALA A 122 11.665 13.085 0.971 1.00 11.13 -0.346 N
# ATOM 206 CA ALA A 122 10.648 13.926 1.569 1.00 11.41 0.172 C
# ATOM 207 C ALA A 122 11.131 15.364 1.571 1.00 11.61 0.240 C
# ATOM 208 O ALA A 122 12.323 15.632 1.403 1.00 11.78 -0.271 OA
# ATOM 209 CB ALA A 122 10.348 13.478 2.998 1.00 10.72 0.042 C
# ATOM 210 H ALA A 122 12.621 13.193 1.315 1.00 0.00 0.163 HD
# ATOM 211 N THR A 123 10.196 16.283 1.776 1.00 11.79 -0.345 N
# ATOM 212 CA THR A 123 10.534 17.686 1.953 1.00 11.84 0.190 C
# ATOM 213 C THR A 123 9.774 18.241 3.152 1.00 12.05 0.222 C
# ATOM 214 O THR A 123 8.868 17.586 3.671 1.00 12.08 -0.287 OA
# ATOM 215 CB THR A 123 10.273 18.491 0.649 1.00 12.02 0.144 C
# ATOM 216 OG1 THR A 123 10.808 19.813 0.790 1.00 11.74 -0.393 OA
# ATOM 217 CG2 THR A 123 8.779 18.723 0.409 1.00 11.30 0.042 C
# ATOM 218 H THR A 123 9.229 16.002 1.885 1.00 0.00 0.163 HD
# ATOM 219 HG1 THR A 123 11.739 19.741 0.956 1.00 0.00 0.210 HD
# ATOM 220 N ILE A 149 21.031 17.360 -1.244 1.00 11.50 -0.326 NA
# ATOM 221 CA ILE A 149 20.030 16.443 -0.695 1.00 11.16 0.194 C
# ATOM 222 C ILE A 149 20.669 15.806 0.527 1.00 11.40 0.242 C
# ATOM 223 O ILE A 149 21.818 15.372 0.464 1.00 11.23 -0.271 OA
# ATOM 224 CB ILE A 149 19.635 15.356 -1.721 1.00 11.30 0.014 C
# ATOM 225 CG1 ILE A 149 18.877 15.979 -2.895 1.00 10.65 0.002 C
# ATOM 226 CG2 ILE A 149 18.794 14.248 -1.046 1.00 11.03 0.012 C
# ATOM 227 CD1 ILE A 149 18.826 15.097 -4.137 1.00 12.78 0.005 C
# ATOM 228 H ILE A 149 21.989 17.032 -1.278 1.00 0.00 0.180 HD
# ATOM 229 N TYR A 150 19.930 15.761 1.631 1.00 11.16 -0.346 N
# ATOM 230 CA TYR A 150 20.458 15.239 2.889 1.00 11.90 0.180 C
# ATOM 231 C TYR A 150 20.104 13.785 3.133 1.00 11.90 0.241 C
# ATOM 232 O TYR A 150 18.926 13.422 3.221 1.00 12.35 -0.271 OA
# ATOM 233 CB TYR A 150 20.001 16.110 4.058 1.00 11.76 0.073 C
# ATOM 234 CG TYR A 150 20.682 17.447 4.050 1.00 12.50 -0.056 A
# ATOM 235 CD1 TYR A 150 20.163 18.512 3.312 1.00 12.40 0.010 A
# ATOM 236 CD2 TYR A 150 21.872 17.642 4.751 1.00 13.12 0.010 A
# ATOM 237 CE1 TYR A 150 20.801 19.742 3.289 1.00 13.12 0.037 A
# ATOM 238 CE2 TYR A 150 22.521 18.865 4.731 1.00 13.87 0.037 A
# ATOM 239 CZ TYR A 150 21.980 19.910 4.001 1.00 13.21 0.065 A
# ATOM 240 OH TYR A 150 22.616 21.125 3.984 1.00 13.02 -0.361 OA
# ATOM 241 H TYR A 150 18.982 16.116 1.615 1.00 0.00 0.163 HD
# ATOM 242 HH TYR A 150 23.394 21.145 4.520 1.00 0.00 0.217 HD
# ATOM 243 N GLY A 151 21.131 12.941 3.228 1.00 11.78 -0.351 N
# ATOM 244 CA GLY A 151 20.991 11.520 3.503 1.00 11.88 0.225 C
# ATOM 245 C GLY A 151 21.339 11.195 4.955 1.00 11.73 0.236 C
# ATOM 246 O GLY A 151 21.381 12.069 5.820 1.00 11.48 -0.272 OA
# ATOM 247 H GLY A 151 22.083 13.319 3.195 1.00 0.00 0.163 HD
# ATOM 248 N ILE A 152 21.627 9.925 5.232 1.00 11.73 -0.346 N
# ATOM 249 CA ILE A 152 21.999 9.437 6.555 1.00 11.80 0.180 C
# ATOM 250 C ILE A 152 23.412 8.862 6.484 1.00 11.89 0.241 C
# ATOM 251 O ILE A 152 24.271 9.503 5.869 1.00 11.83 -0.271 OA
# ATOM 252 CB ILE A 152 20.904 8.523 7.143 1.00 11.64 0.013 C
# ATOM 253 CG1 ILE A 152 20.536 7.372 6.203 1.00 11.72 0.002 C
# ATOM 254 CG2 ILE A 152 19.656 9.335 7.510 1.00 13.03 0.012 C
# ATOM 255 CD1 ILE A 152 19.482 6.459 6.807 1.00 11.33 0.005 C
# ATOM 256 H ILE A 152 21.670 9.250 4.470 1.00 0.00 0.163 HD
# ATOM 257 N GLU A 153 23.706 7.755 7.177 1.00 12.00 -0.347 N
# ATOM 258 CA GLU A 153 25.072 7.301 7.365 1.00 12.14 0.163 C
# ATOM 259 C GLU A 153 25.688 6.748 6.073 1.00 12.25 0.219 C
# ATOM 260 O GLU A 153 24.985 6.183 5.227 1.00 12.49 -0.287 OA
# ATOM 261 CB GLU A 153 25.167 6.305 8.535 1.00 12.26 0.044 C
# ATOM 262 CG GLU A 153 24.804 4.831 8.230 1.00 12.09 0.116 C
# ATOM 263 CD GLU A 153 23.324 4.579 7.940 1.00 11.17 0.172 C
# ATOM 264 OE1 GLU A 153 22.996 3.503 7.395 1.00 11.67 -0.648 OA
# ATOM 265 OE2 GLU A 153 22.476 5.444 8.253 1.00 12.22 -0.648 OA
# ATOM 266 H GLU A 153 22.981 7.133 7.544 1.00 0.00 0.163 HD
# ATOM 267 N ASN A 156 24.620 3.641 3.511 1.00 11.56 -0.326 NA
# ATOM 268 CA ASN A 156 23.174 3.426 3.553 1.00 11.42 0.199 C
# ATOM 269 C ASN A 156 22.553 3.137 2.159 1.00 11.44 0.243 C
# ATOM 270 O ASN A 156 22.966 3.688 1.134 1.00 11.29 -0.271 OA
# ATOM 271 CB ASN A 156 22.493 4.626 4.218 1.00 11.60 0.138 C
# ATOM 272 CG ASN A 156 21.085 4.270 4.620 1.00 11.51 0.217 C
# ATOM 273 OD1 ASN A 156 20.164 4.472 3.840 1.00 10.74 -0.274 OA
# ATOM 274 ND2 ASN A 156 20.916 3.707 5.804 1.00 11.00 -0.370 N
# ATOM 275 H ASN A 156 25.016 4.493 3.924 1.00 0.00 0.180 HD
# ATOM 276 2HD2 ASN A 156 19.999 3.479 6.150 1.00 0.00 0.159 HD
# ATOM 277 1HD2 ASN A 156 21.740 3.622 6.443 1.00 0.00 0.159 HD
# ATOM 278 N ASP A 157 21.519 2.288 2.150 1.00 11.51 -0.345 N
# ATOM 279 CA ASP A 157 20.731 1.845 0.999 1.00 11.62 0.186 C
# ATOM 280 C ASP A 157 19.943 3.001 0.369 1.00 12.02 0.241 C
# ATOM 281 O ASP A 157 19.759 3.023 -0.847 1.00 11.71 -0.271 OA
# ATOM 282 CB ASP A 157 19.723 0.735 1.415 1.00 11.55 0.147 C
# ATOM 283 CG ASP A 157 18.765 1.054 2.564 1.00 11.89 0.175 C
# ATOM 284 OD1 ASP A 157 19.182 1.675 3.557 1.00 10.60 -0.648 OA
# ATOM 285 OD2 ASP A 157 17.582 0.644 2.574 1.00 12.39 -0.648 OA
# ATOM 286 H ASP A 157 21.161 1.985 3.048 1.00 0.00 0.163 HD
# ATOM 287 N GLY A 158 19.492 3.973 1.169 1.00 11.98 -0.351 N
# ATOM 288 CA GLY A 158 18.846 5.178 0.677 1.00 12.21 0.225 C
# ATOM 289 C GLY A 158 19.858 6.139 0.087 1.00 12.14 0.236 C
# ATOM 290 O GLY A 158 19.643 6.612 -1.023 1.00 12.46 -0.272 OA
# ATOM 291 H GLY A 158 19.709 3.906 2.166 1.00 0.00 0.163 HD
# ATOM 292 N ASN A 159 20.985 6.349 0.784 1.00 11.91 -0.347 N
# ATOM 293 CA ASN A 159 22.128 7.158 0.336 1.00 11.69 0.171 C
# ATOM 294 C ASN A 159 22.619 6.733 -1.034 1.00 11.98 0.220 C
# ATOM 295 O ASN A 159 22.738 7.558 -1.935 1.00 11.83 -0.287 OA
# ATOM 296 CB ASN A 159 23.309 7.088 1.319 1.00 11.90 0.136 C
# ATOM 297 CG ASN A 159 23.088 7.968 2.533 1.00 11.42 0.217 C
# ATOM 298 OD1 ASN A 159 21.971 8.144 3.023 1.00 14.57 -0.274 OA
# ATOM 299 ND2 ASN A 159 24.150 8.541 3.040 1.00 8.90 -0.370 N
# ATOM 300 H ASN A 159 21.061 5.916 1.694 1.00 0.00 0.163 HD
# ATOM 301 2HD2 ASN A 159 24.040 9.116 3.865 1.00 0.00 0.159 HD
# ATOM 302 1HD2 ASN A 159 25.077 8.400 2.642 1.00 0.00 0.159 HD
# ATOM 303 N ILE A 162 20.190 7.710 -3.901 1.00 12.21 -0.327 NA
# ATOM 304 CA ILE A 162 20.287 9.128 -4.228 1.00 12.29 0.180 C
# ATOM 305 C ILE A 162 21.598 9.426 -4.950 1.00 12.35 0.221 C
# ATOM 306 O ILE A 162 21.601 10.142 -5.954 1.00 12.59 -0.287 OA
# ATOM 307 CB ILE A 162 20.179 10.043 -2.985 1.00 12.46 0.013 C
# ATOM 308 CG1 ILE A 162 18.987 9.672 -2.097 1.00 12.46 0.002 C
# ATOM 309 CG2 ILE A 162 20.090 11.519 -3.416 1.00 12.03 0.012 C
# ATOM 310 CD1 ILE A 162 19.075 10.291 -0.707 1.00 12.48 0.005 C
# ATOM 311 H ILE A 162 20.304 7.420 -2.936 1.00 0.00 0.180 HD
# ATOM 312 N VAL A 179 24.564 14.939 1.077 1.00 12.38 -0.326 NA
# ATOM 313 CA VAL A 179 25.237 15.236 2.332 1.00 12.08 0.194 C
# ATOM 314 C VAL A 179 24.992 14.066 3.276 1.00 11.87 0.242 C
# ATOM 315 O VAL A 179 23.853 13.796 3.663 1.00 11.45 -0.271 OA
# ATOM 316 CB VAL A 179 24.745 16.552 2.969 1.00 12.10 0.011 C
# ATOM 317 CG1 VAL A 179 25.613 16.914 4.169 1.00 12.06 0.012 C
# ATOM 318 CG2 VAL A 179 24.731 17.691 1.945 1.00 11.62 0.012 C
# ATOM 319 H VAL A 179 23.624 15.286 0.930 1.00 0.00 0.180 HD
# ATOM 320 N GLU A 180 26.065 13.362 3.618 1.00 11.81 -0.346 N
# ATOM 321 CA GLU A 180 25.960 12.170 4.465 1.00 12.14 0.177 C
# ATOM 322 C GLU A 180 26.339 12.483 5.900 1.00 12.10 0.241 C
# ATOM 323 O GLU A 180 27.287 13.227 6.153 1.00 11.96 -0.271 OA
# ATOM 324 CB GLU A 180 26.857 11.051 3.937 1.00 12.46 0.045 C
# ATOM 325 CG GLU A 180 26.711 10.790 2.450 1.00 12.39 0.116 C
# ATOM 326 CD GLU A 180 27.369 9.494 2.039 1.00 13.53 0.172 C
# ATOM 327 OE1 GLU A 180 28.620 9.469 1.955 1.00 13.91 -0.648 OA
# ATOM 328 OE2 GLU A 180 26.635 8.505 1.809 1.00 12.09 -0.648 OA
# ATOM 329 H GLU A 180 26.974 13.621 3.263 1.00 0.00 0.163 HD
# ATOM 330 N SER A 181 25.594 11.907 6.839 1.00 12.07 -0.344 N
# ATOM 331 CA SER A 181 25.902 12.055 8.257 1.00 11.98 0.200 C
# ATOM 332 C SER A 181 25.385 10.843 9.014 1.00 11.98 0.243 C
# ATOM 333 O SER A 181 26.126 9.883 9.248 1.00 11.67 -0.271 OA
# ATOM 334 CB SER A 181 25.316 13.358 8.823 1.00 12.16 0.199 C
# ATOM 335 OG SER A 181 23.935 13.488 8.521 1.00 12.06 -0.398 OA
# ATOM 336 H SER A 181 24.851 11.275 6.570 1.00 0.00 0.163 HD
# ATOM 337 HG SER A 181 23.837 13.530 7.581 1.00 0.00 0.209 HD
# ATOM 338 N SER A 182 24.101 10.901 9.361 1.00 11.98 -0.344 N
# ATOM 339 CA SER A 182 23.399 9.874 10.128 1.00 11.77 0.200 C
# ATOM 340 C SER A 182 21.911 10.313 10.165 1.00 11.89 0.243 C
# ATOM 341 O SER A 182 21.610 11.434 9.858 1.00 11.39 -0.271 OA
# ATOM 342 CB SER A 182 23.983 9.754 11.538 1.00 12.24 0.199 C
# ATOM 343 OG SER A 182 23.845 10.974 12.255 1.00 11.50 -0.398 OA
# ATOM 344 H SER A 182 23.581 11.740 9.131 1.00 0.00 0.163 HD
# ATOM 345 HG SER A 182 24.214 10.852 13.117 1.00 0.00 0.209 HD
# ATOM 346 N LYS A 183 20.859 9.606 10.560 1.00 11.60 -0.346 N
# ATOM 347 CA LYS A 183 19.583 10.376 10.752 1.00 11.68 0.176 C
# ATOM 348 C LYS A 183 19.576 11.281 11.939 1.00 11.59 0.241 C
# ATOM 349 O LYS A 183 18.733 12.171 11.953 1.00 11.49 -0.271 OA
# ATOM 350 CB LYS A 183 18.309 9.610 10.723 1.00 0.00 0.035 C
# ATOM 351 CG LYS A 183 17.455 9.308 11.973 1.00 0.00 0.004 C
# ATOM 352 CD LYS A 183 18.177 8.493 13.020 1.00 0.00 0.027 C
# ATOM 353 CE LYS A 183 19.161 7.537 12.364 1.00 0.00 0.229 C
# ATOM 354 NZ LYS A 183 18.466 6.708 11.341 1.00 0.00 -0.079 N
# ATOM 355 H LYS A 183 20.943 8.613 10.692 1.00 0.00 0.163 HD
# ATOM 356 HZ1 LYS A 183 18.878 5.799 11.152 1.00 0.00 0.274 HD
# ATOM 357 HZ2 LYS A 183 17.490 6.496 11.464 1.00 0.00 0.274 HD
# ATOM 358 HZ3 LYS A 183 18.465 7.012 10.355 1.00 0.00 0.274 HD
# ATOM 359 N GLN A 184 20.465 11.086 12.922 0.70 11.69 -0.346 N
# ATOM 360 CA GLN A 184 20.556 12.140 13.886 0.70 11.77 0.177 C
# ATOM 361 C GLN A 184 21.042 13.457 13.247 0.70 11.78 0.240 C
# ATOM 362 O GLN A 184 20.450 14.518 13.468 0.70 11.77 -0.271 OA
# ATOM 363 CB GLN A 184 21.433 11.685 15.064 0.70 11.86 0.043 C
# ATOM 364 CG GLN A 184 20.881 10.449 15.859 0.70 12.45 0.089 C
# ATOM 365 CD GLN A 184 21.005 9.079 15.141 0.70 12.58 0.149 C
# ATOM 366 OE1 GLN A 184 21.931 8.974 14.196 0.70 13.41 -0.178 OA
# ATOM 367 NE2 GLN A 184 20.269 8.128 15.467 0.70 8.45 -0.381 N
# ATOM 368 H GLN A 184 21.090 10.271 13.055 0.70 0.00 0.163 HD
# ATOM 369 2HE2 GLN A 184 20.381 7.228 15.019 0.70 0.00 0.158 HD
# ATOM 370 1HE2 GLN A 184 19.570 8.248 16.186 0.70 0.00 0.158 HD
# ATOM 371 N GLY A 185 22.087 13.371 12.424 1.00 11.76 -0.351 N
# ATOM 372 CA GLY A 185 22.617 14.520 11.671 1.00 11.69 0.225 C
# ATOM 373 C GLY A 185 21.616 15.109 10.689 1.00 12.00 0.236 C
# ATOM 374 O GLY A 185 21.431 16.328 10.635 1.00 11.70 -0.272 OA
# ATOM 375 H GLY A 185 22.521 12.468 12.274 1.00 0.00 0.163 HD
# ATOM 376 N MET A 186 20.961 14.236 9.921 1.00 12.04 -0.346 N
# ATOM 377 CA MET A 186 19.958 14.648 8.934 1.00 12.23 0.177 C
# ATOM 378 C MET A 186 18.794 15.386 9.603 1.00 12.44 0.241 C
# ATOM 379 O MET A 186 18.417 16.470 9.174 1.00 11.89 -0.271 OA
# ATOM 380 CB MET A 186 19.446 13.428 8.149 1.00 12.10 0.045 C
# ATOM 381 CG MET A 186 18.412 13.746 7.082 1.00 11.58 0.076 C
# ATOM 382 SD MET A 186 17.457 12.312 6.525 1.00 12.65 -0.173 SA
# ATOM 383 CE MET A 186 16.449 12.014 7.980 1.00 12.54 0.089 C
# ATOM 384 H MET A 186 21.167 13.248 10.008 1.00 0.00 0.163 HD
# ATOM 385 N LEU A 187 18.255 14.803 10.673 1.00 12.67 -0.346 N
# ATOM 386 CA LEU A 187 17.145 15.418 11.407 1.00 13.26 0.177 C
# ATOM 387 C LEU A 187 17.502 16.724 12.101 1.00 13.07 0.241 C
# ATOM 388 O LEU A 187 16.641 17.590 12.264 1.00 12.98 -0.271 OA
# ATOM 389 CB LEU A 187 16.536 14.433 12.407 1.00 13.37 0.038 C
# ATOM 390 CG LEU A 187 15.819 13.247 11.752 1.00 14.61 -0.020 C
# ATOM 391 CD1 LEU A 187 15.477 12.202 12.791 1.00 14.72 0.009 C
# ATOM 392 CD2 LEU A 187 14.568 13.676 10.985 1.00 16.49 0.009 C
# ATOM 393 H LEU A 187 18.608 13.909 10.990 1.00 0.00 0.163 HD
# ATOM 394 N ALA A 188 18.762 16.859 12.512 1.00 13.21 -0.346 N
# ATOM 395 CA ALA A 188 19.264 18.111 13.072 1.00 13.31 0.172 C
# ATOM 396 C ALA A 188 19.209 19.213 12.011 1.00 13.46 0.240 C
# ATOM 397 O ALA A 188 18.840 20.350 12.299 1.00 13.24 -0.271 OA
# ATOM 398 CB ALA A 188 20.685 17.930 13.583 1.00 13.23 0.042 C
# ATOM 399 H ALA A 188 19.411 16.093 12.388 1.00 0.00 0.163 HD
# ATOM 400 N GLN A 189 19.569 18.851 10.782 1.00 13.81 -0.346 N
# ATOM 401 CA GLN A 189 19.539 19.765 9.646 1.00 13.98 0.177 C
# ATOM 402 C GLN A 189 18.104 20.136 9.254 1.00 13.85 0.241 C
# ATOM 403 O GLN A 189 17.820 21.294 8.937 1.00 13.52 -0.271 OA
# ATOM 404 CB GLN A 189 20.294 19.145 8.459 1.00 14.41 0.043 C
# ATOM 405 CG GLN A 189 20.443 20.049 7.239 1.00 15.38 0.089 C
# ATOM 406 CD GLN A 189 21.258 21.307 7.500 1.00 17.22 0.149 C
# ATOM 407 OE1 GLN A 189 22.257 21.210 8.371 1.00 19.78 -0.178 OA
# ATOM 408 NE2 GLN A 189 20.984 22.354 6.912 1.00 17.35 -0.381 N
# ATOM 409 H GLN A 189 19.860 17.896 10.617 1.00 0.00 0.163 HD
# ATOM 410 2HE2 GLN A 189 21.534 23.184 7.080 1.00 0.00 0.158 HD
# ATOM 411 1HE2 GLN A 189 20.219 22.378 6.252 1.00 0.00 0.158 HD
# ATOM 412 N VAL A 190 17.202 19.156 9.284 1.00 13.86 -0.347 N
# ATOM 413 CA VAL A 190 15.775 19.417 9.064 1.00 14.02 0.166 C
# ATOM 414 C VAL A 190 15.253 20.421 10.102 1.00 14.30 0.219 C
# ATOM 415 O VAL A 190 14.514 21.350 9.762 1.00 14.13 -0.287 OA
# ATOM 416 CB VAL A 190 14.948 18.102 9.099 1.00 14.45 0.008 C
# ATOM 417 CG1 VAL A 190 13.451 18.376 9.064 1.00 14.20 0.012 C
# ATOM 418 CG2 VAL A 190 15.347 17.192 7.939 1.00 13.67 0.012 C
# ATOM 419 H VAL A 190 17.494 18.215 9.512 1.00 0.00 0.163 HD
# ATOM 420 N ILE A 200 14.126 22.005 2.370 1.00 11.66 -0.326 NA
# ATOM 421 CA ILE A 200 15.143 20.956 2.466 1.00 11.74 0.194 C
# ATOM 422 C ILE A 200 14.565 19.673 1.876 1.00 11.78 0.242 C
# ATOM 423 O ILE A 200 13.363 19.429 1.988 1.00 11.82 -0.271 OA
# ATOM 424 CB ILE A 200 15.617 20.759 3.947 1.00 11.89 0.014 C
# ATOM 425 CG1 ILE A 200 16.806 19.783 4.021 1.00 12.45 0.002 C
# ATOM 426 CG2 ILE A 200 14.454 20.323 4.850 1.00 11.59 0.012 C
# ATOM 427 CD1 ILE A 200 17.373 19.578 5.447 1.00 11.83 0.005 C
# ATOM 428 H ILE A 200 13.155 21.726 2.409 1.00 0.00 0.180 HD
# ATOM 429 N VAL A 201 15.414 18.885 1.216 1.00 11.57 -0.346 N
# ATOM 430 CA VAL A 201 15.025 17.581 0.684 1.00 11.51 0.180 C
# ATOM 431 C VAL A 201 15.910 16.521 1.329 1.00 11.35 0.241 C
# ATOM 432 O VAL A 201 17.133 16.668 1.379 1.00 11.16 -0.271 OA
# ATOM 433 CB VAL A 201 15.104 17.529 -0.869 1.00 11.76 0.009 C
# ATOM 434 CG1 VAL A 201 14.802 16.125 -1.396 1.00 11.62 0.012 C
# ATOM 435 CG2 VAL A 201 14.138 18.538 -1.481 1.00 11.93 0.012 C
# ATOM 436 H VAL A 201 16.386 19.150 1.143 1.00 0.00 0.163 HD
# ATOM 437 N PHE A 202 15.276 15.463 1.834 1.00 11.11 -0.346 N
# ATOM 438 CA PHE A 202 15.958 14.470 2.661 1.00 11.22 0.180 C
# ATOM 439 C PHE A 202 15.260 13.108 2.608 1.00 11.29 0.241 C
# ATOM 440 O PHE A 202 14.198 12.967 2.006 1.00 11.42 -0.271 OA
# ATOM 441 CB PHE A 202 16.048 14.978 4.104 1.00 10.67 0.073 C
# ATOM 442 CG PHE A 202 14.707 15.211 4.742 1.00 11.26 -0.056 A
# ATOM 443 CD1 PHE A 202 14.137 14.244 5.570 1.00 10.85 0.007 A
# ATOM 444 CD2 PHE A 202 14.007 16.397 4.515 1.00 10.34 0.007 A
# ATOM 445 CE1 PHE A 202 12.885 14.447 6.150 1.00 11.52 0.001 A
# ATOM 446 CE2 PHE A 202 12.762 16.608 5.087 1.00 11.79 0.001 A
# ATOM 447 CZ PHE A 202 12.200 15.634 5.915 1.00 10.91 0.000 A
# ATOM 448 H PHE A 202 14.270 15.390 1.740 1.00 0.00 0.163 HD
# ATOM 449 N LEU A 203 15.807 12.099 3.287 1.00 11.71 -0.346 N
# ATOM 450 CA LEU A 203 15.183 10.789 3.407 1.00 11.70 0.177 C
# ATOM 451 C LEU A 203 14.185 10.764 4.578 1.00 12.11 0.240 C
# ATOM 452 O LEU A 203 14.587 10.842 5.733 1.00 11.90 -0.271 OA
# ATOM 453 CB LEU A 203 16.291 9.766 3.700 1.00 11.94 0.038 C
# ATOM 454 CG LEU A 203 17.258 9.512 2.526 1.00 11.83 -0.020 C
# ATOM 455 CD1 LEU A 203 18.461 8.692 3.005 1.00 11.18 0.009 C
# ATOM 456 CD2 LEU A 203 16.553 8.802 1.372 1.00 12.06 0.009 C
# ATOM 457 H LEU A 203 16.661 12.260 3.809 1.00 0.00 0.163 HD
# ATOM 458 N GLY A 204 12.888 10.612 4.300 1.00 11.84 -0.351 N
# ATOM 459 CA GLY A 204 11.849 10.477 5.320 1.00 12.11 0.225 C
# ATOM 460 C GLY A 204 11.388 9.026 5.381 1.00 11.88 0.236 C
# ATOM 461 O GLY A 204 11.330 8.386 4.331 1.00 12.39 -0.272 OA
# ATOM 462 H GLY A 204 12.610 10.410 3.346 1.00 0.00 0.163 HD
# ATOM 463 N TRP A 205 11.021 8.500 6.557 1.00 11.68 -0.346 N
# ATOM 464 CA TRP A 205 10.469 7.153 6.724 1.00 11.68 0.181 C
# ATOM 465 C TRP A 205 9.365 7.085 7.764 1.00 11.46 0.241 C
# ATOM 466 O TRP A 205 9.364 7.863 8.715 1.00 11.65 -0.271 OA
# ATOM 467 CB TRP A 205 11.527 6.078 7.034 1.00 11.18 0.075 C
# ATOM 468 CG TRP A 205 12.368 6.231 8.252 1.00 11.52 -0.028 A
# ATOM 469 CD1 TRP A 205 12.279 5.486 9.374 1.00 11.31 0.096 A
# ATOM 470 CD2 TRP A 205 13.567 7.039 8.396 1.00 11.04 -0.002 A
# ATOM 471 NE1 TRP A 205 13.351 5.771 10.193 1.00 11.88 -0.365 N
# ATOM 472 CE2 TRP A 205 14.223 6.652 9.595 1.00 12.12 0.042 A
# ATOM 473 CE3 TRP A 205 14.210 8.013 7.600 1.00 12.40 0.014 A
# ATOM 474 CZ2 TRP A 205 15.502 7.114 9.918 1.00 11.27 0.030 A
# ATOM 475 CZ3 TRP A 205 15.512 8.457 7.895 1.00 11.78 0.001 A
# ATOM 476 CH2 TRP A 205 16.163 8.000 9.051 1.00 11.54 0.002 A
# ATOM 477 H TRP A 205 10.990 9.082 7.386 1.00 0.00 0.163 HD
# ATOM 478 HE1 TRP A 205 13.509 5.279 11.068 1.00 0.00 0.165 HD
# ATOM 479 N GLU A 206 8.490 6.088 7.602 1.00 11.69 -0.346 N
# ATOM 480 CA GLU A 206 7.671 5.520 8.669 1.00 12.08 0.177 C
# ATOM 481 C GLU A 206 8.153 4.070 8.875 1.00 12.10 0.243 C
# ATOM 482 O GLU A 206 8.390 3.397 7.862 1.00 11.88 -0.271 OA
# ATOM 483 CB GLU A 206 6.196 5.468 8.240 1.00 12.38 0.045 C
# ATOM 484 CG GLU A 206 5.479 6.814 8.423 1.00 13.95 0.116 C
# ATOM 485 CD GLU A 206 4.975 7.074 9.850 1.00 16.11 0.172 C
# ATOM 486 OE1 GLU A 206 5.484 6.468 10.816 1.00 16.70 -0.648 OA
# ATOM 487 OE2 GLU A 206 4.058 7.900 9.967 1.00 16.69 -0.648 OA
# ATOM 488 H GLU A 206 8.642 5.490 6.801 1.00 0.00 0.163 HD
# ATOM 489 N PRO A 207 8.249 3.566 10.124 1.00 11.89 -0.337 N
# ATOM 490 CA PRO A 207 7.910 4.294 11.345 1.00 11.84 0.179 C
# ATOM 491 C PRO A 207 9.056 5.215 11.760 1.00 11.79 0.241 C
# ATOM 492 O PRO A 207 10.214 4.800 11.728 1.00 11.40 -0.271 OA
# ATOM 493 CB PRO A 207 7.688 3.228 12.408 1.00 11.84 0.037 C
# ATOM 494 CG PRO A 207 8.590 2.088 11.972 1.00 11.93 0.022 C
# ATOM 495 CD PRO A 207 8.654 2.197 10.443 1.00 12.02 0.127 C
# ATOM 496 N HIS A 208 8.726 6.447 12.151 1.00 12.04 -0.346 N
# ATOM 497 CA HIS A 208 9.643 7.356 12.820 1.00 11.94 0.182 C
# ATOM 498 C HIS A 208 8.886 8.540 13.444 1.00 12.48 0.243 C
# ATOM 499 O HIS A 208 7.987 9.094 12.797 1.00 12.92 -0.271 OA
# ATOM 500 CB HIS A 208 10.759 7.825 11.868 1.00 11.83 0.095 C
# ATOM 501 CG HIS A 208 11.908 8.495 12.555 1.00 10.74 0.053 A
# ATOM 502 ND1 HIS A 208 11.850 9.779 13.050 1.00 9.65 -0.247 NA
# ATOM 503 CD2 HIS A 208 13.142 8.027 12.872 1.00 10.15 0.116 A
# ATOM 504 CE1 HIS A 208 13.005 10.088 13.611 1.00 10.80 0.207 A
# ATOM 505 NE2 HIS A 208 13.804 9.039 13.526 1.00 10.24 -0.359 N
# ATOM 506 H HIS A 208 7.737 6.684 12.198 1.00 0.00 0.163 HD
# ATOM 507 HE2 HIS A 208 14.757 8.986 13.877 1.00 0.00 0.166 HD
# ATOM 508 N PRO A 209 9.273 9.014 14.650 1.00 12.66 -0.337 N
# ATOM 509 CA PRO A 209 8.702 10.234 15.252 1.00 12.90 0.179 C
# ATOM 510 C PRO A 209 8.732 11.505 14.381 1.00 12.86 0.241 C
# ATOM 511 O PRO A 209 7.979 12.443 14.655 1.00 12.39 -0.271 OA
# ATOM 512 CB PRO A 209 9.555 10.433 16.514 1.00 12.90 0.037 C
# ATOM 513 CG PRO A 209 9.994 9.054 16.884 1.00 12.51 0.022 C
# ATOM 514 CD PRO A 209 10.225 8.356 15.564 1.00 12.51 0.127 C
# ATOM 515 N MET A 210 9.577 11.536 13.351 1.00 13.34 -0.346 N
# ATOM 516 CA MET A 210 9.678 12.706 12.465 1.00 13.73 0.177 C
# ATOM 517 C MET A 210 8.332 13.063 11.830 1.00 14.03 0.241 C
# ATOM 518 O MET A 210 8.060 14.232 11.540 1.00 13.99 -0.271 OA
# ATOM 519 CB MET A 210 10.755 12.508 11.383 1.00 13.78 0.045 C
# ATOM 520 CG MET A 210 10.444 11.440 10.331 1.00 13.35 0.076 C
# ATOM 521 SD MET A 210 11.648 11.392 8.987 1.00 13.72 -0.173 SA
# ATOM 522 CE MET A 210 12.812 10.171 9.605 1.00 10.69 0.089 C
# ATOM 523 H MET A 210 10.203 10.757 13.190 1.00 0.00 0.163 HD
# ATOM 524 N ASN A 211 7.501 12.044 11.628 1.00 14.68 -0.346 N
# ATOM 525 CA ASN A 211 6.192 12.192 11.003 1.00 15.25 0.185 C
# ATOM 526 C ASN A 211 5.215 12.979 11.868 1.00 15.79 0.241 C
# ATOM 527 O ASN A 211 4.373 13.721 11.351 1.00 16.01 -0.271 OA
# ATOM 528 CB ASN A 211 5.634 10.808 10.646 1.00 15.10 0.137 C
# ATOM 529 CG ASN A 211 6.515 10.136 9.590 1.00 15.00 0.217 C
# ATOM 530 OD1 ASN A 211 6.447 10.437 8.397 1.00 14.34 -0.274 OA
# ATOM 531 ND2 ASN A 211 7.416 9.268 10.031 1.00 14.70 -0.370 N
# ATOM 532 H ASN A 211 7.791 11.117 11.908 1.00 0.00 0.163 HD
# ATOM 533 2HD2 ASN A 211 8.056 8.781 9.405 1.00 0.00 0.159 HD
# ATOM 534 1HD2 ASN A 211 7.396 8.986 11.009 1.00 0.00 0.159 HD
# ATOM 535 N ALA A 212 5.351 12.819 13.183 1.00 16.30 -0.346 N
# ATOM 536 CA ALA A 212 4.566 13.559 14.160 1.00 17.03 0.172 C
# ATOM 537 C ALA A 212 5.251 14.856 14.600 1.00 17.66 0.240 C
# ATOM 538 O ALA A 212 4.579 15.846 14.906 1.00 17.51 -0.271 OA
# ATOM 539 CB ALA A 212 4.280 12.682 15.367 1.00 16.99 0.042 C
# ATOM 540 H ALA A 212 6.074 12.202 13.526 1.00 0.00 0.163 HD
# ATOM 541 N ASN A 213 6.583 14.838 14.643 1.00 18.15 -0.346 N
# ATOM 542 CA ASN A 213 7.367 15.976 15.132 1.00 18.84 0.184 C
# ATOM 543 C ASN A 213 7.540 17.082 14.089 1.00 19.09 0.241 C
# ATOM 544 O ASN A 213 7.701 18.250 14.440 1.00 19.34 -0.271 OA
# ATOM 545 CB ASN A 213 8.735 15.512 15.658 1.00 18.73 0.121 C
# ATOM 546 CG ASN A 213 8.626 14.642 16.904 1.00 19.14 0.151 C
# ATOM 547 OD1 ASN A 213 9.693 13.908 17.211 1.00 19.76 -0.178 OA
# ATOM 548 ND2 ASN A 213 7.602 14.634 17.585 1.00 19.07 -0.381 N
# ATOM 549 H ASN A 213 7.075 13.984 14.409 1.00 0.00 0.163 HD
# ATOM 550 2HD2 ASN A 213 7.557 14.053 18.409 1.00 0.00 0.158 HD
# ATOM 551 1HD2 ASN A 213 6.808 15.197 17.317 1.00 0.00 0.158 HD
# ATOM 552 N PHE A 214 7.515 16.707 12.814 1.00 19.61 -0.347 N
# ATOM 553 CA PHE A 214 7.601 17.666 11.715 1.00 20.09 0.166 C
# ATOM 554 C PHE A 214 6.430 17.453 10.761 1.00 20.31 0.219 C
# ATOM 555 O PHE A 214 5.840 16.373 10.722 1.00 20.32 -0.287 OA
# ATOM 556 CB PHE A 214 8.921 17.504 10.943 1.00 20.30 0.072 C
# ATOM 557 CG PHE A 214 10.155 17.721 11.777 1.00 21.29 -0.056 A
# ATOM 558 CD1 PHE A 214 10.861 16.640 12.294 1.00 21.40 0.007 A
# ATOM 559 CD2 PHE A 214 10.622 19.012 12.032 1.00 21.88 0.007 A
# ATOM 560 CE1 PHE A 214 12.010 16.838 13.068 1.00 22.57 0.001 A
# ATOM 561 CE2 PHE A 214 11.766 19.222 12.799 1.00 22.36 0.001 A
# ATOM 562 CZ PHE A 214 12.462 18.130 13.321 1.00 21.63 0.000 A
# ATOM 563 H PHE A 214 7.399 15.730 12.576 1.00 0.00 0.163 HD
# ATOM 564 N LEU A 216 6.041 16.869 7.274 1.00 19.67 -0.326 NA
# ATOM 565 CA LEU A 216 6.729 16.537 6.027 1.00 19.02 0.191 C
# ATOM 566 C LEU A 216 5.797 16.085 4.919 1.00 18.22 0.242 C
# ATOM 567 O LEU A 216 4.675 15.632 5.162 1.00 17.79 -0.271 OA
# ATOM 568 CB LEU A 216 7.871 15.519 6.222 1.00 19.59 0.040 C
# ATOM 569 CG LEU A 216 7.897 14.407 7.273 1.00 20.61 -0.020 C
# ATOM 570 CD1 LEU A 216 8.706 13.221 6.785 1.00 21.08 0.009 C
# ATOM 571 CD2 LEU A 216 8.500 14.944 8.534 1.00 21.36 0.009 C
# ATOM 572 H LEU A 216 5.723 16.117 7.868 1.00 0.00 0.180 HD
# ATOM 573 N THR A 217 6.292 16.218 3.695 1.00 17.08 -0.344 N
# ATOM 574 CA THR A 217 5.601 15.759 2.509 1.00 16.40 0.205 C
# ATOM 575 C THR A 217 6.513 14.767 1.824 1.00 15.65 0.243 C
# ATOM 576 O THR A 217 7.617 15.126 1.414 1.00 15.57 -0.271 OA
# ATOM 577 CB THR A 217 5.316 16.946 1.571 1.00 16.32 0.146 C
# ATOM 578 OG1 THR A 217 4.391 17.841 2.196 1.00 16.48 -0.393 OA
# ATOM 579 CG2 THR A 217 4.583 16.486 0.307 1.00 16.97 0.042 C
# ATOM 580 H THR A 217 7.218 16.611 3.580 1.00 0.00 0.163 HD
# ATOM 581 HG1 THR A 217 4.783 18.165 2.993 1.00 0.00 0.210 HD
# ATOM 582 N TYR A 218 6.064 13.517 1.725 1.00 14.71 -0.346 N
# ATOM 583 CA TYR A 218 6.770 12.515 0.931 1.00 14.01 0.180 C
# ATOM 584 C TYR A 218 6.542 12.836 -0.540 1.00 13.78 0.241 C
# ATOM 585 O TYR A 218 5.423 13.176 -0.938 1.00 13.09 -0.271 OA
# ATOM 586 CB TYR A 218 6.261 11.105 1.257 1.00 14.04 0.073 C
# ATOM 587 CG TYR A 218 6.642 10.605 2.630 1.00 13.76 -0.056 A
# ATOM 588 CD1 TYR A 218 5.848 10.920 3.752 1.00 14.23 0.010 A
# ATOM 589 CD2 TYR A 218 7.812 9.841 2.793 1.00 13.15 0.010 A
# ATOM 590 CE1 TYR A 218 6.228 10.480 5.031 1.00 13.99 0.037 A
# ATOM 591 CE2 TYR A 218 8.146 9.344 4.061 1.00 13.75 0.037 A
# ATOM 592 CZ TYR A 218 7.370 9.681 5.180 1.00 14.52 0.065 A
# ATOM 593 OH TYR A 218 7.739 9.248 6.408 1.00 14.08 -0.361 OA
# ATOM 594 H TYR A 218 5.156 13.281 2.098 1.00 0.00 0.163 HD
# ATOM 595 HH TYR A 218 7.261 9.670 7.135 1.00 0.00 0.217 HD
# ATOM 596 N LEU A 219 7.606 12.747 -1.333 1.00 13.49 -0.347 N
# ATOM 597 CA LEU A 219 7.539 13.103 -2.750 1.00 13.58 0.163 C
# ATOM 598 C LEU A 219 7.068 11.931 -3.600 1.00 13.70 0.219 C
# ATOM 599 O LEU A 219 7.506 10.795 -3.399 1.00 14.22 -0.287 OA
# ATOM 600 CB LEU A 219 8.900 13.591 -3.263 1.00 13.42 0.037 C
# ATOM 601 CG LEU A 219 9.700 14.634 -2.477 1.00 13.48 -0.020 C
# ATOM 602 CD1 LEU A 219 10.969 14.992 -3.250 1.00 12.46 0.009 C
# ATOM 603 CD2 LEU A 219 8.871 15.885 -2.180 1.00 12.90 0.009 C
# ATOM 604 H LEU A 219 8.499 12.455 -0.955 1.00 0.00 0.163 HD
# ATOM 605 N PHE A 226 12.861 4.334 -5.313 1.00 14.13 -0.327 NA
# ATOM 606 CA PHE A 226 12.601 3.909 -3.940 1.00 14.03 0.180 C
# ATOM 607 C PHE A 226 11.393 2.978 -3.869 1.00 14.36 0.221 C
# ATOM 608 O PHE A 226 11.123 2.414 -2.810 1.00 14.92 -0.287 OA
# ATOM 609 CB PHE A 226 12.357 5.152 -3.075 1.00 13.66 0.073 C
# ATOM 610 CG PHE A 226 13.663 5.772 -2.622 1.00 13.26 -0.056 A
# ATOM 611 CD1 PHE A 226 14.335 6.684 -3.442 1.00 14.02 0.007 A
# ATOM 612 CD2 PHE A 226 14.256 5.398 -1.408 1.00 13.56 0.007 A
# ATOM 613 CE1 PHE A 226 15.548 7.255 -3.039 1.00 13.78 0.001 A
# ATOM 614 CE2 PHE A 226 15.494 5.966 -1.037 1.00 13.49 0.001 A
# ATOM 615 CZ PHE A 226 16.124 6.922 -1.819 1.00 13.23 0.000 A
# ATOM 616 H PHE A 226 12.280 5.058 -5.717 1.00 0.00 0.180 HD
# ATOM 617 N ASN A 229 4.060 3.896 -4.348 1.00 15.61 -0.326 NA
# ATOM 618 CA ASN A 229 3.325 4.282 -3.132 0.50 15.59 0.199 C
# ATOM 619 C ASN A 229 4.217 4.992 -2.096 1.00 15.45 0.243 C
# ATOM 620 O ASN A 229 4.172 4.715 -0.899 1.00 15.17 -0.271 OA
# ATOM 621 CB ASN A 229 2.574 3.070 -2.527 0.50 15.73 0.138 C
# ATOM 622 CG ASN A 229 1.576 3.420 -1.429 0.50 16.09 0.217 C
# ATOM 623 OD1 ASN A 229 1.441 2.713 -0.440 0.50 16.12 -0.274 OA
# ATOM 624 ND2 ASN A 229 0.872 4.529 -1.588 0.50 16.05 -0.370 N
# ATOM 625 H ASN A 229 3.729 4.255 -5.233 1.00 0.00 0.180 HD
# ATOM 626 2HD2 ASN A 229 0.237 4.765 -0.855 0.50 0.00 0.159 HD
# ATOM 627 1HD2 ASN A 229 0.988 5.101 -2.401 0.50 0.00 0.159 HD
# ATOM 628 N TYR A 230 5.040 5.932 -2.567 1.00 15.19 -0.346 N
# ATOM 629 CA TYR A 230 5.957 6.704 -1.727 1.00 15.12 0.180 C
# ATOM 630 C TYR A 230 7.011 5.819 -1.054 1.00 14.50 0.241 C
# ATOM 631 O TYR A 230 7.331 6.021 0.119 1.00 14.95 -0.271 OA
# ATOM 632 CB TYR A 230 5.191 7.609 -0.741 1.00 15.62 0.073 C
# ATOM 633 CG TYR A 230 4.178 8.485 -1.451 1.00 15.84 -0.056 A
# ATOM 634 CD1 TYR A 230 2.846 8.081 -1.591 1.00 16.47 0.010 A
# ATOM 635 CD2 TYR A 230 4.556 9.704 -2.011 1.00 15.72 0.010 A
# ATOM 636 CE1 TYR A 230 1.918 8.877 -2.265 1.00 16.79 0.037 A
# ATOM 637 CE2 TYR A 230 3.637 10.506 -2.680 1.00 16.29 0.037 A
# ATOM 638 CZ TYR A 230 2.324 10.088 -2.808 1.00 16.84 0.065 A
# ATOM 639 OH TYR A 230 1.414 10.887 -3.477 1.00 17.19 -0.361 OA
# ATOM 640 H TYR A 230 4.930 6.214 -3.530 1.00 0.00 0.163 HD
# ATOM 641 HH TYR A 230 1.789 11.695 -3.794 1.00 0.00 0.217 HD
# ATOM 642 N GLY A 231 7.522 4.842 -1.810 1.00 13.90 -0.351 N
# ATOM 643 CA GLY A 231 8.501 3.873 -1.359 1.00 13.24 0.225 C
# ATOM 644 C GLY A 231 7.925 2.911 -0.334 1.00 12.81 0.235 C
# ATOM 645 O GLY A 231 8.544 2.719 0.704 1.00 13.23 -0.272 OA
# ATOM 646 H GLY A 231 7.184 4.704 -2.752 1.00 0.00 0.163 HD
# ATOM 647 N GLY A 232 6.726 2.358 -0.568 1.00 12.46 -0.352 N
# ATOM 648 CA GLY A 232 6.094 1.385 0.326 1.00 11.86 0.209 C
# ATOM 649 C GLY A 232 7.021 0.184 0.542 1.00 11.80 0.213 C
# ATOM 650 O GLY A 232 7.466 -0.424 -0.430 1.00 11.70 -0.287 OA
# ATOM 651 H GLY A 232 6.295 2.507 -1.473 1.00 0.00 0.162 HD
# ATOM 652 N PHE A 233 8.707 0.229 2.260 1.00 11.20 -0.330 NA
# ATOM 653 CA PHE A 233 9.921 -0.550 2.441 1.00 11.33 0.178 C
# ATOM 654 C PHE A 233 9.604 -1.911 3.048 1.00 11.26 0.375 A
# ATOM 655 O PHE A 233 8.608 -2.080 3.758 1.00 11.40 -0.147 OA
# ATOM 656 CB PHE A 233 10.913 0.218 3.309 1.00 0.00 0.070 C
# ATOM 657 CG PHE A 233 11.526 1.445 2.670 1.00 0.00 -0.056 A
# ATOM 658 CD1 PHE A 233 10.898 2.695 2.811 1.00 0.00 0.007 A
# ATOM 659 CD2 PHE A 233 12.719 1.337 1.936 1.00 0.00 0.007 A
# ATOM 660 CE1 PHE A 233 11.467 3.838 2.224 1.00 0.00 0.001 A
# ATOM 661 CE2 PHE A 233 13.288 2.481 1.347 1.00 0.00 0.001 A
# ATOM 662 CZ PHE A 233 12.662 3.731 1.492 1.00 0.00 0.000 A
# ATOM 663 H PHE A 233 8.130 0.337 3.095 1.00 0.00 0.180 HD
# ATOM 664 N THR A 234 8.824 -3.031 3.305 1.00 11.58 0.104 N
# ATOM 665 CA THR A 234 8.732 -4.052 4.330 1.00 11.51 0.344 C
# ATOM 666 C THR A 234 10.106 -4.205 4.975 1.00 11.65 0.255 C
# ATOM 667 O THR A 234 11.134 -3.940 4.335 1.00 11.46 -0.271 OA
# ATOM 668 CB THR A 234 8.189 -5.364 3.720 1.00 11.81 0.157 C
# ATOM 669 OG1 THR A 234 9.060 -5.796 2.686 1.00 11.15 -0.393 OA
# ATOM 670 CG2 THR A 234 6.802 -5.192 3.085 1.00 10.62 0.042 C
# ATOM 671 H THR A 234 9.550 -3.189 2.611 1.00 0.00 0.323 HD
# ATOM 672 HG1 THR A 234 9.798 -6.260 3.060 1.00 0.00 0.210 HD
# ATOM 673 N VAL A 235 10.108 -4.660 6.230 1.00 11.95 -0.347 N
# ATOM 674 CA VAL A 235 11.367 -4.886 6.948 1.00 11.76 0.166 C
# ATOM 675 C VAL A 235 11.463 -6.360 7.311 1.00 11.88 0.219 C
# ATOM 676 O VAL A 235 10.480 -6.965 7.733 1.00 11.90 -0.287 OA
# ATOM 677 CB VAL A 235 11.531 -3.986 8.187 1.00 12.06 0.008 C
# ATOM 678 CG1 VAL A 235 12.976 -4.039 8.712 1.00 11.43 0.012 C
# ATOM 679 CG2 VAL A 235 11.131 -2.537 7.884 1.00 11.50 0.012 C
# ATOM 680 H VAL A 235 9.235 -4.847 6.709 1.00 0.00 0.163 HD
# ATOM 681 N LEU A 261 3.944 -0.771 12.958 1.00 15.84 -0.328 NA
# ATOM 682 CA LEU A 261 4.265 0.662 12.953 1.00 16.28 0.177 C
# ATOM 683 C LEU A 261 3.910 1.328 14.281 1.00 16.27 0.220 C
# ATOM 684 O LEU A 261 4.682 2.141 14.791 1.00 16.48 -0.287 OA
# ATOM 685 CB LEU A 261 3.538 1.374 11.790 1.00 16.36 0.038 C
# ATOM 686 CG LEU A 261 4.396 1.901 10.631 1.00 16.91 -0.020 C
# ATOM 687 CD1 LEU A 261 5.111 0.771 9.892 1.00 17.91 0.009 C
# ATOM 688 CD2 LEU A 261 3.543 2.737 9.671 1.00 16.66 0.009 C
# ATOM 689 H LEU A 261 3.306 -1.122 12.259 1.00 0.00 0.180 HD
# ATOM 690 N GLU A 264 6.456 0.248 17.052 1.00 15.33 -0.326 NA
# ATOM 691 CA GLU A 264 7.770 0.832 16.793 1.00 14.94 0.191 C
# ATOM 692 C GLU A 264 7.792 2.338 17.071 1.00 15.03 0.242 C
# ATOM 693 O GLU A 264 8.703 2.829 17.735 1.00 14.99 -0.271 OA
# ATOM 694 CB GLU A 264 8.261 0.501 15.383 1.00 14.44 0.046 C
# ATOM 695 CG GLU A 264 8.629 -0.971 15.218 1.00 13.96 0.112 C
# ATOM 696 CD GLU A 264 9.489 -1.245 14.004 1.00 13.50 0.139 C
# ATOM 697 OE1 GLU A 264 9.419 -2.371 13.465 1.00 12.57 -0.650 OA
# ATOM 698 OE2 GLU A 264 10.247 -0.346 13.605 1.00 13.37 -0.776 OA
# ATOM 699 H GLU A 264 5.857 0.013 16.271 1.00 0.00 0.180 HD
# ATOM 700 HE2 GLU A 264 10.753 -0.613 12.853 1.00 0.00 0.167 HD
# ATOM 701 N ASN A 265 6.773 3.048 16.590 1.00 15.07 -0.347 N
# ATOM 702 CA ASN A 265 6.625 4.478 16.858 1.00 15.63 0.171 C
# ATOM 703 C ASN A 265 6.558 4.785 18.360 1.00 15.73 0.220 C
# ATOM 704 O ASN A 265 7.099 5.797 18.811 1.00 15.76 -0.287 OA
# ATOM 705 CB ASN A 265 5.410 5.062 16.111 1.00 15.30 0.136 C
# ATOM 706 CG ASN A 265 5.764 5.584 14.718 1.00 16.37 0.217 C
# ATOM 707 OD1 ASN A 265 6.804 6.214 14.522 1.00 16.85 -0.274 OA
# ATOM 708 ND2 ASN A 265 4.883 5.339 13.747 1.00 17.05 -0.370 N
# ATOM 709 H ASN A 265 6.053 2.587 16.047 1.00 0.00 0.163 HD
# ATOM 710 2HD2 ASN A 265 5.059 5.688 12.811 1.00 0.00 0.159 HD
# ATOM 711 1HD2 ASN A 265 4.043 4.816 13.944 1.00 0.00 0.159 HD
# ATOM 712 N MET A 268 10.217 4.159 19.769 1.00 14.93 -0.326 NA
# ATOM 713 CA MET A 268 11.076 5.197 19.191 1.00 15.12 0.191 C
# ATOM 714 C MET A 268 10.774 6.571 19.788 1.00 14.84 0.242 C
# ATOM 715 O MET A 268 11.677 7.386 19.971 1.00 14.58 -0.271 OA
# ATOM 716 CB MET A 268 10.928 5.241 17.673 1.00 15.11 0.046 C
# ATOM 717 CG MET A 268 11.388 3.992 16.945 1.00 15.05 0.076 C
# ATOM 718 SD MET A 268 10.868 4.027 15.206 1.00 16.23 -0.173 SA
# ATOM 719 CE MET A 268 12.024 5.261 14.568 1.00 15.55 0.089 C
# ATOM 720 H MET A 268 9.566 3.678 19.160 1.00 0.00 0.180 HD
# ATOM 721 N GLY A 269 9.501 6.817 20.096 1.00 14.94 -0.352 N
# ATOM 722 CA GLY A 269 9.095 8.028 20.807 1.00 14.74 0.209 C
# ATOM 723 C GLY A 269 9.757 8.159 22.175 1.00 15.10 0.213 C
# ATOM 724 O GLY A 269 10.238 9.235 22.534 1.00 14.86 -0.287 OA
# ATOM 725 H GLY A 269 8.792 6.126 19.888 1.00 0.00 0.162 HD
# ATOM 726 N ILE A 271 12.583 6.748 23.091 1.00 15.79 -0.326 NA
# ATOM 727 CA ILE A 271 14.009 6.921 22.831 1.00 16.20 0.194 C
# ATOM 728 C ILE A 271 14.317 8.346 22.372 1.00 16.57 0.242 C
# ATOM 729 O ILE A 271 15.183 9.015 22.942 1.00 16.13 -0.271 OA
# ATOM 730 CB ILE A 271 14.500 5.884 21.777 1.00 16.36 0.014 C
# ATOM 731 CG1 ILE A 271 14.422 4.465 22.350 1.00 16.05 0.002 C
# ATOM 732 CG2 ILE A 271 15.922 6.229 21.286 1.00 16.38 0.012 C
# ATOM 733 CD1 ILE A 271 14.458 3.361 21.301 1.00 16.35 0.005 C
# ATOM 734 H ILE A 271 12.062 6.121 22.492 1.00 0.00 0.180 HD
# ATOM 735 N LEU A 272 13.599 8.807 21.350 1.00 16.95 -0.347 N
# ATOM 736 CA LEU A 272 13.916 10.080 20.710 1.00 17.45 0.163 C
# ATOM 737 C LEU A 272 13.363 11.310 21.411 1.00 17.47 0.219 C
# ATOM 738 O LEU A 272 14.100 12.274 21.650 1.00 17.52 -0.287 OA
# ATOM 739 CB LEU A 272 13.486 10.073 19.242 1.00 17.86 0.037 C
# ATOM 740 CG LEU A 272 14.551 9.701 18.218 1.00 18.82 -0.020 C
# ATOM 741 CD1 LEU A 272 13.991 9.912 16.822 1.00 19.34 0.009 C
# ATOM 742 CD2 LEU A 272 15.808 10.535 18.401 1.00 19.73 0.009 C
# ATOM 743 H LEU A 272 12.883 8.223 20.933 1.00 0.00 0.163 HD
# TER 744 LEU A 272 `;
# -
# ## Load the PDB texts into models
# + language="javascript"
#
# let models = binana.load_ligand_receptor.from_texts(
# ligPDBTxt, recepPDBTxt
# );
# window.ligand = models[0];
# window.receptor = models[1];
# -
# ## Get information about the hydrogen bonds (example)
# + language="javascript"
#
# window.hbondInf = binana.interactions.get_hydrogen_bonds(
# ligand, receptor
# );
# + language="javascript"
#
# // Counting/characterizing the acceptors and donors (counts)
# output(
# element,
# JSON.stringify(
# hbondInf["counts"],
# null, 2
# )
# );
# + language="javascript"
#
# // List the atoms involved in each hydrogen bond, and the
# // angles/distances
# let toShow = "";
# for(let hbondLabel of hbondInf["labels"]) {
# toShow += JSON.stringify(
# hbondLabel, null, 2
# ) + "\n";
# }
# output(element, toShow);
# -
# ## Get information about the cation-pi interactions (example)
# + language="javascript"
#
# window.cationPiInf = binana.interactions.get_cation_pi(
# ligand,
# receptor
# );
# + language="javascript"
#
# // Counting/characterizing the acceptors and donors (counts)
# output(
# element,
# JSON.stringify(
# cationPiInf["counts"],
# null, 2
# )
# );
# + language="javascript"
#
# // List the atoms involved in each cation-pi interaction
# let toShow = "";
# for(let cationPiLabel of cationPiInf["labels"]) {
# toShow += JSON.stringify(
# cationPiLabel, null, 2
# ) + "\n";
# }
# output(element, toShow);
# -
# ## Other interactions are also available
# + language="javascript"
#
# let toShow = "";
# toShow += "Available functions for detecting interactions:\n";
# let funcNames = Object.keys(binana.interactions).filter(
# n => n.startsWith("get_")
# );
# toShow += funcNames.join("\n");
# output(element, toShow);
# -
# ## Get PDB-formatted text
# + language="javascript"
#
# window.pdbTxt = binana.output.pdb_file.write(
# ligand,
# receptor,
# null, // closest
# null, // close
# null, // hydrophobics
# hbondInf, // hydrogen bonds
# null, // halogen bonds
# null, // salt_bridges
# null, // metal_coordinations
# null, // pi_pi
# cationPiInf, // cat_pi
# null, // active_site_flexibility
# null, // log_output
# true, // as_str
# )
#
# let pdbRemarkLines = pdbTxt.split("\n")
# .filter(l => l.startsWith("REMARK") && l !== 'REMARK');
# let pdbRemarkTxt = pdbRemarkLines.join(",")
# .replace(/REMARK {0,1}/g, "")
# .replace(".,", ".");
# output(element, pdbRemarkTxt);
# + language="javascript"
#
# output(element, pdbTxt);
# -
# ## Get the interactions as a dictionary for easier big-data analysis
# + language="javascript"
#
# window.data = binana.output.dictionary.collect(
# null, // closest
# null, // close
# null, // hydrophobics
# hbondInf, // hydrogen_bonds
# null, // halogen_bonds
# null, // salt_bridges
# null, // metal_coordinations
# null, // pi_pi
# cationPiInf, // cat_pi
# null, // electrostatic_energies
# null, // active_site_flexibility
# null, // ligand_atom_types
# null, // ligand_rotatable_bonds
# )
#
# let toShow = "KEYS: ";
# toShow += Object.keys(window.data).join(", ") + ". ";
# toShow += "\n\nHYDROGEN-BOND DATA (EXAMPLE):\n\n";
# toShow += JSON.stringify(window.data["hydrogenBonds"], null, 2);
#
# output(element, toShow);
# -
# ## Some prefer CSV-formatted data
# + language="javascript"
#
# let csv = binana.output.csv.collect(window.data).slice(0, 500) + "\n\n..."
#
# output(element, csv);
# -
# ## Get all the interactions at once
# + language="javascript"
#
# window.allInf = binana.interactions.get_all_interactions(
# ligand, receptor
# );
# + language="javascript"
#
# output(
# element,
# JSON.stringify(
# Object.keys(allInf), null, 2
# )
# );
# -
# ## Get and display PDB-formatted text containing all interactions
# + language="javascript"
#
# window.pdbTxt = binana.output.pdb_file.write_all(
# ligand, receptor,
# allInf,
# null, // log_output
# true // as_str
# );
#
# output(
# element,
# pdbTxt
# );
# -
# ## Get all interactions as a single dictionary
# + language="javascript"
#
# let allData = binana.output.dictionary.collect_all(allInf)
#
# let out = JSON.stringify(Object.keys(allData))
# out += "\n\nHydrogen bonds (example):\n\n";
# out += JSON.stringify(allData["hydrogenBonds"], null, 4)
#
# output(
# element,
# out
# );
| web_app/src/binanajs/Examples.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
import pandas as pd
import numpy as np
# %matplotlib inline
# # Reading CSV and splitting into training and test data
dtype_dict = {'bathrooms':float, 'waterfront':int, 'sqft_above':int, 'sqft_living15':float, 'grade':int, 'yr_renovated':int, 'price':float, 'bedrooms':float, 'zipcode':str, 'long':float, 'sqft_lot15':float, 'sqft_living':float, 'floors':str, 'condition':int, 'lat':float, 'date':str, 'sqft_basement':int, 'yr_built':int, 'id':str, 'sqft_lot':int, 'view':int}
sales = pd.read_csv('kc_house_data.csv', dtype=dtype_dict)
train_data = pd.read_csv('kc_house_train_data.csv', dtype=dtype_dict)
test_data = pd.read_csv('kc_house_test_data.csv', dtype=dtype_dict)
print(train_data)
train_data['price'].mean()
train_data['sqft_living'].mean()
train_data['sqft_living'].var()
# # Learning multiple regression model
from sklearn import linear_model
regr = linear_model.LinearRegression(fit_intercept=False)
X = np.ones((len(train_data), 4))
X[:,1:] = train_data[['sqft_living', 'bedrooms', 'bathrooms']].values
y = train_data['price']
X
regr.fit(X, y)
regr.coef_
# # Adding new features t odataset
def add_new_features(dataset):
dataset['bedrooms_squared'] = dataset['bedrooms'] * dataset['bedrooms']
dataset['bed_bath_rooms'] = dataset['bedrooms'] * dataset['bathrooms']
dataset['log_sqft_living'] = np.log(dataset['sqft_living'])
dataset['lat_plus_long'] = dataset['lat'] + dataset['long']
add_new_features(train_data)
add_new_features(test_data)
train_data.columns.values
# # Computing mean for newly added features
np.mean(test_data['bedrooms_squared'])
np.mean(train_data['bedrooms_squared'])
np.mean(test_data['bed_bath_rooms'])
np.mean(test_data['log_sqft_living'])
np.mean(test_data['lat_plus_long'])
# # Evaluating the models with new features
feature_set1 = ['sqft_living', 'bedrooms', 'bathrooms', 'lat', 'long']
feature_set2 = feature_set1 + ['bed_bath_rooms']
feature_set3 = feature_set2 + ['bedrooms_squared', 'log_sqft_living', 'lat_plus_long']
def train_linear_regression(dataset, feature_set):
y = dataset['price']
X = np.ones((len(dataset), len(feature_set) + 1))
X[:,1:] = dataset[feature_set]
regr = linear_model.LinearRegression(fit_intercept=False)
regr.fit(X, y)
return regr
model1 = train_linear_regression(train_data, feature_set1)
model2 = train_linear_regression(train_data, feature_set2)
model3 = train_linear_regression(train_data, feature_set3)
# # What is the sign (positive or negative) for the coefficient/weight for ‘bathrooms’ in Model 1?
model1.coef_[3]
# What is the sign (positive or negative) for the coefficient/weight for ‘bathrooms’ in Model 2?
model2.coef_[3]
# # Estimating RSS for Linear Regression Models
def predict(model, dataset, feature_set):
X = np.ones((len(dataset), len(feature_set) + 1))
X[:,1:] = dataset[feature_set]
return model.predict(X)
def compute_rss(model, dataset, feature_set):
y_hat = predict(model, dataset, feature_set)
y = dataset['price']
return (y - y_hat).T.dot(y - y_hat)
# ## For train data
train_rss = [compute_rss(model1, train_data, feature_set1), compute_rss(model2, train_data, feature_set2), compute_rss(model3, train_data, feature_set3)]
train_rss
train_rss.index(min(train_rss))
# ## For test data
test_rss = [compute_rss(model1, test_data, feature_set1), compute_rss(model2, test_data, feature_set2), compute_rss(model3, test_data, feature_set3)]
test_rss
test_rss.index(min(test_rss))
np.array(test_rss) - np.array(train_rss)
| ml-regression/week1-2/week2-simple-regression-assignment-1.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
from __future__ import print_function
from sympy import Symbol, symbols, sin, cos, Rational, expand, simplify, collect, S
from galgebra.printer import Eprint, Get_Program, Print_Function, Format
from galgebra.ga import Ga, one, zero
from galgebra.mv import Nga
Format()
X = (x, y, z) = symbols('x y z')
o3d = Ga('e_x e_y e_z', g=[1, 1, 1], coords=X)
(ex, ey, ez) = o3d.mv()
grad = o3d.grad
c = o3d.mv('c', 'scalar')
a = o3d.mv('a', 'vector')
b = o3d.mv('b', 'vector')
A = o3d.mv('A','mv')
B = o3d.mv('B','mv')
# The inner product of blades in GAlgebra is zero if either operand is a scalar:
#
# $$\begin{split}\begin{aligned}
# {\boldsymbol{A}}_{r}{\wedge}{\boldsymbol{B}}_{s} &\equiv {\left <{{\boldsymbol{A}}_{r}{\boldsymbol{B}}_{s}} \right >_{r+s}} \\
# {\boldsymbol{A}}_{r}\cdot{\boldsymbol{B}}_{s} &\equiv {\left \{ { \begin{array}{cc}
# r\mbox{ and }s \ne 0: & {\left <{{\boldsymbol{A}}_{r}{\boldsymbol{B}}_{s}} \right >_{{\left |{r-s}\right |}}} \\
# r\mbox{ or }s = 0: & 0 \end{array}} \right \}}
# \end{aligned}\end{split}$$
#
# This definition comes from _<NAME> and <NAME>, “Clifford Algebra to Geometric Calculus,” Kluwer Academic Publishers, 1984_.
#
# In some other literature, the inner product is defined without the exceptional case for scalar part and the definition above is known as "the modified Hestenes inner product" (this name comes from the source code of [GAViewer](http://www.geometricalgebra.net/gaviewer_download.html)).
c|a
a|c
c|A
A|c
# $ab=a \wedge b + a \cdot b$ holds for vectors:
a*b
a^b
a|b
(a*b)-(a^b)-(a|b)
# $aA=a \wedge A + a \cdot A$ holds for the products between vectors and multivectors:
a*A
a^A
a|A
(a*A)-(a^A)-(a|A)
# $AB=A \wedge B + A \cdot B$ does NOT hold for the products between multivectors and multivectors:
A*B
A|B
(A*B)-(A^B)-(A|B)
(A<B)+(A|B)+(A>B)-A*B
| examples/ipython/inner_product.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
import os
os.listdir()
import pandas
df7 = pandas.read_json("http://pythonhow.com/supermarkets.json")
df7
df7.set_index("Address")
df8 = df7.set_index("Address")
df8
df8.loc["735 Dolores St":"332 Hill St", "Country":"ID"]
df8.loc["332 Hill St", "Country"]
df8.loc[:,"Country"]
df8.loc[:,"Country"]
list(df8.loc[:,"Country"])
# This is upper bound exclusive, as in the index of 4 is not included in the range
df8.iloc[1:4,1:4]
# This is upper bound exclusive, as in the index of 4 is not included in the range
df8.iloc[3,1:4]
df8.ix[3,4]
df8.iloc[3,4]
| s06/lecture101.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
print("Hello")
import os
os.listdir()
import pandas as pd
df_csv = pd.read_csv("supermarkets.csv")
df_csv
df_json = pd.read_json("supermarkets.json")
df_json
df_xls = pd.read_excel("supermarkets.xlsx" ,sheet_name=0)
df_xls
import os.path
from os import path
path.exists("supermarkets-commas.txt")
# +
if path.exists("supermarkets-commas.txt") :
df_txt_1 = pd.read_csv("supermarkets-commas.txt")
else :
print("File not avalible")
df_txt_1
# +
if path.exists("supermarkets-semi-colons.txt") :
#df_txt_2 = pd.read_csv("supermarkets-semi-colons.txt",delimiter=";")
df_txt_2 = pd.read_csv("supermarkets-semi-colons.txt",sep=";")
else :
print("File not avalible")
df_txt_2
# +
# default Headers
if path.exists("data.txt") :
df_txt_3 = pd.read_csv("data.txt",sep="," ,header=None)
else :
print("File not avalible")
df_txt_3
# -
df_txt_3.columns = ["ID","Address","City","State","Country","Name","Employees"]
df_txt_3
df_txt_4 = df_txt_3.set_index("ID")
df_txt_4
df_txt_4.City
# +
# Indexing and Slicing
df_txt_4.loc["2":"5","State":"Country"]
# -
list(df_txt_4.State)
list(df_txt_4.Country)
df_txt_4.iloc[1:4,2:3]
# Deleting Columns and Rows
# 1 - Column Delete and 0 is row delete
#df_txt_4
df_txt_4.drop("City" , 1)
df_txt_5 = df_txt_4.drop(1 , 0)
df_txt_5
df_txt_4.describe()
df_txt_4.describe(include = 'all')
df_txt_5.columns
df_txt_5.shape
# +
# Updating and Adding new Columns and Rows
# -
df_txt_5["Continent"] = df_txt_5["Country"] + ", North"
df_txt_5
# +
# transpose Data
df_txt_6 = df_txt_5.T
df_txt_6
# +
### Geocoding Addresses with Pandas and Geopy
### pip3 install geopy
# -
import geopy
from geopy.geocoders import ArcGIS
nom = ArcGIS()
df_txt_5
dir(geopy)
nom.geocode("631 E Royal ln , TX 75038")
import pandas as pd
import os
os.listdir()
df_geopy = pd.read_csv("supermarkets.csv")
df_geopy
df_geopy["Address"] = df_geopy["Address"]+ " ," + df_geopy["City"]+" ,"+df_geopy["State"]+","+df_geopy["Country"]
df_geopy
df_geopy["Coordinates"] = df_geopy["Address"].apply(nom.geocode)
df_geopy
df_geopy["Coordinates"][1]
df_geopy.Coordinates[1]
df_geopy.Coordinates[1].latitude
df_geopy["Latitude"] = df_geopy["Coordinates"].apply(lambda x : x.latitude if x != None else None)
df_geopy["Longitude"] = df_geopy["Coordinates"].apply(lambda x : x.longitude if x != None else None)
df_geopy
| Data_Analysis_with_Pandas/Data Analysis with Pandas.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Advanced fMRI data analysis
# ## General Linear Model 1
#
#
# In this assignment, your task is to complete a few linear regression excercises in Python.
#
# You can choose to answer in Polish or English (it will not affect your grade).
#
# **DEADLINE:** 08-05-2020
#
# -------------------
# ## Linear regression analysis with signals of non-neuronal origin
# *Confounds* (or nuisance regressors) are variables representing fluctuations with a potential non-neuronal origin. Such non-neuronal fluctuations may drive spurious results in fMRI data analysis, including standard activation GLM and functional connectivity analyses. Read [more](https://fmriprep.readthedocs.io/en/stable/outputs.html#confounds).
#
# Run simple and multiple linear regression to investigate associations between regressors.
#
# Confounds regressors calculated with *fMRIPrep* are stored in data folder (`/data/sub-01_task-rhymejudgment_desc-confounds_regressors.tsv`)
# ### Task 1
#
# Investigate linear relationship between *global signal* (signal from the whole brain) and signal from *white matter*.
# Load libraries
import nipype.interfaces.fsl as fsl
import nipype.interfaces.spm as spm
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
# +
# Load DataFrame with confounds
confounds_path = "data/sub-01_task-rhymejudgment_desc-confounds_regressors.tsv"
confounds = pd.read_csv(confounds_path, delimiter="\t")
# Print all column names (use df.columns.values)
confounds.columns.values
# +
# Select columns representing global signal and white matter signal
b = confounds[["global_signal","white_matter"]]
# Plot association between these signals using on scatterplot
plt.scatter(confounds["global_signal"], confounds["white_matter"])
# +
# Run simple linear regression for global signal and white matter signal
from sklearn.linear_model import LinearRegression
a = confounds["global_signal"].values
c= confounds["white_matter"].values
linear_regression = LinearRegression()
linear_regression.fit(a.reshape(-1, 1), c.reshape(-1, 1))
# Print intercept and beta values
intercept = linear_regression.intercept_
beta = linear_regression.coef_
print("intercept:", intercept)
print("beta:", beta)
# +
# Make a scatterplot representing association between signals with fitted linear regression line
x = np.linspace(517,528,100)
y = beta*x+intercept
y = np.squeeze(y)
plt.scatter(a,c)
plt.plot(x,y)
# -
# ### Task 2
#
# *Framewise displacement* variable in confounds table (stored as `framewise_displacement`) is a quantification of the estimated bulk-head motion. Run multiple linear regression to predict `framewise_displacement` from six motion parameters (3 rotations, 3 translations). Use previously loaded confounds table.
#
# +
# Filter dataframe to store only 6 motion parameters
six_motion = confounds[["trans_x", "trans_y", "trans_z", "rot_x", "rot_y", "rot_z"]].drop(six_motion.index[0])
print(six_motion.shape)
# Print firt 5 rows of motion parameters
print(six_motion.head())
# Filter dataframe to store framewise displacement
frame_disp = confounds[["framewise_displacement"]].drop(frame_disp.index[0])
print(frame_disp)
# +
# Fit multiple linear regression model
regr = LinearRegression()
regr.fit(six_motion, frame_disp)
# Print intercept and beta values
intercept = regr.intercept_
beta = regr.coef_
print("intercept:", intercept)
print("beta:", beta)
# -
# Which of the 6 motion parameter values has highest corresponding beta value?
#
# **Answer**: Translation Z
# --------
# ## Linear regression on movie/TV series characters profile pictures
# ### Task 3
# In folder `data/characters` you can find pictures of 5 characters from Harry Potter movie stored as 400$\times$400 numpy arrays (RED channel).
#
# Add your favourite movie/TV character from previous homework to the folder (array has to have the same dimension) and run multiple regression to predict your character from other other characters pictures.
#
# You can load more pictures to improve your prediction!!!
#
# +
# Load image of your favoutite character
path = "data/characters/hulk-cgi.jpg.npy"
hulk = np.load(path)
# Load pictures of other characters
path0 = "data/characters/harry.npy"
harry = np.load(path0)
path1 = "data/characters/james.npy"
james = np.load(path1)
path2= "data/characters/lilly.npy"
lilly = np.load(path2)
path3 = "data/characters/syrius.npy"
syrius = np.load(path3)
path4= "data/characters/voldemort.npy"
voldemort = np.load(path4)
# Plot all pictures on a one figure (use plt.subplots)
fig, (ax1, ax2, ax3, ax4, ax5, ax6) = plt.subplots(1,6, figsize=(20, 20))
ax1.imshow(hulk)
ax2.imshow(harry)
ax3.imshow(james)
ax4.imshow(lilly)
ax5.imshow(syrius)
ax6.imshow(voldemort)
# +
# Make a matrix of characters (remember to change matrices to vectors and transpose).
characters_matrix = []
characters=[hulk, harry,james,lilly,syrius,voldemort]
for char in characters:
characters_matrix.append(char.flatten())
characters_matrix = np.array(characters_matrix)
characters_matrix = characters_matrix.T
print(characters_matrix.shape)
# Fit multiple linear regression to predict your favourite character from other characters
linear_regression = LinearRegression()
linear_regression.fit(characters_matrix[:,1:], characters_matrix[:,0])
# Print intercept and beta values
beta = linear_regression.coef_
intercept = linear_regression.intercept_
print(beta, intercept)
# +
# Calculate your predicted character
predict = beta[0]*harry + beta[1]*james + beta[2]*lilly + beta[3]*syrius + beta[4]*voldemort + intercept
# Plot your original character and predicted character on a one plot (use plt.subplots)
fig, (ax1, ax2) = plt.subplots(1,2, figsize=(10,10))
ax1.imshow(hulk)
ax2.imshow(predict)
# -
# Which of the characters has highest and lowest corresponding beta values?
#
# **Highest**: Harry :D
#
# **Lowest**: Voldemort
| 03-fMRIDA_homework.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
import pandas as pd
df = pd.DataFrame(columns=['serial-no','timestamp', 'x', 'y', 'z'])
df
data = {'serial-no': 'abc','timestamp':'timestamp', 'x': 123, 'y':456, 'z':789}
df.append(data, ignore_index=True)
df
data
serial_no='124serial'
timestamp="sometime"
x=12
y=33
z=44
df = df.append({'serial-no': serial_no,'timestamp':timestamp, 'x': x, 'y':y, 'z':z}, ignore_index=True)
df = df.append({'serial-no': serial_no,'timestamp':timestamp, 'x': x, 'y':y, 'z':z}, ignore_index=True)
df
| Pandas Practice.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
from database.strategy import Strategy
from database.market import Market
from transformer.date_transformer import DateTransformer
from transformer.column_transformer import ColumnTransformer
from transformer.model_transformer import ModelTransformer
from transformer.product_transformer import ProductTransformer
from transformer.predictor_transformer import PredictorTransformer
from preprocessor.model_preprocessor import ModelPreprocessor
from preprocessor.predictor_preprocessor import PredictorPreprocessor
from modeler.modeler import Modeler as sp
from utils.date_utils import DateUtils
import pandas as pd
import matplotlib.pyplot as plt
from datetime import datetime, timedelta, timezone
from tqdm import tqdm
import math
import numpy as np
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, VotingClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.linear_model import LinearRegression, SGDRegressor, RidgeCV, SGDClassifier, RidgeClassifier, LogisticRegression
from sklearn.metrics import mean_squared_error, r2_score, mean_squared_log_error, accuracy_score, mean_absolute_percentage_error
from sklearn.model_selection import GridSearchCV, StratifiedKFold, train_test_split, HalvingGridSearchCV
## Loading Constants
start = "2008-01-01"
end = datetime(2021,1,7).strftime("%Y-%m-%d")
# Loading Databases
strat_db = Strategy("unity")
market = Market()
market.connect()
tickers = market.retrieve_data("sp500").sort_values("Symbol")
market.close()
reload = True
quarterly_range = range(1,2)
yearly_range = range(2018,2019)
dataset = "pdr"
market.connect()
classification = market.retrieve_data("dataset_pdr_week_classification")
regression = market.retrieve_data("dataset_pdr_week_regression")
market.close()
for col in regression.columns:
if -99999 == regression[col].min():
regression.drop(col,axis=1,inplace=True)
for col in classification.columns:
if -99999 == classification[col].min():
classification.drop(col,axis=1,inplace=True)
sims = []
gap = 5
week_gap = int(gap/5)
training_years = 7
timeline = DateUtils.create_timeline(start,end)
sims = []
strat_db.connect()
market.connect()
market.drop_table("pdr_weekly_sim")
for year in tqdm(yearly_range):
for quarter in tqdm(quarterly_range):
try:
for ticker in tickers["Symbol"][0:1]:
try:
if ticker in regression.columns:
price = market.retrieve_price_data("{}_prices".format(dataset),ticker)
if dataset == "pdr":
price = ColumnTransformer.rename_columns(price," ")
else:
price = ColumnTransformer.rename_columns(price,"")
price = DateTransformer.convert_to_date(dataset,price,"date")
mr = ModelPreprocessor(ticker)
prot = ProductTransformer(ticker,start,end)
ticker_regression = regression
## regression_model
first = ticker_regression[(ticker_regression["year"] == year - training_years) & (ticker_regression["quarter"] == quarter)].index.values.tolist()[0]
last = ticker_regression[(ticker_regression["year"] == year) & (ticker_regression["quarter"] == quarter)].index.values.tolist()[0]
rqpd = ticker_regression.iloc[first:last-1]
rqpd["y"] = rqpd[ticker]
rqpd["y"] = rqpd["y"].shift(-week_gap)
rqpd = rqpd[:-week_gap]
qpd = mr.day_trade_preprocess_regression(rqpd.copy(),ticker,True)
rpr = sp.regression(qpd,ranked=False,tf=True,deep=True)
# ## classification_model
# ticker_classification = classification
# first = ticker_classification[(ticker_classification["year"] == year - training_years) & (ticker_classification["quarter"] == quarter)].index.values.tolist()[0]
# last = ticker_classification[(ticker_classification["year"] == year) & (ticker_classification["quarter"] == quarter)].index.values.tolist()[0]
# cqpd = ticker_classification.iloc[first:last-1]
# cqpd["y"] = cqpd[ticker]
# cqpd["y"] = cqpd["y"].shift(-week_gap)
# cqpd = cqpd[:-week_gap]
# qpd = mr.day_trade_preprocess_classify(cqpd.copy(),ticker)
# q2c = qpd["X"].columns
# cpr = sp.classification(qpd,tf=False,deep=False)
# price_results = pd.DataFrame([cpr,rpr])
# product_qpds = []
# current_sets = []
except Exception as e:
message = {"status":"weekly modeling","ticker":ticker,"year":str(year),"quarter":str(quarter),"message":str(e)}
print(message)
except Exception as e:
print(year,week,str(e))
market.close()
strat_db.close()
stuff = {
"sgd" : {"model":SGDRegressor(),"params":{"loss":["squared_loss","huber"]
,"learning_rate":["constant","optimal","adaptive"]
,"alpha" : [0.0001,0.001, 0.01, 0.1, 0.2, 0.5, 1]}},
"r" : {"model":RidgeCV(alphas=[0.0001,0.001, 0.01, 0.1, 0.2, 0.5, 1]),"params":{}},
"lr" : {"model":LinearRegression(),"params":{"fit_intercept":[True,False]}}
}
data = qpd
X_train, X_test, y_train, y_test = train_test_split(data["X"], data["y"],train_size=0.75, test_size=0.25, random_state=42)
deep = True
results = []
for regressor in stuff:
print(regressor)
try:
model = stuff[regressor]["model"].fit(X_train,y_train)
params = stuff[regressor]["params"]
if not deep:
model.fit(X_train,y_train)
else:
gs = HalvingGridSearchCV(model,params,cv=10,scoring="neg_mean_squared_error")
gs.fit(X_train,y_train)
model = gs.best_estimator_
y_pred = model.predict(X_test)
accuracy = r2_score(y_test,y_pred)
result = {"api":"skl","model":model,"score":accuracy}
results.append(result)
except Exception as e:
print(str(e))
result = {"api":"skl","model":str(e),"score":-99999}
results.append(result)
continue
results
| boiler/modeler_qa.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3 (ipykernel)
# language: python
# name: python3
# ---
import sys
sys.path.append('/n/scratch3/users/k/kaw308/viewmaker')
from aug_3kg import *
from src.datasets.ptb_xl_1d import PTB_XL_1d
from src.models.vcg import *
from src.models.aug_3kg import *
import numpy as np
import torch
transform = SingleRandomTransform(
RandomRotation(45),
RandomScale(1.5),
RandomGaussian(False),
RandomTimeMask(0.5)
)
out = transform(torch.rand(12,1000))
print(out[0].shape)
| scripts/Untitled.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
from bs4 import BeautifulSoup
import urllib
import os
# use this image scraper from the location that
#you want to save scraped images to
def make_soup(url):
html = urllib.request.urlopen(url).read()
return BeautifulSoup(html)
def get_images(url):
global filename
try:
soup = make_soup(url)
#this makes a list of bs4 element tags
images = [img for img in soup.findAll('img')]
#compile our unicode list of image links
image_links = [each.get('src') for each in images]
for each in image_links:
filename=each.split('/')[-1]
urllib.request.urlretrieve(each, filename)
return filename
except:
pass
# +
link = input('Insira o link para o .png do livro: \n').replace('bg1.png','')
pages = int(input('Insira o numero de paginas do livro: \n'))
for i in range(1,pages+1):
get_images(link + str(i) + ".html")
os.rename(filename, str(i)+'.jpg')
# -
| download livro passei direto.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3 (ipykernel)
# language: python
# name: python3
# ---
# +
#Hi there, Can you see this
import numpy as np
import tensorflow as tf
from numpy import load
import operator
import tensorflow as tf
import matplotlib.pyplot as plt
import os,sys,inspect
sys.path.insert(1, os.path.join(sys.path[0], '..')) #this line should always stay above the next line below
from tfrbm import BBRBM, GBRBM, BBRBMTEMP
from tensorflow.examples.tutorials.mnist import input_data
#load the mnist data
mnist = input_data.read_data_sets('MNIST_data/', one_hot=True)
mnist_images = mnist.train.images
mnist_images1= np.where(mnist_images > 0, 1, 0)
#helper fcts
def show_digit(x,y):
plt.imshow(x)#,cmap = plt.cm.binary)
plt.colorbar(mappable=None, cax=None, ax=None)
plt.title(y)
plt.locator_params(axis="x", nbins=10)
plt.locator_params(axis="y", nbins=1)
plt.show()
#labels pixels
accu = [0]
num_avg = 10
n_data = 10#mnist_images1.shape[0]
print("accuracy",accu)
t1 = np.zeros(10)
num_t= 15
t2 = np.ones(num_t)
img_zer = np.zeros(784-num_t)
print("minist test size",mnist_images1.shape)
#create the BM
bbrbm = BBRBMTEMP(n_visible=794, n_hidden=64, learning_rate=0.01, momentum=0.95, use_tqdm=True,t=1)
#first run
fname = ["1-3","2-3","3-3","4-3","5-3","6-3","7-3","8-3","9-3","10-3","11-3","12-3","13-3","14-3","15-3","16-3","17-3","18-3","19-3","20-3"]
#n_data = mnist_images1.shape[0]
print("number of images", n_data)
#load the saved weights
filename = 'weights_class1kep'
name = 'bbrbm_class1kep'
bbrbm.load_weights(filename,name)
#random image for testing
random_image = np.random.uniform(0,1,784)
image_rec_bin = np.greater(random_image, 0.9) #np.random.uniform(0,1,784))
random_image = image_rec_bin.astype( int)
print("t is ",bbrbm.temp)
for j in range(n_data) :
#random_image = np.random.uniform(0, 1, 784)
#image_rec_bin = np.greater(random_image, np.random.uniform(0, 1, 784))
#random_image = image_rec_bin.astype(int)
#print(j)
#random_image = np.random.rand(1, 784)#np.random.uniform(0, 1, 784)
#show_digit(random_image.reshape(28, 28), "Original rand image")
#image_rec_bin = np.greater(random_image, np.random.rand(1,1))
random_image = np.concatenate((t2, img_zer), axis=0)#image_rec_bin.astype(int)
np.random.shuffle(random_image)
#show_digit(random_image.reshape(28, 28), "Original random image")
image = random_image # mnist_images1[j+20] #
#show_digit(image.reshape(28, 28), "Original image")
#print("image label",mnist.test.labels[j])
a = image.reshape(28,28)
c = image.reshape(28, 28)
#show_digit(image.reshape(28,28))
# img = a[0:16,0:28] #crop the image
###### cropping
#img = a * mask_b
##### without cropping
img = image.reshape(28,28)
# img_org = img
img = np.concatenate((t1, img.flatten()), axis=0)
img_org = img
#print("shape of of org img", img_org.shape)
#imga = random_image#imga = img
show_digit(img_org[10:794].reshape(28,28),"Input image")
#reconstruct image for N-MC
bbrbm.temp = 5
temp_idx = 10
temp_dec_step = 0.01
temp_chng_step = temp_idx
range_idx = int((bbrbm.temp/temp_dec_step)*temp_idx)
print("range index",range_idx)
for i in range(range_idx):
image_rec1 = bbrbm.reconstruct(img.reshape(1,-1),bbrbm.temp)
#print("shape of of rec1",image_rec1.shape)
image_rec1 = image_rec1.reshape(794, )
#if( i > 400 - num_avg -1):
#if(i == 300):
#store_recon_vu[i - (400 - num_avg)] = image_rec1
#set_temp(bbrbm,0.0)
#print("trying to set t to 0")
# bbrbm.temp = 0.1
#print("stored labels : ", store_labels)
#print("index i : ", i)
# print("new temp 1 is ", bbrbm.temp)
#bbrbm.temp = 1
#print("new temp 2 is ", bbrbm.temp)
#print("new shape of of rec1", image_rec1.shape)
#if (i == 1):
#print("i = ", i)
#show_digit(image_rec1[10:794].reshape(28, 28), "reconstructed image ")
#bbrbm.temp = 0.01
if (i == temp_idx):
b = bbrbm.temp
if( bbrbm.temp > temp_dec_step):
bbrbm.temp = bbrbm.temp - temp_dec_step
temp_idx += temp_chng_step
#print("temp is ", bbrbm.temp)
#print("i = ", i)
# else:
# print("temp idx = ", temp_idx)
# show_digit(image_rec1[10:794].reshape(28, 28), "else Reconstructed image T = after i% iterations" % i)
#else:
#bbrbm.temp = 0.0
# show_digit(image_rec1[10:794].reshape(28, 28), "Reconstructed image T = 0 after i% iterations" % i)
# if (i == 100):
# show_digit(image_rec1[10:794].reshape(28, 28), "Reconstructed image T = 2 after 100 iterations" )
# print("temp is ", bbrbm.temp)
# bbrbm.temp = 100
#
if (i == range_idx-temp_chng_step):
print("temp is ", bbrbm.temp)
bbrbm.temp = 0
#show_digit(image_rec1[10:794].reshape(28, 28), "Reconstructed image T = 0 (just changed) after iterations" )
# if (i == 950):
# bbrbm.temp = 0.0
# show_digit(image_rec1[10:794].reshape(28, 28),
# "Reconstructed image T = 0.001 (just changed) after iterations")
#print("temp_idx is ", temp_idx)
#if (i == 150):
# show_digit(image_rec1[10:794].reshape(28, 28), "Reconstructed image T = 0.01 after 50 iterations")
# bbrbm.temp = 0.001
#if (i == 201):
# show_digit(image_rec1[10:794].reshape(28, 28), "Reconstructed image T = 0.001 after 50 iterations")
# bbrbm.temp = 2
# if (i == 250):
# show_digit(image_rec1[10:794].reshape(28, 28), "Reconstructed image T = 2.0 after 50 iterations")
# bbrbm.temp = 1.0
#if (i == 300):
# show_digit(image_rec1[10:794].reshape(28, 28), "Reconstructed image T = 1.0 after 50 iterations")
# bbrbm.temp = 0.0
#t1 = image_rec1[0:10]
rec_backup = image_rec1
#image_rec1 = image_rec1[10:794].reshape(28,28 )
#print("size ofa", a.size)
img= rec_backup#img_org + np.concatenate((t1, (image_rec1 * mask_c).flatten()), axis=0)
#show_digit(image_rec1[10:794].reshape(28, 28), "returned image")
#show_digit(img[10:794].reshape(28, 28), "image to be fed")
#print("temp is ",bbrbm.temp )
show_digit(rec_backup[10:794].reshape(28, 28), "reconstructed image" )
#show_digit(rec_backup[0:10].reshape(1, -1), "reconstructed label")
#max vote for the correct label
#print("index i : ", i)
a = 0
b = 0
reconst_err = True
#for jj in range(store_labels.shape[0]):
#print("label is ", store_labels[jj])
#a = a + store_labels[jj][]
##add rows of the store_recon_vu array##
#a = np.sum(store_recon_vu, axis=0)
#print("labels are ", store_labels)
#print("a is ", a)
#print("shape of labels is ", store_recon_vu.shape[1])
## calculate the majority vote such that if 51 of the iterations is "1" --> Vu = '1' , otherwise Vu = '0'
# for ii in range(store_recon_vu.shape[1]):
# if(a[ii] > num_avg/2):
# a[ii] = 1
#print("num avrg / 2 ", num_avg/2)
# else:
# a[ii] = 0
#show_digit(a[10:794].reshape(28, 28), "reconstructed image using VU majority vote")
## EXTRACT THE LABELS
#rec_labels = a[0:10]
#for ii in range(10):
# b = b + a[ii]
# if( b > 1): # the network can't decide which one is the number among more than one number ('1' in more than one pixel)
# reconst_err = False #set flag to indicate that
#print("RBM Confused ")
#print("a is ", a)
#print("labels are ", store_labels)
#else:
# reconst_err = True
#print("total addition of labels ", a)
#rect_label = np.where(rec_labels == 1)
#print the result of construction
#a1 = rec_backup[0:10]
a2 = mnist.train.labels[j]
a3 = np.where(a2 == True)
#print("org label position" , a2)
#print("recondtructed label (majority vote)", rect_label)
#if no error occured, increment accuracy if label is correctly reconstructed
#if (reconst_err):
# if(rect_label == a3[0]):
# accu[0] = accu[0] + 1
#print("accur value" , accu[0])
#print("org image label", mnist.train.labels[j])
#print("reconstructed image label", rec_backup[0:10])
#fig = plt.figure(figsize=(10, 10))
# setting values to rows and column variables
"""
rows = 2
columns = 1
fig.add_subplot(rows, columns, 2)
plt.imshow(img[10:794].reshape(28, 28)) # new_image.reshape(29,29)
plt.title("Reconstructed Image after %i Iterations" %i)
fig.add_subplot(rows, columns, 1)
plt.imshow(rec_backup[0:10].reshape(1, -1))
plt.title("Labels")
plt.locator_params(axis="x", nbins=10)
#save figure
plt.savefig(fname[j], dpi=None, facecolor='w', edgecolor='w',
orientation='portrait', papertype=None, format=None,
transparent=False, bbox_inches=None, pad_inches=0.1,
frameon=None, metadata=None)
# plt.show()
plt.close()
#plt.show()
"""
#print("j aka number of cases",j)
#print("accu ", accu)
#accuracy = accu[0]/n_data
#print("accuracy ",accuracy )
# -
| tfrbm/SA_new15.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# <img style="float: left;" src="earth-lab-logo-rgb.png" width="150" height="150" />
#
# # Earth Analytics Education - EA Python Course Spring 2021
# ## Important - Assignment Guidelines
#
# 1. Before you submit your assignment to GitHub, make sure to run the entire notebook with a fresh kernel. To do this first, **restart the kernel** (in the menubar, select Kernel$\rightarrow$Restart & Run All)
# 2. Always replace the `raise NotImplementedError()` code with your code that addresses the activity challenge. If you don't replace that code, your notebook will not run.
#
# ```
# # YOUR CODE HERE
# raise NotImplementedError()
# ```
#
# 3. Any open ended questions will have a "YOUR ANSWER HERE" within a markdown cell. Replace that text with your answer also formatted using Markdown.
# 4. **DO NOT RENAME THIS NOTEBOOK File!** If the file name changes, the autograder will not grade your assignment properly.
# 6. When you create a figure, comment out `plt.show()` to ensure the autograder can grade your plots. For figure cells, DO NOT DELETE the code that says `DO NOT REMOVE LINE BELOW`.
#
# ```
# ### DO NOT REMOVE LINE BELOW ###
# student_plot1_ax = nb.convert_axes(plt)
# ```
#
# * Only include the package imports, code, and outputs that are required to run your homework assignment.
# * Be sure that your code can be run on any operating system. This means that:
# 1. the data should be downloaded in the notebook to ensure it's reproducible
# 2. all paths should be created dynamically using the `os.path.join`
#
# ## Follow to PEP 8 Syntax Guidelines & Documentation
#
# * Run the `autopep8` tool on all cells prior to submitting (HINT: hit shift + the tool to run it on all cells at once!
# * Use clear and expressive names for variables.
# * Organize your code to support readability.
# * Check for code line length
# * Use comments and white space sparingly where it is needed
# * Make sure all python imports are at the top of your notebook and follow PEP 8 order conventions
# * Spell check your Notebook before submitting it.
#
# For all of the plots below, be sure to do the following:
#
# * Make sure each plot has a clear TITLE and, where appropriate, label the x and y axes. Be sure to include UNITS in your labels.
#
# ### Add Your Name Below
# **Your Name:** <NAME>
# <img style="float: left;" src="colored-bar.png"/>
# ---
# + [markdown] deletable=false editable=false nbgrader={"cell_type": "markdown", "checksum": "482b6a6fad5a6b7297cd1f14b52b28e1", "grade": false, "grade_id": "hw-instructions", "locked": true, "schema_version": 3, "solution": false, "task": false}
# # Week 04 and 05 Homework - Automate NDVI Workflow
#
# For this assignment, you will write code to generate a plot of the mean normalized difference vegetation index (NDVI) for two different sites in the United States across one year of data:
#
# * San Joaquin Experimental Range (SJER) in Southern California, United States
# * Harvard Forest (HARV) in the Northeastern United States
#
# The data that you will use for this week is available from **earthpy** using the following download:
#
# `et.data.get_data('ndvi-automation')`
#
# ## Assignment Goals
#
# Your goal in this assignment is to create the most efficient and concise workflow that you can that allows for:
#
# 1. The code to scale if you added new sites or more time periods to the analysis.
# 2. Someone else to understand your workflow.
# 3. The LEAST and most efficient (i.e. runs fast, minimize repetition) amount of code that completes the task.
#
# ### HINTS
#
# * Remove values outside of the landsat valid range of values as specified in the metadata, as needed.
# * Keep any output files SEPARATE FROM input files. Outputs should be created in an outputs directory that is created in the code (if needed) and/or tested for.
# * Use the functions that we demonstrated during class to make your workflow more efficient.
# * BONUS - if you chose - you can export your data as a csv file. You will get bonus points for doing this.
#
#
# ## Assignment Requirements
#
# Your submission to the GitHub repository should include:
# * This Jupyter Notebook file (.ipynb) with:
# * The code to create a plot of mean NDVI across a year for 2 NEON Field Sites:
# * NDVI on the x axis and formatted dates on the y for both NEON sites on one figure/axis object
# * The **data should be cleaned to remove the influence of clouds**. See the [earthdatascience website for an example of what your plot might look like with and without removal of clouds](https://www.earthdatascience.org/courses/earth-analytics-python/create-efficient-data-workflows/).
# * BONUS: Create one output `.csv` file that has 3 columns - NDVI, Date and Site Name - with values for SJER and HARV.
#
# Your notebook should:
# * Have *at least* 2 well documented and well named functions with docstrings.
# * Include a Markdown cell at the top of the notebook that outlines the overall workflow using pseudocode (i.e. plain language, not code)
# * Include additional Markdown cells throughout the notebook to describe:
# * the data that you used - and where it is from
# * how data are being processing
# * how the code is optimized to run fast and be more concise
# + [markdown] deletable=false editable=false nbgrader={"cell_type": "markdown", "checksum": "ca51bc48f62e7d3602d0567f742e1b15", "grade": false, "grade_id": "pseudo-code", "locked": true, "points": 15, "schema_version": 3, "solution": false, "task": true}
# # Replace this cell with your pseudocode for this workflow
#
# If you happen to be a diagram person a diagram is ok too
#
#
# -
# ## Maeve's workflow:
# * Import needed packages, set the working directory, and download the data with earthpy.
# * Define a variable for the values used for cloud masking right away because you'll need it throughout the script and it's nice to have at the top of your workflow so it gets called right away.
# * Pick a single scene from a single site and use it to figure out what you need to do to grab and then process the needed files (clipping, masking, etc).
# * Write functions to automate the step-by-step workflow you come up with (probably one to get the files and a separate one to crop, mask, and calculate ndvi). **Make sure you replace any specific variables/parameter names with generic ones so the functions work universally, and not just on a given part of the data.**
# * Test your functions on the single site again to make sure they work and return a reasonable/expected result.
# * Calculate mean ndvi from the cropped and masked ndvi.
# * Pull the date and site name from the file name/directory path and store those in a list with the mean ndvi values.
# * Convert the list to a dataframe and reset the index to the date column.
# * Write a series of nested loops using your functions to automate through *all* of the data in the directories.
# * The outermost loop should cycle through sites (make it generic enough - we only have two in this case but it could be adapted to loop through more sites if the data were available).
# * The crop boundary and pixel qa files should probably be selected in this outer loop, so that those steps aren't repeated for each scene and only change from site to site.
# * Nest a second loop within the outer loop to loop through each scene file within the sites directories. This loop should apply the functions you wrote, calculate mean ndvi, pull scene date from the file or directory name, and then compile site name, date, and mean ndvi in a list.
# * You may need more than one inner loop, but I think just the two nested ones are enough.
# * Outside the loops, convert the list of ndvi and other attributes to a dataframe, as you did for the single site above. Remember to format the date and reset the index to the date column.
# * Plot mean ndvi vs date using the dataframe object you generated with the loop!
# + deletable=false editable=false nbgrader={"cell_type": "code", "checksum": "9c7cd3e2e5089092e06ba301f2719a63", "grade": false, "grade_id": "core-imports", "locked": true, "schema_version": 3, "solution": false, "task": false}
# Autograding imports - do not modify this cell
import matplotcheck.autograde as ag
import matplotcheck.notebook as nb
import matplotcheck.timeseries as ts
from datetime import datetime
# + deletable=false nbgrader={"cell_type": "code", "checksum": "3c4d1141999885a9a9b09772962b180a", "grade": true, "grade_id": "student-imports-answer", "locked": false, "points": 10, "schema_version": 3, "solution": true, "task": false} tags=["hide", "hide_output"]
# Import needed packages in PEP 8 order
# and no unused imports listed (10 points total)
import os
from glob import glob
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
from matplotlib.dates import DateFormatter
from matplotlib.axes._axes import _log as matplotlib_axes_logger
import numpy as np
import pandas as pd
import rasterio as rio
import rioxarray as rxr
import xarray as xr
import earthpy as et
import geopandas as gpd
import seaborn as sns
import warnings
# Prettier plotting with seaborn
sns.set_style('white')
sns.set(font_scale=1.5)
# Suppress a warning about nan values in the ndvi calculation
warnings.simplefilter('ignore')
# Download the necessary data using earthpy
et.data.get_data('ndvi-automation')
# Define a variable for the working directory path.
wd_path = os.path.join(et.io.HOME,
"earth-analytics",
"data")
# Set the working directory or make the directory if it does not already exist.
if os.path.exists(wd_path):
os.chdir(wd_path)
print("The current working directory is", wd_path)
else:
os.makedirs(wd_path)
os.chdir(wd_path)
print("The path does not exist but is being created")
# + deletable=false editable=false hideCode=false hidePrompt=false nbgrader={"cell_type": "code", "checksum": "dcf5b59326bf066172ff61520b658a3d", "grade": true, "grade_id": "student-download-tests", "locked": true, "points": 0, "schema_version": 3, "solution": false, "task": false}
# DO NOT MODIFY THIS CELL
# Tests that the working directory is set to earth-analytics/data
path = os.path.normpath(os.getcwd())
student_wd_parts = path.split(os.sep)
if student_wd_parts[-2:] == ['earth-analytics', 'data']:
print("\u2705 Great - it looks like your working directory is set correctly to ~/earth-analytics/data")
else:
print("\u274C Oops, the autograder will not run unless your working directory is set to earth-analytics/data")
# + [markdown] deletable=false editable=false nbgrader={"cell_type": "markdown", "checksum": "35205d12dc9e8fa05a26fb927c0a2307", "grade": false, "grade_id": "ndvi-mean-site-instructions", "locked": true, "schema_version": 3, "solution": false, "task": false}
# # Figure 1: Plot 1 - Mean NDVI For Each Site Across the Year (50 points)
#
# Create a plot of the mean normalized difference vegetation index (NDVI) for the two different sites in the United States across the year:
#
# * NDVI on the x axis and formatted dates on the y for both NEON sites on one figure/axis object.
# * Each site should be identified with a different color in the plot and legend.
# * The final plot **data should be cleaned to remove the influence of clouds**.
# * Be sure to include appropriate title and axes labels.
#
# Add additional cells as needed for processing data (e.g. defining functions, etc), but be sure to:
# * follow the instructions in the code cells that have been provided to ensure that you are able to use the sanity check tests that are provided.
# * include only the plot code in the cell identified for the final plot code below
# + [markdown] deletable=false editable=false nbgrader={"cell_type": "markdown", "checksum": "ce17d4d685cd4c7034bd7b0bb389342a", "grade": false, "grade_id": "single-scene-instructions", "locked": true, "schema_version": 3, "solution": false, "task": false}
# ## Task 1:
#
# In the cell below, create a single dataframe containing MEAN NDVI, the site name,
# and the date of the data for the HARV site
# scene `HARV/landsat-crop/LC080130302017031701T1-SC20181023151837`. The column names for the final
# DataFrame should be`mean_ndvi`, and `site`, and the data should be **indexed on the date**.
#
# Use the functions that we reviewed in class (or create your own versions of them) to implement your code
#
# ### In the Cell below Place All Functions Needed to Run this Notebook (20 points)
# + deletable=false editable=false nbgrader={"cell_type": "code", "checksum": "0ee340cd9af6c949a08eb4b325716ae0", "grade": false, "grade_id": "cell-618e3588853f3ed8", "locked": true, "schema_version": 3, "solution": false, "task": false}
### DO NOT REMOVE THIS LINE OR EDIT / MOVE THIS CELL ###
start_time = datetime.now()
# + deletable=false nbgrader={"cell_type": "code", "checksum": "653ebd5db668245408615979f6c20944", "grade": true, "grade_id": "function-definitions-check", "locked": false, "points": 40, "schema_version": 3, "solution": true, "task": false}
# In this cell place all of the functions needed to run your notebook
# You will be graded here on function application, docstrings, efficiency so ensure
# All functions are placed here!
def get_bands(band_directory, valid_range=None):
"""Get a sorted list of paths to the files containing landsat bands 4 and 5
and open the files as xarray objects.
Parameters
----------
band_directory : string
A string describing the file directory containing the landsat bands.
valid_range : tuple (optional)
A tuple containing the valid range (min and max) of expected values
(default input is none).
Returns
----------
all_bands : list
A list of two xarray DataArray objects, one for each landsat band.
"""
# Get a list of bands 4 and 5
band_paths = sorted(glob(os.path.join(band_directory,
"*band*[4-5].tif")))
# Open the bands, mask for valid values, and append them to a list
all_bands = []
for path in band_paths:
a_band = rxr.open_rasterio(path, masked=True).squeeze()
if valid_range is not None:
mask = ((a_band < valid_range[0]) | (a_band > valid_range[1]))
a_band = a_band.where(~xr.where(mask, True, False))
all_bands.append(a_band)
return all_bands
def mask_crop_ndvi(all_bands,
crop_bound,
pixel_qa,
vals):
"""Calculate normalized difference vegetation index (NDVI) from the
provided landsat bands. Clip the output NDVI layer and the given
pixel qa layer to the boundary specified by the crop_bound file. Use the
cropped pixel qa layer and vals to apply a cloud mask to the cropped NDVI.
Save the cropped and masked NDVI layer as an xarray.
Parameters
-----------
all_bands : list
A list containing the xarray objects for landsat bands 4 and 5.
crop_bound: geopandas GeoDataFrame
A geopandas dataframe to be used to crop the raster data using
rasterio mask().
pixel_qa: xarray DataArray
An xarray DataArray with pixel qa values that have not yet been turned
into a mask (0s and 1s).
vals: list
A list of values needed to create the cloud mask.
Returns
-----------
ndvi_crop : xarray DataArray
A cropped and masked xarray object containing NDVI values.
"""
crop_json = crop_bound.geometry
# Clip pixel qa cloud mask layer
cl_mask_crop = pixel_qa.rio.clip(crop_json)
# Calculate NDVI
ndvi_xr = (all_bands[1]-all_bands[0]) / (all_bands[1]+all_bands[0])
# Clip NDVI layer
ndvi_crop = ndvi_xr.rio.clip(crop_json)
# Apply cloud mask to NDVI
ndvi_crop = ndvi_crop.where(~cl_mask_crop.isin(vals))
return ndvi_crop
# -
# ##### Reminders from instructor comments
# ` Important: to use the ungraded tests below as a sanity check, name your columns: mean_ndvi and site
# Call the dataframe at the end of the cell so the tests run on it!
# Be sure that the date column is an index of type date
# HINT: the time series lessons may help you remember how to do this!`
#
# ### Preliminary Setup
# The following cell contains code that defines variables for the directories that will be looped through later in the workflow. The code also defines a list of vaules used for cloud masking.
# +
# Define site paths
sites_path = os.path.join("ndvi-automation", "sites")
all_sites = sorted(glob(os.path.join(sites_path, '*/')))
# Name a variable for the folder containing landsat files
landsat_dir = "landsat-crop"
# List the cloud no data vals for Landsat 8:
vals = [328, 392, 840, 904, 1350, 352, 368, 416,
432, 480, 864, 880, 928, 944, 992, 480, 992]
# Specify a valid range of landsat values:
valid_range = (0, 10000)
# -
# #### Single HARV scene setup
# The following cell defines the directory for the specific HARV scene we've been asked to analyze. It also pulls the site name and the date from the directory and navigates to and opens the qa layer and crop layer.
# +
# File path to single scene
harv_single_path = os.path.join(sites_path,
"HARV",
"landsat-crop",
"LC080130302017031701T1-SC20181023151837")
# Get site name and date from directory name
dir_name = os.path.basename(os.path.normpath(harv_single_path))
date = dir_name[10:18]
site_name = os.path.basename(os.path.normpath(all_sites[0]))
# Open scene qa and site boundary files
harv_single_qa_path = glob(os.path.join(harv_single_path,
"*qa*"))
qa_layer = rxr.open_rasterio(harv_single_qa_path[0], masked=True).squeeze()
boundary_path = os.path.join(sites_path,
site_name,
"vector",
site_name + "-crop.shp")
boundary = gpd.read_file(boundary_path)
# -
# #### Single site workflow
# + deletable=false nbgrader={"cell_type": "code", "checksum": "d124eef1d9cf2d0063ab450c9a20dc8e", "grade": false, "grade_id": "single-scene-answer", "locked": false, "schema_version": 3, "solution": true, "task": false} tags=["hide"]
# Create dataframe of mean NDVI in this cell using the functions created above
# Get bands then crop, mask, and calculate ndvi
all_bands = get_bands(harv_single_path, valid_range)
ndvi_value = mask_crop_ndvi(all_bands,
boundary,
qa_layer,
vals)
# Calculate mean ndvi
ndvi_mean = np.nanmean(ndvi_value)
# Capture the mean ndvi, site name, and date in a list
ndvi_list = []
ndvi_list.append([site_name, date, ndvi_mean])
# Convert the NDVI list generated above to a dataframe and rename the columns.
harv_single_mean_ndvi = pd.DataFrame(ndvi_list,
columns=["site", "date", "mean_ndvi"])
harv_single_mean_ndvi['date'] = pd.to_datetime(harv_single_mean_ndvi['date'],
format='%Y%m%d')
harv_single_mean_ndvi = harv_single_mean_ndvi.set_index(['date'])
harv_single_mean_ndvi
# + deletable=false editable=false nbgrader={"cell_type": "code", "checksum": "6121e3a0293ed64f09521b5d248496c3", "grade": true, "grade_id": "single-scene-tests", "locked": true, "points": 15, "schema_version": 3, "solution": false, "task": false}
# This cell is testing your data output above
student_ndvi_ts_single_site = _
single_scene_points = 0
# Ensure the data is stored in a dataframe.
if isinstance(student_ndvi_ts_single_site, pd.DataFrame):
print('\u2705 Your data is stored in a DataFrame!')
single_scene_points += 1
else:
print('\u274C It appears your data is not stored in a DataFrame. ',
'To see what type of object your data is stored in, check its type with type(object)')
# Ensure that the date column is the index
if isinstance(student_ndvi_ts_single_site.index, pd.core.indexes.datetimes.DatetimeIndex):
print('\u2705 You have the index set to the date column!')
single_scene_points += 2
else:
print('\u274C You do not have the index set to the date column.')
# Ensure that the date column is datetime
if isinstance(student_ndvi_ts_single_site.index[0], pd._libs.tslibs.timestamps.Timestamp):
print('\u2705 The data in your date column is datetime!')
single_scene_points += 2
else:
print('\u274C The data in your date column is not datetime.')
# Ensure the site name is correct
if student_ndvi_ts_single_site.site.values[0] == 'HARV':
print('\u2705 You have the correct site name!')
single_scene_points += 5
else:
print('\u274C You do not have the correct site name.')
if np.allclose(0.281131628228094, student_ndvi_ts_single_site.mean_ndvi.values[0]):
print('\u2705 You have the correct mean NDVI value!')
single_scene_points += 5
else:
print('\u274C You do not have the correct mean ndvi value.')
print("\n \u27A1 You received {} out of 15 points for creating a dataframe.".format(
single_scene_points))
single_scene_points
# -
# ## Task 2:
#
# In the cell below, process all of the landsat scenes. Create a DataFrame that contains the following
# information for each scene
#
#
# | | index | site | mean_ndvi |
# |---|---|---|---|
# | Date | | | |
# | 2017-01-07 | 0 | SJER | .4 |
#
# Be sure to call your dataframe at the end of the cell to ensure autograding works.
# HINT: FOR THIS STEP, leave any rows containing missing values (`NAN`).
# +
# Loop through all directories and apply the functions you wrote.
''' This loop contains optional 'print' statements to help track progress.
They are flagged with '# OPTIONAL PRINT' at the end of the line.
Uncomment the ones you wish to use.'''
# Create an empty list for storing ndvi values.
ndvi_list = []
# Loop through each site directory.
for site_files in all_sites:
#print("I am looping through", site_files) # OPTIONAL PRINT
a_site = os.path.split(os.path.normpath(site_files))[1]
print("I am working on the", a_site, "field site now.")
# Get the boundary shapefile for clipping from the vector directory.
vector_dir = os.path.join(site_files, "vector")
boundary_path = os.path.join(vector_dir, a_site + "-crop.shp")
boundary = gpd.read_file(boundary_path)
#print("The current boundary path is", boundary_path) # OPTIONAL PRINT
# Get a list of subdirectories for the current site.
new_path = os.path.join(site_files, landsat_dir)
all_dirs = sorted(glob(os.path.join(new_path, "*/")))
# Loop through each subdirectory where your data are stored.
for a_dir in all_dirs:
#print("Now processing", a_dir) # OPTIONAL PRINT
# Get the date from the directory name
dir_name = os.path.basename(os.path.normpath(a_dir))
date = dir_name[10:18]
# Get cloud mask layer (qa file)
qa_path = glob(os.path.join(a_dir, "*qa*"))
qa_layer = rxr.open_rasterio(qa_path[0], masked=True).squeeze()
# Get landsat bands 4 and 5, crop and mask them, and calculate ndvi
all_bands = get_bands(a_dir, valid_range)
ndvi_value = mask_crop_ndvi(all_bands,
boundary,
qa_layer,
vals)
# Calculate mean NDVI
ndvi_mean = np.nanmean(ndvi_value)
# Capture the site name, and date in a list
ndvi_list.append([a_site, date, ndvi_mean])
print("Processing complete.")
# + deletable=false nbgrader={"cell_type": "code", "checksum": "848dd486333246e15b6b8f0dff745a4b", "grade": false, "grade_id": "cleaned_dataframes_answer", "locked": false, "schema_version": 3, "solution": true, "task": false} tags=["hide"]
# Create dataframe of NDVI including the cleaning data to deal with clouds
# Convert the NDVI list generated above to a dataframe and rename the columns.
mean_ndvi = pd.DataFrame(ndvi_list,
columns=["site", "date", "mean_ndvi"])
mean_ndvi['date'] = pd.to_datetime(mean_ndvi['date'], format='%Y%m%d')
mean_ndvi.reset_index(inplace=True)
mean_ndvi.set_index(['date'], inplace=True)
mean_ndvi
# + deletable=false editable=false nbgrader={"cell_type": "code", "checksum": "1ce5d7d7519d5e569e6cf7c5927c6ffb", "grade": true, "grade_id": "cleaned_dataframes_test", "locked": true, "points": 10, "schema_version": 3, "solution": false, "task": false}
# Last sanity check before creating your plot (10 points)
# Ensure that you call your dataframe at the bottom of the cell above
# and that it has columns called: mean_ndvi and site
# Ensure the data is stored in a dataframe.
student_ndvi_df = _
df_points = 0
if isinstance(student_ndvi_df, pd.DataFrame):
print('\u2705 Your data is stored in a DataFrame!')
df_points += 2
else:
print('\u274C It appears your data is not stored in a DataFrame. ',
'To see what type of object your data is stored in, check its type with type(object)')
# Check that dataframe contains the appropriate number of NAN values
if student_ndvi_df.mean_ndvi.isna().sum() == 15:
print('\u2705 Correct number of masked data values!')
df_points += 2
else:
print('\u274C The amount of null data in your dataframe is incorrect.')
# Ensure that the date column is the index
if isinstance(student_ndvi_df.index, pd.core.indexes.datetimes.DatetimeIndex):
print('\u2705 You have the index set to the date column!')
df_points += 3
else:
print('\u274C You do not have the index set to the date column.')
# Ensure that the date column is datetime
if isinstance(student_ndvi_df.index[0], pd._libs.tslibs.timestamps.Timestamp):
print('\u2705 The data in your date column is datetime!')
df_points += 3
else:
print('\u274C The data in your date column is not datetime.')
# Output for timer, # DO NOT MODIFY
end_time = datetime.now()
total_time = end_time - start_time
print(
"Your total run time for processing the data was {0}.".format(total_time))
print("\n \u27A1 You received {} out of 10 points for creating a dataframe.".format(
df_points))
df_points
# + caption="Plot showing NDVI for each time period at both NEON Sites. In this example the cloudy pixels were removed using the pixel_qa cloud mask. Notice that this makes a significant different in the output values. Why do you think this difference is so significant?" deletable=false nbgrader={"cell_type": "code", "checksum": "f9d5ebf0557e366fa6f1727fd85a7e45", "grade": false, "grade_id": "plot_cleaned_dataframes_answer", "locked": false, "schema_version": 3, "solution": true, "task": false} tags=["hide"]
# Plot mean NDVI for both sites across the year.
fig1, ax1 = plt.subplots(figsize=(14, 10))
# Group the data by site
ndvi_site_gr = mean_ndvi.dropna().groupby('site')
for site, group in ndvi_site_gr:
ax1.plot(group.index.values,
group['mean_ndvi'].values,
label=site,
marker='o')
# Format plot axes and title
ax1.set(xlabel='Date',
ylabel='Mean NDVI Value',
title='Mean Normalized Difference Vegetation Index (NDVI)\n for the HARV and SJER NEON sites, 2017')
ax1.legend()
# Define date format
date_form = DateFormatter("%b-%d")
ax1.xaxis.set_major_formatter(date_form)
### DO NOT REMOVE LINES BELOW ###
final_masked_solution = nb.convert_axes(plt, which_axes="current")
# + deletable=false editable=false nbgrader={"cell_type": "code", "checksum": "d2bc7d91b553a74e6382776fface9c70", "grade": true, "grade_id": "plot_cleaned_dataframes_test_answers", "locked": true, "points": 0, "schema_version": 3, "solution": false, "task": false}
# Ignore this cell for the autograding tests
# + deletable=false editable=false nbgrader={"cell_type": "code", "checksum": "23a1c68916e304be754ea15d9495e781", "grade": true, "grade_id": "plot_cleaned_dataframes_tests", "locked": true, "points": 50, "schema_version": 3, "solution": false, "task": false}
# Ignore this cell for the autograding tests
# + [markdown] deletable=false editable=false nbgrader={"cell_type": "markdown", "checksum": "c660ce8da16752276c4b16e35c7d2726", "grade": false, "grade_id": "question-1", "locked": true, "schema_version": 3, "solution": false, "task": false}
# # Question 1 (10 points)
#
# Imagine that you are planning NEON’s upcoming flight season to capture remote sensing data in these locations and want to ensure that you fly the area when the vegetation is the most green.
#
# When would you recommend the flights take place for each site?
#
# Answer the question in 2-3 sentences in the Markdown cell below.
# + [markdown] deletable=false nbgrader={"cell_type": "markdown", "checksum": "26a85257b913135d401b6dc4fd2a4fc3", "grade": true, "grade_id": "question-1-answer", "locked": false, "points": 10, "schema_version": 3, "solution": true, "task": false}
# The San Joaquin Experimental Range is located near Fresno, CA, an area with a Mediterranean climate. The open oak woodland typically reaches peak greenness in early March. Harvard Forest (near Boston, MA) is a northern hardwood and coniferous forest in a relatively cool and temperate climate. However, warming temperatures have resulted in an earlier onset of spring weather patterns, and average peak greenness at this location is now also reached by early March. In order to ideally capture peak greenness conditions, NEON flights for these sites would occur the first or second week of March.
# + [markdown] deletable=false editable=false nbgrader={"cell_type": "markdown", "checksum": "603922a2076d0940962432ebc5069ef9", "grade": false, "grade_id": "question-2", "locked": true, "schema_version": 3, "solution": false, "task": false}
# # Question 2 (10 points)
#
# How could you modify your workflow to look at vegetation changes over time in each site?
#
# Answer the question in 2-3 sentences in the Markdown cell below.
# + [markdown] deletable=false nbgrader={"cell_type": "markdown", "checksum": "f4ae5b1f3a47c9bf44714a2de486da54", "grade": true, "grade_id": "question-2-answer", "locked": false, "points": 10, "schema_version": 3, "solution": true, "task": false}
# In order to look at changes in vegetation over time, I'd first obtain landsat data from an additional year. I'd process the data the same way those from 2017 were in this workflow, and then additionally calculate a difference in mean ndvi from year to year. The difference operation could probably be added to the end of the multi-site processing loop.
# + [markdown] deletable=false editable=false nbgrader={"cell_type": "markdown", "checksum": "df53001e9821bf3baef478a3b29bde33", "grade": false, "grade_id": "additional-markdown-cell-check", "locked": true, "points": 10, "schema_version": 3, "solution": false, "task": true}
# # Do not edit this cell! (10 points)
#
# The notebook includes:
# * additional Markdown cells throughout the notebook to describe:
# * the data that you used - and where it is from
# * how data are being processing
# * how the code is optimized to run fast and be more concise
# + [markdown] deletable=false editable=false nbgrader={"cell_type": "markdown", "checksum": "bcc0e446306a9db445d1ab243227c563", "grade": false, "grade_id": "pep8-formatting-check", "locked": true, "points": 30, "schema_version": 3, "solution": false, "task": true}
# # Do not edit this cell! (20 points)
#
# The notebook will also be checked for overall clean code requirements as specified at the **top** of this notebook. Some of these requirements include (review the top cells for more specifics):
#
# * Notebook begins at cell [1] and runs on any machine in its entirety.
# * PEP 8 format is applied throughout (including lengths of comment and code lines).
# * No additional code or imports in the notebook that is not needed for the workflow.
# * Notebook is fully reproducible. This means:
# * reproducible paths using the os module.
# * data downloaded using code in the notebook.
# * all imports at top of notebook.
# + [markdown] deletable=false editable=false nbgrader={"cell_type": "markdown", "checksum": "67969627ed2d8a81a168d0ed1831224d", "grade": false, "grade_id": "cell-bf1766fe2443b94a", "locked": true, "points": 0, "schema_version": 3, "solution": false, "task": true}
# ## BONUS - Export a .CSV File to Share (10 points possible)
#
# This is optional - if you export a **.csv** file with the columns specified above: Site, Date and NDVI Value you can get an additional 10 points.
#
# * FULL CREDIT: File exists in csv format and contains the columns specified.
# We will check your github repo for this file!
#
| ea-2021-04-ndvi-automation-mccormick.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# ## 第0讲 模板
# ### Problem 问题描述
#
# ### Math Background 数学背景
#
# 1.
# + [markdown] heading_collapsed=true
# ### Prerequisites 预备知识
# -
#
# ### Solution 编程求解
#
# ### Summary 知识点小结
# 1. 阿第三方
# 2. 阿第三方
# + hidden=true
# + hidden=true
# -
# ### 计算机小知识
# 暂缺
# + [markdown] heading_collapsed=true
# ### Assignments 作业
# + [markdown] hidden=true
# 1. The length and width of a rectangle are 18cm and 13cm respectively. What the perimeter and the area of this rectangle? write only two lines of codes to provide the answer directly, and an extra line of code to print out the result like the follow sentence:
# + hidden=true
| source/2022/NotOnline/000_Lecture_Template.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# ## This assignment
#
# In this assignment, you'll learn (or review):
#
# * How to set up Jupyter on your own computer.
# * Python basics, like defining functions.
# * How to use the `numpy` library to compute with arrays of numbers.
# # 2. Python
#
# Python is the main programming language we'll use in this course. We assume you have some experience with Python or can learn it yourself, but here is a brief review.
#
# Below are some simple Python code fragments.
#
# You should feel confident explaining what each fragment is doing. If not,
# please brush up on your Python. There a number of tutorials online (search
# for "Python tutorial"). https://docs.python.org/3/tutorial/ is a good place to
# start.
2 + 2
# This is a comment.
# In Python, the ** operator performs exponentiation.
import math
math.e**(-2)
print("Hello" + ",", "world!")
"Hello, cell output!"
def add2(x):
"""This docstring explains what this function does: it adds 2 to a number."""
return x + 2
# +
def makeAdder(amount):
"""Make a function that adds the given amount to a number."""
def addAmount(x):
return x + amount
return addAmount
add3 = makeAdder(3)
add3(4)
# -
# add4 is very similar to add2, but it's been created using a lambda expression.
add4 = lambda x: x + 4
add4(5)
sameAsMakeAdder = lambda amount: lambda x: x + amount
add5 = sameAsMakeAdder(5)
add5(6)
# +
def fib(n):
if n <= 1:
return 1
# Functions can call themselves recursively.
return fib(n-1) + fib(n-2)
fib(4)
# -
# A for loop repeats a block of code once for each
# element in a given collection.
for i in range(5):
if i % 2 == 0:
print(2**i)
else:
print("Odd power of 2")
# A list comprehension is a convenient way to apply a function
# to each element in a given collection.
# The String method join appends together all its arguments
# separated by the given string. So we append each element produced
# by the list comprehension, each separated by a newline ("\n").
print("\n".join([str(2**i) if i % 2 == 0 else "Odd power of 2" for i in range(5)]))
# #### Question 1
#
# ##### Question 1a
# Write a function nums_reversed that takes in an integer `n` and returns a string
# containing the numbers 1 through `n` including `n` in reverse order, separated
# by spaces. For example:
#
# >>> nums_reversed(5)
# '5 4 3 2 1'
#
# ***Note:*** The ellipsis (`...`) indicates something you should fill in. It *doesn't* necessarily imply you should replace it with only one line of code.
# +
def nums_reversed(n):
lst1 = list(range(n + 1))
lst2 = lst1[1:]
lst3 = lst2[::-1]
print(lst3)
nums_reversed(4)
# -
_ = ok.grade('q01a')
_ = ok.backup()
# ##### Question 1b
#
# Write a function `string_splosion` that takes in a non-empty string like
# `"Code"` and returns a long string containing every prefix of the input.
# For example:
#
# >>> string_splosion('Code')
# 'CCoCodCode'
# >>> string_splosion('data!')
# 'ddadatdatadata!'
# >>> string_splosion('hi')
# 'hhi'
#
# + for_assignment_type="student"
def string_splosion(string):
ans = ''
for i in range(len(string)):
ans = ans + string[:(i+1)]
return ans
string_splosion('data!')
# -
_ = ok.grade('q01b')
_ = ok.backup()
# ##### Question 1c
#
# Write a function `double100` that takes in a list of integers
# and returns `True` only if the list has two `100`s next to each other.
#
# >>> double100([100, 2, 3, 100])
# False
# >>> double100([2, 3, 100, 100, 5])
# True
#
# + for_assignment_type="student"
def double100(nums):
if 100 in nums:
first = nums.index(100)
if nums[first + 1] == 100:
return True
else:
return False
double100([2, 3, 100, 100, 5])
# -
_ = ok.grade('q01c')
_ = ok.backup()
# ##### Question 1d
#
# Write a function `median` that takes in a list of numbers
# and returns the median element of the list. If the list has even
# length, it returns the mean of the two elements in the middle.
#
# >>> median([5, 4, 3, 2, 1])
# 3
# >>> median([ 40, 30, 10, 20 ])
# 25
# + for_assignment_type="student"
def median(number_list):
half = len(number_list) // 2
if len(number_list) % 2 == 0:
right = number_list[half]
left = number_list[half - 1]
return (right + left) / 2
else:
return number_list[half]
median([ 40, 30, 10, 20 ])
# -
_ = ok.grade('q01d')
_ = ok.backup()
# # 3. `NumPy`
#
# The `NumPy` library lets us do fast, simple computing with numbers in Python.
# ## 3.1. Arrays
#
# The basic `NumPy` data type is the array, a homogeneously-typed sequential collection (a list of things that all have the same type). Arrays will most often contain strings, numbers, or other arrays.
# Let's create some arrays:
# +
import numpy as np
array1 = np.array([2, 3, 4, 5])
array2 = np.arange(4)
array1, array2
# -
# Math operations on arrays happen *element-wise*. Here's what we mean:
array1 * 2
array1 * array2
array1 ** array2
# This is not only very convenient (fewer `for` loops!) but also fast. `NumPy` is designed to run operations on arrays much faster than equivalent Python code on lists. Data science sometimes involves working with large datasets where speed is important - even the constant factors!
# **Jupyter pro-tip**: Pull up the docs for any function in Jupyter by running a cell with
# the function name and a `?` at the end:
# +
# np.arange?
# -
# **Another Jupyter pro-tip**: Pull up the docs for any function in Jupyter by typing the function
# name, then `<Shift>-<Tab>` on your keyboard. Super convenient when you forget the order
# of the arguments to a function. You can press `<Tab>` multiple tabs to expand the docs.
#
# Try it on the function below:
np.linspace
# #### Question 2
# Using the `np.linspace` function, create an array called `xs` that contains
# 100 evenly spaced points between `0` and `2 * np.pi`. Then, create an array called `ys` that
# contains the value of $ \sin{x} $ at each of those 100 points.
#
# *Hint:* Use the `np.sin` function. You should be able to define each variable with one line of code.)
xs = np.linspace(0, 2 * np.pi)
ys = np.sin(np.linspace(0, 2 * np.pi))
_ = ok.grade('q02')
_ = ok.backup()
# The `plt.plot` function from another library called `matplotlib` lets us make plots. It takes in
# an array of x-values and a corresponding array of y-values. It makes a scatter plot of the (x, y) pairs and connects points with line segments. If you give it enough points, it will appear to create a smooth curve.
#
# Let's plot the points you calculated in the previous question:
# +
import matplotlib.pyplot as plt
plt.plot(xs, ys);
# -
# This is a useful recipe for plotting any function:
# 1. Use `linspace` or `arange` to make a range of x-values.
# 2. Apply the function to each point to produce y-values.
# 3. Plot the points.
# You might remember from calculus that the derivative of the `sin` function is the `cos` function. That means that the slope of the curve you plotted above at any point `xs[i]` is given by `cos(xs[i])`. You can try verifying this by plotting `cos` in the next cell.
# +
yc = np.cos(np.linspace(0, 2 * np.pi))
plt.plot(xs, yc);
# -
# Calculating derivatives is an important operation in data science, but it can be difficult. We can have computers do it for us using a simple idea called *numerical differentiation*.
#
# Consider the `i`th point `(xs[i], ys[i])`. The slope of `sin` at `xs[i]` is roughly the slope of the line connecting `(xs[i], ys[i])` to the nearby point `(xs[i+1], ys[i+1])`. That slope is:
#
# (ys[i+1] - ys[i]) / (xs[i+1] - xs[i])
#
# If the difference between `xs[i+1]` and `xs[i]` were infinitessimal, we'd have exactly the derivative. In numerical differentiation we take advantage of the fact that it's often good enough to use "really small" differences instead.
# #### Question 3
#
# Define a function called `derivative` that takes in an array of x-values and their
# corresponding y-values and computes the slope of the line connecting each point to the next point.
#
# >>> derivative(np.array([0, 1, 2]), np.array([2, 4, 6]))
# np.array([2., 2.])
# >>> derivative(np.arange(5), np.arange(5) ** 2)
# np.array([0., 2., 4., 6.])
#
# Notice that the output array has one less element than the inputs since we can't
# find the slope for the last point.
#
# It's possible to do this in one short line using [slicing](http://pythoncentral.io/how-to-slice-listsarrays-and-tuples-in-python/), but feel free to use whatever method you know.
#
# **Then**, use your `derivative` function to compute the slopes for each point in `xs`, `ys`.
# Store the slopes in an array called `slopes`.
# +
def derivative(xvals, yvals):
y_dim = np.diff(yvals)
x_dim = np.diff(xvals)
slopes = y_dim / x_dim
return slopes
slopes = derivative(xs, ys)
derivative(np.array([0, 1, 2]), np.array([2, 4, 6]))
# -
_ = ok.grade('q03')
_ = ok.backup()
# #### Question 4
# Plot the slopes you computed. Then plot `cos` on top of your plot, calling `plt.plot` again in the same cell. Did numerical differentiation work?
#
# *Note:* Since we have only 99 slopes, you'll need to take off the last x-value before plotting to avoid an error.
plt.plot(xs[:-1], slopes);
plt.plot(xs, yc);
# In the plot above, it's probably not clear which curve is which. Examine the cell below to see how to plot your results with a legend.
plt.plot(xs[:-1], slopes, label="Numerical derivative")
plt.plot(xs[:-1], np.cos(xs[:-1]), label="True derivative")
# You can just call plt.legend(), but the legend will cover up
# some of the graph. Use bbox_to_anchor=(x,y) to set the x-
# and y-coordinates of the center-left point of the legend,
# where, for example, (0, 0) is the bottom-left of the graph
# and (1, .5) is all the way to the right and halfway up.
plt.legend(bbox_to_anchor=(1, .5), loc="center left");
# ## 3.2. Multidimensional Arrays
# A multidimensional array is a primitive version of a table, containing only one kind of data and having no column labels. A 2-dimensional array is useful for working with *matrices* of numbers.
# The zeros function creates an array with the given shape.
# For a 2-dimensional array like this one, the first
# coordinate says how far the array goes *down*, and the
# second says how far it goes *right*.
array3 = np.zeros((4, 5))
array3
# The shape attribute returns the dimensions of the array.
array3.shape
# You can think of array3 as an array containing 4 arrays, each
# containing 5 zeros. Accordingly, we can set or get the third
# element of the second array in array 3 using standard Python
# array indexing syntax twice:
array3[1][2] = 7
array3
# This comes up so often that there is special syntax provided
# for it. The comma syntax is equivalent to using multiple
# brackets:
array3[1, 2] = 8
array3
# Arrays allow you to assign to multiple places at once. The special character `:` means "everything."
array4 = np.zeros((3, 5))
array4[:, 2] = 5
array4
# In fact, you can use arrays of indices to assign to multiple places. Study the next example and make sure you understand how it works.
# +
array5 = np.zeros((3, 5))
rows = np.array([1, 0, 2])
cols = np.array([3, 1, 4])
# Indices (1,3), (0,1), and (2,4) will be set.
array5[rows, cols] = 3
array5
# -
# #### Question 5
# Create a 50x50 array called `twice_identity` that contains all zeros except on the
# diagonal, where it contains the value `2`.
#
# Start by making a 50x50 array of all zeros, then set the values. Use indexing, not a `for` loop! (Don't use `np.eye` either, though you might find that function useful later.)
# + for_assignment_type="student"
twice_identity = np.identity(50) * 2
twice_identity
# -
_ = ok.grade('q05')
_ = ok.backup()
# # 4. A Picture Puzzle
# Your boss has given you some strange text files. He says they're images,
# some of which depict a summer scene and the rest a winter scene.
#
# He demands that you figure out how to determine whether a given
# text file represents a summer scene or a winter scene.
#
# You receive 10 files, `1.txt` through `10.txt`. Peek at the files in a text
# editor of your choice.
# #### Question 6
# How do you think the contents of the file are structured? Take your best guess.
# **Much like the MNIST dataset, these files are probably structured as pixels where the data represents a greyscale value or the level to which each pixel is dark or has color.**
# #### Question 7
# Create a function called `read_file_lines` that takes in a filename as its argument.
# This function should return a Python list containing the lines of the
# file as strings. That is, if `1.txt` contains:
#
# ```
# 1 2 3
# 3 4 5
# 7 8 9
# ```
#
# the return value should be: `['1 2 3\n', '3 4 5\n', '7 8 9\n']`.
#
# **Then**, use the `read_file_lines` function on the file `1.txt`, reading the contents
# into a variable called `file1`.
#
# *Hint:* Check out [this Stack Overflow page](http://stackoverflow.com/questions/3277503/how-to-read-a-file-line-by-line-into-a-list-with-python) on reading lines of files.
# +
def read_file_lines(filename):
with open(filename) as f:
lines = f.readlines()
file1 = [x.strip() for x in lines]
return file1
file1 = read_file_lines('C:\\Users\\davei\\Documents\\EMSEDataAnalytics\\EMSE6992_Assignments\\data\\HW1\\1.txt')
# -
_ = ok.grade('q07')
_ = ok.backup()
# Each file begins with a line containing two numbers. After checking the length of
# a file, you could notice that the product of these two numbers equals the number of
# lines in each file (other than the first one).
#
# This suggests the rows represent elements in a 2-dimensional grid. In fact, each
# dataset represents an image!
#
# On the first line, the first of the two numbers is
# the height of the image (in pixels) and the second is the width (again in pixels).
#
# Each line in the rest of the file contains the pixels of the image.
# Each pixel is a triplet of numbers denoting how much red, green, and blue
# the pixel contains, respectively.
#
# In image processing, each column in one of these image files is called a *channel*
# (disregarding line 1). So there are 3 channels: red, green, and blue.
#
# #### Question 8
# Define a function called `lines_to_image` that takes in the contents of a
# file as a list (such as `file1`). It should return an array containing integers of
# shape `(n_rows, n_cols, 3)`. That is, it contains the pixel triplets organized in the
# correct number of rows and columns.
#
# For example, if the file originally contained:
#
# ```
# 4 2
# 0 0 0
# 10 10 10
# 2 2 2
# 3 3 3
# 4 4 4
# 5 5 5
# 6 6 6
# 7 7 7
# ```
#
# The resulting array should be a *3-dimensional* array that looks like this:
#
# ```
# array([
# [ [0,0,0], [10,10,10] ],
# [ [2,2,2], [3,3,3] ],
# [ [4,4,4], [5,5,5] ],
# [ [6,6,6], [7,7,7] ]
# ])
# ```
#
# The string method `split` and the function `np.reshape` might be useful.
#
# **Important note:** You must call `.astype(np.uint8)` on the final array before
# returning so that `numpy` will recognize the array represents an image.
#
# Once you've defined the function, set `image1` to the result of calling
# `lines_to_image` on `file1`.
# +
import numpy as np
def lines_to_image(file_lines):
rows, cols = [int(num) for num in file_lines[0].split()]
stripped_lines = [line.strip() for line in file_lines[1:]]
triplets = [[int(num) for num in line.split()]
for line in stripped_lines]
triplet_arr = np.array(triplets)
image_array = triplet_arr.reshape((rows, cols, 3))
return image_array.astype(np.uint8)
image1 = lines_to_image(file1)
image1.shape
# -
_ = ok.grade('q08')
_ = ok.backup()
# #### Question 9
#
# Images in `numpy` are simply arrays, but we can also display them them as
# actual images in this notebook.
#
# Use the provided `show_images` function to display `image1`. You may call it
# like `show_images(image1)`. If you later have multiple images to display, you
# can call `show_images([image1, image2])` to display them all at once.
#
# The resulting image should look almost completely black. Why do you suppose
# that is?
def show_images(images, ncols=2, figsize=(10, 7), **kwargs):
"""
Shows one or more color images.
images: Image or list of images. Each image is a 3-dimensional
array, where dimension 1 indexes height and dimension 2
the width. Dimension 3 indexes the 3 color values red,
blue, and green (so it always has length 3).
"""
def show_image(image, axis=plt):
plt.imshow(image, **kwargs)
if not (isinstance(images, list) or isinstance(images, tuple)):
images = [images]
images = [image.astype(np.uint8) for image in images]
nrows = math.ceil(len(images) / ncols)
ncols = min(len(images), ncols)
plt.figure(figsize=figsize)
for i, image in enumerate(images):
axis = plt.subplot2grid(
(nrows, ncols),
(i // ncols, i % ncols),
)
axis.tick_params(bottom=False, left=False, top=False, right=False,
labelleft=False, labelbottom=False)
axis.grid(False)
show_image(image, axis)
show_images(image1)
# #### Question 10
#
# If you look at the data, you'll notice all the numbers lie between 0 and 10.
# In `NumPy`, a color intensity is an integer ranging from 0 to 255, where 0 is
# no color (black). That's why the image is almost black. To see the image,
# we'll need to rescale the numbers in the data to have a larger range.
#
# Define a function `expand_image_range` that takes in an image. It returns a
# **new copy** of the image with the following transformation:
#
# old value | new value
# ========= | =========
# 0 | 12
# 1 | 37
# 2 | 65
# 3 | 89
# 4 | 114
# 5 | 137
# 6 | 162
# 7 | 187
# 8 | 214
# 9 | 240
# 10 | 250
#
# This expands the color range of the image. For example, a pixel that previously
# had the value `[5 5 5]` (almost-black) will now have the value `[137 137 137]`
# (gray).
#
# Set `expanded1` to the expanded `image1`, then display it with `show_images`.
#
# [This page](https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html#boolean-array-indexing)
# from the numpy docs has some useful information that will allow you
# to use indexing instead of `for` loops.
#
# However, the slickest implementation uses one very short line of code.
# *Hint:* If you index an array with another array or list as in question 5, your
# array (or list) of indices can contain repeats, as in `array1[[0, 1, 0]]`.
# Investigate what happens in that case.
# +
# This array is provided for your convenience.
transformed = np.array([12, 37, 65, 89, 114, 137, 162, 187, 214, 240, 250])
expanded1 = image1.astype('float64')
expanded1 *= (255/expanded1.max())
show_images(expanded1)
# -
_ = ok.grade('q10')
_ = ok.backup()
# #### Question 11
#
# Eureka! You've managed to reveal the image that the text file represents.
#
# Now, define a function called `reveal_file` that takes in a filename
# and returns an expanded image. This should be relatively easy since you've
# defined functions for each step in the process.
#
# Then, set `expanded_images` to a list of all the revealed images. There are
# 10 images to reveal (including the one you just revealed).
#
# Finally, use `show_images` to display the `expanded_images`.
# +
def reveal_file(filename):
...
filenames = ['1.txt', '2.txt', '3.txt', '4.txt', '5.txt',
'6.txt', '7.txt', '8.txt', '9.txt', '10.txt']
expanded_images = ...
show_images(expanded_images, ncols=5)
# -
# Notice that 5 of the above images are of summer scenes; the other 5
# are of winter.
#
# Think about how you'd distinguish between pictures of summer and winter. What
# qualities of the image seem to signal to your brain that the image is one of
# summer? Of winter?
#
# One trait that seems specific to summer pictures is that the colors are warmer.
# Let's see if the proportion of pixels of each color in the image can let us
# distinguish between summer and winter pictures.
# #### Question 12
# To simplify things, we can categorize each pixel according to its most intense
# (highest-value) channel. (Remember, red, green, and blue are the 3 channels.)
# For example, we could just call a `[2 4 0]` pixel "green." If a pixel has a
# tie between several channels, let's count it as none of them.
#
# Write a function `proportion_by_channel`. It takes in an image. It assigns
# each pixel to its greatest-intensity channel: red, green, or blue. Then
# the function returns an array of length three containing the proportion of
# pixels categorized as red, the proportion categorized as green, and the
# proportion categorized as blue (respectively). (Again, don't count pixels
# that are tied between 2 or 3 colors as any category, but do count them
# in the denominator when you're computing proportions.)
#
# For example:
#
# ```
# >>> test_im = np.array([
# [ [5, 2, 2], [2, 5, 10] ]
# ])
# >>> proportion_by_channel(test_im)
# array([ 0.5, 0, 0.5 ])
#
# # If tied, count neither as the highest
# >>> test_im = np.array([
# [ [5, 2, 5], [2, 50, 50] ]
# ])
# >>> proportion_by_channel(test_im)
# array([ 0, 0, 0 ])
# ```
#
# Then, set `image_proportions` to the result of `proportion_by_channel` called
# on each image in `expanded_images` as a 2d array.
#
# *Hint:* It's fine to use a `for` loop, but for a difficult challenge, try
# avoiding it. (As a side benefit, your code will be much faster.) Our solution
# uses the `NumPy` functions `np.reshape`, `np.sort`, `np.argmax`, and `np.bincount`.
# + for_assignment_type="student"
def proportion_by_channel(image):
...
image_proportions = ...
image_proportions
# -
_ = ok.grade('q12')
_ = ok.backup()
# Let's plot the proportions you computed above on a bar chart:
# You'll learn about Pandas and DataFrames soon.
import pandas as pd
pd.DataFrame({
'red': image_proportions[:, 0],
'green': image_proportions[:, 1],
'blue': image_proportions[:, 2]
}, index=pd.Series(['Image {}'.format(n) for n in range(1, 11)], name='image'))\
.iloc[::-1]\
.plot.barh();
# #### Question 13
#
# What do you notice about the colors present in the summer images compared to
# the winter ones?
#
# Use this info to write a function `summer_or_winter`. It takes in an image and
# returns `True` if the image is a summer image and `False` if the image is a
# winter image.
#
# **Do not hard-code the function to the 10 images you currently have (eg.
# `if image1, return False`).** We will run your function on other images
# that we've reserved for testing.
#
# You must classify all of the 10 provided images correctly to pass the test
# for this function.
#
# + for_assignment_type="student"
def summer_or_winter(image):
...
# -
_ = ok.grade('q13')
_ = ok.backup()
# Congrats! You've created your very first classifier for this class.
# #### Question 14
#
# 1. How do you think your classification function will perform
# in general?
# 2. Why do you think it will perform that way?
# 3. What do you think would most likely give you false positives?
# 4. False negatives?
# *Write your answer here, replacing this text.*
# **Final note:** While our approach here is simplistic, skin color segmentation
# -- figuring out which parts of the image belong to a human body -- is a
# key step in many algorithms such as face detection.
# # Optional: Our code to encode images
# Here are the functions we used to generate the text files for this assignment.
#
# Feel free to send not-so-secret messages to your friends if you'd like.
import skimage as sk
import skimage.io as skio
def read_image(filename):
'''Reads in an image from a filename'''
return skio.imread(filename)
def compress_image(im):
'''Takes an image as an array and compresses it to look black.'''
res = im / 25
return res.astype(np.uint8)
def to_text_file(im, filename):
'''
Takes in an image array and a filename for the resulting text file.
Creates the encoded text file for later decoding.
'''
h, w, c = im.shape
to_rgb = ' '.join
to_row = '\n'.join
to_lines = '\n'.join
rgb = [[to_rgb(triplet) for triplet in row] for row in im.astype(str)]
lines = to_lines([to_row(row) for row in rgb])
with open(filename, 'w') as f:
f.write('{} {}\n'.format(h, w))
f.write(lines)
f.write('\n')
summers = skio.imread_collection('orig/summer/*.jpg')
winters = skio.imread_collection('orig/winter/*.jpg')
len(summers)
# +
sum_nums = np.array([ 5, 6, 9, 3, 2, 11, 12])
win_nums = np.array([ 10, 7, 8, 1, 4, 13, 14])
for im, n in zip(summers, sum_nums):
to_text_file(compress_image(im), '{}.txt'.format(n))
for im, n in zip(winters, win_nums):
to_text_file(compress_image(im), '{}.txt'.format(n))
# -
# # 5. Submitting this assignment
#
# First, run this cell to run all the autograder tests at once so you can double-
# check your work.
_ = ok.grade_all()
# Now, run this code in your terminal to make a
# [git commit](https://www.atlassian.com/git/tutorials/saving-changes/git-commit)
# that saves a snapshot of your changes in `git`. The last line of the cell
# runs [git push](http://stackoverflow.com/questions/2745076/what-are-the-differences-between-git-commit-and-git-push), which will send your work to your personal Github repo.
# ```
# # Tell git to commit all the changes so far
# git add -A
#
# # Tell git to make the commit
# git commit -m "hw1 finished"
#
# # Send your updates to your personal private repo
# git push origin master
# ```
# Finally, we'll submit the assignment to OkPy so that the staff will know to
# grade it. You can submit as many times as you want and you can choose which
# submission you want us to grade by going to https://okpy.org/cal/data100/sp17/.
# Now, we'll submit to okpy
_ = ok.submit()
# Congrats! You are done with homework 1.
| EMSEDataAnalytics-master/EMSE6992_Assignments/HW1_v1.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: SageMath 9.0
# language: sage
# name: sagemath
# ---
# # Algebra Lineal
#
# Cuaderno de apoyo para las actividades, ejercicios, proyectos y tareas, del curso de _Algebra Lineal_ de la _UnADM_.
# +
def comp_vec(vi, vf):
return (vf[0]-vi[0], vf[1]-vi[1])
# Vector v
vi = (1,-2)
vf = (-5,2)
vm = comp_vec(vi, vf)
print(vm)
# Vector w
wi = (0,0)
wf = (-1,-4)
wm = comp_vec(wi, wf)
print(wm)
# W-V
print(vector(wm)-vector(vm))
# +
vi = (1,-2)
vf = (-5,2)
v = vector(comp_vec(vi, vf))
print(v)
wi = (0,0)
wm = (-1,-4)
w = vector(wm)
print(w)
v*w
# -
vector([3,4])*vector([-5,6])
# +
def pero_f(u1, u2, v1, v2):
print(vector([u1,u2]) * vector([v1,v2]))
pero_f(-8,-3,3,8)
pero_f(4,6,-6,4)
pero_f(3,1,2,3)
# -
| B1-1/BALI/U1/Notebook_apoyo.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 2
# language: python
# name: python2
# ---
# + hideCode=false hidePrompt=false
import sys
spark_home = '/Users/arj/Make/bin/spark-2.1.0-bin-hadoop2.7'
sys.path.insert(0, spark_home + "/python")
from pyspark import SparkConf, SparkContext
urlMaster = 'spark://Arjuns-MacBook-Pro.local:7077'
conf = (
SparkConf()
.setAppName('spark.app')
.setMaster(urlMaster)
)
sc = SparkContext(conf=conf)
# + hideCode=false hidePrompt=false
# building corpus
from nltk.corpus import brown
sentences = brown.sents()[:1000]
corpus = sc.parallelize(sentences).map(lambda s: ' '.join(s))
# + hideCode=false hidePrompt=false
# + hideCode=false hidePrompt=false
from itertools import chain
from pattern.text.en import parsetree
def get_chunks(sentence):
return list(chain.from_iterable(
map(
lambda sentence: sentence.chunks,
parsetree(sentence)
)
))
chunks = corpus \
.map(get_chunks)
print chunks.take(2)
# + [markdown] hideCode=false hidePrompt=false
# #### nouns word count
# +
def match_noun_like_pos(pos):
import re
return re.match(re.compile('^N.*'), pos) != None
noun_like = chunks \
.flatMap(lambda chunks: chunks) \
.filter(lambda chunk: chunk.part_of_speech == 'NP') \
.flatMap(lambda chunk: chunk.words) \
.filter(lambda word: match_noun_like_pos(word.part_of_speech)) \
.map(lambda word: word.string.lower())
print noun_like.take(10)
# +
noun_word_count = noun_like \
.map(lambda word: (word, 1)) \
.reduceByKey(lambda a, b: a + b) \
.sortBy(lambda d: d[1], ascending=False)
print noun_word_count.take(10)
# -
# ##### LDA
from pyspark.mllib.clustering import LDA, LDAModel
from pyspark.mllib.linalg import Vectors
vocabulary = noun_word_count.map(lambda w: w[0]).collect()
vocabulary[:5]
# +
doc_nouns = chunks \
.map(lambda chunks: filter(
lambda chunk: chunk.part_of_speech == 'NP',
chunks
)) \
.filter(lambda chunks: len(chunks) > 0) \
.map(lambda chunks: list(chain.from_iterable(map(
lambda chunk: chunk.words,
chunks
)))) \
.map(lambda words: filter(
lambda word: match_noun_like_pos(word.part_of_speech),
words
)) \
.filter(lambda words: len(words) > 0) \
.map(lambda words: map(
lambda word: word.string.lower(),
words,
))
doc_nouns.take(1)
# +
def get_vector_representation(nouns, vocab):
return Vectors.dense(map(
lambda word: 1.0 if word in nouns else 0.0,
vocab
))
doc_vecs = doc_nouns \
.map(lambda nouns: get_vector_representation(set(nouns), vocabulary)) \
.zipWithIndex().map(lambda x: [x[1], x[0]])
# -
ldaModel = LDA.train(doc_vecs, k=3)
print("Learned topics (as distributions over vocab of " + str(ldaModel.vocabSize())
+ " words):")
topics = ldaModel.topicsMatrix()
for topic in range(3):
print("Topic " + str(topic) + ":")
topic_words = sorted(map(
lambda d: (topics[d[0]][topic], d[1]),
enumerate(vocabulary)
), reverse=True)
for word in topic_words[:10]:
print("{}: {}".format(word[1], word[0]))
print '-----------'
| Chapter09/chapter_9/3.spark/.ipynb_checkpoints/Spark Text Mining Example-checkpoint.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3 (ipykernel)
# language: python
# name: python3
# ---
# # Subseting of the META3.1 database
# ***
# **Author:** [<NAME>](https://github.com/andresawa/)
# Laboratório de Estudos dos Oceanos e Clima – LEOC, Instituto de Oceanografia, Universidade Federal do Rio Grande.
# email: <EMAIL>
# **Last change:** 12/10/2021
# ***
# ### Import Libraries
import numpy as np
import xarray as xr
# ### Define the spatial and temporal limits of the data and the unwanted variables
# +
# Limits
lon_min, lon_max, lat_min, lat_max, time_min, time_max = -50+360, 20, -40, -15, np.datetime64("2006-10-01"), np.datetime64("2011-10-31")
# Define the unwanted variables
unwanted_vars = ["amplitude",
"cost_association",
"effective_contour_height",
"effective_contour_shape_error",
"inner_contour_height",
"latitude_max",
"longitude_max",
"num_contours",
"num_point_e",
"num_point_s",
"observation_flag",
"speed_contour_height",
"speed_contour_shape_error",
"uavg_profile",
"observation_number",
"speed_contour_latitude",
"speed_contour_longitude",
"speed_area",
"speed_average",
"speed_radius"]
# -
# ### Filter the cyclonic eddies and save to a new file
# +
# Load the cyclonic eddies and subset using the limits (latitude and time)
cyc = xr.open_dataset("/mnt/storage/Downloads/AVISO/META3.1exp_DT_allsat/META3.1exp_DT_allsat_Cyclonic_long_19930101_20200307.nc")
cyc_subset = cyc.sel(obs =
(cyc.latitude >= lat_min) &
(cyc.latitude <= lat_max) &
(cyc.time >= time_min) &
(cyc.time <= time_max) &
((cyc.longitude >= lon_min) | (cyc.longitude <= lon_max))
)
# Drop the unwanted variables
cyc_clean = cyc_subset.drop_vars(unwanted_vars)
# Save the new file
cyc_clean.to_netcdf("~/META3_1_cyclonic.nc", encoding = {"effective_contour_longitude": {"zlib": True, "chunksizes": (16000, 50)}, "effective_contour_latitude": {"zlib": True, "chunksizes": (16000, 50)}})
# -
# ### Filter the anticyclonic eddies and save to a new file
# +
# Load the cyclonic eddies and subset using the limits (latitude and time)
acyc = xr.open_dataset("/mnt/storage/Downloads/AVISO/META3.1exp_DT_allsat/META3.1exp_DT_allsat_Anticyclonic_long_19930101_20200307.nc")
acyc_subset = acyc.sel(obs =
(acyc.latitude >= lat_min) &
(acyc.latitude <= lat_max) &
(acyc.time >= time_min) &
(acyc.time <= time_max) &
((acyc.longitude >= lon_min) | (acyc.longitude <= lon_max))
)
# Drop the unwanted variables
acyc_clean = acyc_subset.drop_vars(unwanted_vars)
# Save the new file
acyc_clean.to_netcdf("~/META3_1_anticyclonic.nc", encoding = {"effective_contour_longitude": {"zlib": True, "chunksizes": (16000, 50)}, "effective_contour_latitude": {"zlib": True, "chunksizes": (16000, 50)}})
| database_preparation.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # STIS DATA Preprocessing
# Essential Pkg
import fnmatch
import os
import numpy as np
from osgeo import gdal
#### Unzip folders
import zipfile
# ### STEP I : unzip STIS files for each period
### STEP I : Fxn to unzip files for each period
def unzip(input_dir,output_dir):
"""
@input_dir : contains STIS data (ex : 1 year data, each zip file contains images (for multiple band)
for a month)
@output_dir : output directory, where you want t unzip files
"""
files = os.listdir(input_dir)
for file in files:
filePath=input_dir+'/'+file
print(filePath)
with zipfile.ZipFile(filePath, 'r') as zip_ref:
zip_ref.extractall(output_dir)
input_dir = 'ziped_file_directory'
output_dir = 'unziped_files_directory'
# usage
unzip(input_dir,output_dir)
# ### STEP II : rename files for needed bands
# +
##### Rename file names for visible band (B2,B3,B4,B5), in order to make then custom and readable
### ex : from SENTINEL2A_20170126-105612-238_L2A_T31TEJ_D_V1-4_ATB_R1.tif to 20170126_B1.tif
# -
### STEP II : rename files for needed bands
def rename_file(directory, bandlist):
for root, dirnames, filenames in os.walk(directory):
for i in bandlist:
for filename1 in fnmatch.filter(filenames,i):
# print(filename1)
old_file = os.path.join(root, filename1)
# new_fname = filename1.split("_")[0]+'-'+filename1.split("_")[-1]
new_fname = filename1.split("_")[1].split('-')[0]+'-'+filename1.split("_")[-1]
new_file = os.path.join(root, new_fname)
# print(new_file)
os.rename(old_file, new_file)
# B2 (bleue), B3 (verte), B4 (rouge), et B8 (proche infra-rouge).
bandlist = ['*_FRE_B2.tif', '*_FRE_B3.tif', '*_FRE_B4.tif', '*_FRE_B8.tif']
directory = 'unziped_files_directory'
# usage
rename_file(directory,bandlist)
# fxn to compute ndvi
def ndvi(red, nir):
return ((nir.astype('float32') - red.astype('float32')) / (nir+red))
# ### STEP III - Generate NDVI bands
####STEP III - Generate NDVI band
def ndvi_generator(directory):
dic = {}
nir_band = ['*-B4.tif', '*-B8.tif']
outpath = ''
liste =[]
for root, dirnames, filenames in os.walk(directory):
for x in filenames:
tmp = x.split('-')[0]
dic[tmp] = {}
for i in nir_band:
for filename in fnmatch.filter(filenames, i):
bd = filename.split('-')[-1].split('.')[0]
dic[tmp][bd] = os.path.join(root,filename)# filename # []
dic = {k: v for k, v in dic.items() if v}
# print(dic, len(dic))
for K in dic:
# print(dic[K]['B4'])
redbname = dic[K]['B4']
# print(redbname.shape
red_band_data =gdal.Open(redbname)
red_band_array = red_band_data.ReadAsArray().astype('float32')
print(red_band_array.shape)
# print(red_band_array)
nirfile = dic[K]['B8']
nir_band_data = gdal.Open(nirfile)
nir_band_array = nir_band_data.ReadAsArray().astype('float32')
print(nir_band_array.shape)
# print(nir_band_array)
# compute ndvi value
ndvi_val = ndvi(red_band_array,nir_band_array)
###
# outfile = nirfile.split('.')[0] + '-ndvi.tif'
outfile = nirfile.split('.')[0] + '_NDVI.tif'
print(outfile)
x_pixels = red_band_array.shape[0] # number of pixels in x
y_pixels = red_band_array.shape[1] # number of pixels in y
print(x_pixels,y_pixels,K)
driver = gdal.GetDriverByName('GTiff')
ndvi_data = driver.Create(outfile,x_pixels, y_pixels, 1,gdal.GDT_Float32)
# x = ndvi_data.GetRasterBand(1)
# print(x)
ndvi_data.GetRasterBand(1).WriteArray(ndvi_val)
geotrans=red_band_data.GetGeoTransform() # input GeoTranform information
proj=red_band_data.GetProjection() # projection information from input file
ndvi_data.SetGeoTransform(geotrans)
ndvi_data.SetProjection(proj)
ndvi_data.FlushCache()
ndvi_data=None
directory = "unziped_files_directory"
# # usage
ndvi_generator(directory)
##### NOTE : Faire attention aux bandes utilisées, pour ne pas avoir des erreurs ci-dessous :
########### error : ValueError: array larger than output file, or offset off edge : Check the
# that you are using the right bands, if you accountred that error
# ### STEP IV - Generate multi-bande images
#### STEP IV - Generate multi-bande images
def multi_band_generator(data):
dic = {}
nir_band = ['*-B2.tif','*-B3.tif','*-B4.tif', '*-B8.tif','*-B8_NDVI.tif']
outpath = ''
liste =[]
for root, dirnames, filenames in os.walk(directory):
for x in filenames:
tmp = x.split('-')[0]
dic[tmp] = {}
for i in nir_band:
for filename in fnmatch.filter(filenames, i):
bd = filename.split('-')[-1].split('.')[0]
dic[tmp][bd] = os.path.join(root,filename)# filename # []
dic = {k: v for k, v in dic.items() if v}
for K in dic:
bluebname = dic[K]['B2']
blue_band_data =gdal.Open(bluebname)
blue_band_array = blue_band_data.ReadAsArray().astype('float32')
greenbname = dic[K]['B3']
green_band_data =gdal.Open(greenbname)
green_band_array = green_band_data.ReadAsArray().astype('float32')
redbname = dic[K]['B4']
red_band_data =gdal.Open(redbname)
red_band_array = red_band_data.ReadAsArray().astype('float32')
nirbname = dic[K]['B8']
nir_band_data =gdal.Open(nirbname)
nir_band_array = nir_band_data.ReadAsArray().astype('float32')
ndvibname = dic[K]['B8_NDVI']
ndvi_band_data =gdal.Open(ndvibname)
ndvi_band_array = ndvi_band_data.ReadAsArray().astype('float32')
###################
# Create output filename based on input name
# outfile = os.path.join(outpath,K.split('-')[0] + '_MULTI.tif')
# print(outfile)
# outfile = './'+ K.split('.')[0] + '_MULTI.tif'
r_path = '/unziped_files/multi_bands_tif' # specify outpath
outfile = r_path +'/'+K+'_multi.tif' # name for each multiband file
x_pixels = red_band_array.shape[0] # number of pixels in x
y_pixels = red_band_array.shape[1] # number of pixels in y
print(x_pixels,y_pixels)
# Set up output GeoTIFF
driver = gdal.GetDriverByName('GTiff')
# Create driver using output filename, x and y pixels, # of bands, and datatype
multibnd_data = driver.Create(outfile,x_pixels, y_pixels, 5,gdal.GDT_Float32)
#multibnd_data1 = driver.Create(outfile1,x_pixels, y_pixels, 5,gdal.GDT_Float32)
#
multibnd_data.GetRasterBand(1).WriteArray(blue_band_array)
multibnd_data.GetRasterBand(2).WriteArray(green_band_array)
multibnd_data.GetRasterBand(3).WriteArray(red_band_array)
multibnd_data.GetRasterBand(4).WriteArray(nir_band_array)
multibnd_data.GetRasterBand(5).WriteArray(ndvi_band_array)
# Setting up the coordinate reference system of the output GeoTIFF
geotrans = red_band_data.GetGeoTransform() # input GeoTranform information
proj = red_band_data.GetProjection() # projection information from input file
# GeoTransform parameters and projection on the output file
multibnd_data.SetGeoTransform(geotrans)
multibnd_data.SetProjection(proj)
multibnd_data.FlushCache()
multibnd_data=None
directory = "unziped_files"
# usage
multi_band_generator(directory)
# ### STEP V -> Cut origin images with the study area shape
# #### run in wrap_cut .sh file using gdalwarp
# * dossier -> multi_bands folder
# * target_shape_file.shp -> hape for the study area
# ### STEP VI -> Check that all images are valid. If not, only keep the good ones
# ### STEP VII -> Segementation
# #### run in segmentation.sh file with otbcli_LargeScaleMeanShift
# * dossier -> multibands folder for a given year (stis for a year)
# ### STEP IIX -> Run Graph4SIT
# * to build graph for each STIS (ex : 2018)
| Img_pre_process.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # 对象和类
# - 一个学生，一张桌子，一个圆都是对象
# - 对象是类的一个实例，你可以创建多个对象，创建类的一个实例过程被称为实例化，
# - 在Python中对象就是实例，而实例就是对象
# ## 定义类
# class ClassName:
#
# do something
#
# - class 类的表示与def 一样
# - 类名最好使用驼峰式
# - 在Python2中类是需要继承基类object的，在Python中默认继承，可写可不写
# - 可以将普通代码理解为皮肤，而函数可以理解为内衣，那么类可以理解为外套
class joker:
pass
joker
# ## 定义一个不含初始化__init__的简单类
# class ClassName:
#
# joker = “Home”
#
# def func():
# print('Worker')
#
# - 尽量少使用
#
#
# ## 定义一个标准类
# - __init__ 代表初始化，可以初始化任何动作
# - 此时类调用要使用()，其中（）可以理解为开始初始化
# - 初始化内的元素，类中其他的函数可以共享
# 
#一切类必须初始化
#在类中，所有的函数的第一个参数，都是标示量，不是参数
class joker:
def _init_(self):
print('我开始初始化')
joker()
#一切类必须初始化
#在类中，所有的函数的第一个参数，都是标示量，不是参数
#若是一个参数需要多次使用，那么可以将其统一放在初始化函数中
class joker:
def __init__(self):
print('我初始化')
self.num1 = num1
self.num2 = num2
def Print_(self,name):
print('helow worid',name)
def SUM(self):
return self.num1+self.num2
def cheng(self):
return self.num1*self.num2
# - Circle 和 className_ 的第一个区别有 __init__ 这个函数
# - 。。。。 第二个区别，类中的每一个函数都有self的这个“参数”
# ## 何为self？
# - self 是指向对象本身的参数
# - self 只是一个命名规则，其实可以改变的，但是我们约定俗成的是self，也便于理解
# - 使用了self就可以访问类中定义的成员
# <img src="../Photo/86.png"></img>
# ## 使用类 Cirlcle
# ## 类的传参
# - class ClassName:
#
# def __init__(self, para1,para2...)：
#
# self.para1 = para1
#
# self.para2 = para2
# ## EP:
# - A：定义一个类，类中含有两个功能：
# - 1、计算随机数的最大值
# - 2、计算随机数的最小值
# - B：定义一个类，（类中函数的嵌套使用）
# - 1、第一个函数的功能为：输入一个数字
# - 2、第二个函数的功能为：使用第一个函数中得到的数字进行平方处理
# - 3、第三个函数的功能为：得到平方处理后的数字 - 原来输入的数字，并打印结果
import random
a = random.randint(0,10)
b = random.randint(0,10)
c = random.randint(0,10)
class joker2:
def __init__(self,a,b,c):
print('走了init')
self.a = a
self.b = b
self.c = c
def max_(self):
return max(self.a,self.b,self.c)
sb = joker2(a,b,c)
class joker3:
def __init__(self):
pass
def input_(self):
num = eval(input('>>'))
return num
def square(self):
num = self.input_()
num_2 = num ** 2
return num_2
def chazhi(self):
num = self.input_()
num2 = self.square()
return num2 - num
ab = joker3()
ab.input_()
ab.square()
class QQ:
def __init__(self):
self.account = '123'
self.password = '<PASSWORD>'
def account_(self):
acc = input('输入账')
passwor = input('输入密码')
if acc == self.account and self.password == <PASSWORD>wor:
print('succeed')
else:
self.yanzhengma()
def yanzhengma(self):
yanzhen = 'ppp'
print('验证码:',yanzhen)
while 1:
N = input('输入验证码')
if N == yanzhen:
print('succeed')
prrint('error')
break
# ## 类的继承
# - 类的单继承
# - 类的多继承
# - 继承标识
# > class SonClass(FatherClass):
#
# def __init__(self):
#
# FatherClass.__init__(self)
class fu(object):
def __init__(self):
self.a = 'a'
self.b = 'b'
def print_(self):
print('fu')
class zi(fu):
def __init__(self):
#告诉父类，子类即将继承父类
fu.__init__(self)
print(self.a)
joker4 = zi()
# ## 私有数据域(私有变量，或者私有函数)
# - 在Python中 变量名或者函数名使用双下划线代表私有 \__Joker, def \__Joker():
# - 私有数据域不可继承
# - 私有数据域强制继承 \__dir__()
# 
# ## EP:
# 
# 
# 
#
# ## 类的其他
# - 类的封装
# - 实际上就是将一类功能放在一起，方便未来进行管理
# - 类的继承（上面已经讲过）
# - 类的多态
# - 包括装饰器：将放在以后处理高级类中教
# - 装饰器的好处：当许多类中的函数需要使用同一个功能的时候，那么使用装饰器就会方便许多
# - 装饰器是有固定的写法
# - 其包括普通装饰器与带参装饰器
# # Homewor
# ## UML类图可以不用画
# ## UML 实际上就是一个思维图
# - 1
# 
class mji:
def __init__(self,num1,num2):
print('初始化')
self.num1=num1
self.num2=num2
def zhouchang(self):
return self.num1 * 2 + self.num2 * 2
def mianji(self):
return self.num1*self.num2
aa = mji(6,5)
aa.zhouchang()
aa.mianji()
# - 2
# 
class money:
def __init__(self):
self.id ='1122'
self.qian = '20000'
def num_(self):
zh = input('id:')
if zh == self.id:
print('进入账户')
else:
print('无效')
def input_(self):
num= eval(input('>>'))
return num
def qu(self):
num = self.input_()
b= self.qian - self.num
return b
def cong(self):
num = self.input_()
c=self.qian + self.num
return c
bb=money()
bb.num_()
bb.input_()
# - 3
# 
# - 4
# 
# 
import math
class Point():
def __init__(self):
pass
def input_(self):
num = eval(input('>>'))
return num
def chang_(self):
num = self.input_()
num_2 = num
return num_2
def ji(self):
num = self.input_()
d = num /(4 * math.tan(math.pi/5))
return d
yy=Point()
yy.input_()
yy.chang_()
yy.ji()
# - 5
# 
# +
from scipy import linalg
import numpy as np
# x1 + x2 + 7*x3 = 2
# 2*x1 + 3*x2 + 5*x3 = 3
# 4*x1 + 2*x2 + 6*x3 = 4
A = np.array([[1, 1, 7], [2, 3, 5], [4, 2, 6]]) # A代表系数矩阵
b = np.array([2, 3, 4]) # b代表常数列
x = linalg.solve(A, b)
print(x)
# -
# - 6
# 
def cross_point(line1,line2):#计算交点函数
x1=line1[0]#取四点坐标
y1=line1[1]
x2=line1[2]
y2=line1[3]
x3=line2[0]
y3=line2[1]
x4=line2[2]
y4=line2[3]
k1=(y2-y1)*1.0/(x2-x1)#计算k1,由于点均为整数，需要进行浮点数转化
b1=y1*1.0-x1*k1*1.0#整型转浮点型是关键
if (x4-x3)==0:#L2直线斜率不存在操作
k2=None
b2=0
else:
k2=(y4-y3)*1.0/(x4-x3)#斜率存在操作
b2=y3*1.0-x3*k2*1.0
if k2==None:
x=x3
else:
x=(b2-b1)*1.0/(k1-k2)
y=k1*x*1.0+b1*1.0
return [x,y]
line1=[1,1,-1,-1]
line2=[-1,1,1,-1]
print(cross_point(line1, line2))
# - 7
# 
class Joker4:
def __init__(self,a,b,c,d,e,f):
self.a = a
self.b = b
self.c = c
self.d = d
self.e = e
self.f = f
def jie_(self):
x = (self.e * self.d - self.b * self.f)/(self.a * self.d - self.b * self.c)
y = (self.a * self.f - self.e * self.c)/(self.a * self.d - self.b * self.c)
if (self.a * self.d - self.b * self.c) == 0:
print('无解')
else:
print(x,y)
kk=Joker4(1,2,4,5,8,9)
kk.jie_()
| 7.23.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
import numpy as np
import pyJHTDB
from pyJHTDB import libJHTDB
# +
import json
with open("parameters-getCutout.txt","r") as pf:
params=json.load(pf)
auth_token=params["token"]
xstart=int(params.get("xstart"))
ystart=int(params.get("ystart"))
zstart=int(params.get("zstart"))
nx=int(params.get("nx"))
ny=int(params.get("ny"))
nz=int(params.get("nz"))
xstep=int(params.get("xstep",1))
ystep=int(params.get("ystep",1))
zstep=int(params.get("zstep",1))
Filter_Width=int(params.get("Filter_Width",1))
time_step=int(params.get("time_step",0))
field=params.get("field","u")
data_set=params.get("dataset","isotropic1024coarse")
if field == 'u':
VarName="Velocity"
dim = 3
elif field == 'a':
VarName="Vector Potential"
dim = 3
elif field == 'b':
VarName="Magnetic Field"
dim = 3
elif field == 'p':
VarName="Pressure"
dim = 1
elif field == 'd':
VarName="Density"
dim = 1
elif field == 't':
VarName="Temperature"
dim = 1
idx_x=np.arange(xstart, xstart+nx, xstep)
idx_y=np.arange(ystart, ystart+ny, ystep)
idx_z=np.arange(zstart, zstart+nz, zstep)
nnx=np.size(idx_x)
nny=np.size(idx_y)
nnz=np.size(idx_z)
npoints=nnx*nny*nnz
split_no=int(np.ceil(npoints/(192000000/dim)))
result=np.zeros((nnz,nny,nnx,dim),dtype='float32')
tmp=np.array_split(np.arange(npoints).reshape(nnx,nny,nnz), split_no)
print(result.shape)
# +
# %%time
lJHTDB = libJHTDB()
lJHTDB.initialize()
lJHTDB.add_token(auth_token)
for t in range(split_no):
xyzs0 = np.unravel_index(tmp[t][0,0,0], (nnx,nny,nnz))
xyze0 = np.unravel_index(tmp[t][-1,-1,-1], (nnx,nny,nnz))
xyzs1 = (idx_x[xyzs0[0]], idx_y[xyzs0[1]], idx_z[xyzs0[2]])
xyze1 = (idx_x[xyze0[0]], idx_y[xyze0[1]], idx_z[xyze0[2]])
temp = lJHTDB.getCutout(
data_set=data_set, field=field, time=time_step,
start=np.array([xyzs1[0], xyzs1[1], xyzs1[2]], dtype = np.int),
size=np.array([xyze1[0]-xyzs1[0]+1, xyze1[1]-xyzs1[1]+1, xyze1[2]-xyzs1[2]+1], dtype = np.int),
step=np.array([xstep, ystep, zstep], dtype = np.int),
filter_width=Filter_Width)
result[xyzs0[2]:xyze0[2]+1, xyzs0[1]:xyze0[1]+1, xyzs0[0]:xyze0[0]+1,:] = temp
lJHTDB.finalize()
print(result.shape)
# +
# %%time
#start = tt.time()
if (dim==3):
Attribute_Type="Vector"
elif (dim==1):
Attribute_Type="Scalar"
nl = '\r\n'
if data_set in ["channel","channel5200", "transition_bl"]:
if data_set == "channel":
ygrid = pyJHTDB.dbinfo.channel['ynodes']
dx=8.0*np.pi/2048
dz=3.0*np.pi/1536
x_offset=0
#xg = np.arange(0,2048.0)
#zg = np.arange(0,1536.0)
#for x in xg:
# xg[int(x)] = 8*np.pi/2048*x
#for z in zg:
# zg[int(z)] = 3*np.pi/1536*z
elif data_set == "channel5200":
ygrid = pyJHTDB.dbinfo.channel5200['ynodes']
dx=8.0*np.pi/10240.0
dz=3.0*np.pi/7680.0
x_offset=0
#xg = np.arange(0,10240.0)
#zg = np.arange(0,7680.0)
#for x in xg:
# xg[int(x)] = 8*np.pi/10240*x
#for z in zg:
# zg[int(z)] = 3*np.pi/7680*z
elif data_set == "transition_bl":
ygrid = pyJHTDB.dbinfo.transition_bl['ynodes']
dx=0.292210466240511
dz=0.117244748412311
x_offset=30.218496172581567
#xg = np.arange(0,3320.0)
#zg = np.arange(0,2048.0)
#for x in xg:
# xg[int(x)] = 0.292210466240511*x+30.218496172581567
#for z in zg:
# zg[int(z)] = 0.117244748412311*z
xcoor=idx_x*dx+x_offset
ycoor=ygrid[idx_y]
zcoor=idx_z*dz
else:
if data_set in ["isotropic1024coarse", "isotropic1024fine", "mhd1024", "mixing"]:
dx=2.0*np.pi/1024.0
elif data_set in ["isotropic4096", "rotstrat4096"]:
dx=2.0*np.pi/4096.0
xcoor=idx_x*dx
ycoor=idx_y*dx
zcoor=idx_z*dx
# +
# %%time
import h5py
filename='test'
fh = h5py.File(filename+'.h5', driver='core', block_size=16, backing_store=True)
fh.attrs["dataset"] = np.string_(data_set)
fh.attrs["timeStep"] = time_step
fh.attrs["xstart"] = xstart
fh.attrs["ystart"] = ystart
fh.attrs["zstart"] = zstart
fh.attrs["nx"] = nx
fh.attrs["ny"] = ny
fh.attrs["nz"] = nz
fh.attrs["x_step"] = xstep
fh.attrs["y_step"] = ystep
fh.attrs["z_step"] = zstep
fh.attrs["filterWidth"] = Filter_Width
shape = [0]*3
shape[0] = nnz
shape[1] = nny
shape[2] = nnx
dset = fh.create_dataset(VarName, (shape[0], shape[1],
shape[2], dim), maxshape=(shape[0], shape[1], shape[2], dim))
dset[...]=result
dset = fh.create_dataset("xcoor", (shape[2],), maxshape=(shape[2],))
dset[...]=xcoor
dset = fh.create_dataset("ycoor", (shape[1],), maxshape=(shape[1],))
dset[...]=ycoor
dset = fh.create_dataset("zcoor", (shape[0],), maxshape=(shape[0],))
dset[...]=zcoor
fh.close()
with open(filename+".xmf", "w") as tf:
print(f"<?xml version=\"1.0\" ?>{nl}", file=tf)
print(f"<!DOCTYPE Xdmf SYSTEM \"Xdmf.dtd\" []>{nl}", file=tf)
print(f"<Xdmf Version=\"2.0\">{nl}", file=tf)
print(f" <Domain>{nl}", file=tf)
print(f" <Grid Name=\"Structured Grid\" GridType=\"Uniform\">{nl}", file=tf)
print(f" <Time Value=\"{time_step}\" />{nl}", file=tf)
print(f" <Topology TopologyType=\"3DRectMesh\" NumberOfElements=\"{nnz} {nny} {nnx}\"/>{nl}", file=tf)
print(f" <Geometry GeometryType=\"VXVYVZ\">{nl}", file=tf)
print(f" <DataItem Name=\"Xcoor\" Dimensions=\"{nnx}\" NumberType=\"Float\" Precision=\"4\" Format=\"HDF\">{nl}", file=tf)
print(f" {filename}.h5:/xcoor", file=tf)
print(f" </DataItem>{nl}", file=tf)
print(f" <DataItem Name=\"Ycoor\" Dimensions=\"{nny}\" NumberType=\"Float\" Precision=\"4\" Format=\"HDF\">{nl}", file=tf)
print(f" {filename}.h5:/ycoor", file=tf)
print(f" </DataItem>{nl}", file=tf)
print(f" <DataItem Name=\"Zcoor\" Dimensions=\"{nnz}\" NumberType=\"Float\" Precision=\"4\" Format=\"HDF\">{nl}", file=tf)
print(f" {filename}.h5:/zcoor", file=tf)
print(f" </DataItem>{nl}", file=tf)
print(f" </Geometry>{nl}", file=tf)
print(f"{nl}", file=tf)
print(f" <Attribute Name=\"{VarName}\" AttributeType=\"{Attribute_Type}\" Center=\"Node\">{nl}", file=tf)
print(f" <DataItem Dimensions=\"{nnz} {nny} {nnx} {dim}\" NumberType=\"Float\" Precision=\"4\" Format=\"HDF\">{nl}", file=tf)
print(f" {filename}.h5:/{VarName}{nl}", file=tf)
print(f" </DataItem>{nl}", file=tf)
print(f" </Attribute>{nl}", file=tf)
print(f"{nl}", file=tf)
print(f" </Grid>{nl}", file=tf)
print(f" </Domain>{nl}", file=tf)
print(f"</Xdmf>{nl}", file=tf)
| examples/DEMO_getCutout.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + [markdown] id="LjmhJ4ad9kBL"
# # Part 2: Build an Embeddings index with Hugging Face Datasets
#
# This notebook shows how txtai can index and search with Hugging Face's [Datasets](https://github.com/huggingface/datasets) library. Datasets opens access to a large and growing list of publicly available datasets. Datasets has functionality to select, transform and filter data stored in each dataset.
#
# In this example, txtai will be used to index and query a dataset.
#
# **Make sure to select a GPU runtime when running this notebook**
# + [markdown] id="8tLWvo9v-Q0u"
# # Install dependencies
#
# Install `txtai` and all dependencies. Also install `datasets` and a specific [sentence-transformers](https://github.com/UKPLab/sentence-transformers) model that does well with general information retrieval tasks.
# + id="Fa5BCjMFqVKE"
# %%capture
# !pip install git+https://github.com/neuml/txtai
# !pip install datasets
# Download sentence-transformer models not on Hugging Face model hub
# !wget https://public.ukp.informatik.tu-darmstadt.de/reimers/sentence-transformers/v0.2/msmarco-distilroberta-base-v2.zip
# !unzip -o msmarco-distilroberta-base-v2.zip
# !mv 0_Transformer/ msmarco-distilroberta-base-v2
# + [markdown] id="hOdEv8MH-e5h"
# # Load dataset and build a txtai index
#
# In this example, we'll load the `ag_news` dataset, which is a collection of news article headlines. This only takes a single line of code!
#
# Next, txtai will index the first 10,000 rows of the dataset. A model trained on msmarco is used to compute sentence embeddings. sentence-transformers has a number of [pre-trained models](https://www.sbert.net/docs/pretrained_models.html) that can be swapped in.
#
# In addition to the embeddings index, we'll also create a Similarity instance to re-rank search hits for relevancy.
# + id="3hYRk9JnsM0J"
# %%capture
from datasets import load_dataset
from txtai.embeddings import Embeddings
from txtai.pipeline import Similarity
def stream(dataset, field, limit):
index = 0
for row in dataset:
yield (index, row[field], None)
index += 1
if index >= limit:
break
def search(query):
return [(score, dataset[uid]["text"]) for uid, score in embeddings.search(query, limit=50)]
def ranksearch(query):
results = [text for _, text in search(query)]
return [(score, results[x]) for x, score in similarity(query, results)]
# Load HF dataset
dataset = load_dataset("ag_news", split="train")
# Create embeddings model, backed by sentence-transformers & transformers
embeddings = Embeddings({"method": "transformers", "path": "msmarco-distilroberta-base-v2"})
embeddings.index(stream(dataset, "text", 10000))
# Create similarity instance for re-ranking
similarity = Similarity("valhalla/distilbart-mnli-12-3")
# + [markdown] id="LBhHcX6eFmGI"
# # Search the dataset
#
# Now that an index is ready, let's search the data! The following section runs a series of queries and show the results. Like basic search engines, txtai finds token matches. But the real power of txtai is finding semantically similar results.
#
# sentence-transformers has a great overview on [information retrieval](https://github.com/UKPLab/sentence-transformers/tree/master/examples/applications/information-retrieval) that is well worth a read.
# + colab={"base_uri": "https://localhost:8080/", "height": 1000} id="YVmbiY92vxEO" outputId="85a6a129-2fbe-41eb-af48-66341ca107cf"
from IPython.core.display import display, HTML
def table(query, rows):
html = """
<style type='text/css'>
@import url('https://fonts.googleapis.com/css?family=Oswald&display=swap');
table {
border-collapse: collapse;
width: 900px;
}
th, td {
border: 1px solid #9e9e9e;
padding: 10px;
font: 15px Oswald;
}
</style>
"""
html += "<h3>%s</h3><table><thead><tr><th>Score</th><th>Text</th></tr></thead>" % (query)
for score, text in rows:
html += "<tr><td>%.4f</td><td>%s</td></tr>" % (score, text)
html += "</table>"
display(HTML(html))
for query in ["Positive Apple reports", "Negative Apple reports", "Best planets to explore for life", "LA Dodgers good news", "LA Dodgers bad news"]:
table(query, ranksearch(query)[:2])
# + [markdown] id="kDx7IBPXR1eS"
# # Next
# In part 3 of this series, we'll explore using word embeddings vs transformer embeddings.
| examples/02_Build_an_Embeddings_index_with_Hugging_Face_Datasets.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .jl
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Julia 1.7.1
# language: julia
# name: julia-1.7
# ---
# # Algorithms
versioninfo()
# ## Definition
#
# * Algorithm is loosely defined as a set of instructions for doing something. Input $\to$ Output.
#
# * [Knuth](https://en.wikipedia.org/wiki/The_Art_of_Computer_Programming): (1) finiteness, (2) definiteness, (3) input, (4) output, (5) effectiveness.
# ## Measure of efficiency
#
# * A basic unit for measuring algorithmic efficiency is **flop**.
# > A flop (**floating point operation**) consists of a floating point addition, subtraction, multiplication, division, or comparison, and the usually accompanying fetch and store.
#
# Some books count multiplication followed by an addition (fused multiply-add, FMA) as one flop. This results a factor of up to 2 difference in flop counts.
#
# * How to measure efficiency of an algorithm? Big O notation. If $n$ is the size of a problem, an algorithm has order $O(f(n))$, where the leading term in the number of flops is $c \cdot f(n)$. For example,
# - matrix-vector multiplication `A * b`, where `A` is $m \times n$ and `b` is $n \times 1$, takes $2mn$ or $O(mn)$ flops
# - matrix-matrix multiplication `A * B`, where `A` is $m \times n$ and `B` is $n \times p$, takes $2mnp$ or $O(mnp)$ flops
#
# * A hierarchy of computational complexity:
# Let $n$ be the problem size.
# - Exponential order: $O(b^n)$ (NP-hard="horrible")
# - Polynomial order: $O(n^q)$ (doable)
# - $O(n \log n )$ (fast)
# - Linear order $O(n)$ (fast)
# - Log order $O(\log n)$ (super fast)
#
# * Classification of data sets by [Huber](http://link.springer.com/chapter/10.1007%2F978-3-642-52463-9_1).
#
# | Data Size | Bytes | Storage Mode |
# |-----------|-----------|-----------------------|
# | Tiny | $10^2$ | Piece of paper |
# | Small | $10^4$ | A few pieces of paper |
# | Medium | $10^6$ (megatbytes) | A floppy disk |
# | Large | $10^8$ | Hard disk |
# | Huge | $10^9$ (gigabytes) | Hard disk(s) |
# | Massive | $10^{12}$ (terabytes) | RAID storage |
#
# * Difference of $O(n^2)$ and $O(n\log n)$ on massive data. Suppose we have a teraflop supercomputer capable of doing $10^{12}$ flops per second. For a problem of size $n=10^{12}$, $O(n \log n)$ algorithm takes about
# $$10^{12} \log (10^{12}) / 10^{12} \approx 27 \text{ seconds}.$$
# $O(n^2)$ algorithm takes about $10^{12}$ seconds, which is approximately 31710 years!
#
# * QuickSort and FFT (invented by statistician <NAME>!) are celebrated algorithms that turn $O(n^2)$ operations into $O(n \log n)$. Another example is the Strassen's method, which turns $O(n^3)$ matrix multiplication into $O(n^{\log_2 7})$.
#
# * One goal of this course is to get familiar with the flop counts for some common numerical tasks in statistics.
# > **The form of a mathematical expression and the way the expression should be evaluated in actual practice may be quite different.**
#
# * For example, compare flops of the two mathematically equivalent expressions: `(A * B) * x` and `A * (B * x)` where `A` and `B` are matrices and `x` is a vector.
# +
using BenchmarkTools, Random
Random.seed!(123) # seed
n = 1000
A = randn(n, n)
B = randn(n, n)
x = randn(n)
# complexity is n^3 + n^2 = O(n^3)
@benchmark ($A * $B) * $x
# -
@code_lowered A * B * x
# complexity is n^2 + n^2 = O(n^2)
@benchmark $A * ($B * $x)
# ## Performance of computer systems
#
# * **FLOPS** (floating point operations per second) is a measure of computer performance.
#
# * For example, my laptop has the Intel i7-6920HQ (Skylake) CPU with 4 cores runing at 2.90 GHz (cycles per second).
versioninfo()
# Intel Skylake CPUs can do 16 DP flops per cylce and 32 SP flops per cycle. Then the **theoretical throughput** of my laptop is
# $$ 4 \times 2.9 \times 10^9 \times 16 = 185.6 \text{ GFLOPS DP} $$
# in double precision and
# $$ 4 \times 2.9 \times 10^9 \times 32 = 371.2 \text{ GFLOPS SP} $$
# in single precision.
#
# * In Julia, computes the peak flop rate of the computer by using double precision `gemm!`
# +
using LinearAlgebra
LinearAlgebra.peakflops(2^14) # matrix size 2^14
| slides/07-algo/algo.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
from __future__ import print_function, division
from datetime import timedelta
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
import matplotlib.colors as colors
# could use the sunpy colormaps instead
import sunpy.cm as scm
from matplotlib.colors import LogNorm
from pylab import figure, cm
# %matplotlib inline
import astropy.time
from astropy.io import fits
from astropy import units as u
from sunpy import sun
import sunpy.map
# +
# Let's start by trying to load in the SXI fits outputted but map2fit.pro
# https://hesperia.gsfc.nasa.gov/ssw/gen/idl/maps/map2fits.pro
infile='oAIA_20150901_033606.fits'
aia_map = sunpy.map.Map(infile)
aia_map.peek(draw_limb=True,draw_grid=15*u.deg)
# Does not work
# +
infile2='AIA_20150901_033606.fits'
aia_map = sunpy.map.Map(infile2)
plt.figure(figsize=(10, 8))
plt.subplot()
aia_map.plot_settings['cmap'] = scm.get_cmap('sdoaia304')
aia_map.plot_settings['norm'] = colors.PowerNorm(gamma=0.5,vmax=100)
aia_map.plot()
aia_map.draw_limb(color='white',linewidth=1,linestyle='dashed')
aia_map.draw_grid(color='white',linewidth=1,linestyle='dotted')
plt.show()
#sxi_map.peek(draw_limb=True,draw_grid=15*u.deg)
#sxi_map.meta
# -
| maps/map_test/.ipynb_checkpoints/aia_idlmaps-checkpoint.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# + [markdown] _uuid="178154c1909b80602abc389b22f18688830e8320"
# ## Import required libraries
# + _cell_guid="b1076dfc-b9ad-4769-8c92-a6c4dae69d19" _uuid="8f2839f25d086af736a60e9eeb907d3b93b6e0e5"
import os, fnmatch
import imageio
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
from PIL import Image
Image.LOAD_TRUNCATED_IMAGES = True
from urllib.error import HTTPError
from urllib.request import urlretrieve
from random import shuffle
from sklearn.model_selection import train_test_split
from sklearn import metrics
from keras.models import Model, Sequential
from keras.utils import np_utils, plot_model, to_categorical
from keras.layers import Maximum, ZeroPadding2D, BatchNormalization
from keras.layers import Input, Dense, Flatten, Activation, Dropout
from keras.optimizers import Adam, SGD
from keras import optimizers, regularizers
from keras import backend as K
from keras.initializers import glorot_uniform
from keras.layers.merge import concatenate
from keras.layers.convolutional import Conv2D
from keras.layers.pooling import MaxPooling2D
from keras.preprocessing.image import ImageDataGenerator
from keras.callbacks import ModelCheckpoint, ReduceLROnPlateau
from keras.layers.advanced_activations import LeakyReLU, ReLU
from keras import applications
from keras.applications.inception_v3 import InceptionV3
# + [markdown] _uuid="750898e44f217002c23d730ef2ba9bacf00fc160"
# ### Set variables for further use
# + _cell_guid="79c7e3d0-c299-4dcb-8224-4455121ee9b0" _uuid="d629ff2d2480ee46fbb7e2d37f6b5fab8052498a"
## Set local variables
labelCode = {}
trainImage = []
testImage = []
allImages = []
rows = 256
cols = 256
channels = 3
## Set the path from where images needs to be read
inputFileFolder = "TrainTestImages"
print('Input Files Base Folder: %s' %(inputFileFolder))
# + [markdown] _uuid="f997fcdcc7426fa2acd8e5b8a4bf87d6bec2a0a8"
# ## Read all the folders/files present in input location and create training/test list having URL of the images
# + _uuid="6d35292f73730247684c04be886669b24bda0f77"
## lop through all the files and sub-folders
for root, dirs, files in os.walk(inputFileFolder):
file=[]
## Read images and convert the same into array, also fetch/set their label
for f in files:
img = imageio.imread(os.path.join(root,f))
## If image is a gray scale image, ignore that image
if(len(img.shape)!=3):
continue
## Set the directory elements
file.append(os.path.join(root,f))
allImages.append(os.path.join(root,f))
if(file!=[]):
## Create/update label dictionary
if(dirs == []):
imageLabel = os.path.basename(os.path.normpath(root))
if imageLabel not in labelCode:
labelCode[imageLabel] = len(labelCode)
## Shuffle the image URL's to split in train and test data
shuffle(file)
idxTrain = int(len(file) * 0.7)
trainImage.extend(file[:idxTrain])
testImage.extend(file[idxTrain:])
# + [markdown] _uuid="88ba1a2b3329da5d70b764777e9163a3c55181f7"
# ### Count the number of images in train and test
# + _uuid="c2191c046d68eb6da59b41db11526568e563e3b1"
cntTestImages = len(testImage)
cntTrainImages = len(trainImage)
print('Train Images: %s, Test Images: %s' % (str(cntTrainImages), str(cntTestImages)))
print('Total (%s): %s' %(str(len(allImages)), str(cntTestImages + cntTrainImages)))
#testImage
# + [markdown] _uuid="a6f5bf480b76c4c4c98be0136d8b48ba23daa2f8"
# ## Create methods for Image reading and model creation
# + _uuid="00c2c30e2feff9bb53270a7bc89d12e93cd072b2"
def getImageAndLabels(lsImagePath):
''' This method is used to read the image from the given path and perform following action:
1. Conver image to array
2. Set the label and lable code for the image based on image path
'''
lsImageData = []
lsImageClass = []
lsImageLabel = []
for path in lsImagePath:
img = imageio.imread(path)
## If image is a gray scale image, ignore that image
if(len(img.shape)!=3):
continue
## Set the directory elements
imgPath, filename = os.path.split(path)
## basename returns the directory in which file is present and
## normpath is used to remove slashes at the end
imageLabel = os.path.basename(os.path.normpath(imgPath))
## Add image array to the list
lsImageData.append(img)
## Add image label code to the list
lsImageClass.append(labelCode[imageLabel])
## Add image label desc to the list
lsImageLabel.append(imageLabel)
return (lsImageData, lsImageClass, lsImageLabel)
# + [markdown] _uuid="82ebd6188a1b523c5012274c0dfc1e3174c95bb2"
# ### Methods for creating CNN model
# + _uuid="d9cc5efc1499cce65c7c4df6a9fea27c6d90d838"
# Dense layers set
def dense_set(inp_layer, n, activation, drop_rate=0):
dp = Dropout(drop_rate)(inp_layer)
dns = Dense(n)(dp)
bn = BatchNormalization(axis=-1)(dns)
act = Activation(activation=activation)(bn)
return act
# + _uuid="c8046464defc90b36b467d792eb036a8c84ebc62"
# Conv. layers set
def conv_layer(feature_batch, feature_map, kernel_size=(3, 3),strides=(1,1), padding='same'):
conv = Conv2D(filters=feature_map, kernel_size=kernel_size, strides=strides,
padding=padding)(feature_batch)
bn = BatchNormalization(axis=3)(conv)
act = ReLU()(bn) #LeakyReLU(1/10)(bn)
return act
# + [markdown] _uuid="b21f740350a6f6b353abbaa5d938aaa135732a3d"
# ### Creating models
# + _uuid="8f4d9a24fc4e9b5e5f67bf224c19d062dc861db0"
def get10LayerModel(myoptim = SGD(lr=1 * 1e-1, momentum=0.9, nesterov=True)):
inp_img = Input(shape=(256, 256, 3))
conv1 = conv_layer(inp_img, 64)
conv2 = conv_layer(conv1, 64)
mp1 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(conv2)
conv3 = conv_layer(mp1, 128)
conv4 = conv_layer(conv3, 128)
mp2 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(conv4)
conv5 = conv_layer(mp2, 256)
conv6 = conv_layer(conv5, 256)
conv7 = conv_layer(conv6, 256)
mp3 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(conv7)
# dense layers
flt = Flatten()(mp3)
ds1 = dense_set(flt, 128, activation='relu') ## Changed it from 128 to 512
#ds2 = dense_set(ds1, 512, activation='relu') ## Added this layer
out = dense_set(ds1, num_classes, activation='softmax')
model = Model(inputs=inp_img, outputs=out)
model.compile(loss='categorical_crossentropy', optimizer=myoptim, metrics=['accuracy'])
model.summary()
return model
# + _uuid="1c447168e455b48c709cf620b2f56e1139cb0827"
def get6LayerModel(myoptim = SGD(lr=1 * 1e-1, momentum=0.9, nesterov=True)):
inp_img = Input(shape=(256, 256, 3))
conv1 = conv_layer(inp_img, 32, padding='same')
mp1 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(conv1)
conv2 = conv_layer(mp1, 64, padding='same')
mp2 = MaxPooling2D(pool_size=(5, 5), strides=(2, 2))(conv2)
conv3 = conv_layer(mp2, 128)
mp3 = MaxPooling2D(pool_size=(5, 5), strides=(2, 2))(conv3)
conv4 = conv_layer(mp3, 256)
mp4 = MaxPooling2D(pool_size=(7, 7), strides=(2, 2))(conv4)
# dense layers
flt = Flatten()(mp4)
ds1 = dense_set(flt, 64, activation='relu')
ds2 = dense_set(ds1, 128, activation='relu')
out = dense_set(ds2, num_classes, activation='softmax')
model = Model(inputs=inp_img, outputs=out)
model.compile(loss='categorical_crossentropy', optimizer=myoptim, metrics=['accuracy'])
model.summary()
return model
# + _uuid="42d8a5ef10bdfb563a3b496b027642195857e2be"
# simple model
def getSimpleModel(myoptim = SGD(lr=1 * 1e-1, momentum=0.9, nesterov=True)):
inp_img = Input(shape=(256, 256, 3))
conv1 = conv_layer(inp_img, 32)
mp1 = MaxPooling2D(pool_size=(4, 4))(conv1)
# dense layers
flt = Flatten()(mp1)
ds1 = dense_set(flt, 256, activation='relu')
out = dense_set(ds1, num_classes, activation='softmax')
model = Model(inputs=inp_img, outputs=out)
model.compile(loss='categorical_crossentropy',
optimizer=myoptim,
metrics=['accuracy'])
model.summary()
return model
# + _uuid="e20f25685e08c224008e000dcdd3741ac21ae7ee"
def trainAndPredictModel(model, x_train, x_test, y_train, y_test, epochs=50, batchSize=16):
''' This method is used to train and test the model and it also creates the confusion matrix'''
## Training and validating the model
model.fit(x= x_train, y=y_train, epochs=epochs, batch_size=batchSize, verbose=2, shuffle=True)
acc = model.evaluate(X_test,y_test)
print("=====================================================================================")
print("Accuracy of the model: %s" %(str(acc)))
print("=====================================================================================")
## Creating confusion matrix and heat-map
ypred = np.zeros((y_test.shape))
y_predict = model.predict(x_test)
for idx, val in enumerate(y_predict):
ypred[idx, np.argmax(val)] = 1
return (model, ypred)
# + _uuid="59df8f7559b051d041a9f5bb6eaacab74bb1fba6"
def createConfusionMatrix(y_test, y_pred):
cr = metrics.classification_report(y_test,y_pred)
print(cr)
cm = metrics.confusion_matrix(y_test.argmax(axis=1), ypred.argmax(axis=1))
#print(cm)
dfCM = pd.DataFrame(cm, index=list(labelCode), columns=list(labelCode))
plt.figure(figsize=(80,20))
ax = sns.heatmap(dfCM,vmax=8, square=True, fmt='.2f',annot=True,
linecolor='white', linewidths=0.1)
plt.show()
# + [markdown] _uuid="88c929c388c2b9663c6963d8cc9c13b07a57c2d3"
# ## Based on train/test URL, fetching the image array and corresponding label
# + _uuid="744799b3ffbd9cc8a9459e85b16a45958102d46f"
xtrain, ytrain, lbl_train = getImageAndLabels(trainImage)
xtest, ytest, lbl_test = getImageAndLabels(testImage)
# + _uuid="732ea085347fa9d5292c958734dc19fb1d74152f"
X_train = np.asarray(xtrain)
y_train = np_utils.to_categorical(np.array(ytrain))
X_test = np.asarray(xtest)
y_test = np_utils.to_categorical(np.array(ytest))
num_classes = y_train.shape[1]
## conver to float
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
##data needs to be normalized from 0
X_train = X_train/255
X_test = X_test/255
print("X_Train Shape:%s" %(str(X_train.shape)))
print("X_Test Shape:%s" %(str(X_test.shape)))
print("Y_Train Shape:%s" %(str(y_train.shape)))
print("Y_Test Shape:%s" %(str(y_test.shape)))
print("Number of classes:%s" %(str(num_classes)))
# + [markdown] _uuid="22746178a09f0cbd2a2a4dfcd59234e7f2ba0110"
# ### Randomly viewing the train image and corresponding label for verification
# + _uuid="e5414f249523d2d34bb43139c5df9f28ef5183b4"
idx = 1380
print("Label:%s, ClassCode:%s, Encoding:%s" %(lbl_train[idx], ytrain[idx], y_train[idx]))
plt.imshow(X_train[idx])
# + [markdown] _uuid="08f01f4ebf16897fbbec0094d99f16234132e538"
# ## Running various models
# + [markdown] _uuid="522f02c075d3f46872c465e629a27fc6261e472b"
# ### Running simple model
# + _uuid="f207b4e200f1c1c381989037950317c0ff9e4bfa"
model1 = getSimpleModel()
# + _uuid="707d389dfd705a9daadae12e7ebe8d1f2cb3dc46"
_, ypred = trainAndPredictModel(model1, X_train, X_test, y_train, y_test)
# + _uuid="98912f700c103763943ec5f2dd40e67fcff1a454"
createConfusionMatrix(y_test, ypred)
# + [markdown] _uuid="92fb2978b0129a328a881a5cf71b29371435fa19"
# #### Viewing random predicted values
# + _uuid="dede7f185725cc158a31bb4d951450e35faf3777"
idx = 160
print("Predicted value: %s" %(ypred[idx]))
print("Actual value: %s" %(y_test[idx]))
print(labelCode)
plt.imshow(X_test[idx])
# + [markdown] _uuid="3715deb7df00ed60d0c1aa03c3dc1e3282461898"
# ### Running simple model with diff learning rate
# + _uuid="9ee8343664a9a9aeb82cfc69684ec1538530b83b"
model2 = getSimpleModel(optimizers.SGD(lr=0.0001, momentum=0.9))
# + _uuid="3cea4784e91d534ea8ca753db6bc307887c620c2"
_, ypred = trainAndPredictModel(model2, X_train, X_test, y_train, y_test)
# + _uuid="f219ff739095018498a4949f478dfa57d201eb4b"
createConfusionMatrix(y_test, ypred)
# + [markdown] _uuid="77d59a914357b01567dd720227b2a84442c1cc54"
# > ### Running 6 layer model
# + _uuid="5de2006a0c4da1fc841c121d69553ec3d313e291"
model3 = get6LayerModel(myoptim='adam')
# + _uuid="0a0f047d12173eea517fda15ddfb810b8e762a58"
_, ypred = trainAndPredictModel(model3, X_train, X_test, y_train, y_test)
# + _uuid="11404abd11a382ce1234c61fedcf361ea84b9bb5"
createConfusionMatrix(y_test, ypred)
# + [markdown] _uuid="5f8d5091f4157d306149a864c90a089709f99768"
# ## Transfer Learning
# + _uuid="bb93a6f49eab0d7b9db282ce4910d443b0feb893"
def createTransferModel(base_model, freezeLayers=10,
optimizer = optimizers.SGD(lr=0.0001, momentum=0.9)):
# Freeze the layers which you don't want to train. Here I am freezing the first 10 layers.
for layer in base_model.layers[:freezeLayers]:
layer.trainable = False
#Adding custom Layers
x = base_model.output
x = Flatten()(x)
x = Dense(1024, activation="relu")(x)
#x = Dropout(0.5)(x)
x = Dense(1024, activation="relu")(x)
predictions = Dense(num_classes, activation="softmax")(x)
# creating the final model
model_final = Model(input = base_model.input, output = predictions)
# compile the model
model_final.compile(loss = "categorical_crossentropy",
optimizer = optimizer,
metrics=["accuracy"])
model_final.summary()
return model_final
# + _uuid="6e1474b514eaf59901cd8ba733adf56e4ade90b0"
# Fetch the base pre-trained model for creating new model
#base_model = InceptionV3(weights='imagenet', include_top=False, input_shape = (rows, cols, channels))
base_model = applications.VGG16(weights = "imagenet",include_top=False,
input_shape = (rows, cols, channels))
# + _uuid="bfe014e0c0da57ea84129e699c0594dab7d15296"
base_model.summary()
# + _uuid="f8a02e66ac6f4234773898320975af98c100139d"
premodel = createTransferModel(base_model)
# + _uuid="12a0bcbd7ce35d145d41bd881d2091060c8f0ecb"
_, ypred = trainAndPredictModel(premodel, X_train, X_test, y_train, y_test)
# + _uuid="53a1dabcdc1acc57d33e39a3089f5e10465287b0"
createConfusionMatrix(y_test, ypred)
# + _uuid="0ad754638660fe6b904ef128ccac686a64b4a2ea"
| models/vgg16transferlearning.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: ward49
# language: python
# name: ward49
# ---
# ## Import Required Packages
# +
# pip install sodapy
# +
# pip install shapely
# +
# pip install geos
# +
# Import pandas library using an alias
import pandas as pd
# library to handle data in a vectorized manner
import numpy as np
# Converts JSON data to list of dictionaries
from sodapy import Socrata
# Find if a point is within a geographic polygon
from shapely.geometry import shape, Point
# To read json data
import json
# -
# ## Define Boundaries of Ward 49
# Data downloaded from
# https://data.cityofchicago.org/Facilities-Geographic-Boundaries/Boundaries-Wards-2015-/sp34-6z76
f = open('Boundaries - Wards (2015-).geojson')
data = json.load(f)
data['features'][0]
data['features'][0]['properties']
for feature in data['features']:
if feature['properties']['ward'] == "49":
print("This is ward 49")
ward49_poly = shape(feature['geometry'])
# ## Import Library Data
# +
# Unauthenticated client only works with public data sets. Note 'None'
# in place of application token, and no username or password:
client = Socrata("data.cityofchicago.org", None)
# First 2000 results, returned as JSON from API / converted to Python list of
# dictionaries by sodapy.
results = client.get("x8fc-8rcq", limit=2000)
# -
# Convert to pandas DataFrame
library_df = pd.DataFrame.from_records(results)
library_df.head()
library_df.columns
# Drop unwanted columns
drop_list = [':@computed_region_rpca_8um6',
':@computed_region_vrxf_vc4k', ':@computed_region_6mkv_f3dw',
':@computed_region_bdys_3d7i', ':@computed_region_43wa_7qmu']
library_df.drop(drop_list, axis=1, inplace=True)
library_df.head()
library_df.isnull().sum()
library_df['hours_of_operation'].replace(np.nan, "Not listed", inplace=True)
library_df.isnull().sum()
library_df[library_df['hours_of_operation'] == 'Not listed']
library_df.dtypes
#results_df['latitude'] = results_df['location'].apply(lambda x: x['latitude'])
library_df['latitude'] = pd.to_numeric(library_df['location'].apply(lambda x: x['latitude']))
library_df.head()
library_df.dtypes
library_df['longitude'] = pd.to_numeric(library_df['location'].apply(lambda x: x['longitude']))
library_df.head()
library_df.drop('location', axis=1, inplace=True)
library_df.head()
library_df['url'] = library_df['website'].apply(lambda x: x['url'])
library_df.head()
library_df.drop('website', axis=1, inplace=True)
library_df.head()
library_df.rename(columns={'name_':'name'}, inplace=True)
library_df.head()
library_df['loc_type_pri'] = "Library"
library_df['loc_type_sec'] = "Library"
library_df.head()
library_column_list = library_df.columns.to_list()
library_column_list
# ## Import School Data
# +
#https://data.cityofchicago.org/resource/p83k-txqt.json
# client = Socrata("data.cityof<EMAIL>", None)
# First 2000 results, returned as JSON from API / converted to Python list of
# dictionaries by sodapy.
results = client.get("p83k-txqt", limit=2000)
# Convert to pandas DataFrame
schools_df = pd.DataFrame.from_records(results)
schools_df.head()
# -
schools_df.columns.to_list()
column_drop_list = ['the_geom','school_id',
':@computed_region_rpca_8um6',
':@computed_region_vrxf_vc4k',
':@computed_region_6mkv_f3dw',
':@computed_region_bdys_3d7i',
':@computed_region_43wa_7qmu']
schools_df.drop(column_drop_list, axis=1, inplace=True)
schools_df.head()
schools_df.dtypes
schools_df['lat'] = pd.to_numeric(schools_df['lat'])
schools_df['long'] = pd.to_numeric(schools_df['long'])
schools_df.dtypes
schools_df['grade_cat'].value_counts()
def convert_schools_type(col):
if col == 'ES':
return 'Elementary School'
elif col == 'HS':
return 'High School'
else:
return 'School'
schools_df['loc_type_sec'] = schools_df.apply(lambda x: convert_schools_type(x['grade_cat']), axis=1)
schools_df.head()
schools_df.drop('grade_cat', axis=1, inplace=True)
schools_df.head()
schools_df.isnull().sum()
# change names to match first dataset
schools_df.rename(columns={'short_name': 'name',
'lat': 'latitude',
'long': 'longitude'},
inplace=True)
schools_df.head()
schools_df['loc_type_pri'] = "School"
schools_df.head()
schools_df['name'] = schools_df['name'].str.title()
schools_df['address'] = schools_df['address'].str.title()
schools_df.head()
# ## Import police stations
#https://data.cityofchicago.org/resource/z8bn-74gv.json
results = client.get("z8bn-74gv", limit=2000)
police_df = pd.DataFrame.from_records(results)
police_df.head()
police_df.shape
police_df.columns
police_df.drop(['district',
':@computed_region_rpca_8um6',
':@computed_region_vrxf_vc4k',
':@computed_region_6mkv_f3dw',
':@computed_region_bdys_3d7i',
':@computed_region_43wa_7qmu',
':@computed_region_awaf_s7ux'],
axis=1,
inplace=True)
police_df.head()
police_df.drop(['x_coordinate', 'y_coordinate','location','fax','tty'], axis=1, inplace=True)
police_df['url'] = police_df['website'].apply(lambda x: x['url'])
police_df.head()
police_df.rename(columns={'district_name':'name'}, inplace=True)
police_df.drop(['website'], axis=1, inplace=True)
police_df['loc_type_pri'] = "Police"
police_df['loc_type_sec'] = "Police"
police_df.head()
police_df.dtypes
police_df['latitude'] = pd.to_numeric(police_df['latitude'])
police_df['longitude'] = pd.to_numeric(police_df['longitude'])
police_df.dtypes
# ## Import public health clinics
#https://data.cityofchicago.org/resource/kcki-hnch.json
results = client.get("kcki-hnch", limit=2000)
clinic_df = pd.DataFrame.from_records(results)
clinic_df
# Nothing in Ward 49
# ## Import park facilities
#https://data.cityofchicago.org/resource/eix4-gf83.json
results = client.get("eix4-gf83", limit=4500)
parks_df = pd.DataFrame.from_records(results)
parks_df.head()
parks_df.shape
parks_df.groupby('facility_n').size()
parks_df.columns
parks_df.rename(columns={'park':'name',
'facility_n':'loc_type_sec',
'x_coord':'longitude',
'y_coord':'latitude'},
inplace=True)
parks_df.head()
parks_df.drop(['objectid','park_no','the_geom','facility_t','gisobjid']
, axis=1
, inplace=True)
parks_df.head()
parks_df.drop_duplicates(subset=['name','loc_type_sec'],
keep='first',
inplace=True)
parks_df.head()
parks_df.dtypes
parks_df['longitude'] = pd.to_numeric(parks_df['longitude'])
parks_df['latitude'] = pd.to_numeric(parks_df['latitude'])
parks_df.dtypes
parks_df['loc_type_pri'] = "Park"
parks_df['name'] = parks_df['name'].str.title()
parks_df['loc_type_sec'] = parks_df['loc_type_sec'].str.title()
parks_df.head()
# ## Import fire stations
#https://data.cityofchicago.org/resource/28km-gtjn.json
results = client.get("28km-gtjn", limit=2000)
fire_df = pd.DataFrame.from_records(results)
fire_df.head()
fire_df.columns
fire_df.drop(['engine',
':@computed_region_rpca_8um6',
':@computed_region_vrxf_vc4k',
':@computed_region_6mkv_f3dw',
':@computed_region_bdys_3d7i',
':@computed_region_43wa_7qmu',
':@computed_region_awaf_s7ux'],
axis=1,
inplace=True)
fire_df.head()
fire_df['longitude'] = pd.to_numeric(fire_df['location'].apply(lambda x: x['longitude']))
fire_df.head()
fire_df['latitude'] = pd.to_numeric(fire_df['location'].apply(lambda x: x['latitude']))
fire_df.head()
fire_df.drop(['location'], axis=1, inplace=True)
fire_df.head()
fire_df['loc_type_pri'] = "Fire Station"
fire_df['loc_type_sec'] = "Fire Station"
fire_df.head()
fire_df['address'] = fire_df['address'].str.title()
fire_df['city'] = fire_df['city'].str.title()
fire_df.head()
# ## Merge Datasets
poi_df = pd.concat([library_df, schools_df, police_df, parks_df, fire_df], ignore_index=True)
poi_df.head()
poi_df.dtypes
poi_df.shape
# ## Create Empty Dataset for Ward Locations
df_column_list = poi_df.columns.to_list()
ward49_df = pd.DataFrame(columns=df_column_list)
ward49_df.dtypes
ward49_df['latitude'] = ward49_df['latitude'].astype(float)
ward49_df['longitude'] = ward49_df['longitude'].astype(float)
ward49_df.dtypes
# ## Save Ward 49 Locations to New Dataset
# determine if each location is in Ward 49
#entries = []
entries = {}
for index, row in poi_df.iterrows():
point = Point(row['longitude'], row['latitude'])
if ward49_poly.contains(point):
print("{}: {} {} is in Ward 49. YAY!!!".format(index, row['name'], row['loc_type_sec']))
#pd.concat([ward49_df, poi_df.loc[index, :]], ignore_index=True)
ward49_df = ward49_df.append(poi_df.loc[index])
#entries.append(row)
#print(pd.DataFrame(row))
#for i in df_column_list:
#print(i, row[i])
#entries.update({i: row[i]})
#print(entries)
#pd.concat([ward49_df, entries], ignore_index=True)
#ward49_df
ward49_df.head()
ward49_df.shape
ward49_df.groupby('loc_type_pri')['name'].count()
ward49_df.groupby('loc_type_sec')['name'].count()
ward49_df[(ward49_df['loc_type_sec'] == 'Basketball Backboard') | (ward49_df['loc_type_sec'] == 'Basketball Court')].sort_values(['name','loc_type_sec'])
ward49_df.drop(ward49_df[ward49_df['loc_type_sec'] == 'Basketball Backboard'].index, inplace=True)
ward49_df.shape
ward49_df[(ward49_df['loc_type_sec'] == 'Fitness Center') | (ward49_df['loc_type_sec'] == 'Fitness Course')].sort_values(['name','loc_type_sec'])
ward49_df.drop(ward49_df[ward49_df['loc_type_sec'] == 'Fitness Course'].index, inplace=True)
ward49_df.shape
ward49_df[(ward49_df['loc_type_sec'] == 'Playground') | (ward49_df['loc_type_sec'] == 'Playground Park')].sort_values(['name','loc_type_sec'])
ward49_df.loc[ward49_df['loc_type_sec'] == 'Playground Park', 'loc_type_sec'] = "Playground"
ward49_df.groupby('loc_type_sec')['name'].count()
beach_df = ward49_df[ward49_df['loc_type_sec'].str.contains('Beach')]
beach_df
#beach_df['name'].apply(lambda x: x.replace('Beach','').strip())
beach_df['name'].str.replace('Beach','',case=False).str.strip()
#beach_df['name'] = beach_df['name'].str.replace('Beach','',case=False).str.strip() #SettingWithCopyWarning
#beach_df.loc[:,'name'] = beach_df['name'].apply(lambda x: x.replace('Beach','')) #SettingWithCopyWarning
#beach_df = beach_df.apply(lambda x: x.name.replace('Beach',''))
beach_df
ward49_df['name'] = ward49_df['name'].apply(lambda x: x.replace('Beach',''))
ward49_df.head()
ward49_df[ward49_df['loc_type_sec'] == 'Beach']
# Save data as file
ward49_df.to_excel(excel_writer='./data/Ward49.xlsx',
sheet_name='Sheet1',
columns=df_column_list,
header=True,
index=False,
verbose=True)
| .ipynb_checkpoints/Ward49_import-checkpoint.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Extraktion der Währungscodes
# Dieses Notebook extrahiert aus der Liste von [Justforex](https://justforex.com/education/currencies) die Währeungscodes für jedes Land und speichert sie in einem CSV.
from bs4 import BeautifulSoup
import requests
import codecs
import pandas
# +
response = requests.get("https://justforex.com/education/currencies")
htmlContent = response.text
htmlContent
# +
soup = BeautifulSoup(htmlContent, "html5lib")
table = soup.table
table
# +
headers = []
for header in table.find_all("th"):
headers.append(header.text)
headers
# +
rows = []
for row in table.find_all("tr"):
rows.append(row)
del rows[0]
rows
# +
def transformList(htmlList):
items = []
for item in htmlList.find_all("li"):
items.append(item.text)
return items
data = []
for row in rows:
dataSet = {}
i = 0
for column in row.find_all("td"):
if headers[i] == "Country":
items = transformList(column)
dataSet[headers[i]] = items
else:
dataSet[headers[i]] = column.text
i += 1
data.append(dataSet)
data
# +
dataframe = pandas.DataFrame(data)
dataframe = dataframe.loc[:,["Currency", "Digital code", "Name", "Symbol", "Country"]]
dataframe.head()
# +
def fillSymbol(row):
if not row["Symbol"]:
row["Symbol"] = row["Currency"]
return row
dataframe = dataframe.apply(fillSymbol, axis=1)
dataframe.head()
# +
dataframe = dataframe.loc[:,["Currency", "Digital code", "Name", "Symbol"]]
dataframe.head()
# +
headers = {
"Currency": "code",
"Digital code": "digitalCode",
"Name": "name",
"Symbol": "symbol"
}
dataframe = dataframe.rename(columns=headers)
dataframe.head()
# +
def escapeUnicode(value):
unicode = str(codecs.unicode_escape_encode(value)[0])
unicode = unicode[2:len(unicode) - 1]
return unicode.replace("\\\\", "\\")
dataframe["symbol"] = dataframe["symbol"].apply(escapeUnicode)
dataframe.head()
# -
dataframe.to_csv("C:\\temp\\currency.csv", index=False)
| database/i18n/data/notebooks/currency-code-extract.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Lab 10.01 : Convolutional layer - demo
import torch
import torch.nn as nn
# ### Make a convolutional module
# * inputs: 2 channels
# * output: 5 activation maps
# * filters are 3x3
# * padding with one layer of zero to not shrink anything
mod = nn.Conv2d( 2 , 5 , kernel_size=3, padding=1 )
# ### Make an input 2 x 6 x 6 (two channels, each one has 6 x 6 pixels )
# +
bs=1
x=torch.rand(bs,2,6,6)
print(x)
# -
# ### Feed it to the convolutional layer: the output should have 5 channels (each one is 6x6)
# +
y=mod(x)
print(y)
# -
# ### Lets look at the 5 filters.
# * Our filters are 2x3x3
# * Each of the filter has 2 channels because the inputs have two channels
mod.weight
| codes/labs_lecture10/lab01_conv_layer/.ipynb_checkpoints/conv_layer_demo-checkpoint.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# + [markdown] colab_type="text" id="N6ZDpd9XzFeN"
# ##### Copyright 2018 The TensorFlow Hub Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# + cellView="both" colab={} colab_type="code" id="KUu4vOt5zI9d"
# Copyright 2018 The TensorFlow Hub Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
# + [markdown] colab_type="text" id="CxmDMK4yupqg"
# # Object detection
#
# <table align="left"><td>
# <a target="_blank" href="https://colab.research.google.com/github/tensorflow/hub/blob/master/examples/colab/object_detection.ipynb">
# <img src="https://www.tensorflow.org/images/colab_logo_32px.png" />Run in Google Colab
# </a>
# </td><td>
# <a target="_blank" href="https://github.com/tensorflow/hub/blob/master/examples/colab/object_detection.ipynb">
# <img width=32px src="https://www.tensorflow.org/images/GitHub-Mark-32px.png" />View source on GitHub</a>
# </td></table>
#
# + [markdown] colab_type="text" id="Sy553YSVmYiK"
# This Colab demonstrates use of a TF-Hub module trained to perform object detection.
# + [markdown] colab_type="text" id="v4XGxDrCkeip"
# ## Imports and function definitions
#
# + cellView="form" colab={} colab_type="code" id="6cPY9Ou4sWs_"
#@title Imports and function definitions
# For running inference on the TF-Hub module.
import tensorflow as tf
import tensorflow_hub as hub
# For downloading the image.
import matplotlib.pyplot as plt
import tempfile
from six.moves.urllib.request import urlopen
from six import BytesIO
# For drawing onto the image.
import numpy as np
from PIL import Image
from PIL import ImageColor
from PIL import ImageDraw
from PIL import ImageFont
from PIL import ImageOps
# For measuring the inference time.
import time
# Check available GPU devices.
print("The following GPU devices are available: %s" % tf.test.gpu_device_name())
# + [markdown] colab_type="text" id="ZGkrXGy62409"
# ## Example use
# + [markdown] colab_type="text" id="vlA3CftFpRiW"
# ### Helper functions for downloading images and for visualization.
#
# Visualization code adapted from [TF object detection API](https://github.com/tensorflow/models/blob/master/research/object_detection/utils/visualization_utils.py) for the simplest required functionality.
# + colab={} colab_type="code" id="D9IwDpOtpIHW"
def display_image(image):
fig = plt.figure(figsize=(20, 15))
plt.grid(False)
plt.imshow(image)
def download_and_resize_image(url, new_width=256, new_height=256,
display=False):
_, filename = tempfile.mkstemp(suffix=".jpg")
response = urlopen(url)
image_data = response.read()
image_data = BytesIO(image_data)
pil_image = Image.open(image_data)
pil_image = ImageOps.fit(pil_image, (new_width, new_height), Image.ANTIALIAS)
pil_image_rgb = pil_image.convert("RGB")
pil_image_rgb.save(filename, format="JPEG", quality=90)
print("Image downloaded to %s." % filename)
if display:
display_image(pil_image)
return filename
def draw_bounding_box_on_image(image,
ymin,
xmin,
ymax,
xmax,
color,
font,
thickness=4,
display_str_list=()):
"""Adds a bounding box to an image."""
draw = ImageDraw.Draw(image)
im_width, im_height = image.size
(left, right, top, bottom) = (xmin * im_width, xmax * im_width,
ymin * im_height, ymax * im_height)
draw.line([(left, top), (left, bottom), (right, bottom), (right, top),
(left, top)],
width=thickness,
fill=color)
# If the total height of the display strings added to the top of the bounding
# box exceeds the top of the image, stack the strings below the bounding box
# instead of above.
display_str_heights = [font.getsize(ds)[1] for ds in display_str_list]
# Each display_str has a top and bottom margin of 0.05x.
total_display_str_height = (1 + 2 * 0.05) * sum(display_str_heights)
if top > total_display_str_height:
text_bottom = top
else:
text_bottom = bottom + total_display_str_height
# Reverse list and print from bottom to top.
for display_str in display_str_list[::-1]:
text_width, text_height = font.getsize(display_str)
margin = np.ceil(0.05 * text_height)
draw.rectangle([(left, text_bottom - text_height - 2 * margin),
(left + text_width, text_bottom)],
fill=color)
draw.text((left + margin, text_bottom - text_height - margin),
display_str,
fill="black",
font=font)
text_bottom -= text_height - 2 * margin
def draw_boxes(image, boxes, class_names, scores, max_boxes=20, min_score=0.5):
"""Overlay labeled boxes on an image with formatted scores and label names."""
colors = list(ImageColor.colormap.values())
try:
font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
20)
except IOError:
print("Font not found, using default font.")
font = ImageFont.load_default()
for i in range(min(boxes.shape[0], max_boxes)):
if scores[i] >= min_score:
ymin, xmin, ymax, xmax = tuple(boxes[i].tolist())
display_str = "{}: {}%".format(class_names[i].decode("ascii"),
int(100 * scores[i]))
color = colors[hash(class_names[i]) % len(colors)]
image_pil = Image.fromarray(np.uint8(image)).convert("RGB")
draw_bounding_box_on_image(
image_pil,
ymin,
xmin,
ymax,
xmax,
color,
font,
display_str_list=[display_str])
np.copyto(image, np.array(image_pil))
return image
# + [markdown] colab_type="text" id="D19UCu9Q2-_8"
# ## Apply module
#
# Load a public image from Open Images v4, save locally, and display.
# + colab={} colab_type="code" id="YLWNhjUY1mhg"
image_url = "https://farm1.staticflickr.com/4032/4653948754_c0d768086b_o.jpg" #@param
downloaded_image_path = download_and_resize_image(image_url, 1280, 856, True)
# + [markdown] colab_type="text" id="t-VdfLbC1w51"
# Apply the TF-Hub module on the downloaded image.
# + colab={} colab_type="code" id="uazJ5ASc2_QE"
with tf.Graph().as_default():
detector = hub.Module(
"https://tfhub.dev/google/faster_rcnn/openimages_v4/inception_resnet_v2/1"
)
image_string_placeholder = tf.placeholder(tf.string)
decoded_image = tf.image.decode_jpeg(image_string_placeholder)
# Module accepts as input tensors of shape [1, height, width, 3], i.e. batch
# of size 1 and type tf.float32.
decoded_image_float = tf.image.convert_image_dtype(
image=decoded_image, dtype=tf.float32)
module_input = tf.expand_dims(decoded_image_float, 0)
result = detector(module_input, as_dict=True)
init_ops = [tf.initialize_all_variables(), tf.tables_initializer()]
session = tf.Session()
session.run(init_ops)
# Load the downloaded and resized image and feed into the graph.
with tf.gfile.Open(downloaded_image_path, "rb") as binfile:
image_string = binfile.read()
result_out, image_out = session.run(
[result, decoded_image],
feed_dict={image_string_placeholder: image_string})
print("Found %d objects." % len(result_out["detection_scores"]))
image_with_boxes = draw_boxes(
np.array(image_out), result_out["detection_boxes"],
result_out["detection_class_entities"], result_out["detection_scores"])
display_image(image_with_boxes)
# + [markdown] colab_type="text" id="WUUY3nfRX7VF"
# ### More images
# Perform inference on some additional images with time tracking.
#
# + colab={} colab_type="code" id="rubdr2JXfsa1"
image_urls = ["https://farm7.staticflickr.com/8092/8592917784_4759d3088b_o.jpg",
"https://farm6.staticflickr.com/2598/4138342721_06f6e177f3_o.jpg",
"https://c4.staticflickr.com/9/8322/8053836633_6dc507f090_o.jpg"]
for image_url in image_urls:
image_path = download_and_resize_image(image_url, 640, 480)
with tf.gfile.Open(image_path, "rb") as binfile:
image_string = binfile.read()
inference_start_time = time.clock()
result_out, image_out = session.run(
[result, decoded_image],
feed_dict={image_string_placeholder: image_string})
print("Found %d objects." % len(result_out["detection_scores"]))
print("Inference took %.2f seconds." % (time.clock()-inference_start_time))
image_with_boxes = draw_boxes(
np.array(image_out), result_out["detection_boxes"],
result_out["detection_class_entities"], result_out["detection_scores"])
display_image(image_with_boxes)
| examples/colab/object_detection.ipynb |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# ___
#
# <a href='https://www.udemy.com/user/joseportilla/'><img src='../../Pierian_Data_Logo.png'/></a>
# ___
# <center><em>Content Copyright by <NAME></em></center>
# # Advanced Modules Exercise Puzzle
#
# It's time to test your new skills, this puzzle project will combine multiple skills sets, including unzipping files with Python, using os module to automatically search through lots of files.
#
# ## Your Goal
#
# This is a puzzle, so we don't want to give you too much guidance and instead have you figure out things on your own.
#
# There is a .zip file called 'unzip_me_for_instructions.zip', unzip it, open the .txt file with Python, read the instructions and see if you can figure out what you need to do!
#
# **If you get stuck or don't know where to start, here is a [guide/hints](https://docs.google.com/document/d/1JxydUr4n4fSR0EwwuwT-aHia-yPK6r-oTBuVT2sqheo/edit?usp=sharing)**
| 4-assets/BOOKS/Jupyter-Notebooks/Overflow/07-Advanced-Modules-Exercise-Puzzle.ipynb |