Trabajando con tensores

Clase 5 de 27 • Curso de Introducción a Machine Learning 2019

Resumen

En esta clase nos vamos a la parte práctica, puedes ir a Google Colab: https://colab.research.google.com/ para seguir la clase paso a paso mientras vas aprendiendo junto con el profesor.

Usuario anónimo

user•

Quiero hacer una observación de manera constructiva.La curva de aprendizaje de IA es bastantes dura. Por ejemplo, debemos dominar muy bien la biblioteca Pytorch y también NumPy que ya nos adentrarnos en estos temas de Machine Learning. Pienso que deberia ser requisito indispensable el manejo de Numpy como un curso aparte al de Pytorch para poderle entender bien al profe. Yo algo manejo y algo entiendo. Pero deben haber muchos compañeros de grupo perdidos. Y es fatal para la continuidad. Las explicaciones del profesor están muy bien. Pero falta que Platzi ensamble mas jerárquicamente este conocimiento. De todas maneras gracias a Platzi por este aporte de IA.

Joel Ricci López

student•

Completamente de acuerdo. Y sí, agradecer que platzi tiene este tipo de contenidos en español pero también exigir que mejoren esta área de ML y data science comenzando por lo que comentas (creo que hay mejor calidad en el área de desarollo web). Y hay exigirlo sin miedo, al fin y al cabo pagamos por el contenido. Y a la plataforma también le conviene que seamos mejores estudiantes y mejores clientes.

Emma Juliana Gachancipa Castelblanco

student•

Es verdad muchos cursos de esta ruta son muy generales y suponen que ya tienes conocimientos previos, es necesario que mejoren.

Victor Macas

student•

no se entiende lo funcion stride. :(

Kevin Steven

student•

La idea detrás del stride es que se pueda acceder al elemento de manera física en memoria, más que del simple hecho de accederlo lógicamente ( por ejemplo points[1][0] ). Y es ahí donde stride me dice como hacerlo!. Esto es, que si por ejemplo quieres saber dónde está el numero 3 en el ejemplo que te pongo, tienes que multiplicar cada indice de donde se encuentra en el tensor con su respectivo stride de la dimensión y sumarlos todos juntos. En la imagen, la primera dimensión del tensor esta en azul y la segunda en rojo. Así pues, para obtener el el numero 3 de manera física se hace el cálculo stride:

1(fila del numero 3) X 2(dimensión stride de la fila) + 0(columna del numero 3)X1 (dimensión stride de la columna) = 2

El 2 significa que debes hacer dos saltos en memoria para obtener el numero 3

Puedes hacer la prueba con los ejemplos que Adrian puso en el video.

Luis Fernando Pedroza Taborda

student•

Muchas gracias ikstvn por la aclaracion de esta funcion, la verdad no se habia entendido.

Usuario anónimo

user•

Este vídeo complementa lo aprendido sobre la función .stride(): https://www.youtube.com/watch?v=DfK83xEtJ_k

Diego Armando Casillas Muñoz

student•

Muchas gracias por el aporte, es justo lo que estaba buscando para complementar la clase! Particularmente .stride() me costó trabajo comprenderla.

Arturo Baduna

student•

gracias

Usuario anónimo

user•

Muy bien, el profesor explica bien y nos ayuda a familiarizarnos con todo el tema.

Replicado Por CHRISTIAN PINO.

Curos de Introducción a Machine Learning, video 6, trabajando con tensores.


import torch
import numpy as np

***# Trabajando con tensores***

torch.__version__

tensor_a = torch.ones(2, 2)
tensor_a

#crea tensor de 2x2 con valores aleatorios.
tensor_b = torch.Tensor(2, 2)
print(tensor_b)
tensor_b.uniform_(0, 1) #genera valores aleatorios entre 0 y 1.

tensor_c = torch.rand(2, 2) #crea tensor con valores aleatorios y entre 0 y 1.
tensor_c

result = tensor_b + tensor_c  #suma entre tensores.
print(result)
result.shape
reshaped = result.view(1, 4)
print(reshaped)


points = torch.tensor([[1, 2], [3, 4]])   # puedo usar t minúscula ya que no quiero aleatorio.
print(points)
points[0][1]
print(points)
points[0][1] = 6.5
print(points)
points.storage()

points, points.stride()

p_t =points.t() #para la traspuesta
p_t, p_t.stride()

tensor_x = torch.tensor([1, 2, 3, 4])
print(tensor_x)
torch.unsqueeze(tensor_x, 0)
torch.unsqueeze(tensor_x, 1)

numpyArray = np.random.randn(2, 2)
torch.from_numpy(numpyArray)

Usuario anónimo

user•

Para entender el medoto stride() hay que ver tambien el metodo storage(), ya que este es el que indica como se guardan los datos, por lo que este indica en numero de pasos que hay que recorrer dentro del almacenamiento para desplazarse una fila y una columna respectivamente.

Usuario anónimo

user•

Ojo que los tensores solo soportan valores numericos y booleanos!

Wilson Fernando Antury Torres

student•

.stride() : Nos dice cuantos bytes debemos saltar en memoria para movernos a la siguiente posición a lo lago de un cierto eje.

Alexander Henry Obispo Buendia

student•

Explicación de como trabaja Stride y Storage

Luis Carlos Botero Ochoa

student•

Instalando pytorch con pip, pueden correr sin problema:

import torch
import numpy as np

print(torch.__version__)

print(&quot;T R A B A J A N D O  C O N  T E N S O R E S&quot;)

#Crea tensor con valores de uno acorde a la dimensión dada
tensor_a = torch.ones(2,2)
print(&quot;Tensor con ones: {}&quot;.format(tensor_a))

#Crea tensor con valores aleatorio, sin restricción acorde a dimensión dada
tensor_b = torch.Tensor(2,2)
print(&quot;Tensor con .Tensor: {}&quot;.format(tensor_b))
#Modifica un tensor existente colocando los valores entre la declaración en este caso el tensor_b de 2x2 quedara con valores entre 2 y 3
tensor_b.uniform_(2,3)
print(&quot;Tensor uniformado: {}&quot;.format(tensor_b))

#Crea un tensor con valores aleatorio entre 0 y 1
tensor_c = torch.rand(2,2)
print(&quot;Tensor con rand: {}&quot;.format(tensor_c))

#Operaciones con tensores, aplica elemento a elemento
result_1 = tensor_a + tensor_b
print(&quot;La suma es:{}&quot;.format(result_1))
result_2 = tensor_a - tensor_b
print(&quot;La resta es:{}&quot;.format(result_2))
result_3 = tensor_a * tensor_b
print(&quot;El producto es:{}&quot;.format(result_3))
result_4 = tensor_a / tensor_b
print(&quot;La división es:{}&quot;.format(result_4))

#Conocer la dimension del tensor
print(&quot;Dimension o forma del tensor: {}&quot;.format(result_1.shape))
#Arreglar el tensor, tener en cuenta que las dimensiones debe ser homologables (si es un 2x2, podra ser 4,1 o un 1,4, más no un 3,1 o un 1,3)
reshaped = result_1.view(4,1)
print(&quot;Arreglo del tensor: {}&quot;.format(reshaped))

#Crear un tensor con los valores que decida, nota, cada fila se define dentro [], cada elemento interno se separa por , al igual que el final de la fila.
#Todo el tensor debe estar definido entre []
tensor_d = torch.tensor([[1.3, 2.5],[3.0, 5]])
print(&quot;Tensor creado: {}&quot;.format(tensor_d))
#Indicar el elemento de un tensor (debe estar dentro del tamaño), recordar que siempre el tensor tiene por primer elemento la posición [0],[0]
print(&quot;Posición especifica [0][0]: {}&quot;.format(tensor_d[0][0]))
#Modifica el valor en una posición, cambiamos el 1.3 por 4
tensor_d[0][0] = 4.0
print(&quot;Modificación posición [0][0]: {}&quot;.format(tensor_d))

#Conocer como se guarda, a pensar de la dimensión:
guarda = tensor_d.storage()
print(&quot;El tensor se guarda así: {}&quot;.format(guarda))

#Recorrido entre elementos del tensor, significa que debo contar cuantos elementos de la línea y luego ver el salto
recorrido = tensor_d.stride()
print(&quot;Recorrido del primer elemento del tensor al siguiente: {}&quot;.format(recorrido))

#Traspuesta, al tener una transpuesta el salto de memoria cambia:
tran = tensor_d.t()
print(&quot;Transpuesta es: {}&quot;.format(tran))
recorrido_t = tran.stride()
print(&quot;Recorrido del primer elemento del tensor al siguiente en transpuesta: {}&quot;.format(recorrido_t))

#Añadir dimensiones:
tensor_x = torch.tensor([1,2])
print(tensor_x)
nueva_dim = torch.unsqueeze(tensor_x, 1)
print(&quot;Tensor con nueva dimension:  {}&quot;.format(nueva_dim))

#Crear arreglo usando Nunpy:
#1. Creo el arreglo:
arreglonun = np.random.randn(3,3)
print(&quot;Arreglo creado en Numpy, notese que no es un tensor, carece de los parentesis iniciales: {}&quot;.format(arreglonun))
tensor_f = torch.from_numpy(arreglonun)
print(&quot;Tensor creado a partir del arreglo de nunpy: {}&quot;.format(tensor_f))

Carli Code

teacher•

Para los que quieran ver tutoriales de la página oficial :D https://pytorch.org/tutorials/

Deyvi Jhonny Bustamante Perez

student•

Gracias

Usuario anónimo

user•

Bueno, al inicio bien, después un poco complejo, pero la práctica hace al maestro...

Carlos Sebastián Cano Gutiérrez

student•

https://drive.google.com/file/d/1blXqAjjAPZ4_FCt770JxzqT4nDz0hhk6/view?usp=sharing Este es un archivo de Google colabs, donde estaré subiendo lo visto en la clase, adicionalmente con notas mías que espero lleguen a ser útiles para ustedes :3

Daniela Cardona

student•

Gracias!!

Jaime Ramos

student•

tengan en cuenta que cada vector dentro de un tensor debe tener el mismo tamaño, si no no podrán crearlo, es decir, torch.tensor( [ [1.0, 2.0, 5.0] , [3.0,4.0] ] ) no es posible

Jhon Freddy Puentes Nuñez

student•

Pytoch

Sitio oficial: https://pytorch.org/ Instalación: https://pytorch.org/get-started/locally/#mac-installation Tutoriales: https://pytorch.org/tutorials/ Documentación: https://pytorch.org/docs/stable/index.html Recursos: https://pytorch.org/resources/

Usuario anónimo

user•

No entendí muy bien lo del stride...

Erick Herrera

student•

Holaa, básicamente lo que hace stride es decirte la cantidad de datos que hay entre una matriz y otra, hasta llegar a el escalar, en el ejemplo es un tensor con 2 vectores adentro, para llegar del vector [1.000, 2.500] al siguiente, hay que pasar por 2 datos, luego adentro del vector [1.000, 2.500] , como ya no hay mas vectores, vas de dato a dato, por lo que es 1, y así obtiene (2 , 1) Igual lo dije medio enredado jajaja, espero haberte ayudado un poco. Un abrazo

Usuario anónimo

user•

Según entendí es el "paso" que se da entre una fila u la siguiente, así por ejemplo si hacemos:

tensor_3 = tc.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(tensor_3)

saldrá

tensor([[1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]])

y si llamamos el método stride

tensor_3.stride()

se obtiene

(3,1)

Usuario anónimo

user•

Cordial saludo, Adrián. La verdad no me quedó claro que hace la función .stride. Podrías dar otro ejemplo? Gracias.

Usuario anónimo

user•

Buenas tardes. El método '.stride()' nos permite conocer de qué forma se encuentra almacenada nuestra estructura de datos, es decir, si nuestros datos serán almacenados de forma horizontal, la función nos retornará algo de la forma '(n,1)', donde n es el número de parámetros que tiene cada fila (Cada fila es un dato); si por el contrario nuestros datos tienen una estructura de forma vertical, la función nos retornará algo de la forma '(1,n)', donde n es el número de parámetros que tiene cada columna (Cada columna es un dato).

Un saludo.

Usuario anónimo

user•

Creo que esto hace referencia a lo siguiente, se determina la posición del primer y segundo elemento en el tensor. El primer elemento es 1 y el segundo 2.5. Para el primer caso se identifican las columnas, estan en dos columnas diferentes (2), pero en la misma fila (1) por eso (2, 1). Para el segundo caso con la transpuesta la diferencia ahora es, están en la misma columna (1), pero en dos filas diferentes (2) por eso (1, 2).

Sergio Mesa

student•

Les dejo por si les sirve

# -*- coding: utf-8 -*-
&quot;&quot;&quot;Clase 2 de Introducción a ML - Platzi

Automatically generated by Colaboratory.

&quot;&quot;&quot;

import torch
import numpy as np

&quot;&quot;&quot;# Trabajando con tensores

---
&quot;&quot;&quot;

print('La versión de torch',torch.__version__)
print('La versión de numpy',np.__version__)

# Tensor de 2 x 2 que me genera solo con valores 1
tensor_a = torch.ones(2,2)
tensor_a

# Me genera tensor de 2 x 2 con valores con numericos aleatorios
tensor_b = torch.Tensor(2,2)
print(tensor_b)

# Puedo hacer que me genere los valores aleatorios en este caso entre 0 y 1
tensor_b.uniform_(0,1)

# De esta forma puedo generar un tensor de 2x2 y ya de por si el metodo 
#genera con valores aleatorios entre 0 y 1
tensor_c = torch.rand(2,2)
tensor_c

# Puedo hacer operaciones entre tensores por ejemplo sumarlos en un nuevo tensor
tensor_result = tensor_b + tensor_c
tensor_result

# son Shape puedo ver la forma del tensor
tensor_result.shape
print(tensor_result)
# Con view puedo cambiar la forma, es decir moverlo de un tamaño de matriz a otro
tensor_reshape = tensor_result.view(4,1)
tensor_reshape

# Voy a generar un tensor no aleatorio, notar que se hace con tensor con T
# minuscula
tensor_point = torch.tensor([[1.0,2.0],[3.0,4.0]])
print(tensor_point)

# si quiero cambiar el valor de alguno de los nodos de la matriz puedo hacerlo
# simplemente reaccionado el valor en las coordenadas
tensor_point[0][1] = 2.5
print(tensor_point)

# Con storage puedo saber como se esta almacenando el tensor
tensor_point.storage()

# Con Stride voy a saber como paso de un número a otro a traves de las dimensiones
# por ejemplo nos esta diciendo [2,1], esto quiere decir que para pasar 
# de un Elemento al siguiente tengo 2 elementos formando el primer tensor
# y que para pasar del primer arreglo al siguiente solo 1
tensor_point, tensor_point.stride()

# Con .t puedo hacer una transpuesta de un tensor
tensor_transpuesta = tensor_point.t()
tensor_transpuesta

# Con unsqueeze podermos agregar dimensiones adicionales horizontal o verticalmente
# 0 = horizontal, 1 = vertica
tensor_x = torch.tensor([1,2,3,4])
# Por ejemplo una dimensión en X mas
print(tensor_x, torch.unsqueeze(tensor_x, 0))
# Por ejemplo una dimensión en Y mas
print(tensor_x, torch.unsqueeze(tensor_x, 1))

# Puedo usar numpy que facilita el trabajo con numeros para generar arrays
numpArray = np.random.rand(2,2)
print('Este es el array numpy',numpArray)

# Luego puedo generar un tensor con este array
tensor_np = torch.from_numpy(numpArray)
print('Tensor desde numpy', tensor_np)

Usuario anónimo

user•

Buena clase, se pone mejor.

Rodrigo Urquizo Yepez

student•

El metodo points.t() nos sirve para hallar la transpuesta de una matriz, es decir, las filas se convierten en columnas y las columnas en filas. Los que han llevado algebra lineal se les hara facil entender estos topicos.

Jorge Sebastian Alvarez Herrera

student•

Para los que usen anaconda como yo en windows este comando es útil

conda install pytorch torchvision cudatoolkit=10.1 -c pytorch

Trabajando con tensores

Conceptos básicos de Machine Learning

Bienvenida Curso de Introducción a Machine Learning

Introducción a la terminología de Machine Learning

Terminología y regresión lineal

Trabajando con Pytorch

Introducción a Pytorch, trabajar con tensores y representar datasets con tensores

Trabajando con tensores

Representando datasets con tensores

Implementaciones de algoritmos de Machine Learning en Pytorch

Implementación de regresión lineal en Pytorch, Regresión logística, Implementación de regresión logística en Pytorch

Regresión logística

Implementación de regresión logística en Pytorch

Redes Neurales y reconocimiento de imágenes

Cómo funciona el reconocimiento facial

Neuronas y función de activación, Usando un modelo pre entrenado para reconocimiento de imágenes, Trabajando un dataset

Usando un modelo pre entrenado para reconocimiento de imágenes

Trabajando un dataset

Reconocimiento de imágenes

Construyendo un modelo, Implementando un clasificador totalmente conectado, Mejoras, limitaciones y conclusiones

Training and Loss: entrenando y ajustando nuestro modelo

Implementando un clasificador totalmente conectado

Mejoras, limitaciones y conclusiones

Collab con Scikit

Aprende a usar Collab con scikit

Demo con Scikit: división de datos

Demo con Scikit: validación de datos

Algoritmos más usados en Machine Learning

Los algoritmos más usados en Machine Learning

Algoritmos supervisados en Machine Learning

Algoritmos no supervisados en Machine Learning

Bonus: Redes neuronales y herramientas

Qué es lo que está detrás de una red neuronal

Cómo funciona una red convolucional intuitivamente y porque son tan buenas con imágenes

Redes generativas

Cierre

Conclusiones y siguientes pasos