Graficar vectores

Seria muy bueno que platzi diera clases de la libreria matplotlib

Desde google colab lo hice asi

No sé si funcione igual en windows o en linux pero aquí dejo la línea para importar el notebook de graficarVectores.ipynb

%run "./funciones_auxiliares/graficarVectores.ipynb"

Si deseas plotting de varias funciones en una sola ventana pero de forma separadas, te paso este sencillo ejemplo:

import matplotlib.pyplot as plt

x = np.arange(1,100,0.2)
y1 = np.sin(x)
y2 = x ** 2 + 2 * x
y3 = np.log(x)
y4 = x + 2

ax1 = plt.subplot(221) # (rows|columns|index)
ax2 = plt.subplot(222)
ax3 = plt.subplot(223)
ax4 = plt.subplot(224)

ax1.plot(x,y1)
ax2.plot(x,y2,'y--')
ax3.plot(x,y3,'r')
ax4.plot(x,y4,'g')

plt.tight_layout()
plt.show()

Así me sirvió a mi

%run "funciones_auxiliares\graficarVectores.ipynb"

Me gustaría que se explique lo que hace cada método, como por ejemplo plt.quiver, por todo lo demás, excelente clase! 😄

Graficar vectores

En las jupyter notebook escribimos:

%matplotlib inline

import numpy as np
import matplotlib.pyplot as plt

v1 = np.array([2,5])
v2 = np.array([3,2])

# vecs: vectores.
# cols: colores.
# alpha: valor de transparencia.
def graficarVectores(vecs, cols, alpha=1):
    plt.figure()
    plt.axvline(x=0, color="grey", zorder=0)
    plt.axhline(y=0, color="grey", zorder=0)
    
    for i in range(len(vecs)):
        # El origen de los vectores inicia en el punto (0,0)
        x = np.concatenate([[0,0], vecs[i]])
        plt.quiver([x[0]],
                  [x[1]],
                  [x[2]],
                  [x[3]],
                  angles='xy', scale_units='xy', scale=1, 
                  color=cols[i], alpha=alpha)

graficarVectores([v1,v2], ['orange', 'blue'])
# Definimos los limites
plt.xlim(-1, 8)
plt.ylim(-1, 8)

Recuerda que a veces es muy buena idea y practica colocar funciones que vamos a llamar reiterada veces en otra jupyter notebook para esto colocamos lo anterior el anterior codigo en una carpeta de funciones importantes y le pondremos de nombre a la notebook graficarVectores.

# Llamos a la funcion de otra notebook a nuestro hilo principal de la sgte manera:
# colocamos el directorio de la notebook a la que vamos a llamar.
%run "./funcionesImportante/graficarVectores.ipynb"

# Luego ejecutamos la ultima linea de codigo, que grafica la funcion para comprobar que se
# ha realizado correctamente.
graficarVectores([v1,v2], ['orange', 'blue'])
plt.xlim(-1, 8)
plt.ylim(-1, 8)

Explicación de esta clase:

Si tenías dudas acerca de la función graficarVectores() esta explicación te será muy útil:

En primer lugar, recordemos los dos vectores que deseamos graficar (v1 & v2) y que se usan como ejemplo

import numpy as np
import matplotlib.pyplot as plt

v1 = np.array([2,5])
v2 = np.array([3,2])

Ya que los tenemos como ejemplo prestemos atención a los puntos de la función que nos pudieron llegar a confundir, las funciones :

np.concatenate() # // Nos permite concatenar dos arreglos de números.
plt.quiver # // Nos permite graficar rectas con una flecha al final.

Para entender el funcionamiento de np.concatenate basta con ejemplicar lo que hace en la iteración número 0 del ciclo for:

a = np.concatenate( [ [0,0] , v1] ) # Aquí simulamos la primera linea del ciclo for
print(a)

[0, 0, 2, 5] # // Como puedes observar los dos arreglos o listas se fusionaron y este es el resultado

Si repetimos este proceso para el vector v2, este es el resultado:

b = np.concatenate( [ [0,0] , v2] ) # // Aquí simulamos la primera linea del ciclo for pero en la iteracion 1
print(b)

[0, 0, 3, 2] #// Como puedes observar los dos arreglos o listas se fusionaron nuevamente

Ahora veamos que sucede con la funcion plt.quiver():
\
Esta recibe 4 parametros inciales que son las cordenadas de inicio x_inicial , y_inicial y las coordenadas donde finaliza el vector x_final, y_final :

plt.quiver([x[0]], [x[1]], [x[2]], [x[3]]) 

Por otra parte, el parametro scale_units {‘ancho’, ‘alto’, ‘puntos’, ‘pulgadas’, ‘x’, ‘y’, ‘xy’} es opcional y nos permite graficar los vectores con unidades especificas, en este caso en las unidades de este plano(x,y).

De igual forma el parametro angles ayuda a determinar el ángulo de las flechas, esto se explica mejor en la documentacion de MatplotLib https://matplotlib.org/stable/api/as_gen/matplotlib.axes.Axes.quiver.html .

Espero les haya servido mucho la explicación. Like si te sirvió 💚… ** And remember Never Stop Learning_**

Excelente clase.

que diferencia hay entre matplotlib inline y matplotlib notebook?

🐍 Como preparar un buen análisis de datos.

1️⃣ Una cucharada de Numpy, https://numpy.org/doc/

2️⃣ Una taza de Pandas, https://pandas.pydata.org/docs/

3️⃣ Matplotlib, al gusto, https://matplotlib.org

Desde Colab hice estos pasos:

1. En la parte derecha le di clic a “files” y se abrió esa barra lateral.
2. Clic en “Mount Drive” (antes al hacer esto salían unas líneas de código, ahora ya no aparecen).
3. Me apareció la carpeta de Drive y ahí busqué el archivo graficarVectores.ipynb.
4. En los 3 puntitos le di a “Copy path”.
5. Puse esa dirección después de %run. Y ya funcionó.

Sé que suena algo engorroso, pero en realidad es super sencillo y no toma casi nada de tiempo hacerlo.

les dejo una ligera modificación para que las dimensiones de la gráfica sean automáticas.

def graficavectores(vectores,colores,alpha=1):
#Se determina el área de la gráfica
plt.figure()
# se dibijan los ejems
plt.axvline(x=0,color=“grey”,zorder=0)
plt.axhline(y=0,color=“grey”,zorder=0)

min_x = 0
max_x = 0
min_y = 0
max_y = 0
for m in range(len(vectores)):
    min_x = min(vectores[m][0],min_x) 
    max_x = max(vectores[m][0],max_x)  
    min_y = min(vectores[m][1],min_y)
    max_y = max(vectores[m][1],max_y)  
plt.xlim(min_x-1,max_x+1)
plt.ylim(min_y-1,max_y+1)

for n in range(len(vectores)):
        x = np.concatenate([[0,0],vectores[n]])
        plt.quiver([x[0]],
                   [x[1]],
                   [x[2]],
                   [x[3]],
                  angles='xy',scale_units='xy',scale=1,
                  color=colores[n],
                  alpha=alpha)

¿qué significa el ‘plt.quiver()’ ? 😦

La linea de %run para usuarios linux como yo quedaria de esta manera:

%run "./funciones_auxiliares/graficarVectores.ipynb"

Si te arroja es el siguiente error al llamar la función externa:

Error: No module named nbformat

la solución es instalar nbformat en el ambiente virtual

Hola!
Entiendo que el objetivo, además de aprender álgebra lineal, es acostumbrarse al entorno de anaconda y propiamente al de jupyter.
Yo he andando de terco trabajando todo desde la instalación local de python y, pese a que instalé también jupyter desde consola y lo puedo invocar, he preferido seguir con el IDE de VSC y no encontré como usar esa parte del %run ahí.

Pero encontré una librería que se llama importlib que de igual forma, permite cargar funciones como librerías para ser ejecutadas. Así quedó mi script de prueba de la función en un script externo.
Yo genero el vector por medio de escalares aleatorios y paso esas variables como entrada de mi función externa:

# Se genera un script para crear vectores aleatorios para usar script graficador
import numpy as np
import random
import importlib.util
from icecream import ic
import matplotlib.pyplot as plt

v_escalar1 = int(random.choice((1, 3, 5)))
v_escalar2 = int(random.choice((1, 2, 4, 5)))

def run():

    
    '''
    Como no pude usar el metodo del profesor, lo hice por medio la libreria de importar librerias
    Se define la cabecera indicando nombre y ruta con extensión
    Luego se inportan los módulos y al final se ejecutan
    '''
    spec = importlib.util.spec_from_file_location('graficarVectores', './utils/graficarVectores.py')
    foo = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(foo)
    
    vector1 = np.array([v_escalar1, v_escalar1 + v_escalar2])
    vector2 = np.array([v_escalar2 + v_escalar1, v_escalar2])
    ic(vector1)
    ic(vector2)


    foo.graficarVectores([vector1, vector2], ['blue', 'black'])
    plt.xlim(-1, 12)
    plt.ylim(-1, 12)
    plt.show()


if __name__ == '__main__':
    run()

En linux me funciono el run de la siguiente manera

%run ..//funciones_auxiliares/"graficarVectores.ipynb"

en mac me funciono

%run "../funciones_auxiliares/graficarVectores.ipynb"

:

para los que tienen problemas con el %run, lo más seguro es por cómo tienen ordenados sus archivos, ya que el profesor tiene el archivo de la clase en una carpeta, y al dirigirse a un archivo fuera de esta, usa “…” para referirse a la carpeta contenedora de la que está usando, y en la que está funciones_auxiliares también

les recomiendo el curso de terminal y línea de comandos, aunque pueden aprender a utilizar la terminal por ustedes mismos, el punto es perderle el miedo, además les recomiendo aprender linux ya que es una de las herramientas más poderosas que pueden tener

si usas linux o mac y tienes tus carpetas organizadas igual que el profesor, solo cambia los “\” por “/”, y para todos los OS, si tienes funciones_auxiliares en el mismo directorio que visualizar vectores, quita los “…” ya que hacen referencia a la carpeta contenedora

espero haberme dado a entender, si tienen preguntas me lo pueden decir 😄

dejo un pseudo gráfico para que me entiendan mejor

funciones_auxiliares:
`-- graficar_vectores.ipynb
sistema_de_ecuaciones_lineales:
|-- comprobacion_sistema_de_ecuaciones_lineal.ipynb
|-- graficar_vectores.ipynb
|-- inversa_para_resolver_ecuaciones_lineales.ipynb
`-- soluciones_sistema_de_ecuaciones.ipynb```

No se porque en el video se usa el caracter \ en vez de /.
En mi caso funciona perfecto usando /. Les comparto la manera en que lo hago.

%run "./funciones_auxiliares/graficarVectores.ipynb"```

En deepnote se importan de forma automatica cuando son notebooks del mismo proyecto

El archivo en el que se hace correr el programa principal tiene que estar en una carpeta al igual que la funcion auxiliar si esta libre en la carpeta FundamentosAL saldra error en la linea %run … 👀

Es un misterio para mi que representan x[0], x[1], x[2] y x[3].

Desde Deepnote: %run “…/Funciones/graficarVectores.ipynb”

A mi me funciono la función auxiliar con la siguiente ruta:

%run ".\\funciones_auxiliares\graficarVectores.ipynb"

Si usan la plataforma de DeepNote la ruta de acceso seria:

si se encuentran en la misma carpeta

%run '/work/funcionesauxiliares.ipynb'

si el notebook se encuentra en una carpeta aparte

%run '/work/Curso Fundamentos de Algebra/carpeta/funcionesauxiliares.ipynb'

Solucion de error al usar %run
El profe nos enseña a llamar la función con:

%run "..\\Funciones_Auxilares/graficar_vectores.ipynb"

Pero cuando corro el codigo sale el error:

Exception: File `'..\\\\Funciones_Auxilares/graficar_vectores.ipynb.py'` not found.

Como ven me agrega dos varas inclinadas de más, así que deducí que internamente Jupyter te pone las barras, simplemente lo cambié por:

%run "Funciones_Auxilares/graficar_vectores.ipynb"

y sirvió 😄

PARA WINDOWS

%run “./funciones_auxiliares/graficar_vectores.ipynb”

Hay que tener en cuenta las rutas que el profe utiliza, sus notebooks de las clases están dentro de carpetas, por eso utiliza doble punto “…\” para subir un nivel en el árbol de carpetas, si no estamos utilizando subcarpetas con “.\” nos funcionará adecuadamente

Para los que están trabajando con Google Colab, el método que uso para trabajar con archivos en carpetas internas es el siguiente:

Importar drive en el espacio de trabajo y vincular con su cuenta de google:

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

Aquí para vincular les pedirá un código de acceso que obtendrán del link que se les mostrará al momento de ejecutar el código. Con esto ya están listos para importar el archivo:

%run 'ubicacion archivo drive'

En mi caso para la función graficarVectores, lo encuentro así:

%run '/content/drive/My Drive/Mau/cursos/Fundamentos de Álgebra lineal con python/funciones_auxiliares/graficarVectores.ipynb'

Y listo, ya pueden trabajar con su función.

Funciono bien en DeepNote:

si alguien no puede importar el notebook y le sale este error

ModuleNotFoundError: No module named 'nbformat'

les recomiendo instalar o actualizar la librería nbformat por medio de pip o canda

pip install nbformat

para los que lo están haciendo en google colab
este tutorial les servirá mucho
https://www.youtube.com/watch?v=8jWvmfK_Yo0

Exelente clase, me parecio algo muy profesional

A mi me funciono de la siguiente forma:
%run “.\funciones_auxiliares\graficarVectores.ipynb”

y estoy en windows

me estuve peleando con la ruta hasta que pude hacerlo 😄 a mi me funcionó
%run “…/FundamentosAL/Funciones_Auxiliares/graficarVectores.ipynb”
😃

Dejo la version de graficando vectores , que dibuja una grilla y encuentra el xmax y ymax automaticamente.

def graficarVectores(vectores, colores, alpha = 1):
    
    plt.figure()
    plt.axvline(x = 0, color='red', zorder = 0)
    plt.axhline(y = 0, color='red', zorder = 0)
    plt.grid(zorder = 0)
    xmax = 0
    ymax = 0
    
    for i in range(len(vectores)):
        x = np.concatenate([[0,0], vectores[i]])
        plt.quiver([x[0]],
                   [x[1]],
                   [x[2]],
                   [x[3]],
                   angles = 'xy',
                   scale_units = 'xy',
                   scale = 1,
                   color = colores[i],
                   alpha = alpha)
        if vectores[i][0] > xmax:
            xmax = vectores[i][0]
        if vectores[i][1] > ymax:
            ymax = vectores[i][1]    
    plt.xlim(-1, xmax + 1)
    plt.ylim(-1, ymax + 1)

Algo que me funciono para el %run por lo menos en Colaboratory:
-Añadir mi drive
-Tocar la funcion y copiar ruta de acceso
%run “Ruta de acceso”

lito

Hi people’s, les comparto como graficar con pyplot de forma rápida varias funciones en un solo plot:

import numpy as np
import matplotlib.pyplot as plt

x = np.arange(-100,101,1)      # Array x
y1 = 25 * x ** 2 - 2 * x       # y1 = 0.5x²+2x
y2 = ((0.5 * x ** 2) // 2 * x)  # y2 = ½x²/2x
y3 = np.sin(0.25 * x) * 250000 # y3= 250K sin(¼x)

#================================================
plt.plot(x,y1,'r.')
plt.plot(x,y2,'b--')
plt.plot(x,y3,'y')
plt.show()

yo lo hice en mac y escribi el siguinete codigo
%run “…//funciones_auxiliares/graficarVectores.ipynb”

muy buen truco el del run y las funciones

Tambien seria muy chevere que enseñara las otras librerias como sklearn, pandas, platform, etc…

Excelente metodo de %run

Nota.
Para reutilizar las funciones de otro notebook de jupyter:

%run <route>

def graficarVectores(vecs, cols, alpha = 1):
    plt.figure()
    plt.axvline(x=0, color='grey', zorder = 0)
    plt.axhline(y=0, color='grey', zorder = 0)
    
    for i in range(len(vecs)):
        x = np.concatenate([[0,0], vecs[i]])
        plt.quiver( [x[0]],
                    [x[1]],
                    [x[2]],
                    [x[3]],
                    angles = 'xy', scale_units='xy',scale=1, color = cols[i],
                    alpha = alpha)

graficarVectores([v1,v2], ['orange', 'blue'])
plt.xlim(-1,8)
plt.ylim(-1,8)```

se puede hacer lo mismo de llamar funciones en google collab?

despues de mucho tiempo asi me funcionó:
%run “./funciones_auxiliares/graficarVectores.ipynb”

Excelente esta clase, para la reutilización de funciones

Hola les comparto gráficos de barra o Bar Charts con Matplotlib:

import matplotlib.pyplot as plt
import numpy as np
from matplotlib import style
style.use('bmh')
#=============Tuples==========================
python = (85, 67, 23, 98)
java = (50, 67, 89, 14)
networking = (60, 20, 56, 22)
machine_learning = (88, 23, 10, 87)
#=========List of Name========================
peolple = ['Bob', 'Anna', 'John', 'Marks']
#=============================================
index = np.arange(4)
#=============================================
plt.bar(index, python, width=0.2, label="Python")
plt.bar(index + 0.2, java, width=0.2, label="Java")
plt.bar(index + 0.4, networking, width=0.2, label="Networking")
plt.bar(index + 0.6, machine_learning, width=0.2, label="Machine Learning")
#============Legend and Label==============================================
plt.title("IT Skill Levels")
plt.xlabel("Person")
plt.ylabel("Skill Level")
plt.xticks(index + 0.3, peolple)
plt.legend(loc='upper right')
plt.ylim(0, 150)
#==============================================
plt.show()

Si desean otro Style aca les dejo el enlace:
[Style_Sheets(https://matplotlib.org/gallery/style_sheets/style_sheets_reference.html#sphx-glr-gallery-style-sheets-style-sheets-reference-py)

Tambien puedes imprimir en ventanas peradas lo que desees:

import numpy as np
import matplotlib.pyplot as plt

x = np.arange(1,100,0.2)
y1 = np.sin(x)
y2 = x ** 2 + 2 * x
y3 = np.log(x)
y4 = x + 2
#==========================================
plt.figure(1)
ax1 = plt.subplot(211) # (rows|columns|index)
ax1.plot(x,y1)
ax2 = plt.subplot(212) # (rows|columns|index)
ax2.plot(x,y2,'y--')
#==========================================
plt.figure(2)
plt.plot(x,y1,'r--')
#==========================================
plt.figure(3)
ax3 = plt.subplot(212) # (rows|columns|index)
ax3.plot(x,y3,'r')
ax4 = plt.subplot(211) # (rows|columns|index)
ax4.plot(x,y4,'g')
#==========================================
plt.show()

Figure(1):

Figure(2):

Figure(3):