Maestría Ciencia de datos y análisis de datos

masivos Big Data

Equipo
Magdaleno Arroyo Dulce María
000-00- 4830

Niño Peña Christiam Alejandro

000-00- 5220

Cuellar Perez Lina Marcela

000-00- 5204

3.2 Practica. Análisis, implementación y prueba de

técnicas IA aplicadas al Web Mining
Unidad 3

Dr. Humberto Muñoz Bautista

02 de julio de 2023
 INTRODUCCIÓN

La práctica que se desarrolla a continuación tiene como propósito la

implementación de dos técnicas de Webmining en inteligencia artificial, la primera
usando Web Scraping para la identificación de imágenes, y la segunda con
Minería de inteligencia de enjambre con reglas de clasificación aplicados a
sistemas de recomendaciones de puntuaciones de video juegos en Amazon.

Teniendo en cuenta que las paginas se actualizan de forma constante y los

archivos contenidos ya sea en imágenes como datos de calificaciones de
usuarios, se hace necesario tener una estructura que permita extraer los datos de
forma continua, para ello se usan técnicas para tener el mayor contenido y de la
mejor forma posible. (JavaTPoint, 2022)
 DESARROLLO

1. TÉCNICA 1. TECNOLOGÍA MULTIAGENTE – WEB SCRAPING

1.1. ANÁLISIS DE LA TÉCNICA

WebScraping permite extraer datos y contenido de cualquier sitio web, en pocas

palabras es una técnica para la manipulación de datos que permite realizar un
análisis posterior, en este proceso se extrae el código HTML y/o los datos
almacenados en bases de datos.

Según (Mishkin, 2023) para implementar este tipo de técnica es necesario

importar algunas librerías requeridas para que se puedan importar los datos, estas
son:

- Request: “la biblioteca Requests es una herramienta integral para cualquier

proyecto de web scraping. Los datos que devuelve la biblioteca Requests
pueden ser difíciles de leer, pero es la forma más sencilla de recibir la
información que necesita en su proyecto de web scraping.” (Mishkin, 2023)
- BS4: Librería que permite extraer datos de archivos XML y HTML. (Mishkin,
2023)

Imagen 1. Pasos del WebScraping.

(JavaTPoint, 2022)
 1.2. IMPLEMENTACIÓN DE LA TÉCNICA

FASE 1. DESCARGA DE IMAGENES

from bs4 import *

import requests
import os

def folder_create(images):
try:
folder_name = input("Ingrese el nombre del directorio destino: ")
os.mkdir(folder_name)
except:
print("Directorio existente con el mismo nombre")
folder_create()
download_images(images, folder_name)

def download_images(images, folder_name):

count=0
print(f"Total {len(images)} Imagen encontrada")
if len(images) != 0:
for i, image in enumerate(images):
try:
image_link = image["data-srcset"]
except:
try:
image_link = image["data-src"]
except:
try:
image_link = image["data-fallback-src"]
except:
try:
image_link = image["src"]
except:
pass
try:
r = requests.get(image_link).content
try:
r=str(r,'utf-8')
except UnicodeDecodeError:
with open(f"{folder_name}/images{i+1}.jpg","wb+") as f:
f.write(r)
count += 1
except:
pass
if count == len(images):
print("Se han descargado todas las imagenes")
else:
print(f"Total {count} Imagenes descargadas de {len(images)}")

def main(url):
r = requests.get(url)
soup = BeautifulSoup(r.text,'html.parser')
images = soup.findAll('img')
folder_create(images)
url = 'https://co.pinterest.com/rangertrop/pokemon/'
main(url)

url = 'https://co.pinterest.com/rangertrop/autos/'
main(url)

FASE 2. GENERACIÓN DEL ARREGLO DE IMÁGENES

pip install opencv-python

import cv2
import numpy as np
import os
import matplotlib.pyplot as plt

pokemon_directorio_ruta="C:\\MV\\Pokemon\\"
pokemon=[]
img_size=150
for img in os.listdir(pokemon_directorio_ruta):
img = cv2.imread(os.path.join(pokemon_directorio_ruta,img))
img_resize = cv2.resize(img,(img_size, img_size))
pokemon.append(img_resize)

autos_directorio_ruta="C:\\MV\\Autos\\"
autos=[]
img_size=150
for img in os.listdir(autos_directorio_ruta):
img = cv2.imread(os.path.join(autos_directorio_ruta,img))
img_resize = cv2.resize(img,(img_size, img_size))
autos.append(img_resize)

pokemon = np.array(pokemon)
print(pokemon.shape)

autos = np.array(autos)
print(autos.shape)
FASE 3. VALIDACIÓN DE IMÁGENES
print(pokemon[4].shape)
plt.figure()
plt.imshow(np.squeeze(pokemon[4]))
plt.colorbar()
plt.grid(False)
plt.show()

print(autos[4].shape)
plt.figure()
plt.imshow(np.squeeze(autos[4]))
plt.colorbar()
plt.grid(False)
plt.show()
FASE 4. CONCATENACIÓN DE IMÁGENES
imagenes = np.concatenate([pokemon, autos])
print(len(imagenes))
Imagen = np.array(imagenes)

print(Imagen.shape)

etiqueta_pokemon = np.repeat(0,35)
print(len(etiqueta_pokemon))

etiqueta_autos = np.repeat(1,32)
print(len(etiqueta_autos))

labels = np.concatenate([etiqueta_pokemon, etiqueta_autos])

print(len(labels))
Labels = np.array(labels)

FASE 5. GENERACIÓN DE ETIQUETAS

class_name=['Pokemon','Auto']

plt.figure(figsize=(10,10))
for i in range(20):
plt.subplot(5,5,i+1)
plt.xticks([])
plt.yticks([])
plt.grid(False)
plt.imshow(Imagen[i])
plt.xlabel(class_name[Labels[i]])

plt.show()
FASE 6. APLICACIÓN DE TENSORFLOW
from __future__ import absolute_import, division, print_function,
unicode_literals

variable_name = ""
try:
%tensorflow_version 2.x
except Exception:
pass

from __future__ import absolute_import, division, print_function,

unicode_literals

# TensorFlow and tf.keras

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import datasets, layers, models
import tensorflow.keras.optimizers as Optimizer

import numpy as np
import matplotlib.pyplot as plt
print(tf.__version__)

FASE 7. GENERACIÓN DEL MODELO

model = keras.Sequential([
keras.layers.Flatten(input_shape=(150,150,3)),
keras.layers.Dense(128, activation='relu'),
keras.layers.Dense(2,activation='softmax'),
])
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(Imagen, Labels, epochs=30)
trained=model.fit(Imagen, Labels, epochs=30)
 1.3. EVALUACIÓN DE LA TÉCNICA
img=Imagen[3]
print(img.shape)
img=(np.expand_dims(img,0))
print(img.shape)

plt.figure()
plt.imshow(Imagen[3])
plt.colorbar()
plt.grid(False)
plt.show()

predecir = model.predict(img)
print(predecir)
print(np.sum(predecir))
print(np.argmax(predecir))
print(class_name[np.argmax(predecir)])

img = Imagen[66]
print(img.shape)
img=(np.expand_dims(img,0))
print(img.shape)

plt.figure()
plt.imshow(Imagen[66])
plt.colorbar()
plt.grid(False)
plt.show()
predecir=model.predict(img)
print(predecir)
print(np.sum(predecir))
print(np.argmax(predecir))
print(class_name[np.argmax(predecir)])

rgb = Imagen[66]
gris = cv2.cvtColor(rgb, cv2.COLOR_BGR2GRAY)

plt.figure()
plt.imshow(gris)
plt.colorbar()
plt.grid(False)
plt.show()

test_eval = model.evaluate(test_X, test_Y_one_hot, verbose=1)

print('Test loss:', test_eval[0])

print('Test accuracy:', test_eval[1])
 2. TÉCNICA 2. INTELIGENCIA DE ENJAMBRE – MINERIA DE REGLAS DE
CLASIFICACIÓN – SISTEMAS DE RECOMENDACIONES PARA
USUARIOS QUE COMPRAN VIDEOJUEGOS

Una tienda de videojuegos busca mejorar sus ventas adaptándose a los gustos
específicos de cada cliente, se ha pensado en métodos para poder sugerir juegos
que cumplan con los perfiles, género y diversión de nuestros clientes. Para ello se
utilizó como referencia (Mavuduru, 2020).

Para poder conseguir esto se ha pensado en implementar un sistema de

recomendaciones utilizando las bases de datos de Amazon y los datos que iremos
recolectando con cada una de las ventas realizadas, el objetivo principal es poder
realizar ventas de calidad y que cada recomendación sea idónea y segura del gusto
del consumidor.

Se ha seleccionado y clasificado los datos para con el lenguaje de programación

Python y una librería especializada para sistemas de recomendaciones llamada
Surprise para programar una solución de aprendizaje de máquina que sugiera títulos
en base a cruzar los datos de casi 80000 juegos con 500000 calificaciones.

El resultado final será un título de juego que puede llegar a cumplir con los intereses
del cliente. El trabajo se divide en problema, justificación, metodología, se muestran
los resultados para llegar a la discusión y obtener las conclusiones.

Estas calificaciones se obtienen el archivo CSV generado de la semántica web de

contenido de calificaciones, como se observa en la Imagen 2.
Imagen 2. Calificaciones de videojuegos.

Fuente. (Mavuduru, 2020)

PROBLEMA

La organización tiene una afiliación con Amazon para la venta de videojuegos según
demanda y peticiones. Últimamente se han tenido problema en adquirir juegos que
sean atractivos o generen mayor número de ventas, nuestros clientes exigen juegos
que se adapten a sus expectativas y gustos.

Con base a lo anterior, se ha pensado en aplicar un sistema de recomendación

utilizando los datos disponibles de calificaciones de los usuarios para los títulos
vendidos y de esta manera poder ofrecer títulos que se adapten a sus gustos para
generar mejores ventas y no tener títulos en inventario por mucho tiempo.

a. ENTENDIMIENTO DE LOS DATOS

Los datos utilizados que se descargaron del sitio oficial de amazon por medio de
se definen en 2 matrices de la siguiente manera:
Archivo: Video_Games_Rating.csv
- reviewerID – Id del usuario, p.e. A2SUAM1J3GNN3B
- asin – Id del videojuego, p.e. 0000013714
- overall – calificación del juego
- unixReviewTime – tiempo de la revisión (unix time)

Archivo: meta_Video_Games.json
- asin – Id del videojuego, p.e. 0000013714
- title – nombre del juego
 b. PREPARACIÓN DE LOS DATOS

Los datos se descargaron de la página https://nijianmo.github.io/amazon/index.html,

se seleccionaron los conjuntos de datos 5-core que son subconjuntos de datos de
todos los usuarios y juegos con al menos 5 calificaciones. De igual manera se
seleccionaron únicamente las columnas que se requerían del archivo
meta_video_games.json, lo anterior, para efectos de la aplicación. Estos datos
estan actualizándose continuamente en tiempo real ya que son las opiniones de los
datos de ventas de todos los días, por ese se usa la extracción de datos.

c. MODELO SELECCIONADO

El modelo seleccionado es sistema de recomendaciones por colaboración, lo

anterior, porque tenemos calificaciones de varios usuarios en títulos de videojuegos
que van de 1 a 5 estrellas.
Para la ejecución del sistema de recomendaciones se utilizó la librería Surprise y
lenguaje de programación Python, el código resultante es el siguiente:
a. Importar la librería Surprise

pip install surprise

b. Importar las librerías para manipulación de datos y visualización

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline

c. Cargar la data de ratings, editar el dataset de los juegos calificados por los
usuarios

ratings_data = pd.read_csv('Video_Games_Rating.csv',header=None)
ratings_data.set_axis(["idgame", "iduser", "rating", "timeunix"],axis=1,inplace=True)
ratings_data = ratings_data[["iduser", "idgame", "rating"]]
ratings_data.head(10)
Figura 1. Top 10 datos de calificaciones

Fuente. Los autores

d. Cargar la metadata de los juegos

import pandas as pd
df = pd.read_json ('
https://jmcauley.ucsd.edu/data/amazon_v2/categoryFilesSmall/Video_Games_5.json, lines=True)
df.to_csv ('new_video_games.csv', index = None)
df
Figura 2. Top 4 datos de juegos

Fuente. Los autores

 e. Seleccionar las columnas de identificador de juego y titulo

metadata_games = df[["asin", "title"]]

metadata_games.set_axis(["idgame", "title"],axis=1,inplace=True)
metadata_games

f. Cargar el dataset con las columnas que se usaran en Surprise

from surprise import Dataset

from surprise import Reader

reader = Reader(rating_scale=(1, 5))

data = Dataset.load_from_df(ratings_data[['iduser', 'idgame', 'rating']], reader)

g. Entrenamiento y validación cruzada de un modelo SVD simple

Podemos entrenar y validar de forma cruzada un modelo que realiza SVD

(descomposición de valores singulares) para construir un sistema de
recomendación en solo unas pocas líneas de código. SVD es un algoritmo de
factorización de matriz popular que se puede usar para sistemas de recomendación.
Los sistemas de recomendación que utilizan la factorización de matrices
generalmente siguen un patrón en el que una matriz de calificaciones se factoriza
en un producto de matrices que representan factores latentes para los elementos
(en este caso, videojuegos) y los usuarios

Figura 3. Matrices de calificaciones

Fuente. (Mavuduru, 2020)

Teniendo en cuenta la figura anterior, observe cómo la matriz de calificación, R,

tiene valores faltantes en algunos lugares. El algoritmo de factorización de matriz
utiliza un procedimiento como el descenso de gradiente para minimizar el error al
predecir calificaciones existentes utilizando los factores de matriz. Por lo tanto, un
algoritmo como SVD construye un sistema de recomendación permitiéndonos
“llenar los vacíos” en la matriz de calificación, prediciendo las calificaciones que
cada usuario asignaría a cada elemento del conjunto de datos.
Comenzando con una matriz de entrada A, SVD en realidad factoriza la matriz
original en tres matrices como se demuestra en la siguiente ecuación.

Figura 4. Ecuación de cruce de matrices

Fuente. [1]

Podemos asignar estas nuevas matrices a la matriz de calificación R y los factores

Q y P del artículo y del usuario de la siguiente manera:

Figura 5. Asignación de matrices

Fuente. [1]
En el caso de nuestro sistema de recomendación de videojuegos, el algoritmo SVD
representará la matriz de calificación como un producto de matrices que representan
los factores de los videojuegos y los factores del usuario, respectivamente.

h. Validación cruzada de un modelo SVD utilizando una validación cruzada

triple.

from surprise import SVD

from surprise.model_selection import cross_validate

svd = SVD(verbose=True, n_epochs=10)

cross_validate(svd, data, measures=['RMSE', 'MAE'], cv=3, verbose=True)
Figura 6. Resultado de validación cruzada

Fuente. Los autores

i. Entrenar el modelo en todo el conjunto de datos usando el método de ajuste

después de convertir el conjunto de datos para la validación cruzada en un
objeto surprise Trainset usando el método build_full_trainset.

trainset = data.build_full_trainset()
svd.fit(trainset)

Figura 7. Entrenamiento del modelo

Fuente. Los autores

j. Generación de predicciones de calificación

Ahora que tenemos un modelo SVD entrenado, podemos usarlo para predecir la
calificación que un usuario asignaría a un videojuego dado un ID para el usuario
(uid) y un ID para el videojuego (iid). El siguiente código demuestra cómo hacer esto
con el método de predicción.
svd.predict(uid='A23JCKJ9AHXRZZ', iid='0439381673')
Prediction(uid='A23JCKJ9AHXRZZ', iid='0439381673', r_ui=None, est=3.3333777932271094,
details={'was_impossible': False})

El método de predicción devuelve la Predicción que se muestra a continuación, que

contiene un campo llamado est que indica la calificación estimada del libro para este
usuario específico.

Según el resultado anterior, podemos ver que el modelo predijo que este usuario
específico le daría una calificación de tres estrellas (aproximadamente) al
videojuego correspondiente a un IID de 0439381673. El modelo no recomienda
videojuegos directamente, pero podemos usar esta utilidad de predicción de
calificación para identificar qué videojuegos probablemente disfrutaría un usuario,
lo que nos permite justificar recomendarlos a un usuario.

k. Generación de recomendaciones de Videojuegos

import difflib
import random

def get_game_id(game_title, metadata):

"""
Gets the game ID for a game title based on the closest match in the metadata dataframe.
"""
existing_titles = list(metadata['title'].values)
closest_titles = difflib.get_close_matches(game_title, existing_titles)
game_id = metadata[metadata['title'] == closest_titles[0]]['idgame'].values[0]
return game_id

def get_game_info(game_id, metadata):

"""
Returns some basic information about a game given the game id and the metadata dataframe.
"""
game_info = metadata[metadata['idgame'] == game_id][['idgame', 'title']]
return game_info.to_dict(orient='records')

def predict_review(user_id, game_title, model, metadata):

 """
Predicts the review (on a scale of 1-5) that a user would assign to a specific game.
"""
game_id = get_game_id(game_title, metadata)
review_prediction = model.predict(uid=user_id, iid=game_id)
return review_prediction.est

def generate_recommendation(user_id, model, metadata, thresh=4):

"""
Generates a book recommendation for a user based on a rating threshold. Only
games with a predicted rating at or above the threshold will be recommended
"""
game_titles = list(metadata['title'].values)
random.shuffle(game_titles)

for game_title in game_titles:

rating = predict_review(user_id, game_title, model, metadata)
if rating >= thresh:
game_id = get_game_id(game_title, metadata)
return get_game_info(game_id, metadata)

La función generate_recommendation genera una recomendación de videojuego

para un usuario iterando a través de la lista aleatoria de títulos de juegos y
prediciendo las calificaciones de los usuarios para cada título hasta que encuentra
un videojuego con una calificación igual o superior al umbral especificado que lo
califica para recomendarlo a un usuario. Mezclar los títulos de los juegos al principio
agrega algo de aleatoriedad a la recomendación del videojuego. Ejecutar la función
como se demostró anteriormente produjo el siguiente resultado (tenga en cuenta
que, debido a la aleatoriedad de la función, puede obtener una recomendación
diferente).

Figura 8. Resultados de la recomendación

Fuente. Los autores

 CONCLUSIÓN

La variedad de técnicas disponibles para la minería web permite realizar tareas

que benefician a cualquier organización, como se desarrolló en esta práctica, web
scraping permitió generar bases de datos de imágenes y poder realizar la
predicción de estas para su uso en otras aplicaciones, también en el caso de
sistemas de recomendaciones por medio de contenidos y semántica web en las
puntuaciones de videojuegos, en este último, aunque se extrae datos de un sitio
web, estas calificaciones de los videojuegos están continuamente cambiando por
lo que se debe estar aplicando actualización continua al contenido web para tener
resultados en tiempo real.

La actualidad de este tipo de técnicas esta combinándose con las maquinas de

aprendizaje e inteligencia artificial generando modelos más complejos que
permiten obtener predicciones más precisas, ya sea de contenido o de compra de
productos.
 REFERENCIAS

JavaTPoint. (2022). Web Scraping Using Python. Obtenido de

https://www.javatpoint.com/web-scraping-using-python
Mavuduru, A. (2020). How you can build simple recommender systems with
Surprise. Obtenido de https://towardsdatascience.com/how-you-can-build-
simple-recommender-systems-with-surprise-b0d32a8e4802
Mishkin, V. (2023). Web Scraping with Python. Obtenido de
https://webscraping.ai/blog/web-scraping-with-python