DEV Community: Pedro Chaparro

Buscador de vídeos con OpenSearch y React | Parte 3 | Limpieza y almacenamiento de los datos

Pedro Chaparro — Fri, 18 Nov 2022 14:08:31 +0000

⚠️ Nota: La idea original de este proyecto surgió gracias al canal Soumil Shah, por lo que doy crédito y recomiendo ver su serie de vídeos sobre Elastic Search Aquí.

El repositorio con el resultado final puede ser consultado en Github.

Índice

Post 1 - Introducción: Aquí
Post 2 - Recolección de los datos: Aquí
Post 3 - Limpieza y almacenamiento de los datos: Aquí
Post 4 - Desarrollo de la API (🚧 Trabajando en ello...)
Post 5 - Desarrollo del cliente Web (🚧 Trabajando en ello...)

Requisitos

Python (3.10.6 Opcional) y conocimientos básicos de Python.
Jupyter Notebook
Docker / Conocimientos sobre Docker y Docker Compose.

"Instalación" de Open Search con Docker

Luego de realizar una limpieza sencilla de los datos, estos serán almacenados en Open Search, por lo que comenzaremos utilizando Docker para inicializar el servicio de Open Search.

Para esto, dentro de la carpeta backend/ crearemos el archivo docker-compose.yml con el siguiente contenido (Leer los comentarios del código) (Más información):

version: "3"

services:
  # Este es el servicio principal de Open Search, que nos
  # permitirá almacenar datos y realizar búsquedas. 
  se-opensearch:
    # Imagen de docker oficial de open search
    image: opensearchproject/opensearch:1.3.6
    container_name: se-opensearch 
    # Nombre del host dentro de la red de docker
    hostname: se-opensearch
    restart: on-failure
    ports: 
      - "9200:9200"
      # Performance analyzer, no lo usaremos, pero 
      # en la documentacion oficial lo utilizan
      - "9600:9600" 
    expose:
      - "9200"
      - "9600"
    environment: 
      - discovery.type=single-node
      # Deshabilitamos el plugin de seguridad para poder
      # conectarnos sin certificados SSL (no recomendado
      # para producción)
      - DISABLE_SECURITY_PLUGIN=true 
    volumes: 
      # Creamos un volúmen para que los datos no se pierdan
      # al momento de detener el contenedor de docker. 
      - opensearch-data-1:/usr/share/opensearch/data
    networks: 
      # Red interna de docker.
      - se-opensearch-net

  # Este servicio es opcional, solamente añade un dashboard
  # web para poder visualizar nuestros datos. 
  se-opensearch-dashboards:
    image: opensearchproject/opensearch-dashboards:1.3.6
    container_name: se-opensearch-dashboards
    hostname: se-opensearch-dashboards
    depends_on:
      - se-opensearch
    restart: always
    ports: 
      - "5601:5601"
    expose: 
      - "5601"
    environment: 
      - OPENSEARCH_HOSTS="http://se-opensearch:9200"
      - DISABLE_SECURITY_DASHBOARDS_PLUGIN=true
    networks: 
      - se-opensearch-net

# Creamos el volúmen 
volumes:
  opensearch-data-1:

# Creamos la red
networks:
  se-opensearch-net:

Una vez creado y guardado el archivo docker-compose.yml, dentro de la carpeta database/ ejecutamos el comando docker-compose up para iniciar el / los servicios:

docker-compose up

Limpieza de los datos

Para comenzar con este apartado, dentro de la carpeta data/cleansing/ crearemos un archivo de Jupyter Notebook, pero antes, de manera opcional, crearemos un entorno virtual de Python (Más información):

Dentro de la carpeta cleansing/:

virtualenv -p python3 environment

Para activar el entorno virtual desde Linux:

source environment/bin/activate

Para activar el entorno virtual desde Windows:

./environment/Scripts/activate

Independientemente de si hemos creado o no el entorno virtual, ahora realizaremos la instalación de Jupyter Notebook, para esto, ejecutamos en la consola:

pip install notebook

Luego de instalarlo, lo ejecutamos con:

jupyter notebook

Dentro de la interfaz web de Jupyter Notebook, creamos un nuevo "cuaderno":

Dentro del nuevo cuaderno, instalaremos los paquetes necesarios:

!pip install pandas
# Paquete para conectarnos a open search
!pip install opensearch-py
# "Paquete" para convertir los textos a vectores
!pip install sentence-transformers

import pandas as pd
import json
import re # Expresiones regulares

# Estos dos paquetes los usaremos para generar un numero 
# aleatorio mas adelante
import time 
import math

# Coneccion a Open Search
from opensearchpy import OpenSearch
# Helpers para insertar todos los datos de manera rápida
from opensearchpy import helpers 

from sentence_transformers import SentenceTransformer
# Descargamos el modelo para transformar los textos 
# (Esto puede demorar un poco)
transformer_model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')

Luego de instalar los paquetes, "leemos" el archivo data.json generado con el web scraping y lo convertimos a un DataFrame de pandas:

# Leer el archivo
file = open('../scraping/data.json')
data = json.load(file)
# Convertir a un DataFrame de pandas
df = pd.DataFrame(data)
# Mostar el DataFrame
df

Si todo fue correcto, deberíamos ver una tabla como la siguiente:

El primer paso que realizaremos para limpiar los datos es eliminar las entradas duplicadas, para esto, ejecutamos el siguiente código:

print('Length before dropping duplicates: {}'.format(df.shape))
# Eliminamos entradas duplicadas a partir de la url ya que
# esta deber ser única. 
df.drop_duplicates(subset=['url'], keep='first', inplace=True, ignore_index=False)
print('Length after dropping duplicates: {}'.format(df.shape))

Luego de eliminar los datos duplicados, podemos eliminar los caracteres indeseados, que en este caso serían:

Enlaces en las descripciones de los videos
Saltos de línea.
Caracteres no alfanuméricos (Incluídos los emojis)
Espacios en blanco redundantes.

Lo anterior lo haremos mediante expresiones regulares ejecutando el siguiente código:

# Realizamos una copia del dataframe para no afectar el 
# original en caso de que algo salga mal
df_bk = df.copy()

# Iteramos cada fila del DataFrame
for index in df_bk.index:
    title = df_bk['title'][index]
    description = df_bk['description'][index]
    tags = df_bk['tags'][index]
    new_tags = []

    # Remove urls
    title = re.sub(r'(http|https|www)\S+', '', title)
    description = re.sub(r'(http|https|www)\S+', '', description)

    # Remove \n texts
    title = title.replace('\n', ' ')
    description = description.replace('\n', ' ')

    # Remove non-alphanumeric chars
    # title = re.sub(r'[^a-zA-Z0-9\']', ' ', title)
    description = re.sub(r'[^a-zA-Z0-9]', ' ', description)

    # Iteramos cada tag ya que los tags son un array de strings
    for tag in tags:
        new_tag = re.sub(r'[^a-zA-Z0-9]', '', tag)
        new_tag = re.sub(' +', ' ', new_tag) 
        new_tags.append(new_tag.)

    # Remove redundant spaces
    title = re.sub(' +', ' ', title)
    description = re.sub(' +', ' ', description)

    # Set new value
    df_bk['title'][index] = title
    df_bk['description'][index] = description
    df_bk['tags'][index] = tags

# Mostramos el DataFrame resultante al final
df_bk

Si el paso anterior se ejecutó correctamente, deberíamos ver una tabla similar a la que se mostró unos cuantos pasos atrás.

Almacenamiento en Open Search

Teniendo los datos, el paso restante es almacenarlos en Open Search, para lo cual, primero generamos una conexión:

# Connection variables
host = 'localhost'
port = '9200'
# Usuario y contraseñas por defecto
auth = ('admin', 'admin')

# Connect
client = OpenSearch(
    timeout = 300,
    hosts = [{'host': host, 'port': port}],
    http_compress = True, 
    http_auth = auth,
    use_ssl = False,
    verify_cers = False,
)

client.ping()

Si ejecutamos la celda anterios, debería mostrarse un True, caso contrario, comprobar que el docker-compose esté siendo ejecutado o revisar la documentación oficial:

Antes de almacenar los datos en Open Search, crearemos una nueva columna para almacenar el vector que representa cada uno de los vídeos (Más información):

# Creamos una columna vacía
df_bk = df_bk.assign(vector="")

Ahora, insertaremos en la nueva columna el vector del vídeo correspondiente (Más información):

# Iteramos cada fila / vídeo
for index in df_bk.index:
    title = df_bk['title'][index]
    description = df_bk['description'][index]
    tags = df_bk['tags'][index]

    # Creamos un solo string que contenga los textos importantes del vídeo
    bundle = title + ' ' + description

    for tag in tags:
        bundle += ' ' + tag

    # Transformarmos el string único a un vector con el 
    # modelo descargado previamente
    vector = transformer_model.encode(bundle)
    # Asignamos el vector a la columna vacía
    df_bk['vector'][index] = vector

# Mostramos el DataFrame final
df_bk

Si todo se ejecutó correctamente, deberíamos ver una tabla como la siguiente:

Teniendo todos los datos del vídeo, podemos crear el índice de Open Search, el cual puede ser visto como el equivalente a una tabla en bases de datos relacionales, aunque no son exactamente lo mismo:

index_name = 'videos'

index_body = {
    'settings': {
        # Es necesario configurar esto para utilizar el plugin KNN
        # EN la mayoría de campos se dejaron los valores por defecto
        'index': {
            'number_of_shards': 20, 
            'number_of_replicas': 1,
            'knn': {
                'algo_param': {
                    # Default 512: https://opensearch.org/docs/latest/search-plugins/knn/knn-index#method-definitions
                    # Higher values lead to more accurate but slower searches.
                    'ef_search': 256, 
                    # Using during graph creation
                    'ef_construction': 256, 
                    # Bidirectional links for each element
                    'm': 4 
                }
            }
        },
        'knn': 'true'
    },
    # A continuación se definen las "columnas" del índice, las
    # cuales son los campos de nuestros videos
    'mappings': {
        'properties': {
            'url': {
                'type': 'text'
            },
            'thumbnail': {
                'type': 'text'
            },
            'title': {
                'type': 'text'
            }, 
            'description': {
                'type': 'text'
            },
            'tags': {
                # Text type can be used as array
                'type': 'text'
            }, 
            'vector': {
                'type': 'knn_vector', 
                'dimension': 384
            }
        }
    }
}

# Si el índice ya existe, lo eliminamos (Esto es solo en caso
# de ejecutar el notebook nuevamente)
if(client.indices.exists(index=index_name)):
    client.indices.delete(index=index_name)

# Creamos el índice
reply = client.indices.create(index_name, index_body)
print(reply)

Lo anterior debería mostrar una respuesta como la siguiente:

{'acknowledged': True, 'shards_acknowledged': True, 'index': 'videos'}

Finalmente, podemos insertar nuestros datos; para esto, podríamos iterar cada una de las filas e insertarlas individualmente, pero utilizaremos el método bulk de Open Search que nos permite insertar grandes cantidades de datos de un manera rápida:

# Crearemos un array ya que el método bulk recibe un elemento
# iterable
data = []

# Iteramos cada fila del DataFrame
for index in df_bk.index:
    # Tomamos todos los datos
    url = df_bk['url'][index]
    thumbnail = df_bk['thumbnail'][index]
    title = df_bk['title'][index]
    description = df_bk['description'][index]
    tags = df_bk['tags'][index]
    vector = df_bk['vector'][index]

    # Formamos un diccionario con los datos y lo insertamos al array
    # El campo _index es necesario para indicarle a Open Search
    # el índice al que debe agregar los datos
    data.append({'_index': index_name,
                 'url': url, 
                 'thumbnail': thumbnail, 
                 'title': title, 
                 'description': description, 
                 'tags': tags, 
                 'vector': vector})

# Insertamos los datos
reply = helpers.bulk(client, data, max_retries=5)

Para comprobar que los datos se insertaron correctamente, podemos simular búsquedas dentro del Notebook (Ver ídea original):

# Recibir el input por teclado
query = input('Enter your query: ')
# Convertir el input a un vector (Para poder usar el plugin KNN en Open Search).
query_vector = transformer_model.encode(query)

open_search_query = {
    # Tomamos 24 resultados
    'size': 24, 
    # Campos que nos interesan de la respuesta
    '_source': ['url', 'thumbnail', 'title', 'tags'],
    # Filtro
    "query": {
        "bool": {
            'must': [
                # Usamos el plugin knn
                {'knn': {
                    "vector": {
                        # Le pasamos nuestro vector
                        "vector": query_vector,
                        # Tomamos los 24 "vecinos más cercanos"
                        "k": 24
                    }
                }}
            ]
        }
    }
}

response = client.search(
    # Buscamos en nuestro índice
    index = index_name, 
    # Limitamos a 24 resultados
    size = 24, 
    # Cuerpo de la búsqueda
    body = open_search_query,
    request_timeout = 64
)

# Simplificamos el resultado ya que por defecto tiene muchos
# otros campos
videos = [x['_source'] for x in response['hits']['hits']]

# Mostramos los resultados obtenidos
videos

A continuación algunos ejemplos de búsquedas:

Final

Con esto se concluye esta tercera parte en la que hicimos una limpieza sencilla de nuestros datos y los almacenamos en Open Search, te invito a continuar con la siguiente en la que desarrollaremos una API de Python para permitir a nuestros usuaruios realizar búsquedas.

Referencias

Para consultar las referencias dirigirse a cada uno de los enlaces que aparencen dentro o al final de los diferentes párrafos.

Buscador de vídeos con OpenSearch y React | Parte 2 | Recolección de datos

Pedro Chaparro — Fri, 18 Nov 2022 14:05:09 +0000

⚠️ Nota: La idea original de este proyecto surgió gracias al canal Soumil Shah, por lo que doy crédito y recomiendo ver su serie de vídeos sobre Elastic Search Aquí.

El repositorio con el resultado final puede ser consultado en Github.

Índice

Post 1 - Introducción: Aquí
Post 2 - Recolección de los datos: Aquí
Post 3 - Limpieza y almacenamiento de los datos: Aquí
Post 4 - Desarrollo de la API (🚧 Trabajando en ello...)
Post 5 - Desarrollo del cliente Web (🚧 Trabajando en ello...)

Requisitos:

Go (1.19.2 Opcional) y conocimientos básicos de Go.

Creación de las carpetas y archivos

Para el desarrollo de las diferentes partes del proyecto, crearemos 3 carpetas principales, frontend, backend y data:

.
├── frontned
├── backend
└── data

Ahora, dentro de la carpeta de data, crearemos la carpeta scraping y cleansing, para la obtención y limpieza de los datos respectivamente:

data/
├── scraping
├── cleansing

Por ahora solo crearemos un nuevo módulo de Go para obtener los datos, esto dentro de la carpeta scraping/:

cd data/scraping
go mod init github.com/username/reponame

Si el anterior paso fue ejecutado correctamente, debería haber un archivo go.mod dentro de la carpeta scraping/:

data/
├── scraping
│   ├── go.mod
├── cleansing

Obtención de los datos

En primer lugar, debemos descargar el paquete youtubescraper, para ello, estando dentro de la carpeta scraping/ ejecutamos:

go get github.com/PChaparro/go-youtube-scraper

Si no se mostró ningún error en la consola, dentro de la misma carpeta, creamos el archivo main.go:

touch main.go

Dentro del nuevo archivo creado, podemos copiar el siguiente código para comprobar que la instalación haya sido correcta y el paquete esté funcionando:

package main

import (
    "fmt"

    // Importamos el paquete para hacer el scraping
    youtubescraper "github.com/PChaparro/go-youtube-scraper"
)

func main() {
    // Usamos el metodo GetVideosData con los siguientes argumentos
    // El primer argumento es una key de la api de youtube, en este caso no lo vamos a usar
    // El segundo argumento es el texto que queremos buscar en youtube
    // El tercer argumento es el numero de videos que queremos obtener (100)
    // El cuarto argumenteo es el limite de concurrencia para el funcionamiento del paquete
    // El ultimo argumento es si queremos usar la api de youtube en lugar de web scraping
    videos, err := youtubescraper.GetVideosData("", "Learn web development", 100, 64, false)

    if err != nil {
        fmt.Print("Error :(")
    }

    fmt.Println(len(videos.Videos))
}

El argumento del límite de concurrencia hace referencia al número máximo de go routines que el paquete podrá utilizar para obtener los datos de los vídeos. Lo anterior puede verse como el número de vídeos que el paquete procesará al mismo tiempo. Más información.

Si todo sale bien, podemos ejecutar el archivo main.go y al cabo de unos segundos (en mi caso 20 segundos aunque puede variar dependiendo de la conexión a internet) veremos un número en consola:

go run main.go
... Luego de unos segundos
100

El número mostrado hace referencia al número de datos obtenido por el paquete, puede ser exactamente el mismo que el número de datos solicitado o puede ser un poco menor.

Sabiendo que el paquete funcionó correctamente, es momento de obtener los más de 2000 datos para nuestro buscador, esta vez, utilizando una API key de Youtube para que el proceso sea mucho más rápido.

Primero creamos un archivo .env en dentro de la carpeta scraping/:

touch .env

Dentro del archivo creado, colocaremos la variable de entorno KEY (aunque puede tener cualquier nombre) y su valor será nuestra API key de Youtube. Si no tienes una API key, te recomiendo ver este vídeo:

KEY=your api key

Una vez creado el archivo .env con la variable KEY que almacena nuestra API Key, es momento de hacer algunos cambios en el código (Leer los comentarios):

package main

import (
    // Paquete para convertir los videos a bytes para guardarlos como json
    "encoding/json"
    "fmt"

    // Paquete para crear el archivo .json final
    "os"
    // Paquete para medir el tiempo que demora la ejecucion
    "time"

    // Paquete para obtener los datos
    youtubescraper "github.com/PChaparro/go-youtube-scraper"
    // Interfaces / tipos del paquete para obtener los datos
    ysi "github.com/PChaparro/go-youtube-scraper/interfaces"
    // Paquete para leer la variable de entorno
    "github.com/joho/godotenv"
)

func main() {
    // Cargar las variables de entorno
    err := godotenv.Load()

    if err != nil {
        fmt.Println("Error al cargar las variables de entorno.")
    }

    // Leer y verificar la variable de entorno
    key := os.Getenv("KEY")

    if key == "" {
        fmt.Println("La variable de entorno está vacía")
    } else {
        // Búsquedas que queremos realizar
        queue := []string{
            "Learn web development",
        }

        // Array para guardar los vídeos
        results := []ysi.Video{}

        // Iterar cada una de las búsquedas definidas anteriormente
        for _, query := range queue {
            // Tomar el tiempo de inicio
            start := time.Now()

            // Obtener los vídeos de la búsqueda actual
            videos, _ := youtubescraper.GetVideosData(key, query, 100, 64, true)
            // Agregar los vídeos de la búsqueda actual al array de resultados
            results = append(results, videos.Videos...)

            // Imrprimir el tiempo que tomó
            fmt.Printf("%s query took %v\n", query, time.Since(start))
        }

        // Crear los bytes que serán guardasos en formato json
        json, err := json.Marshal(results)

        if err != nil {
            fmt.Printf("Error al convertir a bytes")
        } else {
            // Si no hay ningún error, guardamos el resultado como un .json
            // El 0666 final son permisos de lectura y escritura para todos los usuarios
            os.WriteFile("data.json", json, 0666)
        }

    }

}

Si no hay ningún error, luego de ejecutar el archivo veríamos un mensaje en la consola como el siguiente:

go run main.go
... Luego de unos segundos
Learn web development query took 4.953656575s

El mensaje, como el caso anterior, nos indica que los datos se obtubieron de manera satisfactoria, y deberíamos poder encontrar un archivo data.json creado dentro de la carpeta scraping/:

data/
├── scraping
│   ├── .env
│   ├── go.mod
│   ├── go.sum
│   ├── main.go
│   ├── data.json
├── cleansing

Dentro del archivo data.json podremos ver un array de objetos como el siguiente:

Si lo anterior es cierto, felicidades 🎉! Haz completado el paso de recolección satisfactoriamente, el único paso restante es agregar más búsquedas al array queue, como en el siguiente ejemplo:

queue := []string{
    "Learn web development",
    "Top new games", 
    "Best world carnivals",
        ...
}

Luego de agregar más elementos (Ten en cuenta el límite de peticiones diarios de la API de Youtube, con 10 o 15 está más que bien), puedes ejecutar de nuevo el archivo main.go para obtener los nuevos resultados.

Final

Con esto se concluye esta segunda parte en la que recolectamos nuestros datos utilizando un paquete de web scraping, te invito a continuar con la siguiente en la que limpiaremos nuestros datos y los almacenaremos en Open Search.

Referencias

Para consultar las referencias dirigirse a cada uno de los enlaces que aparencen dentro o al final de los diferentes párrafos.

Buscador de vídeos con OpenSearch y React | Parte 1 | Introducción

Pedro Chaparro — Fri, 18 Nov 2022 14:02:40 +0000

⚠️ Nota: La idea original de este proyecto surgió gracias al canal Soumil Shah, por lo que doy crédito y recomiendo ver su serie de vídeos sobre Elastic Search Aquí.

El repositorio con el resultado final puede ser consultado en Github.

Índice

Post 1 - Introducción: Aquí
Post 2 - Recolección de los datos: Aquí
Post 3 - Limpieza y almacenamiento de los datos: Aquí
Post 4 - Desarrollo de la API (🚧 Trabajando en ello...)
Post 5 - Desarrollo del cliente Web (🚧 Trabajando en ello...)

Introducción

A través de los diferentes posts vamos a desarrollar un sitio web full-stack que nos permitirá buscar vídeos de una manera rápida y obtener resultados coherentes con el texto ingresado. En la siguiente imagen se puede ver el resultado final del front-end funcional:

Stack tecnológico

A continuación se presenta el listado de los lenguajes de programación y herramientas que usaremos en los diferentes pots:

⚠️ Nota: Las definiciones se presentan de manera sencilla, con el fin de facilitar el entendimiento del proyecto a realizar, para más información recomiendo ver los sitios web / documentación oficial de los lenguajes / herramientas.

Go / Golang: Mediante este lenguaje de programación haremos uso del paquete youtubescraper para obtener la url, miniatura, título, descripción y tags de vídeos publicados en la plataforma Youtube.
Python: Este lenguaje será utilizado para hacer una limpieza sencilla de los datos, insertar los datos en open search y desarrollar los endpoints de la API que será consultada por el front-end.
Open search: Es el motor de búsquedas y análisis que nos permitirá almacenar los datos y realizar búsquedas semánticas, lo cual se explicará más adelante. Más información.
Sentence transformers: Este paquete de python nos permitirá transformar los vídeos y las búsquedas en vectores, los cuales serán usados para encontrar vídeos similares semánticamente a las búsquedas realizadas por los usuarios. Más información.
React: Es la librería que utilizaremos para el desarrollo del front-end, lo que nos permitirá dividir responsabilidades entre componentes.

¿Por qué vamos a utilizar Open Search y Sentence Transformers?

La funcionalidad más importante del sitio web a desarrollar es la búsqueda de vídeos a partir de textos. Si bien, podríamos utilizar cualquier otra base de datos como Postgres o MongoDB para almacenar los datos y buscar el texto ingresado por el usuario en el título, descripción y tags de los diferentes vídeos para obtener los resultados, esto podría no arrojar resultados precisos en muchos escenarios, como en los siguientes dos ejemplos:

Un error de digitación: En caso de hacer una búsqueda exacta del texto ingresado por el usuario, una frase con un error como "Crate web sites" (Falta la e en Create) podría no obtener resultados a pesar de que en la base de datos existan cientos o miles de registros con la frase "Create web sites".
Una búsqueda por significado: Un usuario podría realizar una búsqueda como "I don´t know which new video game i should buy", claramente, podemos inferir que lo que desea encontrar son recomendaciones de videojuegos, pero una base de datos "convencional" podría no encontrar resultados para su búsqueda debido a que no hay textos similares en los títulos, descripciones o tags de ningún vídeo.

Como los dos ejemplos anteriores, existen muchos más, por ejemplo, las búsquedas en diferentes lenguajes. Como solución, la "libería" sentence transformers ofrece diferentes modelos de inteligencia artificial entrenados con millones o billones de datos para extraer los significados de textos a un vector de longitud fija y que, según el modelo escogido, pueden soportar más de 50 lenguajes diferentes. Más información.

A partir del vector generado por sentence transformers se pueden aplicar algoritmos como el coseno de similitud o K-NN que permiten encontrar vectores similares, y, por tanto, vídeos similares a la semántica / "significado" del texto ingresado. Es justo aquí donde Open Search ofrece una gran ventaja, ya que cuenta con un plugin del algoritmo K-NN que nos permitirá realizar búsquedas rápidas y acertadas de manera sencilla.

Final

Con esto se concluye esta primer parte, que solamente sirve como contextualización, te invito a continuar con la siguiente.

Referencias

Para consultar las referencias dirigirse a cada uno de los enlaces que aparencen dentro o al final de los diferentes párrafos.

Web Scraping y Concurrencia - GO

Pedro Chaparro — Fri, 28 Oct 2022 19:50:15 +0000

Recursos

Esta implementación fue realizada gracias al trabajo colaborativo. El código fuente y los aportes de cada persona se encuentran en Github.

Introducción

Uno de los métodos más conocidos para la obtención de información desde sitios públicos en internet es el web scraping, que, a partir de diversos métodos como el uso de selectores css o expresiones regulares permite obtener los textos presentes en el HTML del sitio web.

En este caso, el objetivo de la implementación del web scraping es la obtención de títulos, descripciones, etiquetas, enlaces y "miniaturas" de vídeos publicados en la plataforma YouTube con fines netamente de aprendizaje.

Inicialmente, se realizaron 3 implementaciones en los lenguajes de programación Ruby (ver más información), JavaScript (ver más información) y Python (ver más información). A pesar de que las tres implementaciones requerían tiempos relativamente bajos para completar la recolección, se identificó una posible oportunidad de mejora utilizando el lenguaje Go, esto debido a su soporte para la concurrencia.

Implementación y resultados

Para la obtención de los datos requeridos se escogieron diferentes búsquedas (Ejm. How to create websites, Colombian music) y se obtuvieron, al menos, 140 enlaces de los vídeos resultantes de cada búsqueda empleando el paquete go-rod para inicializar un navegador sin interfaz gráfica (headless) y realizar de manera automática el scroll hasta tener el número mínimo de vídeos y obtener los enlaces.

El siguiente paso fue iterar los enlaces obtenidos y, con ayuda del paquete SizedWaitGroup, iniciar de manera concurrente la ejecución de funciones para obtener los datos de cada enlace. A pesar de que Go ofrece de manera estándar el paquete sync con el que se pueden crear WaitGroups, se optó por el paquete SizedWaitGroup para evitar el consumo excesivo de recursos al limitar el número de GoRoutines concurrentes.

Al modificar el límite de GoRoutines concurrentes, se obtuvieron los siguientes resultados:

Como se observa en el gráfico, con tan solo pasar de una GoRoutine concurrente (Ejecución secuencial) a dos, el tiempo de ejecución se reduce de 113.6039s a 61.4714s, es decir, un 45.8897% apróximadamente, y al utilizar ocho GoRoutines, se reduce a 28.7748s, lo cual es 74.6709% menos en comparación al tiempo inicial.

Para finalizar, así se ven en la consola las ejecuciones con un límite de 1 y 8 GoRoutines respectivamente (Los primeros 20 segundos corresponden al tiempo para hacer el scroll con el web-driver`):

Referencias

Google (2022) Sync, sync package - sync - Go Packages. pkg.go.dev. Available at: https://pkg.go.dev/sync (Accessed: October 28, 2022).
Ionos (2020) ¿Qué es el web scraping?, IONOS Digital Guide. Ionos. Available at: https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/que-es-el-web-scraping/ (Accessed: October 28, 2022).
Manqueros, R. (2021) How to properly handle concurrency and parallelism with Golang. Medium. Available at: https://medium.com/analytics-vidhya/how-to-properly-handle-concurrency-and-parallelism-with-golang-89dd054b739f (Accessed: October 28, 2022).
Nikolov, M.A. (2015) Concurrent map and slice types in go, Concurrent map and slice types in Go – Marin Atanasov Nikolov – A place about Open Source Software, Operating Systems and some random thoughts. Marin Atanasov Nikolov . Available at: https://dnaeon.github.io/concurrent-maps-and-slices-in-go/ (Accessed: October 28, 2022).
Remeh (2019) Sizedwaitgroup, sizedwaitgroup package - github.com/remeh/sizedwaitgroup - Go Packages. pkg.go.dev. Available at: https://pkg.go.dev/github.com/remeh/sizedwaitgroup (Accessed: October 28, 2022).
Skakun, V. (2022) The Best Programming Languages for Web Scraping. scrape-it. Available at: https://scrape-it.cloud/blog/web-scraping-languages (Accessed: October 28, 2022).