Conceptos básicos de álgebra lineal y configuración del entorno de trabajo

1

Presentación del curso y la necesidad del Álgebra Lineal

2

Anaconda + Python, Creación de un entorno y actualización de paquetes

3

Uso de Jupyter Notebook

4

Creando las bases, escalares, vectores y matrices. ¿Qué es un tensor? ¿Cómo se representa?

Realiza operaciones básicas

5

Dimensión de un escalar, vector, matriz o tensor

6

Transposición, suma de matrices y escalares

7

Suma de matrices y vectores (broadcasting)

Operaciones con matrices

8

Producto interno entre una matriz y un vector

9

Producto interno entre dos matrices

10

Propiedades de las matrices: la multiplicación de matrices es asociativa y distributiva, no es conmutativa

11

Transposición de un producto de matrices

12

Cómo comprobar la solución de un sistema de ecuaciones lineal

13

Tipos especiales de matrices: Identidad, Inversa, Singulares

14

Aplicación de la inversa de una matriz para resolver un sistema de ecuaciones lineales

Sistema de ecuaciones lineales

15

Ejemplos de sistemas sin solución, con una solución y con infinitas soluciones

16

Graficar vectores

17

¿Qué es una combinación líneal?

18

¿Qué es un espacio y un subespacio?

19

Vectores linealmente independientes

20

Validar que una matriz tenga inversa

Normas

21

Qué es una norma y para qué se usa. Desigualdad Triangular

22

Tipos de normas: norma 0, norma 1, norma 2, norma infinito y norma L2 al cuadrado

23

El producto interno como función de una norma y su visualización

Matrices y vectores especiales

24

La matriz diagonal y la matriz simétrica: sus propiedades

25

Vectores ortogonales, matrices ortogonales y sus propiedades

26

Matrices ortogonales y sus propiedades

Otras funciones de álgebra lineal

27

El determinante y la traza

28

Cierre del curso. Continua con el Curso de Álgebra Lineal Aplicada a Machine Learning.

Creando las bases, escalares, vectores y matrices. ¿Qué es un tensor? ¿Cómo se representa?

4/28
Recursos
Transcripción

Aportes 150

Preguntas 16

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Es bastante interesante como un tensor se puede visualizar como imagen, así se entiende cómo es que funciona la IA con el reconocimiento de imágenes, convirtiendo a tensores y comparando los números. Experimentando y cureosenado un poco, salió esto:

Dejo el notebook por acá, porque el tensor es demasiado grande para dejarlo comentado.

No sabía exactamente por qué la función .imshow recibía un tensor si lo que mostraba se parecía más a una matriz, hasta que me puse a experimentar con los números y me di cuenta que realmente sí es una matriz con vectores de colores en RGB, la primera posición del vector es el rojo, la segunda el verde y la tercera el azul

Comparto esta imagen que me ayudo a entender que todo viene de un tensor.

Yoshi hecho con tensores


Hecho con amor…!

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np

tensor = np.array([
    
[[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0]],
[[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0]],
[[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0]],
[[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0]],
[[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0]],
[[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0]],
[[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0],[255,255,0]],
[[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205]],
[[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[255,255,255],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205]],
[[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[255,255,255],[0,0,205],[0,0,205],[0,0,205],[255,255,255],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205]],
[[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[255,255,255],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[255,255,255],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205]],
[[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205]],
[[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[255,255,255],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[255,255,255],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205]],
[[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205],[0,0,205]],
[[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0]],
[[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0]],
[[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0]],
[[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0]],
[[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0]],
[[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0]],
[[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0],[255,0,0]],
])

plt.imshow(tensor, interpolation="nearest")
plt.show()```

escalar = 42
import numpy as np
vector = np.array([2,5,7])
matriz = np.array([[1,5],[9,4],[5,5]])

tensor = np.array([
[[255,255,255],[255,255,255],[255,255,255]],
[[0,0,0],[0,0,0],[0,0,0]],
[[128,128,128],[128,128,128],[128,128,128]]
])

%matplotlib inline
import matplotlib.pyplot as plt
plt.imshow(tensor, interpolation=‘nearest’)
plt.show()

Tipos de datos

  • Escalar: en matemáticas se refiere a un número, en python se refiere a cualquier dato que ya no podemos dividir en más componentes.
  • Vector: es un grupo de escalares en forma de lista, sólo tiene una dimensión,
  • Matriz: es un grupo de vectores, podríamos decir una lista de listas. Tiene dos dimensiones
  • Tensor: es un grupo de matrices (una lista de matrices). Tiene tres dimensiones. Podemos pensar en un cubo de Rubik como un tensor.

Notas:

  • El módulo numpy (numerical python) nos sirve entre otras cosas para trabajar con arreglos numéricos (vectores, matrices o tensores) en python
import numpy as np #importacion convencional de numpy
arreglo_num = np.array([<arreglo>])
  • matplotlib,pyplot → un módulo de graficado en python (ahora lo usamos para graficar colores)
%matplotlib inline #con esta línea podemos graficar directamente en jupyter notebook
import matplotlib.pyplot as plt #importacion convencional de pyplot
plt.imshow(tensor, interpolation='nearest') #imshow recibe un tensor que representa los colores en RGB de una imagen
plt.show()

Hice el logo de Platzi.

Me encantó el iniciar el tema de tensores con un ejemplo tan claro su potencial como es en el ámbito de ver, crear e interpretar imágenes.

Yo hice la bandera de mi país (México) con pixeles😅

Les dejo el código que usé (como verán, usé variables para nombrar los diferentes colores: Green, Red, Light Green, etc. y hacer el código más entendible):

# Reto Extendido
G=[0,68,47]
R=[200,12,29]
W=[255,255,255]
B=[133,59,22]
LG=[101,108,38]
LB=[7,122,125]
O=[249,162,69]
tensorMexico=np.array([
#     Parte de arriba
    [G,G,G,G,G,G,G,G,G,W,W,W,W,W,W,W,W,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,W,W,W,W,W,W,W,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,W,W,W,W,W,W,W,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,W,W,W,W,W,W,W,W,R,R,R,R,R,R,R,R,R],
#     Logo
    [G,G,G,G,G,G,G,G,G,W,W,W,W,B,W,W,W,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,W,W,W,W,B,W,W,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,LG,B,B,W,B,B,W,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,W,LG,B,B,B,B,B,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,W,LG,W,B,B,B,B,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,W,W,B,B,B,B,W,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,LG,R,W,B,B,R,LG,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,LG,W,G,R,G,W,LG,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,W,LG,LB,O,LB,LG,W,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,W,W,LG,LG,LG,W,W,W,R,R,R,R,R,R,R,R,R],
#     Parte de abajo
    [G,G,G,G,G,G,G,G,G,W,W,W,W,W,W,W,W,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,W,W,W,W,W,W,W,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,W,W,W,W,W,W,W,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,W,W,W,W,W,W,W,W,R,R,R,R,R,R,R,R,R],
])
  • Vectores: arreglo unidimensional.
  • Matriz: arreglo bidimensional.
  • Tensores: arreglo de una o N dimensiones.

http://mathesaurus.sourceforge.net/numeric-numpy.html buen enlace para revisar temas de operaciones básicas en matemáticas con python.

Aquí mi pequeño aporte 😄

Hice una función que te arrojase una matriz con números al azar para después mostrarla, ojalá alguien lo pruebe jsjsjs.

import random
def matriz_aleatoria():
    tensor = []
    for i in range(3):
        fila = []
        for j in range(3):
            fila.append(random.randint(0,255))
        tensor.append(fila)
    return tensor
plt.imshow(matriz_aleatoria(),interpolation='nearest')
plt.show()

Y aquí el resultado:

getting closer to being an artificial intelligence engineer

escalar_ = 42

import numpy as np
vector_ = np.array([2,3,5,7])

matriz_ = np.array([[1,2],[3,4],[5,6]])

tensor = np.array([
[[255,255,255],[255,255,255],[255,255,255]],
[[0,0,0],[0,0,0],[0,0,0]],
[[128,128,128],[128,128,128],[128,128,128]]
])

%matplotlib inline
import matplotlib.pyplot as plt
plt.imshow(tensor, interpolation=‘nearest’)
plt.show()

Los escalares, vectores, matrices, tensores se diferencian en los grados de libertad que tenemos para interactuar.

Escalar: en matemáticas es un número cualquiera, pero en python un escalar puede ser varias cosas (número entero, punto flotante, número complejo, string, null type, booleano, etc)

escalar = 5.7686
print(escalar)
5.7686

Vector: es un conjunto de números

vector = np.array([2,3,5,7])
print(vector)
[2 3 5 7]

Matriz: tiene 2 grados de libertad, el conjunto de varios vectores

matriz = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(matriz)

**Tensor:**tiene 3 o más grados de libertad, es el conjunto de matrices

tensor = np.array([
    [[14,24,34],[45,55,56],[67,68,79]],
    [[100,101,102],[103,104,105],[160,170,180]],
    [[190,200,210], [220,230,204], [255,227,238]]
])
print(tensor)
[[[ 14  24  34]
  [ 45  55  56]
  [ 67  68  79]]

 [[100 101 102]
  [103 104 105]
  [160 170 180]]

 [[190 200 210]
  [220 230 204]
  [255 227 238]]]

¿Doge o Shiba?🐕‍🦺

Resumen de la clase:

  • Conoceremos los elementos básicos para hacer las construcciones de algebra lineal que a su vez se utilizan en los algoritmos de de machine Learning, Deep Learning y análisis de datos.
  • Tenemos el escalar, el vector, la matriz y el tensor, los cuales se diferencian en los grados de libertad.

Escalar:

  • Una cantidad escalar es simplemente un número.

Vector

  • Un vector es un conjunto de números. Tiene un grado de libertad

Matriz

  • Una matriz es un conjunto de vectores, tiene 2 grados de libertad.

Tensor

  • Este tendrá 1 o más grados de libertad que la matriz.
tensor = np.array([
    [[255,255,255],[255,255,255],[255,255,255]],
    [[0,0,0],[0,0,0],[0,0,0]],
    [[128,128,128],[128,128,128],[128,128,128]]
])
plt.imshow(tensor, interpolation = 'nearest')
plt.show()

Hola! Les comparto algo que encontré mientras hacia mis notas.
Para hacer lo explicado mas gráfico, fui utilizando asignación de variables, de tal manera que se vea claramente que un tensor es una colección de matrices, una matriz es una colección de vectores, un vector es una colección de escalares y un escalar sería nuestra unidad mínima, peeeero al momento de querer graficarlo, me marcaba un error. Tuve que aplicar la función squeeze() a mi tensor para poder graficar como imagen sus valores.
Según revise, squeeze ‘limpia’ de espacios y/o basura, pero eso no me queda muy claro, pese que en la imagen, se aprecia claramente que hay un espacio doble entre matriz y matriz.

Luego, hice operaciones intermedias entre el vector, la matriz y el tensor para tener valores diferentes, para que la imagen fuera clara en las diferencias.
Estoy trabajando en un entorno local, les comparto captura de mi ejecución y el link en GitHub del script que utilice.

Saludos.
https://tuit.es/od0pQ

Práctica Escalar, vector, matriz y tensor:

Increíble todo lo que se aprende. A seguir el curso

tensor = np.array([
    [[255,255,255],[255,255,255],[255,255,255]],
    [[0,0,0],[0,0,0],[0,0,0]],
    [[128,128,128],[128,128,128],[128,128,128]]
])
plt.imshow(tensor, interpolation = "nearest")
plt.show()
tensor = np.array([
    [[14,24,34],[45,55,56],[67,68,79]],
    [[100,101,102],[103,104,105],[160,170,180]],
    [[190,200,210], [220,230,204], [255,227,238]]
])
print(tensor)
plt.imshow(tensor, interpolation='nearest')
plt.show()```

Buenas Tardes envio ejercicio propuesto por el profesor
escalar = 42
print(escalar)
print(type(escalar))
42
<class ‘int’>

vector = np.array([2,3,5,7])
print(vector)
[2 3 5 7]

matriz = np.array([[9,8,7],[6,5,4]])
print(matriz)
[[9 8 7]
[6 5 4]]

tensor = np.array ([
[[255,255,255],[255,255,255],[255,255,255]],
[[0,0,0],[0,0,0],[0,0,0]],
[[128,128,128],[128,128,128],[128,128,128]]

])
print(tensor)
[[[255 255 255]
[255 255 255]
[255 255 255]]

[[ 0 0 0]
[ 0 0 0]
[ 0 0 0]]

[[128 128 128]
[128 128 128]
[128 128 128]]]

plt.imshow(tensor, interpolation=‘nearest’)
plt.show()

  • Tensor: puede moverse entre las filas, las columnas y entre matrices.
  • Vector: puede moverse entre columnas y filas.

Preparandonso para el mundial, hize la bandera de mi México lindo y querido

tensor = np.array([
    [[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0]],
    [[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0]],
    [[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0]],
    [[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0]],
    [[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0]],
    
    [[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[139, 69, 19],[255,255,255],[255,255,255],[255,255,255],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0]],
    [[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[139, 69, 19],[139, 69, 19],[255,255,255],[255,255,255],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0]],
    [[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[255,255,255],[255,255,255],[139, 69, 19],[139, 69, 19],[255,255,255],[139, 69, 19],[139, 69, 19],[255,255,255],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0]],
    [[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[255,255,255],[255,255,255],[255, 255, 0],[139, 69, 19],[139, 69, 19],[139, 69, 19],[139, 69, 19],[255,255,255],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0]],
    [[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[255,255,255],[255,255,255],[255,255,255],[139, 69, 19],[139, 69, 19],[139, 69, 19],[139, 69, 19],[255,255,255],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0]],
    [[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[255,255,255],[255,255,255],[255,255,255],[139, 69, 19],[139, 69, 19],[139, 69, 19],[255,255,255],[255,255,255],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0]],
    [[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[255,255,255],[255,255,255],[255, 255, 0],[255,255,255],[139, 69, 19],[139, 69, 19],[139, 69, 19],[255,255,255],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0]],
    [[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[255,255,255],[0, 128, 0],[0, 128, 0],[255,255,255],[255, 255, 0],[255,255,255],[255,255,255],[255,255,255],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0]],
    [[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[255,255,255],[255,255,255],[255,255,255],[0, 128, 0],[0, 128, 0],[0, 128, 0],[255,255,255],[255,255,255],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0]],
    [[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[255,255,255],[0, 128, 0],[255,255,255],[255, 255, 0],[255, 255, 0],[255,255,255],[0, 128, 0],[255,255,255],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0]],
    [[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[255,255,255],[0, 128, 0],[0, 128, 0],[255,255,255],[255,255,255],[0, 128, 0],[0, 128, 0],[255,255,255],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0]],
    [[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[255,255,255],[255,255,255],[255,255,255],[0, 128, 0],[0, 128, 0],[255,255,255],[255,255,255],[255,255,255],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0]],

    [[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0]],
    [[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0]],
    [[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0]],
    [[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0]],
    [[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[0, 128, 0],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0],[255, 0, 0]],
])

plt.imshow(tensor, interpolation = "nearest")
plt.show()

Blanco, negro y gris:

tensor = np.array([
    [[255,255,255],[255,255,255],[255,255,255]],
    [[0,0,0],[0,0,0],[0,0,0]],
    [[128,128,128],[128,128,128],[128,128,128]]            
])
plt.imshow(tensor, interpolation='nearest')
plt.show()

Escala: Lista de numeros int, float, o strings o null
Vectores: Lista de Escalas
Matrices: Lista de vectores
Tensor: Lista de matrices

Tarea:

Aqui mi aporte una carita feliz

dibujo = np.array([[[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255]],
                   [[255,255,255],[255,255,255],[255,51,51],[255,255,255],[255,255,255],[255,51,51],[255,255,255],[255,255,255]],
                   [[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255]],
                   [[255,255,255],[255,255,255],[255,255,255],[0,255,0],[255,255,255],[255,255,255],[255,255,255],[255,255,255]],
                   [[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255]],
                   [[255,255,255],[255,255,0],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,0],[255,255,255]],
                   [[255,255,255],[255,255,255],[255,255,0],[255,255,255],[255,255,255],[255,255,0],[255,255,255],[255,255,255]],
                   [[255,255,255],[255,255,255],[255,255,255],[255,255,0],[255,255,0],[255,255,255],[255,255,255],[255,255,255]],
                   [[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255]],
                   [[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255]]])

plt.imshow(dibujo, interpolation= 'nearest')
plt.show()


PERU DICE PRESENTE!!

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np

R=[200,12,29]
W=[255,255,255]

tensor = np.array([

Parte de arriba

[R,R,R,R,R,R,R,R,R,W,W,W,W,W,W,W,W,W,R,R,R,R,R,R,R,R,R],
[R,R,R,R,R,R,R,R,R,W,W,W,W,W,W,W,W,W,R,R,R,R,R,R,R,R,R],
[R,R,R,R,R,R,R,R,R,W,W,W,W,W,W,W,W,W,R,R,R,R,R,R,R,R,R],
[R,R,R,R,R,R,R,R,R,W,W,W,W,W,W,W,W,W,R,R,R,R,R,R,R,R,R],

Parte de abajo

[R,R,R,R,R,R,R,R,R,W,W,W,W,W,W,W,W,W,R,R,R,R,R,R,R,R,R],
[R,R,R,R,R,R,R,R,R,W,W,W,W,W,W,W,W,W,R,R,R,R,R,R,R,R,R],
[R,R,R,R,R,R,R,R,R,W,W,W,W,W,W,W,W,W,R,R,R,R,R,R,R,R,R],
[R,R,R,R,R,R,R,R,R,W,W,W,W,W,W,W,W,W,R,R,R,R,R,R,R,R,R],

])

plt.imshow(tensor, interpolation=“nearest”)
plt.show()

Está el escalar, el vector, el tensor, la matriz
¿En qué se diferencia cada uno de ellos? En los grados de libertad que estamos teniendo al interactuar.

  • un vector es un conjunto de números
  • un escalar en matemática no es nada más ni nada menos que un número.

  • En python un escalar es algo completamente distinto, puede ser un entero, pude ser un punto flotante, pude ser un número complejo, pero puede ser un string, pero también puede ser un elemento nada (null type).

No me gusta harcodear matrices asi que hize esto:

tensor = np.array([np.uint8(np.ones((3, 3)) * 255 * x) for x in [1, 0, 0.5]])
plt.imshow(tensor, interpolation='nearest')
plt.colorbar()
plt.show()

sabiendo que cada matris en el vector interpreta una fila de la grafica recorro un array [1, 0, 0.5] blanco, negro gris entonces genero una matrix de 3x3 de 255 y lo multiplico por x que es un elemento de la lista [1, 0, 0.5] y me sale este resultado

[[[255 255 255]
  [255 255 255]
  [255 255 255]]

 [[  0   0   0]
  [  0   0   0]
  [  0   0   0]]

 [[127 127 127]
  [127 127 127]
  [127 127 127]]]

Saludos!!! tensor_bolivia:

Un curso que ya está sacando lo mejor de mí:

terc_tensor = np.array([
    [[255,255,255],[255,255,255],[255,255,255]],
    [[0,0,0],[0,0,0],[0,0,0]],
    [[128,128,128],[128,128,128],[128,128,128]]
])

plt.imshow(terc_tensor, interpolation='nearest')

plt.show()

La bandera de mi pais

%matplotlib inline
import matplotlib.pyplot as plt

colores=[[255,255,0],[255,255,0],[0,0,255],[255,0,0]]
tensor=[]
for color in colores:
    section=[]
    for i in range(5):
        section.append(color)
    tensor.append(section)
    
plt.imshow(tensor, interpolation='nearest')
plt.show()

Mi aporte de la bandera Colombiana.

colores=[[255,255,0],[0,0,255],[255,0,0]]
tensor=[]
for color in colores:
    section=[]
    for i in range(5):
        section.append(color)
    tensor.append(section)
    
plt.imshow(tensor, interpolation='nearest')
plt.title('Colombian flag', fontsize=15, pad=20 )
plt.axis('off')
plt.show()

La bandera de mi pais!
output.png

tensor=np.array([
    [[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255]],
    [[255,255,255],[251,255,0],[251,255,0],[251,255,0],[255,255,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255]],
    [[255,255,255],[251,255,0],[251,255,0],[251,255,0],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255]],
    [[255,255,255],[251,255,0],[251,255,0],[251,255,0],[255,255,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255]],
    [[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255]],
    [[0,100,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255]],
    [[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255]],
    [[0,100,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255],[0,100,255]],
    [[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255]],
])

Matemáticamente, el tensor es un objeto que tiene ciertas reglas de transformación. Hay tensores de rango 0 (escalares), tensores de rango 1 (vectores), tensores de rango 2 ( que tienen una representación matricial pero no todas las matrices son tensores) , y los tensores de rango superiores. No confundir matrices con tensores de rango 2, los ultimos pueden sere representados como matrices pero es solo la forma de mostrar los datos nada mas.

#1
a = 37
print(a)
print("\n")

#2
newVector = np.array([2,3,5,7])
print(newVector)
print("\n")

#3
newMatrix = np.array([["a","b","c"],["d","f","g"],["h","i","j"],["k","ñ","l"],["p","k","s"],["x","y","z"]])
print(newMatrix)
print("\n")

#4
newTensor = np.array([
    [[255,255,255],[255,255,255],[255,255,255]],
    [[0,0,0],[0,0,0],[0,0,0]],
    [[128,128,128],[128,128,128],[128,128,128]]
])
plt.imshow(newTensor, interpolation='nearest')
plt.show()

escalar: GL=0
vector: GL=1
matriz: GL=2
tensor: GL=3

import numpy as np

vector = np.array([1,2,3,4])
print(‘Vector:\n’, vector)

matriz = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(’\nMatriz:\n’, matriz)

tensor = np.array([
[[1,2,3], [7,8,9]],
[[1,2,3], [7,8,9]],
[[0,0,0], [255,255,255]],
[[0,0,0], [255,255,255]]
])
print(’\nMatriz:\n’, tensor)
Vector:
[1 2 3 4]

Matriz:
[[1 2 3]
[4 5 6]
[7 8 9]]

Matriz:
[[[ 1 2 3]
[ 7 8 9]]

[[ 1 2 3]
[ 7 8 9]]

[[ 0 0 0]
[255 255 255]]

[[ 0 0 0]
[255 255 255]]]
import matplotlib.pyplot as plt

plt.imshow(tensor, interpolation=‘nearest’)
plt.show()

#Reto
print("______________________")
escalar=42
print(escalar)

print("\n ")

print("Matriz ")

matriz=np.array([2,3,5,7])

print(matriz)

print("\n ")

print(" Matriz de 3x2 ")

matriz1=np.array([[2,3],[5,3],[7,4]])

print(matriz1)



tensor = np.array([
                   [[255,255,255],[255,255,255],[255,255,255]],
                       [[0,0,0],[0,0,0],[0,0,0]],
                   
    [[128,128,128],[128,128,128],[128,128,128]],

])


plt.imshow(tensor, interpolation='nearest')
plt.show()

· Un escalar es un tensor dimensional 0
· Un vector es un tensor unidimensional
· Una matriz es un tensor bidimensional
· Un nd-array es un tensor de n dimensiones

Mi aporte de la clase

Reto:

escalar = 42

vector = np.array([2,3,5,7])

matriz = np.array([[1, 2], [4, 0], [7, 2]])  #Matriz 3x2

tensor = np.array([
    [[255, 255, 255], [255, 255, 255], [255, 255, 255]],
    [[0, 0, 0], [0, 0, 0], [0, 0, 0]],
    [[140, 140, 140], [140, 140, 140], [140, 140, 140]]
])

Hola vengo del futuro, para que no se frustren con los conceptos de las clases posteriores que se vienen, vean este curso de algebra lineal en base a gráficas. Les va ayudar mucho y demasiado a entender todo este curso.
VIDEOS ALGEBRA LINEAL

import numpy as np
%matplotlib inline
import matplotlib.pyplot as plt

#1
escalar = 46
print(escalar)

#2
vector = np.array([2, 3, 5, 7])
print(vector)

#3
matriz = np.array([[1, 2], [3, 4], [5, 6],])
print(matriz)

tensor = np.array([
                   [[255, 255, 255], [255, 255, 255], [255, 255, 255]],
                   [[0, 0, 0], [0, 0, 0], [0, 0, 0]],
                   [[128, 128, 128], [128, 128, 128], [128, 128, 128]],
                  ])
plt.imshow(tensor, interpolation = "nearest")
plt.show() 

Dejo mi tensor blanco, negro, gris:

❤️

Lo que me gustó bastante de este profesor es que a medida que va escribiendo los comandos coloca los import y explica el porqué a DIFERENCIA DEL RESTO que te pone TODOS LOS IMPORT al principio. Esto ayuda mucho a entender el PORQUÉ y no perderse con tooodas las funciones.

A=[0,0,205]
R=[200,12,29]
B=[255,255,255]

tensor = np.array([
    [A,A,A,A,A,A,A,A,A,A,A,A,A,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B],
    [A,A,A,A,A,A,B,A,A,A,A,A,A,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B],
    [A,A,A,A,A,B,B,B,A,A,A,A,A,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B],
    [A,A,A,A,B,B,B,B,B,A,A,A,A,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B],
    [A,B,B,B,B,B,B,B,B,B,B,B,A,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B],
    [A,A,A,B,B,B,B,B,B,B,A,A,A,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B],
    [A,A,A,A,B,B,B,B,B,A,A,A,A,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B],
    [A,A,A,A,B,B,A,B,B,A,A,A,A,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B],
    [A,A,A,B,B,A,A,A,B,B,A,A,A,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B],
    [A,A,A,B,A,A,A,A,A,B,A,A,A,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B],
    [A,A,A,A,A,A,A,A,A,A,A,A,A,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B],
    [R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R],
    [R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R],
    [R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R],
    [R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R],
    [R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R],
    [R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R],
    [R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R],
    [R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R],
    [R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R],
    [R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R],
    [R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R,R]
])

Un tensor hablando matemáticamente se puede considerar como una matriz que tiene por elementos otras matrices.

Solución ejercicio del final:
.

# importar las librerias
import numpy as np
import matplotlib.pyplot as plt

def run():
    escalar  = 42
    vector = np.array([1,3,5,7])
    matriz_3x2 = np.array([[1,2],[5,6],[1,2]])
    tensor = np.array([ [[255,255,255],[255,255,255],[255,255,255]],
                        [[0,0,0],[0,0,0],[0,0,0]],
                        [[128,128,128],[128,128,128],[128,128,128]]
                       ])

    print(escalar)
    print(vector)
    print(matriz_3x2)
    print(tensor)

    plt.imshow(tensor, interpolation = 'nearest')
    

if __name__ == '__main__':
  run()

La salida del código:

42
[1 3 5 7]
[[1 2]
 [5 6]
 [1 2]]
[[[255 255 255]
  [255 255 255]
  [255 255 255]]

 [[  0   0   0]
  [  0   0   0]
  [  0   0   0]]

 [[128 128 128]
  [128 128 128]
  [128 128 128]]]

Quería entender porque usábamos el modulo que usamos para la grafica y salí con informacion extra que me gustaría compartir :0


Creación de Jupyter
Fernando Pérez es un físico colombiano, graduado de la universidad de Antioquia, con un doctorado en fisica de partículas por la universidad de Colorado; en el 2012 ganó el premio de la Free Software Fundation por el avance del software libre, pues Fernando, desde el 2001 desarrolló el padre de Jupyter, IPython ese es (era) una forma de poder interactuar con python mediante un shell interactivo, el cual permitía resaltar líneas y desarrollar operaciones en paralelo pudiéndose estas desarrollar, ejecutar, depurar y ser monitoreadas interactivamente (por eso su nombre, Interactive Python) mediante un notebook en la web, el cual es un documento JSON que contiene una lista ordenada de entradas / salidas las cuales pueden tener código, texto, matemáticas, dibujos y rich media. pudiendo ser convertidos a otros formatos de archivos

En 2014 Fernando anuncia su nuevo proyecto, Jupyter, (dejando a Ipython como shell para Python y Kernell de Jupyter) cuyo nombre seria un homenaje a los cuadernos de Galileo Galilei; el cual es un proyecto de código abierto para la computación interactiva, cuyo objetivo es apoyar la ciencia de datos interactiva y la computación científica en todos los lenguajes de programación.
Jupyter Notebook es el hijo de IPython notebook, el cual es el software que estamos usando para este curso, el cual es un documento JSON en la web con las funcionalidades que ya presentaba IPython, sirviendo como programa de computo en la nube dada su filosofia, Jupyther ha sido usado en varios descubrimientos cientificos (destacando el de las ondas gravitacionales) incluso hay un articulo que habla que el futuro de los “paper” será en los notebooks


Ahora si, analicemos el ultimo pedazo de código

%matplotlib inline

Esto nos dice que el grafico que pongamos será incluido en el notebook, despues del código, será de uso obligatorio despues de importar matplotlib

plt.imshow(tensor, interpolation="nearest")

plt es el la llamada al modulo importado, y estaremos usando la extensión imshow muestra datos como una imagen de pseudocolor, es decir, en un ráster regular 2D.
Esta va acompañado de parámetros, les sugiero ver el link adjunto a la documentación

plt.show

Nos muestra la figura

Mi Perú ❤️

Reto:

#Ejercicio escalar: 42, vector 2,3,5,7 matriz 3x2, graficar tensor 
#en su primer fila blanco segunda negro y tercera gris
esc = 42
vect = np.array([2,3,5,7])
matr = np.array([[1,2],[3,4],[5,6]])

tensor = np.array([
    [[255,255,255],[255,255,255],[255,255,255]],
    [[0,0,0],[0,0,0],[0,0,0]],
    [[128,128,128],[128,128,128],[128,128,128]],
])

print(esc)
print(vect)
print(matr)
plt.imshow(tensor,interpolation='nearest')
plt.show()

Aqui dejo los resultados que obtuve de lo que pidio el profe.
Escalar

esc = 42
print(esc)

42
Vector

vec = np.array([2, 3, 5, 7])
print(vec)

[2 3 5 7]
Matriz

mat = np.array([[1, 7], [3, 4], [2, 2]])
print(mat)

[[1 7]
[3 4]
[2 2]]
Tensor

negro = np.array([0, 0, 0])
gris = np.array([128, 128, 128])
blanco = np.array([255, 255, 255])

ten = np.array([[blanco, blanco, blanco], [negro, negro, negro], [gris, gris, gris]])
print(ten)
plt.imshow(ten, interpolation='nearest')
plt.show()

[[[255 255 255]
[255 255 255]
[255 255 255]]

[[ 0 0 0]
[ 0 0 0]
[ 0 0 0]]

[[128 128 128]
[128 128 128]
[128 128 128]]]

Este es el código para el reto que dejo el profesor

tensor_2 = np.array([
    [[255,255,255],[255,255,255],[255,255,255]],
    [[0,0,0],[0,0,0],[0,0,0]],
    [[128,128,128],[128,128,128],[128,128,128]]
])

Ademas recordando que cada vector es un color si por ejemplo cambiamos uno a
[[255,128,0]] estariamos generando el color naranja en uno de esos cuadros de nuestra matriz de tres por tres, tomando este concepto hice un tensor que hace los colores blanco, gris y negro pero esta vez de forma vertical

tensor_v = np.array([
    [[255,255,255],[128,128,128],[0,0,0]],
    [[255,255,255],[128,128,128],[0,0,0]],
    [[255,255,255],[128,128,128],[0,0,0]]
])

Hice una paleta que simula un circulo cromatico a traves del “Modelo aditivo RGB”:




Para que puedan experimentar:
\

#Crear un tensor de pruebas:
tensor_rgb = np.array([
    [[255,0,0],[255,0,255],[0,0,255]],
    [[255,255,0],[255,255,255],[0,255,255]],
    [[0,0,0],[0,255,0],[127,127,127]]
])
tensor_rgb

#Graficar nuestro tensor de pruebas:
plt.imshow(tensor_rgb, interpolation="nearest")
plt.show()

Comparto mi aporte que es distinto a lo que pidió, pero es que lo fui haciendo mientras seguía el video 🤑.

Escalar es un número, pero en Python puede ser un int, float, string o non type

Un vector es un conjunto de números, donde se colocan escalares, una matriz son vectores apilados (2 grados de libertad), mientras que un tensor tiene uno o más grados de libertad que la matriz, son matrices múltiples

%matplotlib inline
import matplotlib.pyplot as plt
plt.imshow(tensor, interpolation='nearest') 

Representamos la información, en el caso de un tensor la interpolación son los espacios entre dos números

escalar = 42
vector = np.array([2,3,5,7])
matriz = np.array([[5,8],[8,0],[7,2]])
tensor = np.array([
    [[255,255,255],[255,255,255],[255,255,255]],
    [[0,0,0],[0,0,0],[0,0,0]],
    [[128,128,128],[128,128,128],[128,128,128]]
])
print(escalar,'\n',vector,'\n',matriz)
plt.imshow(tensor,interpolation='nearest')
plt.savefig('ejercicios.jpg',dpi=300)
matriz = np.array([[1,2],[3,4],[5,6]])
print(matriz)
tensor = np.array([
    [[255,255,255],[255,255,255],[255,255,255]],
    [[0,0,0], [0,0,0], [0,0,0]],
    [[128,128,128],[128,128,128],[128,128,128]],
])
print(tensor)

Reto

Cargando librerías

import numpy as np
%matplotlib inline
import matplotlib.pyplot as plt

Escalar

escalar = 42
print(escalar)

Vector

	vector = np.array([2,3,5,7])
	print(vector)

Matriz

matriz = np.array([[33,88,72],[4,5,6]])
print ("matriz tres por dos" ) 
print (matriz)

Tensor

tensor = np.array([
[[255,255,255],[255,255,255],[255,255,255]],
 [[0,0,0],[0,0,0],[0,0,0]],
  [[128,128,128],[128,128,128],[128,128,128]],
 ])
print (tensor)
print ("tensor colores: blanco, negro y gris")

plt.imshow(tensor, interpolation=‘nearest’)
plt.show()

Ejercicio: Generar el escalar numero 42; hacer el vector que contenga el 2, 3, 5 y 7; generar una matriz de 3 por 2; graficar un tensor que tenga en su 1ra fila, blanco; en la 2da, negro; y en la tercera, gris.

Estructura necesaria en python para escribir estos objetos: la conseguimos importando la libreria numpy

Diferencias entre escalar, vector, matriz y tensor: Los grados de libertad

Reto:
![](

Interesante, Es la primera vez que relaciono el tensor con una matriz multidimensional. y que al mismo tiempo, le encuentro un uso, super interesante!

escalar = 42
vector = np.array([2,3,5,7])
matriz = np.array([[1,2],[3,4], [5,6]])
tensor = np.array([
  [[255,255,255], [255,255,255], [255,255,255]],
  [[0,0,0], [0,0,0], [0,0,0]],
  [[128,128,128], [128,128,128], [128,128,128]],
])
plt.imshow(tensor, interpolation='nearest')

![](

tensor = np.array([
  [[175,23,60], [102,143,245], [255,255,255]],
  [[0,0,0], [178,245,102], [139,102,245]],
  [[102,226,245], [128,128,128], [230,240,133]],
])
plt.imshow(tensor, interpolation='nearest')

Super claro esa diferencia entre vector, matriz y Tensor, por sus grados de libertad.

👌Fue la explicación más clara de qué es un escalar, un vector, una matriz y un tensor que he escuchado 📚

Algo que me ayudo mucho a entender los tensores más halla de las 3 dimensiones es imaginar los siguiente.
Un vector es una fila
Una mátriz es una tabla
Un tensor3D es un cubo
Un tensor4D es una fila de cubos
Un tensor5D es una tabla de cubos
Un tensor 6D es un cubo de cubos
y así.

La solución del reto:

escalar = 42
vector = np.array([2,3,5,7])
matriz = np.array([i for i in range(6)]).reshape(3,2)
tensor = np.array([[[255,255,255] for i in range(3)],[[0,0,0] for i in range(3)],[[128,128,128] for i in range(3)]])
plt.imshow(tensor, interpolation='nearest')
plt.show()

![](

vector = array de una dimensión
matriz = array bidimensional
tensor = array tridimensional

excelente explicación

como se hace el amarillo

Muchas gracias por la magnifica explicacion de esta clase he aprendido mucho y el profesor es muy bueno

EJERCICIO:
![](

Creo que una de las propiedades importantes de los tensores que no se mencionan es que pueden haber tensores de una dimension(1-D) que seria un vector, tensores de 2 dimensiones(2-D) que seria una matrix y tensores de 3-D.

Espero mucho de este curso! vamos a aprender con todo!