Post Top Ad

Your Ad Spot

jueves, 20 de agosto de 2020

Cómo entrenar un algoritmo de aprendizaje automático con TensorFlow

Cada día, nuestras computadoras se acercan un poco más a funcionar como nuestras mentes. El cerebro humano es un órgano de un potencial casi inimaginable. Piense en lo que podríamos hacer si pudiéramos esencialmente programar un cerebro humano y hacer que cumpliera nuestras órdenes.
El aprendizaje automático ha estado de moda recientemente, a medida que nos acercamos gradualmente a tener una IA real y funcional. El aprendizaje automático juega un papel vital en el análisis predictivo, las recomendaciones personalizadas y muchas otras disciplinas a la vanguardia del mundo digital actual. Sin embargo, el aprendizaje automático todavía está bastante ligado a los datos que le proporcionamos.
El aprendizaje profundo es una rama del aprendizaje automático, que se centra en recrear redes neuronales en código. Tensorflow es una de las bibliotecas más populares para implementar el aprendizaje profundo, especialmente para aquellos que recién comienzan con la disciplina.
Hemos compilado una breve introducción a Tensorflow para mostrarle cómo comenzar con la biblioteca y permitirle experimentar con el aprendizaje profundo por sí mismo. Le mostraremos cómo empezar a trabajar con Tensorflow y le daremos algunos ejemplos rudimentarios de cómo trabajar con datos con la biblioteca. Le mostraremos cómo crear su propio algoritmo de aprendizaje automático basado en un modelo de entrenamiento existente.

Una introducción a TensorFlow

Tensorflow obtiene sus nombres de tensores , que son matrices de datos multidimensionales. Esto también ayuda a explicar qué separa el aprendizaje profundo del aprendizaje automático en un sentido más general.
Para comprender correctamente este concepto se requiere un poco de matemáticas de alto nivel. Tenga paciencia con nosotros por un momento, ya que los conceptos serán mucho más claros con solo un poco de explicación.

Vectores

Los vectores son una forma especial de matriz , o matriz rectangular de números, que se transforman mediante ciertas reglas bajo coordenadas cambiantes. A menudo se ven en relaciones, como productos cruzados, productos puntuales o mapas lineales. La definición más simple de un vector es cualquier cosa que tenga una dirección y una magnitud.
Los tensores se ocupan de un tipo especial de vector conocido como vectores planos . Los vectores planos tratan específicamente con magnitudes escalares. Un escalar puede ser "6 m / s" o "5 m / seg". Por otro lado, un vector podría ser "6 metros al norte" o "5 m / seg al este". Como puede notar, los vectores implican una dirección.
La forma más simple de un vector plano es una coordenada x, y. Con la misma facilidad, puede tener vectores que se ocupan de tres dimensiones, a través de las coordenadas x, y, z. El objetivo de los vectores es ofrecer una abstracción en la que puede trabajar con estas variables sin tener que mapear cada una en un gráfico.
En pocas palabras, usando nuestra definición anterior, un vector es una magnitud escalar dada una definición. Los tensores, por otro lado, son magnitudes escalares con múltiples direcciones.
Los escalares se pueden representar con un solo número. Los vectores se pueden expresar con una secuencia de tres números. Los tensores se pueden representar con una matriz de números 3R. La variable 'R' representa el rango del tensor. Un tensor de segundo rango estaría representado por nueve números, por ejemplo.
Todo esto suena bastante técnico y abstracto. Carguemos TensorFlow para ver cómo se aplican estos principios en acción.

Instalación de TensorFlow

TensorFlow admite API para Python, C ++, Haskell, Java, Go y Rust. También hay un paquete de terceros para R. Para este tutorial, usaremos Python y Google Colab para ejecutar nuestro código. También puede ver y ejecutar el Notebook completo usted mismo o incluso descargar el archivo Python si desea experimentar con el código en sus propios proyectos.

Introducción a TensorFlow

Ahora, probemos algunas funciones básicas para probar algunos de estos conceptos. Comience abriendo Google Colab y creando un nuevo cuaderno. Hemos llamado al nuestro tensorflow-tutorial.
Vamos a crear dos matrices para demostrar cómo se trabaja con tensores. Ingrese lo siguiente en su cuaderno de Google Colab:
import tensorflow as tf

###initialize two constants###
x1 = tf.constant([1,2,3,4])
x2 = tf.constant([5,6,7,8])

###mutliply##
result = tf.multiply(x1, x2)

###Print the result
print(result) 
Deberías ver tf.Tensor([ 5 12 21 32], shape=(4,), dtype=int32)como resultado.
Ahora que hemos visto una instancia de TensorFlow funcionando en abstracto, dirijamos nuestra atención a algunas aplicaciones del mundo real. Comencemos por echar un vistazo a los datos con los que trabajaremos.

Comprender los datos en TensorFlow

Le mostraremos cómo cargar datos en TensorFlow usando tf.dataUsaremos un directorio de imágenes que están disponibles sin licencia de Google. Cada subdirectorio contiene una clase de imágenes.
Comenzaremos cargando las bibliotecas que necesitaremos y definiendo algunas de las variables. Ingrese lo siguiente en su cuaderno de Google Colab después de borrar el código anterior, o simplemente inicie un nuevo cuaderno para este proyecto.
import tensorflow as tf
AUTOTUNE = tf.data.experimental.AUTOTUNE
import IPython.display as display
from PIL import Image
import numpy as np
import matplotlib.pyplot as plt
import os
tf.__version__
A continuación, importará los datos que utilizará pathlib:
import pathlib
data_dir = tf.keras.utils.get_file(origin='https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz',
                                         fname='flower_photos', untar=True)
data_dir = pathlib.Path(data_dir)
Pulsa Ejecutar para iniciar una descarga. Ahora, inserte una nueva celda de código debajo de esta. Para asegurarse de que todo se descargó como debería, inserte lo siguiente en la celda y presione ejecutar:
image_count = len(list(data_dir.glob('*/*.jpg')))
image_count
El fragmento de arriba debería devolverse 3670También puede usar este siguiente comando para ver los subdirectorios, que son los tipos de flores disponibles:
CLASS_NAMES = np.array([item.name for item in data_dir.glob('*') if item.name != "LICENSE.txt"])
CLASS_NAMES
Ese comando responderá con la siguiente variedad de tipos de flores:
array(['roses', 'tulips', 'daisy', 'sunflowers', 'dandelion'],
      dtype='<U10')
Saber eso es útil, pero sería bueno ver algunas imágenes. Para ver algunas de estas imágenes, puede usar el displaycomando. Este comando devolverá algunas rosas:
roses = list(data_dir.glob('roses/*'))
 
for image_path in roses[:3]:
    display.display(Image.open(str(image_path)))

Usando Keras

Keras es una de las razones por las que TensorFlow es tan popular para proyectos de aprendizaje automático. Keras es la API de TensorFlow, que está diseñada para el consumo humano en lugar de una máquina. Keras ha sido tan popular que ahora está completamente integrado en TensorFlow sin tener que cargar una biblioteca adicional.
La tf.keras.preprocessing.función es una forma sencilla y fácil de cargar archivos en su código. Inserte lo siguiente en su celda de código para inicializar Keras:
# The 1./255 is to convert from uint8 to float32 in range [0,1].
image_generator = tf.keras.preprocessing.image.ImageDataGenerator(rescale=1./255)
Ahora, defina algunos parámetros para el cargador de datos.
BATCH_SIZE = 32
IMG_HEIGHT = 224
IMG_WIDTH = 224
STEPS_PER_EPOCH = np.ceil(image_count/BATCH_SIZE)
Y
train_data_gen = image_generator.flow_from_directory(directory=str(data_dir),
                                                     batch_size=BATCH_SIZE,
                                                     shuffle=True,
                                                     target_size=(IMG_HEIGHT, IMG_WIDTH),
                                                     classes = list(CLASS_NAMES))
 
def show_batch(image_batch, label_batch):
  plt.figure(figsize=(10,10))
  for n in range(25):
      ax = plt.subplot(5,5,n+1)
      plt.imshow(image_batch[n])
      plt.title(CLASS_NAMES[label_batch[n]==1][0].title())
      plt.axis('off')
 
image_batch, label_batch = next(train_data_gen)
show_batch(image_batch, label_batch)

Cargar usando TF.Data

Keras es maravilloso, pero puede ser lento y difícil de manejar. Aquí hay otro método para cargar los datos en TensorFlow, usando la TF.datafunción:
list_ds = tf.data.Dataset.list_files(str(data_dir/'*/*'))
for f in list_ds.take(5):
  print(f.numpy())
El print(f.numpy())comando prueba para asegurarse de que las cosas se carguen como deberían. Ejecutar el código anterior devolverá una lista de imágenes y sus directorios:
b'/root/.keras/datasets/flower_photos/daisy/14350958832_29bdd3a254.jpg'
b'/root/.keras/datasets/flower_photos/dandelion/8980273068_cf7e8b880a_n.jpg'
b'/root/.keras/datasets/flower_photos/sunflowers/4933824130_b99839a80d.jpg'
b'/root/.keras/datasets/flower_photos/dandelion/284497233_c19801752c.jpg'
b'/root/.keras/datasets/flower_photos/daisy/3861452393_14d2f95157_m.jpg'
Ahora, aquí hay una función corta para dividir un archivo en un par (img, etiqueta).
def get_label(file_path):
  # convert the path to a list of path components
  parts = tf.strings.split(file_path, os.path.sep)
  # The second to last is the class-directory
  return parts[-2] == CLASS_NAMES
def decode_img(img):
  # convert the compressed string to a 3D uint8 tensor
  img = tf.image.decode_jpeg(img, channels=3)
  # Use `convert_image_dtype` to convert to floats in the [0,1] range.
  img = tf.image.convert_image_dtype(img, tf.float32)
  # resize the image to the desired size.
  return tf.image.resize(img, [IMG_WIDTH, IMG_HEIGHT])
def process_path(file_path):
  label = get_label(file_path)
  # load the raw data from the file as a string
  img = tf.io.read_file(file_path)
  img = decode_img(img)
  return img, label
Ahora puede crear un conjunto de datos de los pares (imagen, etiqueta):
# Set `num_parallel_calls` so multiple images are loaded/processed in parallel.
labeled_ds = list_ds.map(process_path, num_parallel_calls=AUTOTUNE)
for image, label in labeled_ds.take(1):
  print("Image shape: ", image.numpy().shape)
  print("Label: ", label.numpy())

Capacitación para el aprendizaje automático

Ahora está listo para comenzar a entrenar su proyecto de aprendizaje automático para el aprendizaje profundo. Para que su conjunto de datos sea útil para el aprendizaje automático, debe barajarse, clasificarse en lotes y esos lotes deben estar disponibles lo antes posible.
def prepare_for_training(ds, cache=True, shuffle_buffer_size=1000):
  # This is a small dataset, only load it once, and keep it in memory.
  # use `.cache(filename)` to cache preprocessing work for datasets that don't
  # fit in memory.
  if cache:
    if isinstance(cache, str):
      ds = ds.cache(cache)
    else:
      ds = ds.cache()
 
  ds = ds.shuffle(buffer_size=shuffle_buffer_size)
 
  # Repeat forever
  ds = ds.repeat()
 
  ds = ds.batch(BATCH_SIZE)
 
  # `prefetch` lets the dataset fetch batches in the background while the model
  # is training.
  ds = ds.prefetch(buffer_size=AUTOTUNE)
 
  return ds
Luego ingrese:
train_ds = prepare_for_training(labeled_ds)
 
image_batch, label_batch = next(iter(train_ds))
show_batch(image_batch.numpy(), label_batch.numpy())
Esto debería devolver una tabla con imágenes de sus datos, emparejadas con su etiqueta.
Esta base de datos de uso gratuito es un ejemplo de base de datos perfecto para el aprendizaje automático; mostrando miles de variaciones por clasificador de imágenes.

Reentrenamiento de un clasificador de imágenes

Ahora que tenemos nuestro conjunto de datos cargado y clasificado, es hora de preparar estos datos para el aprendizaje profundo. Logramos esto al reentrenar un modelo de aprendizaje automático de clasificador de imágenes existente .
Para empezar, vamos a instalar tensorflow-gpu, que está equipado de forma única para manejar el aprendizaje automático. Comenzaremos instalando algunas bibliotecas adicionales. Ingrese lo siguiente en una nueva celda en Google Colab:
import itertools
import os
 
import matplotlib.pylab as plt
import numpy as np
 
import tensorflow as tf
import tensorflow_hub as hub
 
print("TF version:", tf.__version__)
print("Hub version:", hub.__version__)
print("GPU is", "available" if tf.config.list_physical_devices('GPU') else "NOT AVAILABLE")
Cuando ejecute esto, verá las versiones de TF y hub que está usando. También verá si tiene GPU instalada en su sistema o no. Si no es así, no se preocupe, ya que el siguiente código seguirá funcionando, simplemente se ejecutará un poco más lento.
A continuación, cargaremos el módulo SavedModel, que volveremos a capacitar para nuestras propias necesidades de aprendizaje profundo.
module_selection = ("mobilenet_v2_100_224", 224) #@param ["(\"mobilenet_v2_100_224\", 224)", "(\"inception_v3\", 299)"] {type:"raw", allow-input: true}
handle_base, pixels = module_selection
MODULE_HANDLE ="https://tfhub.dev/google/imagenet/{}/feature_vector/4".format(handle_base)
IMAGE_SIZE = (pixels, pixels)
print("Using {} with input size {}".format(MODULE_HANDLE, IMAGE_SIZE))
 
BATCH_SIZE = 32 #@param {type:"integer"}
Ahora, vamos a asociar nuestra biblioteca de aprendizaje automático con la variable data_dir:
data_dir = tf.keras.utils.get_file(
    'flower_photos',
    'https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz',
    untar=True)
Luego, confirmaremos que todo está cargado como debería ser:
data_dir = tf.keras.utils.get_file(
    'flower_photos',
    'https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz',
    untar=True)
 
datagen_kwargs = dict(rescale=1./255, validation_split=.20)
dataflow_kwargs = dict(target_size=IMAGE_SIZE, batch_size=BATCH_SIZE,
                   interpolation="bilinear")
 
valid_datagen = tf.keras.preprocessing.image.ImageDataGenerator(
    **datagen_kwargs)
valid_generator = valid_datagen.flow_from_directory(
    data_dir, subset="validation", shuffle=False, **dataflow_kwargs)
 
do_data_augmentation = False #@param {type:"boolean"}
if do_data_augmentation:
  train_datagen = tf.keras.preprocessing.image.ImageDataGenerator(
      rotation_range=40,
      horizontal_flip=True,
      width_shift_range=0.2, height_shift_range=0.2,
      shear_range=0.2, zoom_range=0.2,
      **datagen_kwargs)
else:
  train_datagen = valid_datagen
train_generator = train_datagen.flow_from_directory(
    data_dir, subset="training", shuffle=True, **dataflow_kwargs)
Ahora vas a agregar una capa de clasificador lineal encima de feature_exracter_layer:
do_fine_tuning = False #@param {type:"boolean"}
Luego, definirás el modelo de aprendizaje automático:
print("Building model with", MODULE_HANDLE)
model = tf.keras.Sequential([
    # Explicitly define the input shape so the model can be properly
    # loaded by the TFLiteConverter
    tf.keras.layers.InputLayer(input_shape=IMAGE_SIZE + (3,)),
    hub.KerasLayer(MODULE_HANDLE, trainable=do_fine_tuning),
    tf.keras.layers.Dropout(rate=0.2),
    tf.keras.layers.Dense(train_generator.num_classes,
                          kernel_regularizer=tf.keras.regularizers.l2(0.0001))
])
model.build((None,)+IMAGE_SIZE+(3,))
model.summary()
Finalmente, está listo para volver a capacitar al modelo.
model.compile(
  optimizer=tf.keras.optimizers.SGD(lr=0.005, momentum=0.9), 
  loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True, label_smoothing=0.1),
  metrics=['accuracy'])
steps_per_epoch = train_generator.samples // train_generator.batch_size
validation_steps = valid_generator.samples // valid_generator.batch_size
hist = model.fit(
    train_generator,
    epochs=5, steps_per_epoch=steps_per_epoch,
    validation_data=valid_generator,
    validation_steps=validation_steps).history
saved_model_path = "/tmp/saved_flowers_model"
tf.saved_model.save(model, saved_model_path)
¡Ahora tiene un modelo de aprendizaje profundo capacitado y funcional para su proyecto de aprendizaje automático! Recuerde, train_generator.samplespuede tardar un poco si no tiene GPU instaladas, así que tenga paciencia. Podría tardar hasta 30 minutos aproximadamente.

En resumen

Para resumir, en este tutorial, entrenamos con éxito un algoritmo de aprendizaje automático para identificar diferentes tipos de flores. En los pasos anteriores, importamos las bibliotecas y API de TensorFlow que necesitaríamos para comenzar a ejecutar. Luego cargamos una base de datos abierta de imágenes como nuestro conjunto de datos. Nuestro conjunto de datos incluía 3670 imágenes de flores, todas etiquetadas como diente de león, rosas, margaritas, tulipanes o girasoles.
Estructuramos los datos en lotes de manera adecuada, creando pares de imágenes y etiquetas para usar con TensorFlow. Luego volvimos a entrenar un modelo de aprendizaje automático utilizando un clasificador de imágenes existente.
El resultado final es un modelo de aprendizaje automático que ahora puede etiquetar imágenes como tipos de flores con un alto grado de precisión. También puede mejorar con el tiempo si se alimenta con más datos. Con un enfoque similar, los desarrolladores también podrían crear aplicaciones impulsadas por ML para muchos otros objetos.

TensforFlow: Pensamientos finales

El uso de un modelo de aprendizaje profundo de TensorFlow es su propio tema, y ​​este tutorial ya es bastante extenso. Puede leer más sobre esto en este tutorial de TensorFlow para aprender cómo puede usar un modelo de aprendizaje profundo reentrenado en sus propios proyectos.
La automatización, el aprendizaje automático y las decisiones basadas en datos no van a ninguna parte. En todo caso, seguiremos produciendo más datos con cada año que pase. Al mismo tiempo, las demandas comerciales seguirán volviéndose más extremas.
Es probable que las empresas que quieran practicar disciplinas digitales como el análisis predictivo o el marketing personalizado deban incorporar el aprendizaje automático y el aprendizaje profundo en algún momento. Saber cómo programar modelos de aprendizaje profundo usted mismo le brinda un control total sobre sus aplicaciones y datos, lo que hace que el aprendizaje automático sea aún más poderoso.

No hay comentarios.:

Publicar un comentario

Dejanos tu comentario para seguir mejorando!

outbrain

Páginas