HINOJOSA MEDRANO MIGUEL

Asignatura Seminario de Estadistica

Universidad Nacional Autónoma de México

> EJERCICIO 1 ---------------------------------------------

---------------------------
1) Estimar π via simulación
In [1]:

################################################################################
###################################
# 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

# INICIO DE LAS SIMULACIONES

for i in range(num_simulaciones):
# SI LA DISTANCIA DEL PUNTO AL CENTRO ES MENOR AL RADIO, AUMENTAMOS EL CONTA
DOR DE PUNTOS DENTRO DEL CIRCULO
if math.sqrt( math.pow( random.uniform(0, radio), 2) + math.pow( random.unif
orm(0, radio), 2) ) <= radio:
puntos_dentro += 1

# CALCULAMOS LA ESTIMACION DE pi (SE MULTIPLICA POR 4 YA QUE SOLO ESTAMOS SIMULA

NDO EN UN CUADRANTE)
pi_estimada = 4*puntos_dentro/num_simulaciones
print("\nEJERCICIO 2\n")
print("El valor de pi estimado es igual a " + str(pi_estimada))
################################################################################
###################################
# FIN DEL EJERCICIO
################################################################################
###################################

EJERCICIO 2

El valor de pi estimado es igual a 3.14424

Recordemos que el valor verdadero de π es:

π ≈ 3.141592653589793
> EJERCICIO 2 ---------------------------------------------
---------------------------
2) Estimar el volumen de una esfera con radio 1
In [2]:

################################################################################
###################################
# MODULOS NECESARIOS PARA EL EJERCICIO
################################################################################
###################################
import numpy # PARA GENERAR VARIABLES ALEATORIAS Y USAR FUNCIONES
VECTORIALES
################################################################################
###################################
# 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

# GENERAMOS ARREGLOS DE NUMEROS ALEATORIOS ENTRE 0 Y EL RADIO

arreglo_x = numpy.random.uniform(0, radio, num_simulaciones)
arreglo_y = numpy.random.uniform(0, radio, num_simulaciones)
arreglo_z = numpy.random.uniform(0, radio, num_simulaciones)

# CALCULAMOS LAS DISTANCIAS DE LAS COORDENADAS (x,y,z) AL (0,0,0) TOMANDO LA DIS

TANCIA EUCLIDIANA
arreglo_distancias = numpy.sqrt( numpy.power(arreglo_x,2) + numpy.power(arreglo_
y,2) + numpy.power(arreglo_z,2) )

# 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 )

# SI LA DISTANCIA DEL PUNTO AL CENTRO ES MENOR AL RADIO, AUMENTAMOS EL CONTADOR

DE PUNTOS DENTRO DEL CIRCULO
print("\nEJERCICIO 2\n")
print("El valor del volumen estimado es: " + str( volumen_estimado ) )
################################################################################
###################################
# FIN DEL EJERCICIO
################################################################################
###################################

EJERCICIO 2

El valor del volumen estimado es: 4.19808

 Recordemos que el valor verdadero del volumen de una esfera con radio = r se calcula como:
4
V= ⋅ π ⋅ r2
3
Para el caso en que r = 1 tenemos que V ≈ 4.1887902047863905

> EJERCICIO 3 ---------------------------------------------

---------------------------
3) Ejercicio Ley Fuerte de los Grandes Números
In [3]:

################################################################################
###################################
# MODULOS NECESARIOS PARA EL EJERCICIO
################################################################################
###################################
import numpy
import matplotlib.pyplot as plt
################################################################################
###################################
# INICIO DEL ALGORITMO
################################################################################
###################################

# INICIALIZAMOS LOS PARAMETROS

numpy.random.seed(7)
num_simulaciones = 500
probabilidad = 0.5
simulaciones = numpy.random.binomial(1,0.5,num_simulaciones)
eje_x = numpy.linspace(1,num_simulaciones,num_simulaciones)
eje_y = numpy.divide( numpy.cumsum(simulaciones), eje_x )

# 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.

> EJERCICIO 4 ---------------------------------------------

---------------------------
4) Correlación no implica independencia

In [4]:

################################################################################
###################################
# MODULOS NECESARIOS PARA EL EJERCICIO
################################################################################
###################################
import numpy
import matplotlib.pyplot as plt
################################################################################
###################################
# INICIO DEL ALGORITMO
################################################################################
###################################

# INICIALIZAMOS LOS PARAMETROS

num_simulaciones = 1000
num_puntos = 10000

# INICIO DE LAS SIMULACIONES

arreglo_correlaciones = numpy.zeros(num_simulaciones) # CREAMOS UN ARREGLO DON
DE SE GUARDARAN LAS CORRELACIONES
for i in range(num_simulaciones):
# GENERAMOS AMBOS ARREGLOS Y CALCULAMOS SU CORRELACION
coordenadas_x = numpy.random.normal(0,1,num_puntos)
coordenadas_y = numpy.power(coordenadas_x,2)
arreglo_correlaciones[i] = numpy.corrcoef(coordenadas_x,coordenadas_y)[0,1]

# MOSTRAMOS LOS RESULTADOS

print("\nEJERCICIO 4\n")
print("Los datos tienen la siguiente forma:")
# GRAFICAMOS LA DEPENDENCIA DE AMBOS ARREGLOS (LA GRAFICA CORRESPONDE UNICAMENTE
A LA ULTIMA SIMULACION)
plt.figure(1,figsize=(18,6))
plt.scatter(coordenadas_x,coordenadas_y,marker=".")
plt.title("Ejercicio 3")
plt.xlabel("Simulación")
plt.ylabel("Probabilidad")
plt.show()
# MOSTRAMOS LA CORRELACION MEDIA DE TODAS LAS SIMULACIONES
print("Por construcción, estos son dependientes, sin embargo")
print("el valor de la correlación media es: " + str(numpy.mean(arreglo_correlaci
ones)) )

# MOSTRAMOS EL COMPORTAMIENTOS DE LAS CORRELACIONES

print("Analizando las correlaciones podemos hacer un boxplot y un histograma.")
plt.figure(2,figsize=(18,6))
plt.boxplot(arreglo_correlaciones,showmeans=True,vert=False)
plt.title("Boxplot de correlaciones")
plt.xlabel("Correlación")
plt.figure(3,figsize=(18,6))
plt.hist(arreglo_correlaciones,bins=60)
plt.title("Histograma de correlaciones")
plt.xlabel("Simulación")
plt.ylabel("Probabilidad")
plt.show()

################################################################################
###################################
# FIN DEL EJERCICIO
################################################################################
###################################

EJERCICIO 4

Los datos tienen la siguiente forma:

Por construcción, estos son dependientes, sin embargo

el valor de la correlación media es: -0.0015296567775227236
Analizando las correlaciones podemos hacer un boxplot y un histogram
a.
> EJERCICIO 5 ---------------------------------------------
---------------------------
5) Estimar e vía simulación
In [5]:

################################################################################
###################################
# 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
################################################################################
###################################

# INICIALIZAMOS LOS PARAMETROS

num_simulaciones = 100000
simulaciones = zeros(num_simulaciones)

# 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

El valor de e estimado es igual a 2.71702

 Recordemos que el valor verdadero de e es:
e ≈ 2.718281828459045

> EJERCICIO 6 ---------------------------------------------

---------------------------
6) Ejercicios de Números Primos de la Tarea 1
In [6]:

################################################################################
###################################
# 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

# CONTINUAMOS EJECUTANDO EL CODIGO HASYA QUE TENGAMOS LA MISMA CANTIDAD DE NUMER

OS PRIMOS QUE SE HAYA SOLICITADO
while primos_encontrados.size < primeros_numeros_primos:
# APLICAMOS LA FUNCION mod VECTORIALMENTE
arreglo_modulos = mod(numero,primos_encontrados)
# SI ENCONTRAMOS ALGUN 0 EN EL ARREGLO ES PORQUE ALGUNO DE ELLOS DIVIDE AL N
UMERO, LO QUE IMPLICA
# QUE SI NO ENCONTRAMOS UN 0 EN EL ARREGLO ES PORQUE NINGUNO LO DIVIDE Y POR
LO TANTO ES NUMERO PRIMO
if arreglo_modulos.min() != 0:
# GUARDAMOS EL NUMERO PRIMO EN EL ARREGLO
primos_encontrados = numpy.append(primos_encontrados, numero)
# CAMBIAMOS DE NUMERO QUE QUEREMOS COMPROBAR SI ES PRIMO O NO
numero += 1

# MOSTRAMOS LOS PRIMEROS NUMEROS PRIMOS QUE HAYA SOLICITADO EL USUARIO

print("\nEJERCICIO 6\n")
print("Los primeros " + str(primeros_numeros_primos) + " numeros primos son los
siguientes:")
print(primos_encontrados)
################################################################################
###################################
# FIN DEL EJERCICIO
################################################################################
###################################
EJERCICIO 6

Los primeros 100 numeros primos son los siguientes:

[ 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59
61
67 71 73 79 83 89 97 101 103 107 109 113 127 131 137 139 149
151
157 163 167 173 179 181 191 193 197 199 211 223 227 229 233 239 241
251
257 263 269 271 277 281 283 293 307 311 313 317 331 337 347 349 353
359
367 373 379 383 389 397 401 409 419 421 431 433 439 443 449 457 461
463
467 479 487 491 499 503 509 521 523 541]

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`

> EJERCICIO 7 ---------------------------------------------

---------------------------
7) Ejercicio Aglomerativo Jerarquico con Métrica de Valor Absoluto (primeros 15 números naturales)
In [7]:

################################################################################
###################################
# 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
################################################################################
###################################

> EJERCICIO 9 ---------------------------------------------

---------------------------
9) Ejercicio SVM Discos Aleatorios Separados por Kernel Polinomial

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

# GRAFICAMOS TANTO LOS DATOS COMO LA VALIDACION

print("GRAFICA DE LOS DATOS DE TRAINING Y DE VALIDACION")
plt.figure(1,figsize=(18,6))
plt.subplot(1,2,1)
plt.scatter(datos[:,0],datos[:,1],c=datos[:,2])
plt.title("Datos")
plt.subplot(1,2,2)
plt.scatter(datos[:,0],datos[:,1],c=datos[:,2])
plt.title("Validación")
plt.show()

# MAS PARAMETROS (No usamos la variable de indice pues no es necesario guardar l

as graficas)
m = 26
w = 1
# CALCULAMOS SVM

print("GRAFICAS DE LOS DISTINTOS MODELOS")

for i in range(m):
for j in range(w):
s = 2**i/10
# CREAMOS NUESTRO MODELO Y LO AJUSTAMOS
modelo = svm.SVC(C=1, kernel="rbf",probability=False,gamma=s)
X = np.array(datos[:,[0,1]])
y = [y for x in datos[:,[2]] for y in x]
ajuste = modelo.fit(X,y)
# CALCULAMOS LA TASA DE CLASIFICACION EN LA MUESTRA DE CLASIFICACION
prediccion_datos = modelo.predict(np.array(datos[:,0:2]))
prediccion_validacion = modelo.predict(np.array(validacion[:,0:2]))
tabla = pd.crosstab(validacion[:,2],prediccion_validacion)
acc = -1
if tabla.shape == (2,2):
acc = (tabla.iloc[0, 0] + tabla.iloc[1, 1]) / t ** 2
print("> i = "+str(i))
# GRAFICA 1 (izquierda) -----------------------------
plt.figure(figsize=(18,6))
plt.subplot(1,2,1)
plt.scatter(datos[:,0],datos[:,1],c=prediccion_datos)
plt.title("Datos (acc = " + str(acc) + ", sigma = " + str(s) + ")")
sv_proyectados = datos[modelo.support_,0:2]
#GRAFICA 2 (derecha) -----------------------------
plt.subplot(1,2,2)
plt.scatter(sv_proyectados[:,0],sv_proyectados[:,1],c=prediccion_datos[m
odelo.support_])
plt.title("Validacion (No. de VS = " + str(modelo.n_support_[1]) + ")")
plt.show()

################################################################################
###################################
# FIN DEL EJERCICIO
################################################################################
###################################

GRAFICA DE LOS DATOS DE TRAINING Y DE VALIDACION

GRAFICAS DE LOS DISTINTOS MODELOS
> i = 0

> 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

> EJERCICIO 10 --------------------------------------------

----------------------------
10) Graficar Datos de Cualqueir Base de Datos (Hacer 10 gráficas)

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 ------------------
------------------------------------------------------