Aprendizaje Supervisado

Machine Learning

import numpy as np
import pandas as pd

Estructura Proyecto

Importaciones (Libererias que se deben trabajar)

Descripción del dataset

Imagen

De manera escrita, explicar brevemente de que se trata el dataset que se va a trabajar

Problema

En texto, explicar cual es el problema que se quiere resolver con la metodología de CRISP-DM

  • Metodología de 5 por qúe's?
  • Lluvia de ideas
  • Benchmark
  • Espina de pescado (Diagrama de Ishikawa)

Objetivos

Objetivo General. \ 2 o 3 Objetivos especificos.

Hipótesis (cientifica o estadística)

En texto escribir cual es esa hipótesis central que se quiere resolver

Carga De Datos

Ejecución de los comandos para carga datos

  • pandas
  • pd.read_csv() # Lectura
  • pd.read_excel()
  • pd.read_json()
  • pd.read_xml()
  • pd.read_html()
  • open() de python para archivos txt

Describir los datos

Con comandos de pandas como describe e info, describir los datos.

En texto plano describir las columnas.

| Col1 | Descripcion | \ | Col2 | Descripcion |

Uniones de datasets

Si tenemos varios datasets y los debemos unir, este sería el paso para explicarlo.

Podemos unir distinos dataframes con

  • pd.merge
  • pd.join
  • pd.concat
  • pd.stack

Estadística exploratoria

Por cada variable

  • Medidas de tendencia central

    • Media
    • Moda
    • Mediana

  • Medidas de dispersión

    • Desviación estandar
    • Varianza

  • Estadísticos de orden

    • Percentiles
    • Cuartiles

  • Kurtosis

  • Sesgo

  • Máximos y minimos

  • Tablas de frecuencias

Cuando sean categóricas nominales (aunque algunas veces las variables categóricas ordinales también se les aplica) se recomienda transformarlas en variable dummys

Visualización de datos

Estaticos

  • Utilizar matplotlib

  • Utilizar Seaborn

  • Gráficos estaticos

Distintos tipos de gráficos

  • Dispersíon
  • Barras
  • Cajas
  • Rugplots
  • Strips
  • Hexagonales
  • Histogramas
  • KDE
  • Dendograma
  • Mapas de calor (heatmaps)
  • Mapas
  • Mapas coropleticos
  • Pairplots

Análisis de datos faltantes e imputaciones

Utilizar las funciones isnull, is not null, dropna de pandas

Existe una libreria para manejo de nulos se llama missigno

Missingno

Utilizar filtros para hacer imputaciones

df[df["Columna"].isnull()] = -np.inf
df[df["Columna"].isnull()] = df["Columna"].mean()
df[df["Columna"].isnull()] = 0

Agrupaciones

Realizar distintas agrupaciones con la función group de pandas y hacer análisis sobre el resultado.

Tener grupos multindice

pd.groupby(["c1", "c2"])

Funciones sobre agrupaciones. La función apply sobre los grupos

Recuerden que con la función get_groups podemos obtener un diccionario con la lista de indices de cada grupo obtenido.

Filtros

Realizar distintos tipos de filtros a partir de los datos y explicar porque hacerlos sobres sus datos.

df.loc[df["columna"]<0]
df.loc[(df["columna"]<0) & (df["columna"] in not null)]
df.loc[(df["columna"]<0) | (df["columna"] in not null)]
df.loc[((df["columna"]<0) | (df["columna"] in not null)) & ...]

def funcion(x):
  if x["columna1"] is not null:
    return x["columna1"]
  elif x["columna2"] is not null:
    return x["columna2"]
  elif x["columna3"] is not null:
    return x["columna3"]

df["nuevacolumna"] = df.apply(funcion, axis=1)

Construccion de tablas pivote y crosstab

Realizar distintos procesos de tablas pivote.

pd.pivot(df["columna1"], df["columna2"])
pd.melt(df["columna2"])

Pruebas de correlación

Utilizar pruebas de correlación como

  • Pearson
  • Spearman
  • Tau Kendall
  • Prueba de independencia de $\chi^2$ -> chi-cuadrado

Construcción de intervalos de confianza

Algunos intervalos de confianza, respondiendo la hipótesis que se tiene acerca de los datos.

statsmodels

Prueba de hipótesis

Plantearse algunas pruebas de hipótesis sobre los datos

  • Pruebas de una cola de diferencia de medias
  • Pruebas de dos colas de diferencia de medias
  • Utilizar t-student y la Normal
  • Pruebas de homecedasticidad de la varianza
  • Pruebas de normalidad

Gráficos avanzados

Animado o dinamico

  • Utilizar Plotly

  • Gráficos interactivos

Distintos tipos de gráficos

  • Dispersíon
  • Barras
  • Cajas
  • Rugplots
  • Strips
  • Hexagonales
  • Histogramas
  • KDE
  • Dendograma
  • Mapas de calor (heatmaps)
  • Mapas
  • Mapas coropleticos
  • Mapas interactivos
  • Sobre el tiempo

(Opcional) Uso de mapas, mapas coropleticos y datos georeferenciados

Utilizar algunas de las siguientes librerias:

  • Plotly
  • Leaflet
  • Geopandas
  • (opcional) Bokeh

Análisis de regresión y clasificación n-aria

  • Utilizar regresión lineal
  • Utilizar regresión logistica
  • Utilizando Statsmodels

Discusión de los resultados

Limitaciones

Conclusiones

Realizar algunas conclusiones.

Variables dummies o one hot encoding

Suponga que tenemos una serie de pandas de tipo categórico nominal con cuatro datos a,b,c,a

s = pd.Series(list('abca'))
s

Queremos transformar esa variable en varias variables dicotomicas o booleanas.

df = pd.get_dummies(s)
df

df["a"].mean(), df["a"].std()

df["b"].mean(), df["b"].std()

pd.get_dummies(list('abca'))

Que pasa cuando tenemos una variable de tipo categórico nominal con muchas categorías.

En este caso se acostumbra a realizar un proceso de reducción de dimensionalidad. Sin embargo estos lo veremos en el siguiente módulo.

s = pd.Series(list('abcabbccdaaefg'))
s

s.value_counts(normalize = True)

serie = s.apply(
    lambda x: x
    if s.value_counts(normalize = True)[x] > 0.2 else "otro"
    )
serie

serie = s.apply(lambda x: x if x in ("a","b","c") else "otro")
serie

pd.get_dummies(serie)

s = pd.Series(list('abca'))
s

Graficar valores únicos

s.value_counts()

Pandas esa a matplotlib como backend para graficar

pd.options.plotting.backend = "matplotlib"
s.value_counts().plot.bar()

pd.options.plotting.backend = "plotly"

s.value_counts().plot.bar()

Función describe

arreglo = pd.DataFrame(np.ones((1000,5)))

arreglo

arreglo.describe()

La media de tal columan es interesante y es tal valor y me sirve para tal cosa.

arreglo.info()

Columnas

Columna 1 - 20 ->

arreglo.loc[arreglo.loc[1:3, 0] == arreglo.loc[1:3, 1]]

correlacion = df.corr()
sns.heatmap(correlacion)

dataset = pd.DataFrame(np.arange(10).reshape([5,2]))
dataset = dataset.rename(columns={0: "Columna 0", 1: "Columna 1"})

dataset

dataset.columns.get_loc("Columna 0")

list(enumerate(dataset.columns))

dataset.columns.values[dataset.columns.get_loc("Columna 0")+1]

dataset[dataset["Columna 0"]==4].loc[:,dataset.columns.values[dataset.columns.get_loc("Columna 0")+1]]

Optimización con scipy

from scipy.optimize import minimize

def objective_function(x):
  return x ** 2 + 2

res = minimize(objective_function, 5)
res

serie = pd.Series([2,3,5,8])
serie

[minimize(objective_function, x).fun for x in serie]

serie.apply(lambda x: minimize(objective_function,x).fun)

from scipy.optimize import minimize

def objective_function(x, y):
  return 3* x ** 4 - 2 * x + y*3

res = minimize(objective_function, 3, 5)
res

from pyxll import xl_app
def objective_func(arg):
    xl = xl_app()
    # Copy argument values to input range
    xl.Range('C2').Value = float(arg[0])
    xl.Range('C3').Value = float(arg[1])
    # Calculate after changing the inputs
    xl.Calculate()
    # Return the value of the output cell
    result = xl.Range("C4").Value
    return result

def cuadrado(x):
  return x**2

for column in dataset.columns:
  dataset[column + "_cuadrado"] = dataset[column].apply(cuadrado)

dataset

dataset = dataset.infer_objects()

dataset.info()

def infer_df(df, hard_mode=False, float_to_int=False, mf=None):
    ret = {}

    # ToDo: How much does auto convertion cost
    # set multiplication factor
    mf = 1 if hard_mode else 0.5

    # set supported datatyp
    integers = ['int8', 'int16', 'int32', 'int64']
    floats = ['float16', 'float32', 'float64']

    # ToDo: Unsigned Integer

    # generate borders for each datatype
    b_integers = [(np.iinfo(i).min, np.iinfo(i).max, i) for i in integers]
    b_floats = [(np.finfo(f).min, np.finfo(f).max, f) for f in floats]

    for c in df.columns:
        _type = df[c].dtype

        # if a column is set to float, but could be int
        if float_to_int and np.issubdtype(_type, np.floating):
            if np.sum(np.remainder(df[c], 1)) == 0:
                df[c] = df[c].astype('int64')
                _type = df[c].dtype

        # convert type of column to smallest possible
        if np.issubdtype(_type, np.integer) or np.issubdtype(_type, np.floating):
            borders = b_integers if np.issubdtype(_type, np.integer) else b_floats

            _min = df[c].min()
            _max = df[c].max()

            for b in borders:
                if b[0] * mf < _min and _max < b[1] * mf:
                    ret[c] = b[2]
                    break

        if _type == 'object' and len(df[c].unique()) / len(df) < 0.1:
            ret[c] = 'category'

    return ret

infer_df(dataset)

Importar Drive

from google.colab import drive
drive.mount('/gdrive')

import pandas as pd
import numpy as np
dataframe = pd.DataFrame(np.ones([5,5]))

dataframe.to_csv("/gdrive/MyDrive/ejemplo.csv")

Convertir un notebook de colab a un html

!pip install nbconvert

!apt-get install texlive-xetex texlive-fonts-recommended texlive-plain-generic

!jupyter nbconvert --to pdf "1.ipynb"

!jupyter nbconvert --to pdf "1.ipynb"

!jupyter nbconvert --to html --no-input 1.ipynb

Si quiero convertir un html a colab

from bs4 import BeautifulSoup
import json
import urllib.request
#url = 'http://nbviewer.jupyter.org/url/jakevdp.github.com/downloads/notebooks/XKCD_plots.ipynb'
#response = urllib.request.urlopen(url)
#  for local html file
response = open("/1.html")
text = response.read()

soup = BeautifulSoup(text, 'lxml')
# see some of the html
print(soup.div)
dictionary = {'nbformat': 4, 'nbformat_minor': 1, 'cells': [], 'metadata': {}}
for d in soup.findAll("div"):
    if 'class' in d.attrs.keys():
        for clas in d.attrs["class"]:
            if clas in ["text_cell_render", "input_area"]:
                # code cell
                if clas == "input_area":
                    cell = {}
                    cell['metadata'] = {}
                    cell['outputs'] = []
                    cell['source'] = [d.get_text()]
                    cell['execution_count'] = None
                    cell['cell_type'] = 'code'
                    dictionary['cells'].append(cell)

                else:
                    cell = {}
                    cell['metadata'] = {}

                    cell['source'] = [d.decode_contents()]
                    cell['cell_type'] = 'markdown'
                    dictionary['cells'].append(cell)
file = open('notebook.ipynb', 'w')
file.write(json.dumps(dictionary))
file.close()

!jupyter nbconvert --to script /1.ipynb

!sudo apt-get install texlive-xetex texlive-fonts-recommended texlive-plain-generic

!jupyter nbconvert --to pdf /1.ipynb

!cat /proc/meminfo

!nvidia-smi

!cat /proc/cpuinfo

!nproc

import pandas as pd
df = pd.DataFrame({
    'id': [1,1,1,2,2,3,3],
    'departamento': ["Ant", "Suc", "Ant", "Suc", "Ant", "Suc" , "Suc"],
    'product': ['A','A','B','A','B','B','B'],
    'quantity': [2,3,2,1,1,2,1]
})

print(df)

df.groupby("product").agg({"quantity": "mean"})

df2 = df.groupby("product").agg({"quantity": "mean"}).reset_index()
df2

import matplotlib.pyplot as plt
plt.bar(df2["product"], df2["quantity"])

df2 = df.groupby(["product", "departamento"]).agg({"quantity": "mean"}).reset_index()
df2

df2["product"]

df2["product-departamento"] = df2.apply(lambda x: str(x["product"]) + "-" + str(x["departamento"]), axis=1)
df2

import matplotlib.pyplot as plt
plt.bar(df2["product-departamento"], df2["quantity"])

df.groupby(['id','product']).get_group((1, "A"))

df = df.groupby(['id','product']).agg({'quantity':'sum'}).reset_index()

print(df)

import matplotlib.pyplot as plt
import numpy as np

x = np.array([0, 1, 2, 3, 4])
y = np.array([20,34,15,67,23])
custom_ticks = ["Enero", "Febrero", "Marzo", "Abril", "Mayo"]

plt.xticks(x, custom_ticks)
plt.plot(x,y)


import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np

x = np.array([0, 1, 2, 3, 4])
y = np.array([20,34,15,67,23])
custom_ticks = ["Enero", "Febrero", "Marzo", "Abril", "Mayo"]

plt.xticks(x, custom_ticks)
sns.lineplot(x,y)

plt.clim(-4, 4)

import pandas as pd
df = pd.DataFrame({
    'id': [1,1,1,2,2,3,3],
    'departamento': ["Ant", "Suc", "Ant", "Suc", "Ant", "Suc" , "Suc"],
    'product': ['A','A','B','A','B','B','B'],
    'quantity': [2,3,2,1,1,None,None]
})


df.mean(axis=0)

(2+3+2+1+1)/5

Encoding

import pandas as pd
data = pd.read_csv('file_name.csv', encoding='utf-32')
df = pd.read_csv('file.csv', encoding='unicode_escape')
pd.read_csv(filename, delimiter=';')

encoding = "cp1252"
encoding = "ISO-8859-1"

from pathlib import Path
import chardet

filename = "file_name.csv"
detected = chardet.detect(Path(filename).read_bytes())
# detected is something like {'encoding': 'utf-8', 'confidence': 0.99, 'language': ''}

encoding = detected.get("encoding")
assert encoding, "Unable to detect encoding, is it a binary file?"

df = pd.read_csv(filename, encoding=encoding)

And vs &

Si es python puro se utiliza and

3 and 5

import numpy as np
import pandas as pd

df = pd.DataFrame(np.random.rand(20,10))
df

(df[0] > 0) & (df[3]<0)
(df[0] > 0) | (df[3]<0)

Software para video final

  • OBS studio para captura de pantalla

  • KDEnlive para modificación del video

  • Gimp

  • Inkscape

Geopandas

# Creación del objeto Polygon.
p1 = Point((0, 0))
p2 = Point((0, 0))
p3 = Point((0, 0))

p1

p1 = LineString([(0, 0), (3,3)])
p1

p1 = Polygon([(0, 0), (1, 0), (1, 1), (0, 1)])      # Cuadrado azul
p2 = Polygon([(0, 0), (1, 0), (1, 1)])              # Triángulo gris encima del cuadrado p1
p3 = Polygon([(2, 0), (3, 0), (3, 1), (2, 1)])      # Cuadrado rojo
p4 = Point((2, 0))      # Cuadrado rojo


# Creamos el objeto GeoSeries con 3 polígonos.
g = gpd.GeoSeries([p1, p2, p3, p4])

g

# Graficamos el resultado con el método "plot".
g.plot(cmap='coolwarm');

Creacion de colmumna para plotly

df = pd.read_csv('2011_US_AGRI_Exports')
df.head()

" ".join(["o", "oe"])

def funcion(x):
  return "<br>".join([str(column) for column in x])

df.apply(funcion, axis=1)

Opencv

https://medium.com/mlearning-ai/color-shape-and-texture-feature-extraction-using-opencv-cb1feb2dbd73

Carga de archivo a partir de gdrive

image.png

!gdown --id 1Dlew8LZBmCk6CTV3CvsHNwVIN08_EmeC

Exportar tablas en pandas

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randint(10, size=(5,3)))
df

df.to_csv("archivo.xml")

Objeto fecha a columnas

import pandas as pd

date_strings = ['2021/03/18 10:45.123 PM', '2022/01/01 08:30.987 AM', '2022/11/11 01:01.111 PM']

df = pd.DataFrame({"Date": date_strings})
df

df["date"] = pd.to_datetime(df["Date"], format="%Y/%m/%d %I:%M.%f %p")
df

df["date"].dt.year

df['year'] = df['date'].dt.year
df['month'] = df['date'].dt.month
df['day'] = df['date'].dt.day
df['hour'] = df['date'].dt.hour
df['minute'] = df['date'].dt.minute
df['second'] = df['date'].dt.second
df['millisecond'] = df['date'].dt.microsecond // 1000
df['am_pm'] = df['date'].dt.strftime('%p')
df

This website is copyright 2023 All Shaman