UNIDAD 2

2.1.1. Instalación de Python, Anaconda y Jupyter Notebook

# Guardamos dos numeros de entrada
num1 = input('Enter first number: ')
num2 = input('Enter second number: ')

# Sumamos los dos numeros

sum_numbers = float(num1) + float(num2)

# Mostramos por pantalla (print) el resultado

print('The sum of {0} and {1} is {2}'.format(num1, num2, sum_numbers))

2.1.2. Instalación de OpenCV

import numpy as np
import cv2 as cv
from matplotlib import pyplot as plt

# Creamos una imagen negra (todo ceros)

img = np.zeros((512,512,3), np.uint8)

# Dibujamos una linea diagonal azul

cv.line(img,(0,0),(511,511),(255,0,0),5)

# Dibujamos un rectangulo verde

cv.rectangle(img,(384,0),(510,128),(0,255,0),3)

# Dibujamos un circulo azul

cv.circle(img,(447,63), 63, (0,0,255), -1)

# Mostramos la imagen por pantalla

plt.imshow(img)
plt.show()

Ejemplo de uso de HSV en visión artificial

import cv2 as cv
import numpy as np
from matplotlib import pyplot as plt

# Rellenamos el directorio en el que se encuentra nuestra imagen

path_to_image = 'C:/Users/User/Pictures/roya.jpg'

# Leemos la imagen con OpenCV

img = cv.imread(path_to_image)

# OpenCV usa por defecto el espacio de color BGR, hay que cambiarlo a RGB
img = cv.cvtColor(img, cv.COLOR_BGR2RGB)

# Mostramos nuestra imagen en Jupyter Notebook

plt.imshow(img)
plt.show()
CELDA 2
# Convertimos la imagen a HSV para trabajar con ella
hsv = cv.cvtColor(img, cv.COLOR_RGB2HSV)

# Definimos un rango de naranja en HSV para detectar Roya

lower_blue = np.array([10,90,110])
upper_blue = np.array([18,255,255])

# Extraemos los pixeles cuyo color se encuentra en nuestro rango

mask = cv.inRange(hsv, lower_blue, upper_blue)

# Mostramos por pantalla el resultado

plt.imshow(mask)
plt.show()

# Seleccionamos los pixeles que hemos encontrado en nuestra imagen original

res = cv.bitwise_and(img,img, mask= mask)

# Mostramos por pantalla el resultado sobre la imagen original

plt.imshow(res)
plt.show()

Ejemplo de histograma monocromático

import cv2 as cv
from matplotlib import pyplot as plt

# Sustituir esta ruta por donde se encuentre nuestra imagen

path_to_image = 'C:/Users/User/Pictures/home.jpg'

# Abrimos la imagen con OpenCV en formato de grises (opcion 0)

img = cv.imread(path_to_image, 0)

# Mostramos la imagen en escala de grises

plt.imshow(img, cmap="gray")
plt.show()

# Calculamos el histograma con frecuencias desde 0 hasta 255 y lo mostramos

plt.hist(img.ravel(), 255, [0, 255])
plt.show()
Ejemplo de histograma a color

import cv2 as cv
from matplotlib import pyplot as plt

# Abrimos la misma imagen, en este caso a color

img = cv.imread(path_to_image)

# Convertimos la imagen a RGB y la mostramos por pantalla

img = cv.cvtColor(img, cv.COLOR_BGR2RGB)
plt.imshow(img)
plt.show()

# Calculamos el histograma rojo, que es el primer canal [0]

histr = cv.calcHist([img],[0],None,[256],[0,256])
plt.plot(histr, color='red')
plt.xlim([0,255])

# Calculamos el histograma verde, que es el segundo canal [1]

histr = cv.calcHist([img],[1],None,[256],[0,256])
plt.plot(histr, color='green')
plt.xlim([0, 255])

# Calculamos el histograma azul, que es el tercer canal [2]

histr = cv.calcHist([img], [2], None, [256], [0,256])
plt.plot(histr, color='blue')
plt.xlim([0, 255])

# Mostramos el histograma
plt.show()

Ejemplo de negativos y gamma

import cv2 as cv
import numpy as np
from matplotlib import pyplot as plt

# Sustituir esta ruta por donde se encuentre nuestra imagen

path_to_image = 'C:/Users/User/Picture/home.jpg'

# Abrimos la imagen con OpenCV en formato de grises (opcion 0)

img = cv.imread(path_to_image, 0)

# Calculamos el negativo de la imagen

img_not = cv.bitwise_not(img)

# Mostramos las dos imagenes en escala de grises

plt.imshow(img, cmap="gray")
plt.show()
plt.imshow(img_not, cmap="gray")
plt.show()
CELDA 2
# Guardamos el valor gamma en una variable
gamma = 0.5

# Leemos la imagen y la convertimos a RGB

color_img = cv.imread(path_to_image)
color_img = cv.cvtColor(color_img, cv.COLOR_BGR2RGB)

# Creamos una tabla de busqueda para aplicar la correccion gamma

lookUpTable = np.empty((1,256), np.uint8)
for i in range(256):
lookUpTable[0,i] = np.clip(pow(i / 255.0, gamma) * 255.0, 0, 255)

# Aplicamos la correccion gamma con nuestra tabla de busqueda

res = cv.LUT(color_img, lookUpTable)

# Mostramos ambas imagenes por pantalla

plt.imshow(color_img)
plt.show()
plt.imshow(res)
plt.show()

Ejemplo ecualización global y local de histogramas

# Importamos la librería skimage
from skimage import data
from skimage import img_as_ubyte

# Cargamos una imagen de la superficie de la luna

img = img_as_ubyte(data.moon())

# Ecualizacion global del histograma de la imagen

equ = cv.equalizeHist(img)

# Ecualizacion local del histograma de la imagen

clahe = cv.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
cl1 = clahe.apply(img)

# Mostramos las tres imagenes por pantalla en escala de grises

plt.imshow(img, cmap="gray")
plt.show()

plt.imshow(equ, cmap="gray")
plt.show()

plt.imshow(cl1, cmap="gray")
plt.show()
Ejemplo de detectores de bordes
import cv2 as cv
import numpy as np
from matplotlib import pyplot as plt
from skimage import data
from skimage import img_as_ubyte

# Abrimos la imagen de ejemplo "astronaut" y la mostramos por pantalla

img = img_as_ubyte(data.astronaut())
plt.imshow(img)
plt.show()

''' Aplicamos un filtro Gaussiano como el estudiado en la seccion anterior para

eliminar el ruido y mejorar la deteccion de bordes '''
img_blur = cv.GaussianBlur(src=img, ksize=(3, 3), sigmaX=0)

# Mostramos la imagen por pantalla

plt.imshow(img_blur)
plt.show()

# Convertimos la imagen a grises para la busqueda de bordes y mostramos por pantalla

img_blur = cv.cvtColor(img_blur, cv.COLOR_BGR2GRAY)
plt.imshow(img_blur, cmap="gray")
plt.show()

CELDA 2
# Ejecutamos detección de bordes con Sobel, en los ejes x e y, con un kernel de 5 x 5
sobelxy = cv.Sobel(src=img_blur, ddepth=cv.CV_8U, dx=1, dy=1, ksize=5)

# Mostramos la imagen por pantalla

plt.imshow(sobelxy, cmap="gray")
plt.show()

CELDA 3
# Deteccion de bordes laplaciano con un kernel de 5 x 5
laplacian = cv.Laplacian(src=img_blur, ddepth=cv.CV_8U, ksize=5)

# Mostramos por pantalla el resultado del filtro laplaciano

plt.imshow(laplacian, cmap="gray")
plt.show()
CELDA 4
# Detección de bordes Canny

edges = cv.Canny(image=img_blur, threshold1=100, threshold2=200)

# Mostramos el resultado por pantalla

plt.imshow(edges, cmap="gray")
plt.show()

CELDA 5 (CONTORNOS)

# Detectamos los contornos sobre el resultado de Canny sin aproximación

contours, _ = cv.findContours(image=edges, mode=cv.RETR_TREE,
method=cv.CHAIN_APPROX_NONE)

# Dibujamos los contornos en una copia de la imagen original a color

img_copy = img.copy()

# Con esta funcion dibujamos los contornos indicando color, grosor y tipo de linea
cv.drawContours(image=img_copy, contours=contours, contourIdx=-1, color=(0, 255, 0),
thickness=2, lineType=cv.LINE_AA)

# Mostramos el resultado
plt.imshow(img_copy)
plt.show()

# Repetimos mismo procedimiento pero en este caso empleamos una aproximación simple
contours, _ = cv.findContours(image=edges, mode=cv.RETR_TREE,
method=cv.CHAIN_APPROX_SIMPLE)

img_copy = img.copy()

cv.drawContours(image=img_copy, contours=contours, contourIdx=-1, color=(0, 255, 0),

thickness=2, lineType=cv.LINE_AA)

plt.imshow(img_copy)
plt.show()
Detección de rectas y círculos
import cv2 as cv
from matplotlib import pyplot as plt
import numpy as np
import math

# Es esencial cambiar esta ruta por la ubicacion de la imagen que hemos descargado
img_path = "C:/Users/User/Images/sudoku.png"
img = cv.imread(img_path, cv.IMREAD_GRAYSCALE)

plt.imshow(img, cmap='gray')
plt.show()

CELDA 2
# Ejecutamos Canny sobre nuestra imagen, y la mostramos por pantalla
canny = cv.Canny(img, 50, 200, None, 3)
plt.imshow(canny, cmap='gray')
plt.show()
CELDA 3

''' Ejecutamos la función de HoughLines. Esta función devuelve una lista de lineas en
forma de ecuaciones paramétricas '''
lines = cv.HoughLines(canny, 1, np.pi / 180, 145)

''' Convertimos la imagen original (en escala de grises) a una imagen a color para
poder dibujar las lineas encontradas en un color que resalte, en lugar de en negro
'''
img_rgb = cv.cvtColor(img, cv.COLOR_GRAY2BGR)

''' Iteramos a lo largo de todas las lineas encontradas para poder dibujarlas en la
imagen. No es necesario comprender estos calculos. '''
for i in range(0, len(lines)):

# obtenemos los parametros rho y theta para esta linea

rho = lines[i][0][0]
theta = lines[i][0][1]

''' calculamos los valores a y b, que sirven para calcular los puntos que definen
la ecuacion de nuestra recta '''
a = math.cos(theta)
b = math.sin(theta)

# gracias a x0 e y0 ya tenemos la ecuacion completa de nuestra recta

x0 = a * rho
y0 = b * rho

''' Calculamos dos puntos cualesquiera por los que pasa nuestra recta segun su
ecuacion '''

pt1 = (int(x0 + 1000 * (-b)), int(y0 + 1000 * (a)))

pt2 = (int(x0 - 1000 * (-b)), int(y0 - 1000 * (a)))

''' Usamos la funcion cv.line() para dibujar la recta que pasa por pt1 y pt2
sobre nuestra imagen a color en violeta y con grosor 3 '''
cv.line(img_rgb, pt1, pt2, (255, 0, 255), 3, cv.LINE_AA)

# Mostramos la imagen por pantalla

plt.imshow(img_rgb)
CELDA 5 (CÍRCULOS)
# Es muy importante cambiar esta ruta por la ubicacion de nuestra imagen descargada
logo_img_path = "C:/Users/Images/opencv-logo.png"

# Leemos la imagen en escala de grises

img = cv.imread(logo_img_path, 0)

# Suavizamos la imagen con un filtro "median" y la mostramos por pantalla

img = cv.medianBlur(img, 5)
plt.imshow(img, cmap='gray')
plt.show()

# Ejecutamos HoughCircles de Opencv sobre la imagen en escala de grises

circles = cv.HoughCircles(img, cv.HOUGH_GRADIENT, 1, 20,
param1=50, param2=30, minRadius=0, maxRadius=0)
# Redondeamos el resultado
circles = np.uint16(np.around(circles))

''' Convertimos la imagen de grises en color para poder dibujar los circulos
encontrados en verde brillante '''
cimg = cv.cvtColor(img, cv.COLOR_GRAY2BGR)

for i in circles[0, :]:

# Dibujamos en verde el circulo
cv.circle(cimg, (i[0], i[1]), i[2], (0, 255, 0), 6)

# Dibujamos el punto central del circulo en color violeta

cv.circle(cimg, (i[0], i[1]), 2, (255, 0, 255), 5)

# Mostramos por pantalla el resultado del dibujo de los circulos

plt.imshow(cimg)
plt.show()
Ejemplo detección de esquinas

import cv2 as cv
from matplotlib import pyplot as plt
import numpy as np

# Es importante cambiar la ruta de esta imagen por donde la hayamos descargado

img_path = "C:/Users/User/Images/blox.jpg"

# Leemos la imagen en color

img_color = cv.imread(img_path)

# Convertimos la imagen a escala de grises, y la mostramos por pantalla

img = cv.cvtColor(img_color, cv.COLOR_BGR2GRAY)
plt.imshow(img, cmap='gray')
plt.show()

# Lanzamos busqueda de esquinas para las mejores 25 al menos a 10 pixeles cada una
corners = cv.goodFeaturesToTrack(img, 25, 0.01, 10)
corners = np.int0(corners)

# Iteramos por cada una de las esquinas devueltas por el metodo

for i in corners:
# Obtenemos las coordenadas de la esquina
x, y = i.ravel()

# Dibujamos a color un circulo verde en las coordenadas de la esquina extraida

cv.circle(img_color, (x, y), 3, (0, 255, 0), -1)

# Mostramos la imagen por pantalla para ver las 25 mejores esquinas

plt.imshow(img_color)
plt.show()
ORB

import cv2 as cv
from matplotlib import pyplot as plt

# Importante cambiar esta ruta por la de nuestra imagen descargada

img_path= "C:/Users/User/Images/blox.jpg"

# Abrimos la imagen en escala de grises

img = cv.imread(img_path,0)

# Creamos un objeto de la clase ORB al que llamamos "orb"

orb = cv.ORB_create()

''' Lanzamos el metodo de deteccion de caracteristicas y guardamos el resultado en un

array llamado "features" '''
features = orb.detect(img)

''' Describimos nuestras features y guardamos la descripcion en una variable llamada

description '''
features, description = orb.compute(img, features)

''' Dibujamos las features sobre nuestra imagen, de color azul, y la mostramos por
pantalla '''
img2 = cv.drawKeypoints(img, features, None, color=(0,255,255))

plt.imshow(img2)

plt.show()

Feature matching
import cv2 as cv
import matplotlib.pyplot as plt

# Importante recordar cambiar las rutas por nuestras rutas locales

img1_path = "C:/Users/User/Images/box.png"
img2_path = "C:/Users/User/Images/box_in_scene.png"

# Leemos las imagenes en escala de grises

img1 = cv.imread(img1_path, 0)
img2 = cv.imread(img2_path, 0)

# Inicializamos un objeto de tipo ORB para extraer las features de ambas imagenes
orb = cv.ORB_create()

# Obtenemos las caracteristicas y sus descriptores para despues hacer matching

kp1, des1 = orb.detectAndCompute(img1, None)
kp2, des2 = orb.detectAndCompute(img2, None)
CELDA 2

''' Inicializamos un objeto de tipo BFMatcher, y usamos crossCheck para mejorar el

resultado de la operación '''
bf = cv.BFMatcher(cv.NORM_HAMMING, crossCheck=True)

# Ejecutarmos el algoritmo de match para ambos descriptores

matches = bf.match(des1, des2)

# Ordenamos todas las caracteristicas extraidas en funcion de la distancia entre

ellas (de mejor a peor)
matches = sorted(matches, key=lambda x: x.distance)

# Dibujamos los mejores 10 matches

img3 = cv.drawMatches(img1, kp1, img2, kp2, matches[:10], None)

''' Mostramos el resultado por pantalla aumentando el tamaño por defecto de plt para
poder ver todos los datos relevantes '''
plt.rcParams['figure.figsize'] = [12, 6]

plt.imshow(img3)
plt.show()
Reconocimiento de objetos con ORB
''' Convertimos las caracteristicas encontradas en puntos planos para poder estimar
su homografia '''
src_pts = np.float32([ kp1[m.queryIdx].pt for m in matches[:12] ]).reshape(-1,1,2)
dst_pts = np.float32([ kp2[m.trainIdx].pt for m in matches[:12] ]).reshape(-1,1,2)

# Buscamos la homografia entre los dos conjuntos de puntos mediante el metodo RANSAC
M, mask = cv.findHomography(src_pts, dst_pts, cv.RANSAC,5.0)

# Convertimos la mascara calibrada en 3d en una lista

matchesMask = mask.ravel().tolist()

# Obtenemos el tamaño de la imagen, para saber el tamaño del objeto que buscamos
h,w = img1.shape

# Convertimos tamaños en las coordenadas de la bbox que vamos a buscar en img2

pts = np.float32([ [0,0],[0,h-1],[w-1,h-1],[w-1,0] ]).reshape(-1,1,2)

''' Empleando los puntos que ha devuelto la homografia podemos convertirlos en la

perspectiva de la segunda imagen para segmentar nuestro libro gracias a
cv.perspectiveTransform '''
dst = cv.perspectiveTransform(pts,M)

''' Dibujamos las lineas que unen los puntos resultantes de las coordenadas del libro
una vez aplicada la perspectiva con la funcion polylines de OpenCV '''
img2 = cv.polylines(img2,[np.int32(dst)],True,255,3, cv.LINE_AA)

# Mostramos la imagen por pantalla

plt.imshow(img2, cmap = 'gray')
plt.show()
UNIDAD 3
Primer ejemplo Google Colab
import cv2 as cv
import numpy as np
from matplotlib import pyplot as plt
from skimage import io

# URL en la que se encuentra la imagen que queremos descargar

url = "https://iiif.lib.ncsu.edu/iiif/0052574/full/800,/0/default.jpg"

# Descargamos la imagen y la almacenamos en la variable img

img = io.imread(url)

# Mostramos la imagen por pantalla

plt.imshow(img)

CELDA 2
plt.hist(img.ravel(), bins=256, range=[0, 256])
plt.show()

CELDA 3
# Detección de bordes Canny
edges = cv.Canny(image=img, threshold1=100, threshold2=200)

# Mostramos el resultado por pantalla

plt.imshow(edges, cmap="gray")
plt.show()

Clasificación de objetos

# TensorFlow y tf.keras
import tensorflow as tf
from tensorflow import keras

# Librerias de soporte que siempre importamos

import numpy as np
import matplotlib.pyplot as plt
CELDA 2

# Descargamos el dataset de fashion MNIST

fashion_mnist = keras.datasets.fashion_mnist

# Creamos los conjuntos de entrenamiento y evaluacion con sus imagenes y sus

etiquetas
(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load
_data()

# Guardamos la correspondencia entre las neuronas de salida y los nombres de

cada una de las clases
class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

CELDA 3

plt.figure(figsize=(10,10))
for i in range(10):
plt.subplot(5,5,i+1)
plt.xticks([])
plt.yticks([])
plt.grid(False)
plt.imshow(train_images[i], cmap='gray')
plt.xlabel(class_names[train_labels[i]])
plt.show()
CELDA 4

'''
Inicializamos un objeto de tipo Sequential de keras, que nos permite
implementar de forma muy sencilla las distintas capas de una CNN.
'''
model = keras.Sequential()

# La 1a capa de nuestra CNN son 64 neuronas de convolucion con kernel 2x2

model.add(keras.layers.Conv2D(filters=64, kernel_size=2, padding='same',
activation='relu', input_shape=(28,28,1)))

# Despues, aplicaremos un Max Pooling de 2x2 a los feature maps de salida

model.add(keras.layers.MaxPooling2D(pool_size=2))

# Volvemos a pasar una capa convolucional. Esta vez 32 neuronas de 2x2

model.add(keras.layers.Conv2D(filters=32, kernel_size=2, padding='same',
activation='relu'))

# Aplicamos downsampling para reducir dimensiones de nuestros feature maps

model.add(keras.layers.MaxPooling2D(pool_size=2))

# Ahora, aplanamos los feature maps. Ya hemos extraido las caracteristicas

model.add(keras.layers.Flatten())

''' Para realizar la clasificacion primero pasamos por una capa

Fully Connected de 256 neuronas '''
model.add(keras.layers.Dense(256, activation='relu'))

# Por ultimo, añadimos una Fully Connected de 10 neuronas, una por cada clase
model.add(keras.layers.Dense(10, activation='softmax'))

'''
Compilamos el modelo con los parametros de calculo de error y optimizador
Usaremos adam, que es una implementacion de Stochastic Gradient Descent
'''

model.compile(loss='sparse_categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
CELDA 5

# Lanzamos el entrenamiento de nuestra red neuronal convolucional

model.fit(train_images,
train_labels,
batch_size=64,
epochs=10,
validation_data=(test_images, test_labels))

CELDA 6

# Evaluamos el resultado de nuestra CNN contra el test de evaluacion

test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)

print('\nAccuracy in test set:', test_acc)

CELDA 7

# Lista de imagenes que queremos comprobar

image_list = [1, 4, 12]

# Para cada imagen de la lista

for i in image_list:

# Extraemos la imagen del conjunto de test

img = test_images[i]

# Definimos el tamaño de nuestro plot de salida

plt.figure(figsize=(10,3))

# En la primera posicion del plot, pintamos la imagen

plt.subplot(1,2,1)
plt.imshow(img, cmap='gray')

# Convertimos la imagen a un tensor para que pueda ser procesada por Keras
img = (np.expand_dims(img,0))

# Pedimos al modelo CNN la prediccion de nuestra imagen

predictions_single = model.predict(img)

# En la segunda parte del plot pintamos las probabilidades de cada clase

plt.subplot(1,2,2)
plt.grid(False)
plt.xticks(range(10), class_names, rotation=45)
plt.yticks([])
plt.bar(range(10), predictions_single[0])
plt.show()
Ejemplo Detección de Objetos

import os
import pathlib

import matplotlib
import matplotlib.pyplot as plt

import scipy.misc
import numpy as np
from six import BytesIO
from PIL import Image, ImageDraw, ImageFont
from six.moves.urllib.request import urlopen

import tensorflow as tf
import tensorflow_hub as hub

CELDA 2

# url de nuestro modelo de model hub

model_url = 'https://tfhub.dev/tensorflow/faster_rcnn/resnet101_v1_640x640/1'

# cargaremos el modelo en tf hub para poder hacer inferencia posteriormente

print('loading model...')
hub_model = hub.load(model_url)
print('model loaded!')

CELDA 3

# Descargaremos una imagen sin derechos de wikipedia para usarla de ejemplo

image_path = 'https://upload.wikimedia.org/wikipedia/commons/6/60/
Naxos_Taverna.jpg'
response = urlopen(image_path)
image_data = response.read()
image_data = BytesIO(image_data)
image = Image.open(image_data)
(im_width, im_height) = image.size
image_np = np.array(image.getdata()).reshape(
(1, im_height, im_width, 3)).astype(np.uint8)

# Mostramos la imagen por pantalla

plt.figure(figsize=(12,16))
plt.imshow(image_np[0])
plt.show()
CELDA 4

# Ejecutamos el proceso de inferencia sobre el modelo preentrenado de tf

results = hub_model(image_np)

# Almacenamos los resultados de la inferencia para pintarlos por pantalla

result = {key:value.numpy() for key,value in results.items()}

CELDA 5

# Clonamos el respositorio de la librería de Tensorflow “models”

!git clone --depth 1 https://github.com/tensorflow/models

CELDA 6

%%bash
sudo apt install -y protobuf-compiler
cd models/research/
protoc object_detection/protos/*.proto --python_out=.
cp object_detection/packages/tf2/setup.py .
python -m pip install .

CELDA 7

# Importamos todas las utilidades que necesitamos para mostrar resultados

from object_detection.utils import label_map_util
from object_detection.utils import visualization_utils as viz_utils
from object_detection.utils import ops as utils_ops
CELDA 8

PATH_TO_LABELS = './models/research/object_detection/data/
mscoco_label_map.pbtxt'
category_index = label_map_util.create_category_index_from_labelmap(PATH_T
O_LABELS, use_display_name=True)
label_id_offset = 0
image_np_with_detections = image_np.copy()

viz_utils.visualize_boxes_and_labels_on_image_array(
image_np_with_detections[0],
result['detection_boxes'][0],
(result['detection_classes'][0] + label_id_offset).astype(int),
result['detection_scores'][0],
category_index,
use_normalized_coordinates=True,
max_boxes_to_draw=200,
min_score_thresh=.30,
agnostic_mode=False)

plt.figure(figsize=(15,20))
plt.imshow(image_np_with_detections[0])
plt.show()

Ejemplo GAN

import torch
import urllib
from PIL import Image
from torchvision import transforms
import matplotlib.pyplot as plt

CELDA 2

# Cargamos el modelo de DeepLab v3 desde el modelhub de pytorch

model = torch.hub.load('pytorch/vision:v0.10.0', 'deeplabv3_resnet50', pretra
ined=True)
# Levantamos el modelo para evaluar imagenes, mostrando estructura del modelo
model.eval()
CELDA 3

# Descargamos una imagen para usarla como ejemplo

url, filename = ("https://github.com/pytorch/hub/raw/master/images/
deeplab1.png", "deeplab1.png")
urllib.request.urlretrieve(url, filename)# sample execution (requires torchvi
sion)

# Abrimos la imagen y la convertimos a RGB

input_image = Image.open(filename)
input_image = input_image.convert("RGB")

# Modificamos las dimensiones de la imagen para la entrada esperada

preprocess = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225
]),
])

input_tensor = preprocess(input_image)
input_batch = input_tensor.unsqueeze(0)

''' Si hemos activado la aceleracion por GPU, movemos el modelo y la imagen de

ejemplo a la GPU '''
if torch.cuda.is_available():
input_batch = input_batch.to('cuda')
model.to('cuda')

CELDA 4

# Ejecutamos la inferencia sobre la imagen

with torch.no_grad():
output = model(input_batch)['out'][0]

# Guardamos los valores de las predicciones con mayor probabilidad

output_predictions = output.argmax(0)
CELDA 5

''' Creamos una paleta de color para que cada clase pueda ser coloreada distit
a en el output '''
palette = torch.tensor([2 ** 25 - 1, 2 ** 15 - 1, 2 ** 21 - 1])
colors = torch.as_tensor([i for i in range(21)])[:, None] * palette
colors = (colors % 255).numpy().astype("uint8")

# Generamos una imagen de salida con las predicciones en ella

r = Image.fromarray(output_predictions.byte().cpu().numpy()).resize(input_ima
ge.size)
r.putpalette(colors)
plt.imshow(input_image)
plt.show()
plt.imshow(r)
plt.show()