def max (n1, n2): if n1 > n2: print(n1) elif n2 > n1: print(n2) else: print("Son iguales")

max(799,1)

def max_de_tres (n1, n2, n3): if n1 == n2 and n2 == n3 and n1 == n3: print('Los tres numeros son iguales') elif n1 >= n2 and n1 >= n3: print(n1) elif n2 >= n1 and n2 >= n3: print(n2) elif n3 >= n1 and n3 >= n2: print(n3) else: print("Ingrese otras vez los numeros, por favor")

max_de_tres(1,0,0)

def largor (entrada): contador = 0 for item in entrada: contador += 1 return contador

largor("Onomatopeya")

def vocal (caracter): l_vocales = ['a','e','i','o','u'] if caracter in l_vocales: print(f"El caracter '{caracter}' es una vocal") else: print("No es una vocal")

vocal('u')

def suma(lista): suma=0 for item in range(len(lista)): suma=suma+lista[item] return suma

suma([1,1,1,10,10,10])

def reverso (cadena): reversada = cadena[::-1] print(reversada)

cadena = 'estoy probando' reverso(cadena)

def generar_n_caracteres(n, carcater): resultado = carcater*n print(resultado)

generar_n_caracteres(5,'z')

import pandas as pd import numpy as np import matplotlib.pyplot as plt import seaborn as sns from sklearn.model_selection import train_test_split from sklearn.linear_model import LinearRegression from sklearn.metrics import mean_squared_error #from sklearn import datasets

# Importar la base #boston_data = datasets.load_boston() data_url = "http://lib.stat.cmu.edu/datasets/boston" raw_df = pd.read_csv(data_url, sep="\s+", skiprows=22, header=None) data = np.hstack([raw_df.values[::2, :], raw_df.values[1::2, :2]]) target = raw_df.values[1::2, 2]

#df = pd.DataFrame(boston_data.data, columns=boston_data.feature_names) feature_names = ['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT'] df = pd.DataFrame(data, columns=feature_names) df.head()

#df['MEDV'] = boston_data.target df['MEDV'] = target df.head()

df.isnull()

df.isnull().sum()

# columnas a usar en el dataframe categorica_test = ["blanca", "roja", "verde"] continua_test = [1, 2, 3] # pásalas a formato dataframe df_test = pd.DataFrame(list(zip(categorica_test, continua_test)), columns =['color', 'valor']) df_test

pd.get_dummies(df_test,columns=['color'])

precios = df.MEDV # Algunas estadísticas básicas precio_minimo = np.min(precios) # Alternativa usando Pandas # precio_minimo = precios.min() precio_maximo = np.max(precios) # Alternativa usando Pandas # precio_maximo = precios.max() precio_promedio = np.mean(precios) # Alternativa usando Pandas # precio_promedio = precios.mean() precio_mediano = np.median(precios) # Alternativa usando Pandas # precio_mediano = precios.median() precio_desvest = np.std(precios) # Alternativa usando Pandas # precio_desvest = precios.std(ddof=0) # Otras estadísticas cuartil_1 = np.percentile(precios, 25) cuartil_3 = np.percentile(precios, 75) inter_cuartil = cuartil_3 - cuartil_1 # Muestra las estadísticas print ("Estadísticas para el conjunto de datos de Boston-Dataset:\n") print ("Precio Mínimo: ${:,.2f}".format(precio_minimo)) print ("Precio Máximo: ${:,.2f}".format(precio_maximo)) print ("Precio Promedio: ${:,.2f}".format(precio_promedio)) print ("Precio Mediano: ${:,.2f}".format(precio_mediano)) print ("Desviación Estándar de Precios: ${:,.2f}".format(precio_desvest)) print ("Primer Cuartil de Precios: ${:,.2f}".format(cuartil_1)) print ("Tercer Cuartil de Precios: ${:,.2f}".format(cuartil_3)) print ("Rango Intercuantílico de Precios: ${:,.2f}".format(inter_cuartil))

sns.set(rc={'figure.figsize':(11.7,8.27)}) sns.histplot(df['MEDV'], bins=30) plt.show()

plt.plot(df.B, df.MEDV, 'o') # 'o' muestra scatter (por defecto es línea)

x = "INDUS" y = "MEDV" sns.lmplot(x=x,y=y,data=df)

precios = df.MEDV columnas = ["LSTAT", "RM", "INDUS"] for i, col in enumerate(columnas): sns.lmplot(x=col,y="MEDV",data=df,fit_reg=True)

correlation_matrix = df.corr().round(2) # annot = True; para imprimir los valores en cada cuadro sns.heatmap(data=correlation_matrix, annot=True)

# renombra las variables para usar las convenciones de X, y X_rooms = df.RM # única variables explicativa y_price = df.MEDV # variable a predecir

X_rooms

X_rooms.shape

# es mejor usar arreglos tamaño (n, 1) X_rooms = np.array(X_rooms).reshape(-1,1) y_price = np.array(y_price).reshape(-1,1) print(X_rooms.shape) print(y_price.shape)

# en una sóla línea de código se obtienen los cuatros segmentos X_train_1, X_test_1, Y_train_1, Y_test_1 = train_test_split(X_rooms, y_price, test_size = 0.2, random_state=5) # asegúrate que las dimensiones de los datos son las esperadas print(X_train_1.shape) print(X_test_1.shape) print(Y_train_1.shape) print(Y_test_1.shape)

# instancia el modelo reg_1 = LinearRegression() reg_1.fit(X_train_1, Y_train_1) # estima el modelo siempre con datos de entrenamiento y_train_predict_1 = reg_1.predict(X_train_1) # genera las predicciones # RMSE en numpy usa sólo los valores reales y las predicciones rmse = (np.sqrt(mean_squared_error(Y_train_1, y_train_predict_1))) # en scikitlearn se estima en una sóla línea las predicciones r2 = round(reg_1.score(X_train_1, Y_train_1),2) print("Desempeño del modelo para los datos de entrenamiento") print("--------------------------------------") print('RMSE: {}'.format(rmse)) print('R2: {}'.format(r2))

# evaluación del modelo para datos de test y_pred_1 = reg_1.predict(X_test_1) rmse = (np.sqrt(mean_squared_error(Y_test_1, y_pred_1))) r2 = round(reg_1.score(X_test_1, Y_test_1),2) print("Desempeño del modelo para los datos de test") print("--------------------------------------") print("RMSE: {}".format(rmse)) print("R2: {}".format(r2))

# 1. Definiendo variables # "X" -> conjunto de variables explicativas # "y" -> variable a predecir (precios) x = df.drop(columns=['MEDV']) y = df.MEDV # 2. Segmentación de Train y Test x_train, x_test, y_train, y_test = train_test_split(x, y_price, test_size = 0.2, random_state=42) # 3. Instanciar la regresión lineal y ajustar el modelo reg_all = LinearRegression() reg_all.fit(x_train, y_train) # 4. Generar las predicciones sobre el conjunto X de entrenamiento y_train_predict_all = reg_all.predict(x_train) # 4a. Calcular el RMSE y R2 rmse = (np.sqrt(mean_squared_error(y_train, y_train_predict_all))) r2 = round(reg_all.score(x_train, y_train),2) print("Desempeño del modelo para los datos de entrenamiento") print("--------------------------------------") print('RMSE: {}'.format(rmse)) print('R2: {}'.format(r2))

# 5. Generar las predicciones sobre el conjunto X de test y_pred = reg_all.predict(x_test) rmse = (np.sqrt(mean_squared_error(y_test, y_pred))) r2 = round(reg_all.score(x_test, y_test),2) print("Desempeño del modelo para los datos de test") print("--------------------------------------") print("RMSE: {}".format(rmse)) print("R2: {}".format(r2))

# pasa los precios reales de test y los pronósticos para graficarlos plt.scatter(y_pred, y_test) # dos argumentos # estas 5 líneas de código no necesitas modificarlas plt.xlabel("Precio Real ($1000)") plt.ylabel("Precio Pronosticado ($1000)") plt.title("Precios Reales vs. Precios Pronosticados de Casas")

import pandas as pd import numpy as np import matplotlib.pyplot as plt import seaborn as sn from sklearn.model_selection import train_test_split from sklearn.preprocessing import LabelEncoder from sklearn.preprocessing import MinMaxScaler from sklearn.linear_model import LogisticRegression from sklearn.metrics import confusion_matrix

tc_data = pd.read_csv('crx.data', header=None) tc_data.head()

# diccionario con nombres nuevas_variables = { 0: "genero", 1: "edad", 2: "deuda", 3: "estado_civil", 4: "cliente", 5: "educacion", 6: "etnia", 7: "años_empleado", 8: "no_pago", 9: "empleado", 10: "score_crediticio", 11: "licencia_conduccion", 12: "ciudadania", 13: "zip", 14: "ingreso", 15: "tarjeta_aprobada" } # usa el diccionario para renombrar las variables tc_data = tc_data.rename(columns = nuevas_variables) tc_data.head()

tc_data.info()

# imprime todos los valores únicos de cada columna for col in tc_data.columns: print(col) print(pd.unique(tc_data[col])) print()

# Reemplaza los '?'s con NaN tc_data = tc_data.replace('?', np.nan)

# Imputar los no reportados con el promedio tc_data.fillna(tc_data.mean(), inplace=True) # Verifica que las variables numéricas no tengan NAN print(tc_data.isnull().sum())

# imputar con el valor más frecuente los valores no reportados en las variables categóricas for col in tc_data.columns: if tc_data[col].dtypes == 'object': tc_data[col].fillna(tc_data[col].mode()[0], inplace=True) # Verifica que las variables numéricas no tengan NAN print(tc_data.isnull().sum())

# 2da revision: imprime todos los valores únicos de cada columna for col in tc_data.columns: print(col) print(pd.unique(tc_data[col])) print()

tc_data.describe()

tc_data.describe(include='object')

# Eliminando las variables tc_data = tc_data.drop(["licencia_conduccion", "zip"], axis=1) tc_data.head()

# Instanciar el Label Encoder le = LabelEncoder() # Hacer la transformación numérica para cada variable categórica for col in tc_data.columns.values: # todas las columnas (pasa los nombres como un arreglo) if tc_data[col].dtypes =='object': # variables categóricas # Usar el Label Encoder para hacer la transformación numérica tc_data[col]=le.fit_transform(tc_data[col])

tc_data.head()

# variables para one-hot encoding dummy_vars = {"genero": str, "estado_civil": str, "cliente": str, "etnia": str, "no_pago": str, "empleado": str, "ciudadania": str, "edad": float} # convierte las variables seleccionadas a categóricas tc_data = tc_data.astype(dummy_vars) tc_data.dtypes

# Crear las nuevas variables dummies tc_data = pd.get_dummies(tc_data, drop_first=True) tc_data

# (Opcional) Re-ordenado las variables: La variable dependiente va al final # Copiar el target en la última columna tc_data["ultima"] = tc_data["tarjeta_aprobada"] # Eliminar la columna inicial del target tc_data = tc_data.drop("tarjeta_aprobada", axis=1) # Nombrar nuevamente para facilidad tc_data.rename(columns={"ultima": "tc_aprobada"}, inplace=True) tc_data

# Convertir dataframe a arreglos de numpy tc_data = tc_data.values tc_data

# Separar las variables explicativas de la variable objetivo X,y = tc_data[:,0:22] , tc_data[:,23] # Segmentación de datos de entrenamiento y test X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=1)

print(f'X_train tiene estructura: {X_train.shape}') print(f'X_test tiene estructura: {X_test.shape}') print(f'\n') print(f'y_train tiene estructura: {y_train.shape}') print(f'y_test tiene estructura: {y_test.shape}')

# Casos NO exitosos (0): Aplicaciones no aprobadas np.count_nonzero(y)

# Casos exitosos (1): Aplicaciones aprobadas y.size - np.count_nonzero(y)

# Revisión de rangos de las varibales explicativas pd.DataFrame(X_train).describe()

# Reescalar X_train y X_test scaler = MinMaxScaler(feature_range=(0,1)) # instanciar rescaledX_train = scaler.fit_transform(X_train) # reescalar X de entrenamiento rescaledX_test = scaler.fit_transform(X_test) # reescalar X de test

# Revisar que los rangos de X_train reescalado sean entre 0 y 1 pd.DataFrame(rescaledX_train).describe()

# Revisa que los rangos de X_test reescalado sean entre 0 y 1 pd.DataFrame(rescaledX_test).describe()

# Instanciar un clasificador de Regresión Logística logreg = LogisticRegression() # Ajustar una regresión a los datos de entrenamiento logreg.fit(rescaledX_train, y_train)

# Usa logreg para predecir aplicaciones de los datos de test y_pronostico = logreg.predict(rescaledX_test) # Matriz de confusión para el modelo logreg matriz_conf = confusion_matrix(y_test, y_pronostico) plt.figure(figsize=(10, 5)) ax = plt.subplot() sn.heatmap(matriz_conf, annot=True, ax = ax, cmap='Blues') plt.xlabel('Predicted') plt.ylabel('True') plt.show()

# Evaluar el modelo en los datos de entrenamiento print("Precisión del clasificador de Reg. logística en train: ", logreg.score(rescaledX_train, y_train)) print("Precisión del clasificador de Reg. logística en test: ", logreg.score(rescaledX_test, y_test))

from sklearn.model_selection import GridSearchCV

# Parametros tol = [0.01, 0.001, 0.0001] max_iter = [150, 200, 300, 1000]

# Crea un diccionario con dos llaves donde tol y max_iter son las llaves y las listas de arriba sus valores correspondientes param_grid = dict(tol = tol, max_iter = max_iter) param_grid # imprime para ver el diccionario

# Crear la instancia de GridSearchCV y guárdala como una variable logreg = LogisticRegression() grid_model = GridSearchCV(estimator = logreg, param_grid = param_grid, cv=5)

# Usar "scaler" para reescalar X y guárdalo en una variable scaler = MinMaxScaler(feature_range=(0,1)) rescaledX = scaler.fit_transform(X)

# Ajustar los datos a grid_model grid_model_result = grid_model.fit(rescaledX, y)

# Summarize results best_score, best_params = grid_model_result.best_score_, grid_model_result.best_params_ # Creating a dictionary to save the best results best_models = {'Logistic': best_score} print(f'Mejor resultado: {best_score}, usando {best_params}')