Proyecto Python
Proyecto Python
Proyecto Python
################################################################################
###################################
# MODULOS NECESARIOS PARA EL EJERCICIO
################################################################################
###################################
import random # PARA GENERAR NUMEROS ALEATORIOS
import math # PARA FUNCIONES MATEMATICAS COMO POTENCIA Y RAIZ CUADRADA
################################################################################
###################################
# INICIO DEL ALGORITMO
################################################################################
###################################
# INICIALIZAMOS LOS PARAMETROS
num_simulaciones = 100000 # NUMERO DE SIMULACIONES
puntos_dentro = 0 # VARIABLE QUE CUENTA EL NUMERO DE PUNTOS QUE ESTAN
DENTRO DEL RADIO
radio = 1 # RADIO DEL CIRCULO
EJERCICIO 2
################################################################################
###################################
# MODULOS NECESARIOS PARA EL EJERCICIO
################################################################################
###################################
import numpy # PARA GENERAR VARIABLES ALEATORIAS Y USAR FUNCIONES
VECTORIALES
################################################################################
###################################
# INICIO DEL ALGORITMO
################################################################################
###################################
# ESTIMAMOS EL VOLUMEN DE LA ESFERA (Se multiplica por 8 debido a que solo estam
os simulando en un octante)
volumen_estimado = 8 * numpy.mean( arreglo_distancias <= radio )
EJERCICIO 2
################################################################################
###################################
# MODULOS NECESARIOS PARA EL EJERCICIO
################################################################################
###################################
import numpy
import matplotlib.pyplot as plt
################################################################################
###################################
# INICIO DEL ALGORITMO
################################################################################
###################################
# GRAFICAMOS
plt.figure(figsize=(18, 6))
plt.plot( eje_x, eje_y )
plt.plot( eje_x, numpy.repeat(probabilidad, num_simulaciones) )
plt.title("Ejercicio 3")
plt.xlabel("Simulación")
plt.ylabel("Probabilidad")
plt.show()
################################################################################
###################################
# FIN DEL EJERCICIO
################################################################################
###################################
NOTA: Se realizaron 500 simulaciones ya que a más simulaciones, se perdía la gráfica.
In [4]:
################################################################################
###################################
# MODULOS NECESARIOS PARA EL EJERCICIO
################################################################################
###################################
import numpy
import matplotlib.pyplot as plt
################################################################################
###################################
# INICIO DEL ALGORITMO
################################################################################
###################################
################################################################################
###################################
# FIN DEL EJERCICIO
################################################################################
###################################
EJERCICIO 4
################################################################################
###################################
# MODULOS NECESARIOS PARA EL EJERCICIO
################################################################################
###################################
from numpy import mean, zeros # PARA CALCULAR LA MEDIA DE UN ARREGLO Y CRE
AR UN ARREGLO DE CEROS
from numpy.random import uniform # PARA GENERAR VARIABLES ALEATORIAS UNIFORME
S
################################################################################
###################################
# INICIO DEL ALGORITMO
################################################################################
###################################
# INICIO DE LA SIMULACIONES
for i in range(num_simulaciones):
# REESTABLECEMOS LOS VALORES POR DEFECTO
suma = 0
n = 0
# MIENTRAS QUE LA SUMA DE LAS VARIABLES UNIFORMES SEA MENOR A 1, SEGUIRMOS G
ENERANDO NUEVAS VARIABLES
while suma <= 1:
suma += uniform(0,1)
n += 1
# GUARDAMOS EL NUMERO DE VARIABLES UNIFORMES QUE SE HAYAN ALCANZADO A GENERA
R
simulaciones[i] = n
# CALCULAMOS LA ESTIMACION DE e
e_estimada = mean(simulaciones)
print("\nEJERCICIO 5\n")
print("El valor de e estimado es igual a " + str(e_estimada))
################################################################################
###################################
# FIN DEL EJERCICIO
################################################################################
###################################
EJERCICIO 5
################################################################################
###################################
# MODULOS NECESARIOS PARA EL EJERCICIO
################################################################################
###################################
import numpy
from operator import mod # OPERACIOND DE MODULO
################################################################################
###################################
# INICIO DEL ALGORITMO
################################################################################
###################################
# INICIALIZACION DE LOS PARAMETROS
primeros_numeros_primos = 100 # CANTIDAD DE LOS PRIMEROS NUMEROS PRIMO
S QUE SE QUIERE ENCONTRAR
numero = 3 # NUMERO QUE QUEREMOS EVALUAR SI ES PRIM
O O NO
primos_encontrados = numpy.array([2]) # ARREGLO DE NUMEROS PRIMOS, POR DEAULT
INICIA CON EL PRIMER NUMERO PRIMO
NOTA: Si se coloca un número grande de numeros primos, Python oculta los números primos
intermedios.
Es decir, muestra los primeros y ultimos números primos del arreglo. Por ejemplo, con
`primeros_numeros_primos = 10000`
################################################################################
###################################
# MODULOS NECESARIOS PARA EL EJERCICIO
################################################################################
###################################
from matplotlib import pyplot as plt
from scipy.cluster.hierarchy import dendrogram, linkage
import numpy as np
#################º##############################################################
####################################
# INICIO DEL ALGORITMO
################################################################################
###################################
# CREAMOS NUESTRO ARREGLO DE
numeros = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
arreglo = [[i] for i in numeros]
# CREAMOS UNA MATRIZ DE CONCORDANCIA
matriz_concordancia = linkage(arreglo,"complete","euclidean")
# CREAMOS NUESTRO DENDOGRAMA
plt.figure(1,figsize=(18,6))
plt.title("Dendograma jerárquico")
plt.xlabel("Numeros del 1 al 15")
plt.ylabel("Distancia")
dendrogram( matriz_concordancia, leaf_font_size=12, leaf_rotation=0, labels = nu
meros)
plt.show()
################################################################################
###################################
# FIN DEL EJERCICIO
################################################################################
###################################
> EJERCICIO 8 ---------------------------------------------
---------------------------
8) Ejercicio 'ks_didactico_codigo'
In [8]:
################################################################################
###################################
# MODULOS NECESARIOS PARA EL EJERCICIO
################################################################################
###################################
from matplotlib import pyplot as plt
from scipy.cluster.hierarchy import dendrogram, linkage
import numpy as np
import pandas as pd
from statsmodels.distributions.empirical_distribution import ECDF
################################################################################
###################################
# INICIO DEL ALGORITMO
################################################################################
###################################
datos = pd.read_csv("/Users/miguelhinojosamedrano/Downloads/ks_didactico.csv", h
eader=0)
# NOMBRE DE LAS COLUMNAS DEL DATASET
columnas = ["PREV_PORCENTAJE_AVANCE_01","PREV_PROMEDIO_STRM_01","IS_BAJA","CORRE
CTED_CLUST_NUM_RI","dis_campus"]
datos_filtrados = datos[datos["CORRECTED_CLUST_NUM_RI"] == 1]
# VARIABLES QUE NO QUEREMOS CONSIDERAR EN EL ANALISIS
datos_filtrados = datos_filtrados.iloc[:,[0,1,2,4]] # QUITAMOS LA COLUMNA 'CORRE
CTED_CLUST_NUM_RI'
datos_filtrados = datos_filtrados[(datos_filtrados["PREV_PORCENTAJE_AVANCE_01"]
< 1) & (datos_filtrados["PREV_PORCENTAJE_AVANCE_01"] >= 0) &
(datos_filtrados["PREV_PROMEDIO_STRM_01"] > 0) & (datos_filtrad
os["PREV_PROMEDIO_STRM_01"] <= 10)]
# VARIABLES NUMERICAS
int_vec = 2
num_vec = [0,1,2]
datos_numericos = datos_filtrados.iloc[:,num_vec]
# FILTRAMOS RENGLOES QUE NO SEAN NA
temporal = datos_numericos[~datos_numericos.isnull().any(axis=1)]
buenos = temporal[temporal["IS_BAJA"] == 0]
malos = temporal[temporal["IS_BAJA"] == 1]
temporal = ["PREV_PORCENTAJE_AVANCE_01","PREV_PROMEDIO_STRM_01","IS_BAJA"]
# DISTRIBUCIONES ACUMULADAS
qtot = ECDF(datos_filtrados["PREV_PORCENTAJE_AVANCE_01"])
qbuenos = ECDF(buenos["PREV_PORCENTAJE_AVANCE_01"])
qmalos = ECDF(malos["PREV_PORCENTAJE_AVANCE_01"])
rango_var = np.sort(np.unique(datos_filtrados["PREV_PORCENTAJE_AVANCE_01"]))
minimo = np.min(rango_var)
maximo = np.max(rango_var)
# OBTENER LA DIFERENCIA DE LAS DISTRIBUCIONES ACUMULADAS
dif = np.repeat(0.0,len(rango_var))
for i in range(len(dif)):
dif[i] = abs( qbuenos(rango_var[i])-qmalos(rango_var[i]) )
KS = np.max(dif)
# UBICACION DE LAS POBLACIONES DE BUENOS Y MALOS EN EL KS
for i in range(len(dif)):
if (dif[i] == KS):
valor_rango_ks = rango_var[i]
prc_buenos = qbuenos(valor_rango_ks)
prc_malos = qmalos(valor_rango_ks)
# GRAFICA KS
plt.figure(1,figsize=(18,6))
plt.plot(rango_var,qbuenos(rango_var),label="buenos")
plt.plot(rango_var, qmalos(rango_var),label="malos")
plt.axhline(prc_buenos,alpha=0.5,color = "#1F77B4",linestyle="dashed")
plt.axhline(prc_malos ,alpha=0.5,color = "#FF7F0E",linestyle="dashed")
plt.axvline(valor_rango_ks,alpha=0.5,color = "purple",linestyle="dashed")
plt.title("Estadístico KS")
plt.xlabel("Variable Porcentaje de Créditos")
plt.ylabel("Porcentaje de población")
plt.legend(fontsize="x-large")
plt.show()
################################################################################
###################################
# FIN DEL EJERCICIO
################################################################################
###################################
In [9]:
################################################################################
###################################
# MODULOS NECESARIOS PARA EL EJERCICIO
################################################################################
###################################
from matplotlib import pyplot as plt
import numpy as np
import pandas as pd
from sklearn import svm
from math import sqrt
################################################################################
###################################
# INICIO DEL ALGORITMO
################################################################################
###################################
t = 100 # 100^2 observaciones en desarrollo
t2 = 100 # 100^2 observaciones en validacion
np.random.seed(2) # Semilla Aleatoria 1
datos = np.column_stack((np.random.uniform(0,1,t*t), np.random.uniform(0
,1,t*t), np.repeat(0,t*t)))
np.random.seed(3) # Semilla Aleatoria 1
validacion = np.column_stack((np.random.uniform(0,1,t*t), np.random.uniform(0
,1,t*t), np.repeat(0,t*t)))
# PARAMETROS
capas = 14
k = 8
# CODIGO PARA CLASIFICAR A LOS DATOS Y A LA VALIDACION
for l in range(len(datos)):
for i in range(capas):
# CALCULAMOS EL RADIO DEL DATO Y LO COMPARAMOS
radio_dato = sqrt(datos[l,0]**2 + datos[l,1]**2)
if i/k <= radio_dato and radio_dato < (i+1)/k:
datos[l,2] = i
datos[l,2] = datos[l,2] % 2
# CALCULAMOS EL RADIO DE LA VALIDACION Y LO COMPARAMOS
radio_validacion = sqrt(validacion[l,0]**2 + validacion[l,1]**2)
if i/k <= radio_validacion and radio_validacion < (i+1)/k:
validacion[l,2] = i
validacion[l,2] = validacion[l,2] % 2
################################################################################
###################################
# FIN DEL EJERCICIO
################################################################################
###################################
> i = 1
> i = 2
> i = 3
> i = 4
> i = 5
> i = 6
> i = 7
> i = 8
> i = 9
> i = 10
> i = 11
> i = 12
> i = 13
> i = 14
> i = 15
> i = 16
> i = 17
> i = 18
> i = 19
> i = 20
> i = 21
> i = 22
> i = 23
> i = 24
> i = 25
In [10]:
################################################################################
###################################
# MODULOS NECESARIOS PARA EL EJERCICIO
################################################################################
###################################
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
################################################################################
###################################
# INICIO DEL ALGORITMO
################################################################################
###################################
datos = pd.read_csv("https://archive.ics.uci.edu/ml/machine-learning-databases/i
ris/iris.data", header=None,
names=["Sepal.Length","Sepal.Width","Petal.Length","Petal.Len
gth","Species"])
# NOMBRE DE LAS COLUMNAS DEL DATASET
columnas = ["Sepal.Length","Sepal.Width","Petal.Length","Petal.Width","Species"]
# GRAFICA 1 y 2 ----------------------------------------------------------------
-----------------------------------
# En estas 2 graficas, se pretende visualizar la proporcion de registros de cada
'specie'
plt.figure(1,figsize=(18,6))
# Grafica de la izquierda
plt.subplot(1,2,1)
species, conteo = np.unique(datos["Species"], return_counts = True)
x = np.arange(len(species))
plt.bar(x, conteo)
plt.xticks(x, species)
plt.title("Ejercicio 10 - Gráfica 1")
plt.xlabel("Tipos de Especies")
plt.ylabel("Frecuencia de cada Especie")
# Grafica de la derecha
plt.subplot(1,2,2)
plt.pie(conteo, labels=species, colors=['gold', 'yellowgreen', 'lightcoral'],
autopct='%1.1f%%', shadow=True, startangle=140)
plt.axis('equal')
plt.title("Ejercicio 10 - Gráfica 2")
plt.xlabel("Proporción de cada Especie")
plt.show()
# GRAFICA 3 -------------------------------------------------------------------
-----------------------------------
# Se pretende visualizar si hay alguna relación lineal de Sepal.Length vs Sepal.
Width
plt.figure(2,figsize=(18,6))
plt.scatter(datos["Sepal.Length"],datos["Sepal.Width"],marker=".",s=200)
plt.title("Ejercicio 10 - Gráfica 3")
plt.xlabel("Sepal.Length")
plt.ylabel("Sepal.Width")
plt.show()
# GRAFICA 4 -------------------------------------------------------------------
-----------------------------------
# Se pretende visualizar si hay alguna relación lineal de Sepal.Length vs Sepal.
Width
# solo que en lugar de puntos, veremos la 'densidad' por regiones
plt.figure(3,figsize=(18,6))
plt.hist2d(datos["Sepal.Length"],datos["Sepal.Width"])
plt.title("Ejercicio 10 - Gráfica 4")
plt.xlabel("Sepal.Length")
plt.ylabel("Sepal.Width")
plt.show()
# GRAFICA 5 y 6 ---------------------------------------------------------------
-----------------------------------
# Se pretende visualizar la densidad de Sepal.Length y la distribución de Sepal.
Length
plt.figure(4,figsize=(18,6))
# Grafica de la izquierda (densidad)
plt.subplot(1,2,1)
plt.hist(datos["Sepal.Length"],bins=50,density=True)
plt.title("Ejercicio 10 - Gráfica 5")
plt.xlabel("Sepal.Length")
plt.ylabel("Probabilidad")
# Grafica de la derecha (distribución)
plt.subplot(1,2,2)
plt.hist(datos["Sepal.Length"],bins=50,density=True,cumulative=True)
plt.title("Ejercicio 10 - Gráfica 6")
plt.xlabel("Sepal.Length")
plt.ylabel("Probabilidad")
plt.show()
# GRAFICA 7 -------------------------------------------------------------------
-----------------------------------
# Se pretende visualizar la dispersión de los datos por columna
plt.figure(5,figsize=(18,6))
plt.boxplot(datos.iloc[0:10,0:4].values, vert=True, patch_artist=True, labels =
columnas[0:4])
plt.title("Ejercicio 10 - Gráfica 7")
plt.xlabel("Sepal.Length")
plt.ylabel("Probabilidad")
plt.show()
# GRAFICA 8 -------------------------------------------------------------------
-----------------------------------
# Se pretende visualizar la dispersión de los datos por columna con histogramas
# de esta manera, se puede saber si pueden ser separables para un posible analis
is de distriminante
plt.figure(6,figsize=(18,6))
plt.hist(datos.iloc[0:10,0:4].values, bins=50, density=True, histtype='step', st
acked=True)
plt.title("Ejercicio 10 - Gráfica 8")
plt.xlabel("Muestra")
plt.ylabel("Valor")
plt.legend(columnas[0:4])
plt.show()
# GRAFICA 9 -------------------------------------------------------------------
-----------------------------------
# Se pretende visualizar el comportamiento de los datos por columna
plt.figure(7,figsize=(18,6))
plt.plot(datos.iloc[:,0],label=columnas[0])
plt.plot(datos.iloc[:,1],label=columnas[1])
plt.plot(datos.iloc[:,2],label=columnas[2])
plt.plot(datos.iloc[:,3],label=columnas[3])
plt.title("Ejercicio 10 - Gráfica 9")
plt.xlabel("Muestra")
plt.ylabel("Valor")
plt.legend()
plt.show()
# GRAFICA 10 -------------------------------------------------------------------
-----------------------------------
# Se pretende visualizar el comportamiento de los datos por columna
plt.figure(8,figsize=(18,6))
x = np.arange(len(datos))
plt.stackplot(x, datos.iloc[:,0], datos.iloc[:,1], datos.iloc[:,2], datos.iloc[:
,3])
plt.title("Ejercicio 10 - Gráfica 10")
plt.xlabel("Muestra")
plt.ylabel("Valor")
plt.legend(columnas[0:4])
plt.show()
################################################################################
###################################
# FIN DEL EJERCICIO
################################################################################
###################################
------------------------------------------------------------------------ FIN DEL ARCHIVO ------------------
------------------------------------------------------