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

es incorrecta la interpretación de hace el profesor del shape del tensor. (3,3,3) indica respectivamente:

(numero de matrices, numero_filas, número_columnas)
si se hace por ejemplo:

#para recuperar cada matriz, vemos que debemos hacer:
#tensor[0,:,:]  donde se recupera la matriz 1
# tensor[1,:,:] se recupera la matriz 2
# tensor[2,:,:] se recupera la tercera matriz
tensor[2,:,:]

Una corrección al comentario realizado al final del video por el profesor acerca de lo que representan los números obtenidos por medio de la función .shape aplicado en el tensor.

• El primer número obtenido representa la cantidad de capas de matrices que tiene el tensor.
• El segundo número obtenido representa la cantidad de filas que tiene cada matriz del tensor.
• El tercer número obtenido representa la cantidad de columnas que tiene cada matriz del tensor.

En las dimensiones del tensor, la primera posición se refiere al número de matrices (no de filas), el segundo a las filas y el tercero a las columnas:

tensor2 = np.array([
    [[1,3],[4,6],[6,8]],
    [[11,13],[14,16],[17,19]],
    [[21,23],[24,26],[27,28]],
    [[32,33],[34,36],[37,39]],
])
print("dimensión: ", tensor2.shape)
dimensión:  (4, 3, 2)

Dimensiones en los arreglos.

• shape: es un atributo de los arreglos, indica las dimensiones del arreglo de acuerdo a su preponderancia.
  • En un vector indica la cantidad de elementos (nro de columnas).
  • En una matriz indica primero el número de filas (cantidad de vectores) y luego en de columnas
  • en un tensor indica el número de matrices, luego el número de vectores (filas) y el número de elementos por vector (columnas)
    Sintaxis:
    <arreglo>.shape
• len(): es un método que devuelve la dimension principal del arreglo (elementos, filas o matrices según sea vector, matriz o tensor)
  Sintaxis:
  len(<arreglo>)
• size: es un atributo que contiene la cantidad de elementos del arreglo.
  Sintaxis:
  <arreglo>.size

Nota

• A través de un tensor podemos representar la variación de una matriz a través del tiempo (si representamos una imagen con una matriz podemos representar un video con un tensor) o como vimos anteriormente los valores RBG de una imagen a color.

el profe no lo mencionó, pero cuando se trabajan con imagenes a color, estas se pueden ver como como tres matrices donde cada matriz se llama un “canal” o “channel” de la imagen y corresponden a los colores RGB(‘red-green-blue’).

Este curso se hace imposible sin verlo en 1.5x

En el minuto 6:30 se plantea algo interesante. Cuando se analiza la forma del tensor se tiene una tupla (3, 3, 3). El primer “3” indica el número de matrices que hay en el tensor, o visto de otra forma, los elementos en la primera fila del tensor. Por ejemplo, si se recupera:

print(tensor[0, :, :])

[[1 2 3]
 [4 5 6]
 [6 7 8]]

Nótese que se imprime la primera matriz del tensor.
Siguiendo la misma lógica, se puede recuperar el segundo vector de la primera matriz:

print(tensor[0, 1, :])

[4 5 6]

Ahora de este mismo vector, re quiere recuperar el tercer número:

print(tensor[0, 1, 2])

6

Espero y esta aclaración les haya sido de ayuda 😉

El profesor se confundió en los parametros de .shape.
Es en este orden (n° matrices, n° filas, n° columnas)

Pueden crear los esquemas apoyandose en una función para crear los arrays aleatorios con sus dimensiones

escalar = 5.678
vector = np.random.randint(0,100, 6)
matriz = np.random.randint(1,100,[3,3])
tensor = np.random.randint(1,100,[3,3,3])

Ahi lo que dice es que genere numeros aleatorios enteros de 1 a 100 y el último es [numero de vectores, cantidad de numeros en el vector]

Con éste código:

Con éste código:

escalar = 4.5667
vector = np.array([2,3,4,5,6,7])
matriz = np.array([[1,2,3,4],[5,6,7,8]])
tensor = np.array([
    [[255,255,255],[255,255,255],[255,255,255]],
    [[128,128,128],[128,128,128],[128,128,128]],
])

print(vector.shape)
print(matriz.shape)
print(tensor.shape)```

Buenas noches.
Comento la tarea porpuesta.
Saludos cordiales.

import numpy as np

#Definicion
escalar = 5.2135
vector = np.array ([1,2,4])
matriz = np.array ([[1,2,4],[1,2,4]])
tensor = np.array ([
[[ 225, 225, 225], [ 225, 225, 225], [ 225, 225, 225]],
[[0, 0, 0], [0, 0, 0], [0, 0, 0]],
[[112, 112, 112], [112, 112, 112], [112, 112, 112]]])

#Uso shape
vector.shape
matriz.shape
tensor.shape

#Uso len
len (vector)
len (matriz)
len (tensor)

#Uso size
print (vector.size)
print (matriz.size)
print (tensor.size)

tensor = np.array([
    [[1,2,3],[4,5,6],[6,7,8],[6,7,8]],
    [[11,12,13],[14,15,16],[17,18,19],[6,7,8]],
    [[21,22,23],[24,25,26],[27,28,29],[6,7,8]],
])
print(tensor.size)
print(tensor.shape)
print(tensor.len)


36
(3, 4, 3)





---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-21-e3e4c4750c77> in <module>
      8 print(tensor.size)
      9 print(tensor.shape)
---> 10 print(tensor.len)

AttributeError: 'numpy.ndarray' object has no attribute 'len'

Comparto apuntes de la clase:

El Tensor representa:
(n° de matricees, n° de filas, n° columnas)

Dimensión de escalares, vectores, matrices y tensores

se usa la función .shape que calcula la dimensión del vector (#elementos), matriz (n°filas, n°columnas) o tensor (n°matrices, n°filas, n°columnas).

La función len(elemento) nos dice cantidad de elementos en caso del vector, cantidad de filas (vectores) en caso de la matriz y la cantidad de matrices en el caso de tensores.

la función elemento**.size** retorna la cantidad de elementos totales

Hago una observación: la intepretación del profesor en el minuto 4:52 .
len(matriz) NO está devolviendo la cantidad de elementos de la primer columna. Sino que el método len intepreta que hay dos listas dentro de la lista ya que una matriz es justamente esto, listas apiladas.

Comparto imagen:

A tensor is a concept from mathematical physics that can be thought of as a generalization of a vector. While tensors can be defined in a purely mathematical sense, they are most useful in connection with vectors in physics.

One of the uses in physics i like most are the relativity.

Detalle: los atributos size y shape son exclusivos del objeto array dentro de la libreria numpy, si se pide .shape o .size para una lista normal ocurre un error en la ejecucion

Que buenos comentarios y correcciones de los compañeros al pequeño error del profesor 😄

El print es nuestro amigo, por lo que aquí les dejo este código por si gustan ver mas a detalle que nos imprime cada cosa

print("Vector: ", vector)
print("Shape: ",vector.shape)
print("Size: ",vector.size)
print("----------------")
print("Matriz: ", matriz)
print("Shape: ",matriz.shape)
print("Size: ",matriz.size)
print("----------------")
print("Tensor: ", tensor)
print("Shape: ",tensor.shape)
print("Size: ",tensor.size)
print("----------------")

Un tensor sirve para pensar en una evolución de la matriz con el tiempo

• En Python, podemos utilizar la librería NumPy para obtener la dimensión de un escalar, vector, matriz o tensor. La dimensión de un objeto se refiere al número de elementos que tiene en cada una de sus dimensiones. En el caso de un escalar, su dimensión es 0. Para vectores, matrices y tensores, la dimensión se refiere al número de filas, columnas y dimensiones, respectivamente.

import numpy as np

# Escalar
escalar = np.array(5)
dim_escal = escalar.ndim  # resultado: 0

# Vector
vector = np.array([1, 2, 3])
dim_vect = vector.ndim  # resultado: 1

# Matriz
matriz = np.array([[1, 2, 3], [4, 5, 6]])
dim_matr = matriz.ndim  # resultado: 2

# Tensor
tensor = np.array([
  [[1, 2], [3, 4]],
  [[5, 6], [7, 8]]
])
dim_tens = tensor.ndim  # resultado: 3

noten que el profesor accidentalmente explico mal la parte de .shape como lo explica el compañero johanR

print(tensor)
[[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]

[[13 14 15 16]
[17 18 19 20]
[21 22 23 24]]

[[25 26 27 28]
[29 30 31 32]
[33 34 35 36]]]
umns.
#the firts 3 represents number of matrix, second 3 number of rows and the 4 represents number of columns.
tensor.shape
(3, 3, 4)

Cabe precisar, que con una matriz se puede ver una imagen en Blanco y negro, y con un tensor de 3 dimensiones, se puede visualizar la misma imagen a colores en formato RGB (Red-Green-Blue), con todas sus combinaciones.

<
tensor = np.array([
       [[233, 234, 235],
        [253, 254, 255]],
    
       [[  0,   5,  10],        
        [ 40,  45,  50]],

       [[118, 119, 120],
        [136, 137, 138]],
              
       [[243, 244, 245],
        [ 20,  25,  30]]
])
print(tensor.size)
24
print(tensor.shape)
(4,2,3)
> 

Es como si las matrices se estuvieran apilando
libro

len Nos dice la cantidad de elementos que hay en la primera dimensión de nuestro objeto.

.size Nos devuelve la multiplicación de las multiplicaciones o lo que seria la cantidad total de elementos que tiene esta matriz.

.shape Sirve para que cada uno de uno de nuestros objetos nos devuelva cuales son sus dimensiones.

Un tensor puede servir para mostrar la evolución del tráfico en el correr del tiempo.

la operación preestablecida para determinar las dimensiones es

ndim

y se usa con notación orientada a objetos:

tensor.ndim

tensor = np.array([[[1,2,3,4],[1,2,3,4],[1,2,3,4]],[[1,2,3,4],[1,2,3,4],[1,2,3,4]]])

print(tensor)

te arroja:
[[[1 2 3 4]
[1 2 3 4]
[1 2 3 4]]

[[1 2 3 4]
[1 2 3 4]
[1 2 3 4]]]

tensor.shape

te arroja:

(2, 3, 4)

donde:
El primer elemento(2) indica la cantidad de matrices.
El segundo elemento(3) indica la cantidad de filas.
El tercero elemento(4) indica la cantidad de columnas.

Les dejo un notebook de google colab

NOTA, en este vide hay un peque error, cuando el profe esta hablando sobre dimensiones de tensores con el metodo shape, el valor que regresa consta de 3 valores: el primer valor es la cantidad de matrices, el segundo la cantidad de filas que tiene cada matriz y el tercer valor es la cantidad de columnas que tiene cada matriz

Lo que entendí 😃
“len” (length) arroja el número de elementos en la primera fila, sin iportar si hay más filas o profundidad (estructuras repetidas).
“size” regresa en número total de elementos que tiene una estructura de datos, teniendo en cuenta filas, columnas y profundidad.
".shape" devuelve las dimensiones de la estructura de datos, el número de columnas, filas y profundidad-

Resumen de la clase
Es importante saber la dimensión pues en Python nos va a permitir operaciones por más que estas no estén definidas matemáticamente.

#Reto 

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

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

Tensor=np.array([[[1,2,3],[4,5,6]]
                 ,[[34,64,77],[231,3213,424]],
                 [[1212,1221,1123],[1212,2342,34234]]])
print("Vector")
print(len(vector))
print("\n Matriz")
print(matriz.shape)
print(matriz.size)
print("\n Tensor")
print(Tensor.shape)
print(Tensor.size)

Import numpy as np

#vectores
vector_1 = np.array([1, 2, 3])
vector_2 = np.array([1, 2, 3, 4])

print(vector_1.size)
print(vector_1.shape)

print(vector_2.size)
print(vector_2.shape)

#matrices
matriz_1 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9],])
matriz_2 = np.array([[1, 2], [3, 4], [5, 6], [7, 8],])

print(matriz_1.size)
print(matriz_2.size)

print(matriz_1.shape)
print(matriz_2.shape)

#tensores
tensor_1 = np.array([
                     [[1, 2, 3], [4, 5, 6]],
                     [[7, 8, 9], [10, 11, 12]],
                     [[13, 14, 15], [16, 17, 18]],
])

print(tensor_1)

print(tensor_1.shape)
print(tensor_1.size)

Para entender las dimensiones del TENSOR imaginen un cubo Rubik.

#filas: representan ancho del cubo
#colummnas: representan largo del cubo
#de matrices: representan la Altura del cubo

Son importantes las dimensiones para realizar cuentas, permitir aunque matemáticamente no estén definidas, las dimensiones son observadas con .shape .Los usos para usar tensores son como para pensar una evolución de una matriz en el tiempo

Análisis funciones : len, size y shape para el siguiente vector:

[ 1  2  3 11 12]

Funcion Len

Resultado funcion len = 5 
Indica el número de elementos del vector 

Funcion Size

Resultado funcion size = 5
indica tamaño del vector  

Funciona .shape

Resultado función .shape = (5, -)
 indica que el arreglo tiene 5 posiciones en un sentido y nada en el otro - devuelve una tupla

Análisis funciones : len, size y shape para la siguiente matrizr:

[[ 1  2  8]
 [ 3  4  7]
 [ 9 10  6]
 [18 45  2]]

Funcion Len

Resultado funcion len = 4
    Indica el numero de filas o registros de la matriz

Funcion Size

Resultado funcion size = 12
indica el numero de elementos  de la matriz

Funciona .shape

Resultado función .shape = (4,3)
el primer dato indica el numero de filas o registros
el segundo dato indica el numero de Columnas

Análisis funciones : len, size y shape para el siguiente tensor:

[[[ 1  2  3]
 [ 4  5  6]
  [ 6  7  8]]

 [[11 12 13]
  [14 15 16]
  [17 18 19]]

 [[21 22 23]
  [24 25 26]
  [27 28 29]]]

Funcion Len

Resultado funcion len = 3

Funcion Size

Resultado funcion size = 27 
indica el numero de elementos del tensor 

Funciona .shape

Resultado función .shape = (3, 3, 3)
el primer dato  indica el  numero de filas
el segundo dato indica el  numero de Columnas
el tercer dato indica el  numero de matrices

<objeto>.shape, Funcion (atributo) que regresa la dimension de nuestros objetos

Shape se refiere al número de profundidad de cada elemento en una estructura, en el caso de la matriz se dice que existen 3 filas con 3 elementos cada una.
En el caso del tensor nos dice que hay primero 3 elementos de tipo matriz, cada matriz tiene un número de filas n en el caso del ejemplo igual 3 filas, y esas filas tienen 3 elementos cada uno. Siempre desde el elemento más complejo hasta el más sencillo o hasta llegar a un escalar.
Ejemplo:

tensor_1 =  np.array([
      [[53,206,253],[48,227,221],[65,250,191],[48,227,119]],
      [[53,206,253],[48,227,221],[65,250,191],[48,227,119]],
      [[53,206,253],[48,227,221],[65,250,191],[48,227,119]],
  ])
np.shape(tensor_1) # puts: (3,4,3)

La interpretación de “shape” puede ser algo confusa ya que, según lo que puedo observar, los valores que devuelve dicho método indican, de izquierda a derecha, la cantidad de elementos de la n-sima dimensión.

En un ejemplo:

tensor = np.array([
    [[1,2,3],[4,5,6],[7,8,9]],
    [[11,12,13],[14,15,16],[17,18,19]],
    [[21,22,23],[24,25,26],[27,28,29]],
    [[31,32,33],[34,35,36],[37,38,39]]
])

tensor.shape

Dará como salida un vector que contiene los elementos de la 3ra (Tensor) , 2da(Matriz) y la 1ra (vector) de izquierda a derecha y sus valores serán entonces (4,3,3). Lo que podemos interpretar entonces es:

• 4 --> Corresponde al numero de matrices dentro del tensor
• 3 --> El primero, corresponde al numero de vectores dentro de cada matriz
• 3 --> El segundo, corresponde al numero de escalares dentro de cada vector

Podemos probar esto proponiendo un Tensor de 4 dimensiones de la forma:

tensor4D = np.array([
    [[[1,2,3],[4,5,6],[7,8,9]],[[11,12,13],[14,15,16],[17,18,19]],[[21,22,23],[24,25,26],[27,28,29]],[[31,32,33],[34,35,36],[37,38,39]]],
    [[[1,2,3],[4,5,6],[7,8,9]],[[11,12,13],[14,15,16],[17,18,19]],[[21,22,23],[24,25,26],[27,28,29]],[[31,32,33],[34,35,36],[37,38,39]]]
])

tensor4D.shape

La salida sería → (2,4,3,3) que se interpreta como:

• 2 → Cantidad de tensores de grado 3 dentro del tensor grado 4
• 4 --> Corresponde al numero de matrices dentro de los tensores de grado 3
• 3 --> El primero, corresponde al numero de vectores dentro de cada matriz
• 3 --> El segundo, corresponde al numero de escalares dentro de cada vector

Finalmente la generalización para un tensor de n grados de libertada al aplicar el método shape, nos daría:

(elementos del grado n, elementos del grado n-1,elementos del grado n-2, … ,elementos del grado 2 [Matriz], elementos del grado 1 [vector])

Por favor, tener en cuenta que esta es mi interpretación y puede estar equivocada. Por tal motivos, les pido que me corrijan de ser necesario.

Slds.-

🤯 Con un tensor podemos representar un video; mientras que con una matriz podemos representar una foto.

📝 El comando .shape() nos habla de dimensiones mientras que el comando .len() nos devuelve solamente la primera dimensión.

Se puede generar un escalar usando numpy.array() para evitar que de error

escalar = np.array(5.679)
escalar.shape

()

y da como salida que tiene 0 dimensiones

• .size : devuelve el total de los elementos de un vector, matriz o tensor.
• .shape: devuelve la dimensión de un vector, matriz y tensor.

Creo que hay un error conceptual con la función len.
Al llamarla, el valor devuelto es el número de ‘objetos’ (un vector en sí es un objeto, una matriz es un grupo de vectores) dentro de la matriz. No es, como dice el profesor, la dimensión del primer elemento del arreglo.

Para una matriz 3x4, la función len devolverá un valor de 3 (que es el número de filas, o el número de vectores fila), aunque en sí cada vector fila tenga 4 componentes.

Los tensores son objetos matemáticos que almacenan valores numéricos y que pueden tener distintas dimensiones. Así, por ejemplo, un tensor de 1D es un vector, de 2D una matriz, de 3D un cubo etc. … En Python, estos tensores normalmente se almacenan en lo que se conoce como NumPy arrays

Buena explicación , solo tomar en cuanta que en los tensores primerote regresa el numero de capas , despues el eje Y y finalmente el eje X

Para saber las dimensiones de un vector llamamos la función “.shape”

la función “len()” nos da la cantidad de elementos que tienen nuestras entidades en la primera columna.

La función “.size” nos da la cantidad de elementos que tiene nuestra entidad

import numpy as np

escalar = False
vector = np.array([1,2,3,4])
matriz = np.array([[14,24,34],[45,55,56],[67,68,79]])
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(escalar)
print(vector)
print(matriz)
print(tensor)

escalar
# False

vector.shape
# (4,)

matriz.shape
# (3, 3)

tensor.shape
# (3, 3, 3)

import numpy as np

vector_ejercicio = np.array([3,4,6,7])
matriz_ejercicio = np.array([[5,4,3,5],[3,4,5,6],[2,5,6,6]])
tensor_ejercicio = np.array([
    [[255,255,233],[234,222,333],[332,343,222],[332,343,222]],
    [[33,45,67],[32,22,78],[22,12,45],[22,12,45]],
    [[1,2,3],[4,5,6],[7,8,9],[7,8,9]],
    [[1,2,3],[4,5,6],[7,8,9],[7,8,9]],
])

vector_ejercicio.shape # Dimension del vector
len(vector_ejercicio) # cantidad de elementos que hay
matriz_ejercicio.shape # Dimension de la matriz

print(tensor_ejercicio.shape)

‘’‘
Blanco
Negro
Gris
’’'
tensorT = 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(tensorT, interpolation=‘nearest’)
plt.show()

++++ clase entendida

Con la funcion shape podemos calcular size. Solo tenemos que multiplicar cada elemento de la tupla resultante. Por ejemplo, supongamos que tenemos una matriz de 3 filas y 4 columnas

>>> s = matriz.shape
>>> print(s)
(3,4)
>>> tamano = s[0]*s[1]
>>> print(tamano)
12
>>> matriz.size
12

empiezo el curso, pero por lo que veo el contenido no es de gran calidad, y no tiene nada que ver con que use windows, nada ! jaja.

En resumen, para saber la dimensión de un objeto vamos a tratar de usar siempre que se pueda la función shape

Si se hace tensor[1,1,1] se obtiene el 15, pero también se obtiene con tensor[1][1][1].
Parece ser que con la primera forma se busca en todo el tensor, mientras que con la segunda forma el tensor se va partiendo en pedazos y buscando en ellos para luego repetir.
Eso, junto a la notación de slices, puede ser mucho en que pensar.
Guarden esta información, creo que puede ser útil: https://stackoverflow.com/questions/509211/understanding-slice-notation

me explotó la cabeza cuando dijo que podíamos representar tiempo

vector.shape -> (#elementos en el vector, )
matriz.shape -> (#vectores en la matriz, #elementos en los vectores)
tensor.shape:
(#matrices, #vectores en las matrices, #elementos en los vectores)

Hola, espero aclarar un poco como manipular el tensor:

import numpy as np
tensor = np.array([
    [[1,2,3],[4,5,6],[7,8,9]],
    [['A','B','D'],['E','F','G'],['H','I','J']],
    [[0.2,'K',True],[0.1,'L',False],[0.4,'N',False]],
])
print(tensor[0,:,:]) # Imprimiendo la primera matriz o capa del tensor.
print()
print(tensor[:,1,:]) # Imprimiendo la segunda fila de cada matriz o capa del tensor.
print()
print(tensor[:,:,2]) # Imprimiendo la tercera columna de cada matriz o capa del tensor.

[[‘1’ ‘2’ ‘3’]
[‘4’ ‘5’ ‘6’]
[‘7’ ‘8’ ‘9’]]

[[‘4’ ‘5’ ‘6’]
[‘E’ ‘F’ ‘G’]
[‘0.1’ ‘L’ ‘False’]]

[[‘3’ ‘6’ ‘9’]
[‘D’ ‘G’ ‘J’]
[‘True’ ‘False’ ‘False’]]

Este instructor explica muy bien, muy claro! Me dan muchas ganas de seguir aprendiendo! 😃