¡Descarga Formulario Final Gestión de datos y más Ejercicios en PDF de Sistemas de Gestión de Bases de Datos solo en Docsity!
Imports:
import pandas as pd import matplotlib.pyplot as plt import numpy as np from sklearn.preprocessing import StandardScaler
Diccionarios
continentes = { "America": ["Mexico", "USA", "Argentina"], "Europa": ["Inglaterra", "Alemania", "Espana", "Francia", "Italia", "Portugal", "Holanda"] } # DF de dicc dicc = {'titulo':(‘Cien años de soledad', 'La catedral del mar', 'Frida Kahlo', 'El perfume'), 'editorial':('Planeta', 'Plaza y Janes', 'Planeta', 'DK Editores'), 'paginas':(400,680,320,140), 'origen':('Colombia', 'España', 'USA', 'Suecia')} df = pd.DataFrame(dicc)
Leer archivos:
df = pd.read_csv ("path_name" , index_col = "columna que se usara de indice", names = ["lista","de","nombres","de","columnas"], skiprows = num_de_columnas_que_se_va_a_saltar, usecols = ["lista","ConNombres","DeColumnas"], nrows = numDeFilasALeer, skiprows = numDeFilasAOmitir, sep = ‘,’)
Metodos:
df.info() # Da numero de columnas, renglones, tipo de variables de cada columna, cantidad de valores no nulos por cada columna df.describe() _# Default: solo te describe las columnas con valores númericos
Te da min, max, mean, quantiles_
df[["lista","de","columnas"]].describe() # Si son columnas no numericas te da: #Cantidad de valores no nulos, cantidad de valores unicos, valor que mas se repitio, veces que se repitio ese valor df.head(n) #Default: primeros 5 valores #No default: Primeros n renglones df.tail(n) #Default: ultimos 5 renglones #No default: ultimos n renglones df[["lista","de","columnas"]].agg(["sum","mean"]) #Te junta los valores de sum, mean de las columnas en la lista en un df nuevo df.groupby("columna en la que se van a agrupar los valores")["columna en la que se va a aplicar la funcion"].sum() #.mean(),.count(),.max(),... df["columna"].unique() #Te da una lista con los valores unicos de la columna df["columna"].value_counts() #Cuenta cuantos hay de cada uno en esa columna #Igual se puede hacer: df.groupby("columna")["columna"].count() df.rename(columns:{‘viejoNom’:’nuevoNom’})
Añadir columna
nueva_columna = [valores nuevos] df["Nombrense Nueva Columna"] = nueva_columna
Buscar por Indices:
indices = [lista,de,indices] df.loc[indices]
Ordenar
# Por indice: df.sort_index(ascending = False/True) # Por valores de una columna: df.sort_values (by = "nom_columna", ascending = False/True)
Renglon menor/mayor de una columna:
valor_min = df["columna"].min() #.max() renglon_valor_min = df.loc[df["columna"]==valor_min] renglon_valor_min # En caso de valores duplicados renglon_valor_min.drop_duplicates(subset="columna que usamos de parametro para repetidos")
Indice con valor minimo/max
min_index = df["columna"].idxmin() #.idxmax() min_index
Subplots
fig, ax = plt.subplots (nrows= , ncols= , figsize = (,)) ax[ 0 , 0 ].scatter(df["columna 1"], df["columna 2"], color = "b") ax[ 0 , 0 ].set_title("Titulo grafica 1") ax[ 0 , 0 ].set_xlabel("") ax[ 0 , 0 ].set_ylabel("") ax[ 0 , 0 ].set_yticks([ 0 , 1 ], ['No', 'Sí']) #En caso de ser valorado booleano ax[ 0 , 1 ].scatter(df["Columna 1"], df["columna 2"], color = "b") ax[ 0 , 1 ].set_title("Titulo Grafica 2) ax[0,1].set_xlabel("") ax[0,1].set_ylabel("") fig.suptitle("Titulo de todas las graficas") plt.tight_layout() plt.show
Graficas de barras:
plt.barh(df.index, df["columna"], color = "color") #barh horizontal, bar vertical plt.title("titulo") plt.xlabel("Titulo x") plt.ylabel("Titulo y") plt.show #Graficar algo por cantidad #Ejemplo de las películas peliculas_por_años = df.groupby("Year")["Film"].count() plt.bar(peliculas_por_años.index, peliculas_por_años.values) #Graficar de groupby de dos columnas #Ejemplo Futbol df_grouped = df.groupby(["Continente", "Liga"]) ["Pais"].count().reset_index() # Crear la gráfica de barras plt.figure(figsize=( 8 , 5 )) plt.bar(df_grouped["Liga"], df_grouped["Pais"], color=['blue', 'green', 'red']) # Configurar etiquetas plt.xlabel("Ligas") plt.ylabel("Número de Países") plt.title("Cantidad de Países por Liga y Continente") # Rotar etiquetas del eje X para mejor visibilidad plt.xticks(rotation= 45 ) # Mostrar la gráfica plt.show()
Grafica de dispersión
plt.scatter(df["columna1"], df["columna2"])
Histogramas
plt.hist(df["columna"], bins = num, color = "color")
Series
#Series a DF: df = pd.Series("series")
Valores faltantes:
#cantidad de valores nulos por columna: nan = df["columna"].isnull().sum() #Lista de columnas con valores faltantes sin_valores= df.columns[(df.isna()== 1 ).any()] #Eliminar renglones con datos faltantes df= df.dropna(axis = 0 , subset = "edad") # axis = 1 borra las columnas #Rellenar valores faltantes df["columna"] = df["columna"].fillna( 0 ) # Reemplaza NaN con 0 df["columna"] = df["columna"].fillna("Desconocido") # Para columnas de texto df["columna"] = df["columna"].fillna(df["columna"].mean()) # Media df["columna"] = df["columna"].fillna(df["columna"].median()) # Mediana df["columna"] = df["columna"].fillna(df["columna"].mode()[ 0 ]) # Moda (el valor más frecuente) df["columna"] = df["columna"].ffill() # Usa el valor anterior (forward fill) df["columna"] = df["columna"].bfill() # Usa el siguiente valor disponible (backward fill)
Valores duplicados
#Identificar cantidad de valores duplicados: duplicados = df.duplicated() num_duplicados = duplicados[duplicados == True].count()
#ver valores de los coeficientes coeficiente = lr.coef_[ 0 ] coeficiente #ver valor del intercepto intercepto = lr.intercept_ intercepto #Revisar accuracy: y_pred_test = lr.predict(X_test) y_pred_train = lr.predict(X_train) mse = mean_squared_error(y_test, y_pred_test) mae = mean_absolute_error(y_test, y_pred_test) #si es 0 es perfecta, entre más grande peor. No hay criterio para los valores, #tiene que ver con el intervalo en el que estan los valores de las ys r2 = r2_score(y_test,y_pred_test) R2 = 1 b el modelo explica al 100% la variabilidad de Y. Ajuste perfecto. 0.7 <= R2 < 1 b el modelo explica una gran parte de la variabilidad de Y. 0.4 <= R2 < 0.7 b el modelo explica parte de la variabilidad de Y. Hay otros factores que influyen. 0 <= R2 < 0.4 b el modelo NO explica bien la variabilidad de Y. R2 = 0 b el modelo NO tiene capacidad predictiva.
Intepretación de MAE y MSE
Si el MSE es mucho mayor que el MAE, significa que hay algunos errores grandes en el modelo (posibles outliers). Si el MSE y el MAE son cercanos, significa que los errores están distribuidos uniformemente sin valores atípicos extremos. Para interpretación en la misma escala de la variable objetivo, a veces se usa la raíz del MSE (RMSE) en lugar del MSE, ya que tiene las mismas unidades que la variable objetivo. Cuando se dice que el MSE o el MAE son "mayores" o "menores", se refiere a su magnitud en relación con los valores de la variable objetivo y (no directamente con X). #para predecir: df_prediccion = pd.DataFrame({"Col1":[int1] ,"Col2":[int2]}) lr.predict(df_prediccion) #Para visualizar los resultados: plt.figure(figsize=( 8 , 5 )) plt.scatter(y_test, y_pred, alpha=0.5, color="blue") plt.plot([y.min(), y.max()], [y.min(), y.max()], '--', color='red') plt.xlabel("Valores reales de satisfacción") plt.ylabel("Predicción del modelo") plt.title("Predicción vs Realidad") plt.grid(True) plt.show() Arboles de decisión from sklearn.tree import DecisionTreeClassifier from sklearn.model_selection import train_test_split from sklearn.metrics import accuracy_score, confusion_matrix #Crear DF con valores independientes (X), y DF con valor dependiente (y) X = pd.DataFrame(df[["lista", "de", "columnas"]]) #Variables predictoras y = pd.DataFrame(df["columna"]) #variable objetivo #LOS DATOS DEBEN DE SER NÚMERICOS #Convertir categorías a numerios encoder = OrdinalEncoder() valores_codificados = encoder.fit_transform(carreras) df["Carrera"] = valores_codificados.astype(int) #Division en entrenamiento y prueba X_train, X_test, y_train, y_test = train_test_split(X,y, test_size = 0.3, stratify = y) cv_scores = cross_val_score(clf, X_train, y_train, cv = 10 ) _#Parametros a conciderar:
media de las puntuaciones de cada fold_
cv_scores.mean() # de. 0% al 100% con respecto la rendimiento del modelo cv_scores.std() #Desviacion esrandar del modelo. se busca que sea menor a 0. #Entrenamiento del arbol clf = DecisionTreeClassifier(max_depth= 4 ) clf.fit(X_train, y_train) #Evaluación del modelo y_pred = clf.predict(X_test) print("Accuracy:", accuracy_score(y_test, y_pred)) print("Matriz de confusión:\n", confusion_matrix(y_test, y_pred)) #Predicciones con X y_pred = clf.predict(X_test) #Generación de Matriz de confusión: matriz = confusion_matrix(y_test, y_pred) #Cantidad de hojas clf.get_n_leaves()
#Graficar arbol tree.plot_tree(clf, feature_names = X.columns) # Puntuacion de exactitud con los valores reales accuracy_prueba = accuracy_score(y_test, y_pred) _# del 0 al 1
Puntuacion de exactitud con los valores de predicción_
accuracy_entrenamiento = accuracy_score(y_train, clf.predict(X_train)) # del 0 al 1 classification_report(y,y_pred) _#Genera una tabla con todas las metricas
Ejemplo tarea determinar profundidad:_
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, stratify=y, random_state= 42 ) def arbol(n, X_train, y_train): modelo = tree.DecisionTreeClassifier(max_depth=n, random_state= 42 ) modelo.fit(X_train, y_train) plt.figure(figsize=( 20 , 20 )) tree.plot_tree(modelo, feature_names=X.columns) plt.title(f"Árbol de decisión con profundidad:{n}") plt.show() return modelo def accuracy(modelo, X_test, y_test): y_pred = modelo.predict(X_test) return accuracy_score(y_test, y_pred) ## Nueva linea: accuracy_list = [] for n in range( 1 , 7 ): clf = arbol(n, X_train, y_train) acc = accuracy(clf, X_test, y_test) accuracy_list.append(acc) Agrupación: import os os.environ["OMP NUM THREADS"]="1" from sklearn.cluster import KMeans from sklearn.preprocessing import StandardScaler from sklearn.metrics import silhouette_score #Normalizar df: scaler=StandardScaler() df_nrm = pd.DataFrame(scaler.fit_transform(X[["lista","de","columnas"]),columns = ["lista","de","columnas"]) df_nrm.head() # detrerminar cantidad de clusters con silueta y codo: l_inertia = [] silueta = [] for i in range ( 1 , 11 ): kmeans = KMeans (n_clusters = i, n_init = "auto") kmeans.fit(X) l_inertia.append(kmeans.inertia_) if (i >= 2 ): silhouette = silhouette_score(X, kmeans.labels_) silueta.append(silhouette) #graficar: plt.plot(range( 1 , 11 ), inertias, marker = "o") plt.title("Metodo del codo") plt.xlabel("Número de clusters") plt.ylabel("Inercias") plt.show() plt.plot(range( 2 , 11 ), silueta, marker = "o") plt.title("Indice de Silhouette") plt.xlabel("Número de clusters") plt.ylabel("Valor de Solhouette") plt.show() #con valor de clusters declarado: kmeans = (KMeans(n_clusters = n, n_init = "auto")) kmeans.fit(X) #Si son mas de dos variables las que se estas agrupando, si se va a querer graficar los #clusters, el fit se debe de hacer solamente sobre las columnas que se van a graficar kmeans.labels_ #Graficar con clusters: plt.figure(figsize=(int,int)) plt.scatter(df_nrm['Col1'], df_nrm['Col2'], c=kmeans.labels_, cmap='viridis', alpha=0.7) plt.scatter(kmeans.cluster_centers_[:, 0 ], kmeans.cluster_centers_[:, 1 ], color='red', marker='X', s= 100 , label='Centroides') plt.title('') plt.xlabel('Col 1') plt.ylabel('Col 2') plt.grid(True) plt.legend() plt.show()
re.match(patrón, texto) #Busca coincidencias solo al inicio del texto. #Si no coincide desde el primer carácter, no encuentra nada. re.match(r"\d+", "123 gatos").group() _# Sí encuentra
'123'_
re.match(r"\d+", "gatos 123") _# No encuentra nada
None_
re.sub(patrón, reemplazo, texto, banderas) #Reemplaza todas las coincidencias del patrón #con el valor dado. re.sub(r"\d+", "NUM",texto) #sustituye todos los digitos por la palabra NUM re.split(patrón, texto) #Divide el texto usando el patrón como separador re.split(r",\s*", "manzana, pera, plátano") #Resultado: ['manzana', 'pera', 'plátano']
Expresiones Regulares Comunes en Python
Ex pr esi ón Significado Ejemplo de coincidencia \d Un dígito (0-9) 3 , 7 \D Cualquier carácter que no sea un dígito a, @, \w Un carácter alfanumérico o guion bajo (a-z, A-Z, 0-9, _) a, G, 7 , _ \W (^) Cualquier carácter que no sea alfanumérico
\s (^) Un espacio en blanco (espacio, tabulación, salto de línea) , \t, \n \S Cualquier carácter que no sea un espacio en blanco a, 1 ,.
. Cualquier carácter (excepto salto de línea) a, 1 , @, etc. ^ Inicio de la línea ^Hola coincide con "Hola mundo" $ Fin de la línea mundo$ coincide con "Hola mundo"
- Cero o más repeticiones del carácter anterior a* coincide con "", "a", "aaa"
- (^) Una o más repeticiones a+ coincide con "a", "aa", "aaaa" Ex pr esi ón Significado Ejemplo de coincidencia ? (^) Cero o una repetición a? coincide con "" o "a" {n } Exactamente n repeticiones \d{3} coincide con "123" {n ,} Al menos n repeticiones \d{2,} coincide con "23", "4567" {n ,m } Entre n y m repeticiones \d{2,4} coincide con "23", "4567" [. .. ] Uno de los caracteres dentro del conjunto [aeiou] coincide con "a", "e" [^ .. .] Cualquier carácter excepto los del conjunto [^aeiou] excluye vocales Alternancia (OR) g a t o perrocoincide con"gato"o"perro" () (^) Agrupar partes de la expresión (ab)+ coincide con "ab", "abab"
Metacaracteres y símbolos usados en expresiones regulares
Símbolo o conjunto Significado / uso [a-zA-Z0- 9] Acepta cualquier letra minúscula, mayúscula o número
. Representa cualquier carácter , excepto salto de línea . (^) Escapa el punto para que se lea como un punto literal (.) _ (^) El guion bajo (underscore) es un carácter válido en nombres de usuario
- Dentro de corchetes, representa un rango (ej. a-z) [a-zA-Z0- 9._-] Acepta letras, números, punto, guion bajo y guion medio
- (^) El elemento anterior debe aparecer una o más veces @ Se usa de forma literal para separar usuario y dominio (en correos) + Escapa el símbolo más (+) si se quiere buscarlo como carácter literal . Escapa el punto para buscar literalmente "." como separador de dominios [a-zA-Z] (^) Acepta solo letras y requiere al menos 2 caracteres (para la extensión del
Símbolo o conjunto Significado / uso {2,} (^) dominio) #Ejemplo del correo: [a-zA-Z0-9.-]+@[a-zA-Z0-9.-]+.[a-zA-Z]{ 2 ,}
Normalización/Lematización/Enraizamiento de texto:
#descargar recursos: nltk.download("stopwords") nltk.download("punkt") import spacy.cli spacy.cli.download("es_core_news_sm") corpus = [ "El curso fue excelente, me ayudó mucho.", "No me gustó el contenido, esperaba más.", "Muy buen curso, aprendí temas importantes.", "Poco útil, los ejemplos no fueron claros.", "Excelente profesor, pero el material fue confuso." ] corpus = np.array(corpus)
Normalización de corpus:
stop_words = set(stopwords.words("spanish")) import numpy as np def normaliza_documento(doc): doc = doc.lower() doc = re.sub(r"[^a-zA-Záéíóúñ\s]", "", doc) tokenizer = nltk.WordPunctTokenizer() tokens = tokenizer.tokenize(doc) filtered_tokens = [token for token in tokens if token not in stop_words] return " ".join(filtered_tokens) corpus = np.array(corpus) corpus_normalizado = np.vectorize(normaliza) corpus_normalizado = corpus_normalizado(corpus) corpus_normalizado
Lematización de corpus:
import spacy nlp = spacy.load("es_core_news_sm") def lematizacion(docto): palabras_con_lemma = [] palabras = docto.split() doc = nlp(" ".join(palabras)) for token in doc: palabras_con_lemma.append(token.lemma_) docto_lemma = " ".join(palabras_con_lemma) return docto_lemma corpus_lematizado = np.vectorize(lematizacion) corpus_lematizado = corpus_lematizado(corpus_normalizado) corpus_lematizado
Enraizamiento de corpus:
#Stemming: stemmer = SnowballStemmer("spanish") def enraizamiento(docto): palabras_con_raiz = [] palabras = docto.split() for palabra in palabras: palabras_con_raiz.append(stemmer.stem(palabra)) docto_raiz = " ".join(palabras_con_raiz) return docto_raiz corpus_enraizado = np.vectorize(enraizamiento) corpus_enraizado = corpus_enraizado(corpus_normalizado) corpus_enraizado
Remplazar elementos de una columna para convertir a float
df["ColumnaNumerica"] =(df["Columna"].str.replace("$","")) df["ColumnaNumerica"] = df["ColumnaNumerica"].astype("float64") Parcial 3 Web Scrapping import requests import re from bs4 import BeautifulSoup url = "https:// DirecciónPáginaWeb /" pag_html = requests.get(url) pag_html.status_code # == 200 significant que OK sopa = BeautifulSoup(pag_html.text, "html5lib") #Título de la página print (sopa.title)
Frecuencia de palabras #Frecuenica: from nltk.probability import FreqDist import matplotlib.pyplot as plt from wordcloud import WordCloud #Obtener todas las palabras del Corpus palabras = [] for documento in corpus_normalizado: for palabra in documento.split(): palabras.append(palabra) #Se crea objeto de la clase FreqDist con la lista de palabras freq= nltk.FreqDist(palabras) #Se crea data frame con las n palabras más comunes frecuencia_palabras = pd.DataFrame(freq.most_common(n)) frecuencia_palabras.columns = ["palabra","frecuencia"] frecuencia_palabras
Visualización en grafica de barras:
plt.bar(frecuencia_palabras["palabra"], frecuencia_palabras["frecuencia"]) plt.xticks(rotation = 90 ) plt.show()
Visualización en nube de palabras:
nube_palabras = WordCloud().generate (" ".join(palabras)) #Se despliéga la imagen generada plt.imshow(nube_palabras, interpolation = "bilinear") plt.axis("off") plt.show() POS Tagging Consiste en identificar y etiquetar las parted del discurso (sustantivos, verbos, adjetivos) en un texto import spacy nlp = spacy.load("es_core_news_sm") corpus = ["n0","n1","n2","..."] documento = nlp(corpus[n]) #n es la linea del corpus que quieres tomar for palabra in documento: print(palabra.text, palabra.pos_) #extraccion de sustantivos: for palabra in documento: if palabra.pos_ in ["NOUN","PROPN"]: print(palabra.text,palabra.pos_) #Extraccion de adjetivos: for palabra in documento: if palabra.pos_ == "ADJ": print(palabra.text,palabra.pos_) #Extraccion de verbos: for palabra in documento: if palabra.pos_ == "VERB": print(palabra.text,palabra.pos_) Etiqueta Categoría gramatical Ejemplos ADJ Adjetivo grande, azul, feliz ADP (^) Adposición en, sobre, bajo, hacia ADV (^) Adverbio rápidamente, muy, ayer AUX Verbo auxiliar ha, había, será, estar CCONJ Conjunción coordinante y, o, pero DET Determinante el, la, un, mi, ese INTJ Interjección ¡ay!, ¡hola!, ¡uf! NOUN (^) Sustantivo común casa, perro, libro NUM (^) Número uno, tres, primero, segundo PART Partícula gramatical que, no, se PRON Pronombre yo, tú, él, lo, nosotros PROPN Nombre propio México, Juan, Google PUNCT Signo de puntuación ., ,, ¿, ¡,! SCONJ (^) Conjunción subordinante aunque, porque, mientras SYM (^) Símbolo %, $, @, + VERB Verbo principal correr, ser, tener, comer X Otro / indefinido ok, iPhone, lol Análisis semántico: sinónimos con wordnet import nltk from nltk.corpus import wordnet as wn nltk.download("wordnet") nltk.download("omw-1.4") verbos = ["comer", "correr", "leer"] # Lista de verbos en español for verbo in verbos: sinonimos = wn.synsets(verbo, lang="spa") # Buscar synsets en
español print(f"Sinónimos de '{verbo}':") for syn in sinonimos: lemmas = syn.lemmas(lang="spa") # Obtener lemas en español for l in lemmas: print("-", l.name()) # Imprimir nombre del sinónimo print("\n") # Separador visual Datos Georefernciados # Imports necesarios import matplotlib.pyplot as plt import geopandas as gpd import pandas as pd
Leer archivo en formato .shp
mapa_shp=gpd.read_file("ubicacion.shp") _# Emplea la función plot sobre el geo df para que observes que representan los datos en él
(todo el mapa es un mismo objeto)_
mapa_shp.plot() plt.title("Mapa SHP") plt.show()
Leer archivo en formato geojason
mapa_gj = gpd.read_file("ubicación.geojson") # renglónes/coulumnas: mapa_gj.shape #Graficarlo por geometría de poligonos (muestra fronteras) mapa_gj.plot() plt.title("Mapa Geojson") plt.show()
Parametros de diseño
Existen parámetros para personalizar las gráficas obtenidas con .plot de geo df:
edgecolor="nombreDelColor" para especificar las líneas divisorias en el mapa
color="nombreColor" para el relleno de cada área delimitada en el mapa
column="nombreColumna" para colorear de diferente color empleando la columna
como atributo (sólo 10 tonos diferentes para elementos categóricos por default)
figsize=(ren,col) para especificar tamaño de la figura donde se desplegará el mapa
mapa_gj.plot(edgecolor = "grey", color = "coral") #Fronteras grises, estados coral mapa_gj.plot(edgecolor = "black", column = "ENTIDAD") #Fronteras negras, estados de 10 diferentes colores mapa_gj.plot(edgecolor = "black", column = "ENTIDAD", figsize = ( 15 , 10 )) _#Cambio en el tamaño
Desplegar información de un renglon:_
slp = mapa_mx_gj.loc[mapa_mx_gj["ENTIDAD"]=="SAN LUIS POTOSI"] #Graficar unicamente un estado: slp.plot() plt.title("San Luis Potosi") plt.show()
Cambio de coordenadas de latitud/longitud a metros
mapa_gj.crs # Si en el primer renglón aparece algo parecido a EPSG: #y en los ejes habla de latitud, longitud, entonces no esta proyectado #Hacemos el cambio a coordenadas X,Y en metros mapa = mapa_gj.to_crs(epsg= 3857 )
Métodos Geométricos:
mapa.area #Calcula el área de cada geometria mapa.centroid #Calcula el centroide de cada geometria mapa.length #Calcula el perimétro de cada geometria mapa.distance(otra_geometria) #Calcula la distancia a una geometría especifica #disancia de un punto especifico a las geometrias #ejemplo estadio azteca
