Centro Nacional de Investigación y Desarrollo Tecnológico · Cuernavaca, Morelos, México. Diciembre de 2013. Centro Nacional de Investigación y Desarrollo Tecnológico Subdirección

Cuernavaca, Morelos, México. Diciembre de 2013.

Centro Nacional de Investigación y Desarrollo Tecnológico

Subdirección Académica

Departamento de Ciencias Computacionales

TESIS DE MAESTRÍA EN CIENCIAS

Anotación Semántica de Partidos de Futbol utilizando

Gamecast

presentada por

Ing. Elizabeth Cadenas Castrejón

como requisito para la obtención del grado de Maestra en Ciencias de la Computación

Director de tesis Dra. Alicia Martínez Rebollar

Codirector de tesis

Dr. Hugo Estrada Esquivel

i

Agradecimientos

Al Consejo Nacional de Ciencias y Tecnología (CONACYT) por el apoyo económico proporcionado para mis estudios y una estancia de investigación, los cuales me permitieron realizar esta investigación de tesis.

Al Centro Nacional de Investigación y Desarrollo Tecnológico (CENIDET) por brindarme la

oportunidad de realizar los estudio de una maestría. A mi directora de tesis la Dra. Alicia Martínez Rebollar y a mi codirector el Dr. Hugo

Estrada Esquivel por el apoyo, la ayuda y el tiempo proporcionado en todo momento en el transcurso del desarrollo de esta investigación.

A mis revisores el Dr. Javier Ortiz Hernández, el M.C. José Luis Ramírez Alcántara y Dr.

Jorge Hermosillo Valadez, por las observaciones y correcciones que han permitido el progreso de esta investigación.

A mis profesores y personal académico, por su experiencia y su conocimiento los cuales

han brindado la estructura de mi formación. Al personal administrativo por el apoyo proporcionado para la realización de los trámites,

proyectos y actividades. Al L.E.F.L. Javier Obispo por tiempo y orientarme con sus conocimientos en futbol los

cuales ayudaron en la creación de una nueva ontología. A mis compañeros de generación Eduardo, Salvador, Alberto, Wendy, Oscar, Israel,

Francisco y Chucho quienes me han ayudado, me han hecho reír y me brindaron una amistad durante todo este tiempo.

A mis compañeros de maestría y doctorado Luis, Wilfrido, Víctor, Samuel, Selene, Ilse,

Lety, Hugo, Nimrod, Julia, Juan Carlos, Hiram, Alejandra, Yolanda, Alfredo, Vicente y el resto de los compañeros de laboratorio quienes me han apoyado durante estos dos años y medio.

ii

Dedicatoria

A mis padres Catalina Sedano y Antonio Cadenas, quienes me han apoyado a lo largo de todos estos años y han estado conmigo en los logros y en los fracaso.

A mis hermanos (Rosario Cadenas, Catalina Cadenas y Antonio) y familiares (Francisca,

Elodia, Maricruz, Taurino, Martha, Rey, Socorro, Pera, Diana, Edith, Tere, Kevin, Derek, Elsy, Erick, Francis, Renato, Lidio) quienes me han animado a continuar cuando me he sentido perdida.

A mis sobrinos Rodrigo Díaz, Caleb Castillo, Rohnél Díaz y Rebeca Castillo quienes con

sus sonrisas y sus travesuras me alegran el corazón. A mi directora de tesis la Dra. Alicia Martínez Rebollar y a mi codirector el Dr. Hugo

Estrada Esquivel quienes además de ser grandes profesionistas son grandes personas, que me han ayudado, guiado y aconsejado en esta travesía llamada maestría. Esta tesis es el resultado de un trabajo mutuo, de esfuerzo y apoyos constante e incondicional, gracias por todo.

A mis amigos y amigas quienes han soportado que en más de una ocasión cancelara

sus invitaciones y fiestas, no las vea, olvide sus cumpleaños y aun así me animan, me desean lo mejor, me levantan el ánimo y me apoyan en lo que pueden.

A mi novio Christian que ha estado a mi lado en mis triunfos y en los momentos difíciles,

que me extiende su mano cuando la necesito, que me hace reír cuando estoy triste y me da fuerza para seguir adelante.

A dios que me ha dado vida, salud, muchas personas que me quieren y sobre todo una gran

perseverancia que me hace continuar.

iii

Abstract

In recent years there has been a steady growth on the Web, which has caused it to become a

huge storage of information. In addition, the great variety of information the Web has, has

enabled it to be one of the most popular means of finding information.

The huge Web content has increased the difficulty and time to locate relevant information

when perfoming searches; therefore, we have developed tools to help access information on

the Web. Existing tools to access the Web show a wide amount of information, because

computers cannot adequately interpret the requested content. Presently, tools are being

developed to enable the semantic description of resources.

Semantic annotation enables you to add information to Web resources, to encourage and

support computers to interpret information. In addition, to help creation of repositories that

have metadata to facilitate resources search.

Usually semantic annotation performed on the text; however, the semantic annotation of

multimedia resource has been developed which has increased the amount of available

information on the Web, as well as consultations and the use of this information.

Images, audio and video are some multimedia resources existing on the Web. Videos are the

most used resources because they contain information that it is easy to understand because

the information being transmitted can be seen and listened.

Usually videos do not contain semantic or textual description that can help computer to

interpret video content, therefore, videos consultation is difficult to perfom.

In the thesis project is presented a semantic annotation method of soccer games. Semantic

annotation method was implemented in a software system which uses the gamecast (minute

by minute report of a game) to generate instances of an ontology of football.

iv

Resumen

En los últimos años se ha presentado un constante crecimiento en la Web, que ha ocasionado que se convierta en un enorme almacén de información. Además la gran variedad de información que tiene la Web ha permitido que sea uno de los medios más populares para la búsqueda de información.

El enorme contenido de la Web ha aumentado la dificultad y el tiempo para localizar

información relevante al realizar búsquedas; es por ello que se han desarrollado herramientas que ayudan al acceso de la información en la Web. Las herramientas que existen para acceder a la Web muestran una amplia cantidad de información; debido a que las computadoras no pueden interpretar adecuadamente el contenido solicitado. Actualmente se están desarrollando herramientas que permitan dar semántica en la descripción de recursos.

La anotación semántica permite agregar información a los recursos de la Web, para

favorecer y apoyar a las computadoras a interpretar la información. Además, de ayudar a la creación de repositorios que cuenten con metadatos que faciliten la búsqueda de recursos.

La anotación semántica generalmente se realiza sobre texto, sin embargo se ha iniciado

el desarrollo de anotación semántica sobre recursos multimedia, la cual se ha incrementado por la cantidad de información o recursos multimedia disponibles en la Web, así como las consultas y uso de esta información.

Algunos recursos multimedia que existen en la Web son: imágenes, audio y video. Los

videos son de los recursos más utilizados debido a que contienen información que es sencilla de entender, porque la información que se está transmitiendo puede verse y escucharse.

Los videos generalmente no contienen semántica o descripción textual que puedan

ayudar a la computadora a interpretar el contenido del video; es por ello, que las consultas de videos son difíciles de realizar.

En este proyecto de tesis se presenta un método de anotación semántica de partidos de

futbol. El método de anotación semántica fue implementado en un sistema de software, el cual utiliza el gamecast (reporte minuto a minuto de un partido) para generar las instancias de una ontología de futbol.

.

v

Índice

CAPÍTULO 1. INTRODUCCIÓN .............................................................................................................. 1

1.1. PLANTEAMIENTO DEL PROBLEMA ........................................................................................... 2

1.1.1. SOLUCIÓN PROPUESTA ..................................................................................................... 3

1.2. OBJETIVOS................................................................................................................................... 3

1.2.1. OBJETIVO GENERAL ........................................................................................................... 3

1.2.2. OBJETIVO ESPECÍFICOS .................................................................................................... 3

1.3. ESTRUCTURA DE LA TESIS ........................................................................................................ 3

CAPÍTULO 2. MARCO TEÓRICO ........................................................................................................... 5

2.1. ONTOLOGÍAS ............................................................................................................................... 6

2.1.1. COMPONENTES DE UNA ONTOLOGÍA .............................................................................. 6

2.1.2. ONTOLOGÍA DE DOMINIO ................................................................................................... 7

2.1.3. LENGUAJES PARA ONTOLOGÍAS ...................................................................................... 7

2.1.3.1. MARCO DE DESCRIPCIÓN DE RECURSOS ................................................... 7

2.1.3.2. LENGUAJE DE ONTOLOGÍAS WEB .................................................................... 7

2.2. WEB SEMÁNTICA ......................................................................................................................... 8

2.3. ANOTACIÓN SEMÁNTICA ........................................................................................................... 8

2.3.1. TIPOS DE ANOTACIONES SEMÁNTICAS ........................................................................... 9

2.4. METADATOS .............................................................................................................................. 10

2.5. REPOSITORIOS AUDIOVISUALES ........................................................................................... 10

CAPÍTULO 3. ESTADO DEL ARTE ...................................................................................................... 11

3.1. CLASIFICACIÓN DEL ESTADO DEL ARTE ............................................................................... 12

3.2. FRAMEWORKS PARA ANOTACIÓN SEMÁNTICA DE RECURSOS MULTIMEDIA ................. 12

3.2.1. FRAMEWORK DE ANOTACIÓN SEMÁNTICA DE VÍDEO DE DEPORTES Y

RECUPERACIÓN PERSONALIZADA (XU ET AL. 2008) .............................................................. 12

3.2.2. MÉTODO DE ANOTACIÓN SEMÁNTICA QUE USA CARACTERÍSTICAS VISUALES,

CARACTERÍSTICAS DEL HABLA Y PATRONES FRECUENTES (TSENG ET AL. 2008) .......... 14

3.2.3. EVENT DESCRIPTION FRAMEWORK (EDF) (NATARAJAN Y NEVATIA 2005) .............. 15

3.3. FRAMEWORKS PARA ANOTACIÓN SEMÁNTICA DE TEXTO O PÁGINAS WEB ................... 16

3.3.1. EXTRACCIÓN DE METADATOS DE DOMINIO DE TEXTOS DEL FUTBOL (Z. ÖZKAN

GOKTURK ET AL. 2008) ............................................................................................................... 16

3.3.2. BAYESIAN NETWORK AND ONTOLOGY BASED SEMANTIC ANNOTATION (BNOSA)

(RAJPUT Y HAIDER 2011B) .......................................................................................................... 18

3.3.3. CERNO (KIYAVITSKAYA ET AL. 2009) .............................................................................. 19

3.3.4. ONTOLOGY BASED TEXT ANNOTATION (ONTEA) (LACLAVÍK ET AL. 2009) ............... 20

3.3.5. KNOWLEDGE AND INFORMATION MANAGEMENT (KIM) (POPOV ET AL. 2003) ......... 21

3.4. CONCLUSIONES DEL ESTUDIO DEL ESTADO DEL ARTE ..................................................... 23

CAPÍTULO 4. METODOLOGÍA DE SOLUCIÓN ................................................................................... 26

4.1. DESCRIPCIÓN GENERAL DEL MÉTODO DE ANOTACIÓN SEMÁNTICA DE VIDEOS

DEPORTIVOS. ................................................................................................................................... 27

4.2. MÓDULO 1: IDENTIFICACIÓN Y EXTRACCIÓN DE PALABRAS RELEVANTES ..................... 29

4.2.1. IDENTIFICACIÓN DE PALABRAS RELEVANTES EN EL GAMECAST............................. 29

vi

4.2.2. EXTRACCIÓN DE PALABRAS RELEVANTES EN EL GAMECAST ................................. 30

4.3. MÓDULO 2: MAPEAR LAS PALABRAS RELEVANTES CON LA INFORMACIÓN DE LA

ONTOLOGÍA ...................................................................................................................................... 31

4.3.1. IDENTIFICAR LA CLASE DE LA ONTOLOGÍA A LA QUE PERTENECE LA PALABRA

RELEVANTE .................................................................................................................................. 31

4.3.2. EXTRACCIÓN DE LA INFORMACIÓN DE WIKIPEDIA DE LAS PALABRAS RELEVANTES

........................................................................................................................................................ 34

4.4. MÓDULO 3: CREACIÓN DE INSTANCIAS Y RELACIONES DE LA ONTOLOGÍA .................... 36

4.4.1. ETIQUETADO DEL GAMECAST ......................................................................................... 36

4.4.2. CREACIÓN DE INSTANCIAS DE LA ONTOLOGÍA ............................................................ 39

4.4.3. CREACIÓN DE LAS RELACIONES DE LA ONTOLOGÍA .................................................. 41

CAPÍTULO 5. HERRAMIENTA ............................................................................................................. 44

5.1. HERRAMIENTAS UTILIZADAS PARA IMPLEMENTAR EL MÉTODO DE ANOTACIÓN

SEMÁNTICA ....................................................................................................................................... 45

5.1.1. PATRONES EN JAVA ......................................................................................................... 45

5.1.2. NETBEANS IDE 7.0.1 ......................................................................................................... 45

5.1.3. JDK 1.7 ................................................................................................................................. 45

5.1.4. APACHE JENA .................................................................................................................... 45

5.1.5. MYSQL ................................................................................................................................. 46

5.1.6. JDBC .................................................................................................................................... 46

5.1.7. PROTÉGÉ ............................................................................................................................ 46

5.1.8. API DE GOOGLE ................................................................................................................. 46

5.1.9. JSON .................................................................................................................................... 47

5.1.10. JSOUP ................................................................................................................................ 47

5.1.11. STANFORD-POSTAGGER ................................................................................................ 47

5.2. INTERFAZ GRÁFICA .................................................................................................................. 47

5.3. FUNCIONAMIENTO .................................................................................................................... 48

5.3.1. PRERREQUISITO DEL SISTEMA ....................................................................................... 48

5.3.1.1 ARCHIVO QUE CONTIENE EL GAMECAST ................................................................ 48

5.3.1.2. DICCIONARIO DE LA BASE DE DATOS ..................................................................... 49

5.3.1.3. ONTOLOGÍA DE FUTBOL ............................................................................................ 51

5.3.2. FUNCIONAMIENTO DEL SISTEMA .................................................................................... 55

5.3.2.1. FUNCIONAMIENTO DEL MÓDULO DE IDENTIFICACIÓN Y EXTRACCIÓN DE

PALABRAS RELEVANTES ........................................................................................................ 55

5.3.2.2. FUNCIONAMIENTO DEL MÓDULO PARA MAPEAR LAS PALABRAS RELEVANTES

CON LA INFORMACIÓN DE LA ONTOLOGÍA ......................................................................... 56

5.3.2.3. FUNCIONAMIENTO DEL MÓDULO PARA CREAR INSTANCIAS Y RELACIONES .. 58

CAPÍTULO 6. PRUEBAS Y RESULTADOS ......................................................................................... 61

6.1. EVALUACIÓN ............................................................................................................................. 62

6.1.1. PRECISIÓN .......................................................................................................................... 62

6.1.2. RECALL ................................................................................................................................ 62

6.2. CASOS DE ESTUDIO ................................................................................................................. 62

6.2.1. CASO DE ESTUDIO 1: GAMECAST DE LA LIGA “ENGLISH LEAGUE ONE” .................. 63

6.2.2. CASO DE ESTUDIO 2: GAMECAST DE LA “LIGA MX” ..................................................... 66

6.2.3. CASO DE ESTUDIO 3: GAMECAST DE LA “FIFA CLUB WORLD CUP” .......................... 70

vii

6.3. CONCLUSIONES DE LAS PRUEBAS Y RESULTADOS OBTENIDOS ..................................... 74

CAPÍTULO 7. CONCLUSIONES Y TRABAJOS FUTUROS ................................................................ 76

7.1. CONCLUSIONES ........................................................................................................................ 77

7.2. CONTRIBUCIONES .................................................................................................................... 77

7.3. TRABAJOS FUTUROS ............................................................................................................... 78

ANEXOS ................................................................................................................................................ 79

ANEXO 1: INSTRUCCIONES PARA INSTANCIAS Y ASIGNAR ATRIBUTOS ................................ 79

ANEXO 2: INSTRUCCIONES PARA CREAR UNA RELACIÓN ........................................................ 81

ANEXO 3: DIAGRAMA DE CLASES .................................................................................................. 83

REFERENCIAS ...................................................................................................................................... 87

Índice de Tablas

TABLA 3.1: CUADRO COMPARATIVO DEL ESTADO DEL ARTE ............................................................ 24 TABLA 6.1: RESULTADOS DE LA EXTRACCIÓN DE LAS PALABRAS RELEVANTE CASO 1 .......... 63

TABLA 6.2: RESULTADO DE LAS INSTANCIAS Y RELACIONES DEL CASO 1 ................................... 63

TABLA 6.3: CÁLCULOS DE RECALL, PRECISIÓN Y TIEMPO DEL CASO 1 ......................................... 64

TABLA 6.4: RESULTADOS DE LA EXTRACCIÓN DE LAS PALABRAS RELEVANTE CASO 2 .......... 67

TABLA 6.5: CÁLCULO DE LAS INSTANCIAS DEL CASO 2 ....................................................................... 67

TABLA 6.6: CÁLCULOS DE RECALL, PRECISIÓN Y TIEMPO DEL CASO 2 ......................................... 68

TABLA 6.7: RESULTADOS DE LA EXTRACCIÓN DE LAS PALABRAS RELEVANTE CASO 3 .......... 71

TABLA 6.8: CÁLCULO DE LAS INSTANCIAS DEL CASO 3 ....................................................................... 71

TABLA 6. 9: CÁLCULOS DE RECALL, PRECISIÓN Y TIEMPO DEL CASO 3 ........................................ 72

TABLA 6.10: RESULTADOS DEL MÉTODO DE ANOTACIÓN SEMÁNTICA .......................................... 75

Índice de Figuras

FIGURA 3.1: ARQUITECTURA DEL MARCO DE ANOTACIÓN SEMÁNTICA Y RECUPERACIÓN

PERSONALIZADA DE VIDEOS DE DEPORTES (XU ET AL. 2008) .......................................................... 13 FIGURA 3.2: ARQUITECTURA DEL MÉTODO DE ANOTACIÓN SEMÁNTICA QUE USA CARACTERÍSTICAS VISUALES, DEL HABLA Y PATRONES FRECUENTES (TSENG ET AL. 2008)

................................................................................................................................................................................ 15 FIGURA 3.3: ARQUITECTURA DE EXTRACCIÓN DE METADATOS DE DOMINIO DE TEXTOS DEL FUTBOL (Z. ÖZKAN GOKTURK ET AL. 2008), (Z. Ö GOKTURK, CICEKLI, Y CICEKLI 2008). ........... 17 FIGURA 3.4: ARQUITECTURA DE BNOSA (RAJPUT Y HAIDER 2011B) ............................................... 19 FIGURA 3.5: ARQUITECTURA CERNO (KIYAVITSKAYA ET AL. 2009) .................................................. 20 FIGURA 3.6: ARQUITECTURA DE KIM (POPOV ET AL. 2003). ............................................................... 23 FIGURA 4.1: METODOLOGÍA DE SOLUCIÓN .............................................................................................. 28

FIGURA 4.2: MÓDULO DE IDENTIFICACIÓN Y EXTRACCIÓN DE PALABRAS RELEVANTES ........ 29

viii

FIGURA 4.3. MÓDULO PARA MAPEAR LAS PALABRAS RELEVANTES CON LA ONTOLOGÍA ...... 31

FIGURA 4.4: SUBCLASES “ACTION” Y “SACTION” .................................................................................... 32

FIGURA 4.5: SUBCLASES DE LA CLASE "PERSON" ................................................................................. 33

FIGURA 4.6: RESULTADO DEL FILTRADO DE LA PALABRA RELEVANTE ......................................... 35

FIGURA 4.7: MÓDULO DE CREACIÓN DE INSTANCIAS Y RELACIONES DE LA ONTOLOGÍA ....... 36

FIGURA 4.8: COMENTARIO ETIQUETADO CON STANFORD ................................................................. 36

FIGURA 4.9: COMENTARIO ETIQUETADO CON LAS REGLAS DE CLASIFICACIÓN ........................ 39

FIGURA 4.10: EJEMPLO DE UNA INSTANCIA DE JUGADOR .................................................................. 40

FIGURA 4.11: ESTRUCTURAS CON VERBO ............................................................................................... 42

FIGURA 4.12: ESTRUCTURA SIN VERBO .................................................................................................... 43

FIGURA 4.13: FRAGMENTO DE LA ONTOLOGÍA ....................................................................................... 43

FIGURA 5.1: INTERFAZ GRÁFICA .................................................................................................................. 48

FIGURA 5.2: FORMATO DEL GAMECAST .................................................................................................... 49

FIGURA 5.3: ARCHIVO DEL GAMECAST (FORMATO DE NOMBRE) ..................................................... 49

FIGURA 5.4: DISEÑO DE LA BASE DE DATOS ........................................................................................... 49

FIGURA 5.5: CLASES PRINCIPALES DE LA ONTOLOGÍA DE FUTBOL ................................................ 52

FIGURA 5.6: SUBCLASE DE OTHER PLAYER ACTION ............................................................................ 53

FIGURA 5.7: CLASE SANCTION ..................................................................................................................... 53

FIGURA 5.8: CLASE PLAYER .......................................................................................................................... 54

FIGURA 5.9: CLASE MINUTE ........................................................................................................................... 54

FIGURA 5.10. PATRÓN DE BÚSQUEDA ....................................................................................................... 55

FIGURA 5. 11: IDENTIFICACIÓN DE PALABRA RELEVANTES ............................................................... 56 FIGURA 6.1: INSTANCIA DE JUGADOR DEL PARTIDO “SWINDON TOWN VS YEOVIL TOWN” ..... 64 FIGURA 6.2: FRAGMENTO DEL OWL DEL PARTIDO “CRAWLEY TOWN VS WALSALL” .................. 65 FIGURA 6.3: FRAGMENTO DE ONTOLOGÍA (CLASE MIDFIELDER) ..................................................... 66 FIGURA 6.4: INSTANCIA SANCIÓN ................................................................................................................ 68 FIGURA 6.5: FRAGMENTO DE ONTOLOGÍA “PUMAS UNAM VS ATLANTE” ....................................... 69 FIGURA 6.6: FRAGMENTO DE ONTOLOGÍA (CLASE FORWARD) ......................................................... 70 FIGURA 6.7: INSTANCIA DE ACCIÓN ............................................................................................................ 72 FIGURA 6.8: FRAGMENTO DE ONTOLOGÍA DEL PARTIDO “INTERNACIONAL VS SEONGNAM

ILHWA” .................................................................................................................................................................. 73 FIGURA 6.9: FRAGMENTO DE ONTOLOGÍA (CLASE GOALKEEPER) .................................................. 74

Capítulo 1. Introducción

1

Capí tulo 1. Introduccio n

Este capítulo se describe el problema que motivó el desarrollo de la investigación, los objetivos del proyecto de investigación descrito y describe brevemente los principales puntos contenidos en esta tesis.


2

1.1. Planteamiento del problema

Hoy en día, existe una gran cantidad de información en la Web. Los usuarios buscan y accedan a la información disponible mediante buscadores, los cuales son herramientas que permiten localizar los recursos solicitados. Los buscadores basados sólo en palabras clave han comenzado a ser poco efectivos.

La efectividad de los buscadores puede mejorarse al incrementar la información que

describa el significado de los recursos que se encuentran en la Web, para permitir de esta forma que los datos sean más accesibles a los usuarios y agentes de software (Kiyavitskaya et al. 2009), es por ello, que actualmente han comenzado a surgir buscadores que intentar mejorar la precisión de las búsquedas dando semántica.

La anotación semántica permite agregar información a los recursos de la Web, para

favorecer y apoyar a las computadoras a interpretar la información. Esta anotación ayuda en la creación de repositorios, los cuales cuentan con metadatos que facilitan la búsqueda de estos recursos, debido a que permiten enriquecer la información y facilitan su procesamiento.

Generalmente la anotación semántica se realiza sobre texto, sin embargo se ha iniciado el

desarrollo de anotación semántica sobre recursos multimedia. La anotación semántica sobre recursos multimedia se ha incrementado por la cantidad de información o recursos multimedia disponibles en la Web. Algunos recursos multimedia que existen en la Web son las imágenes, el audio y el video.

La consultora global de medición digital ComScore Inc., realiza la medición de las

actividades globales de los videos en línea mediante su servicio comScore Video Metrix. El servicio de la consultora, calculó que 187 millones de estadounidenses vieron más de 48 mil millones de videos en línea, esto sólo en Julio del 2013 (Adamo 2013). Los datos obtenidos

de la consultora indican que la cantidad de videos disponibles en la Web es cada vez mayor. Los videos en la Web han aumentado porque son utilizados en diversas áreas como la

educación, los medios informativos, los deportes, el entretenimiento, etc. (Abburu y Anandhi 2010). Además, los videos permiten una forma de comunicación simple, fácil de entender e intuitiva para los usuarios y las organizaciones; es por ello, que el acceso y la búsqueda de videos a través de la Web crece rápidamente.

Generalmente, los videos no incluyen metadatos relacionadas a él o los metadatos que

existen son insuficientes para localizar los videos en forma precisa (Z. O. Gokturk, Cicekli, y Cicekli 2008). En el caso de los videos deportivos además de no contar con metadatos, tampoco cuentan con una descripción textual de los hechos más relevantes, es por ello, que al realizar búsquedas se tiene un gran gasto de tiempo, así como dificultad en el tratamiento (o procesamiento) del video. La anotación semántica en videos deportivos es muy lenta y costosa debido a que es de forma manual y se procesa una gran cantidad de información.


3

1.1.1. Solución propuesta

Con el fin de resolver los problemas que existen actualmente con la anotación semántica de recursos multimedia, en esta investigación de tesis se propone un método que permita hacer anotación semánticamente semiautomáticamente sobre recursos multimedia, específicamente sobre el gamecast de partidos de futbol.

El método de anotación semántica utiliza la narración textual del partido que tiene el

video. La descripción textual utilizada es el gamecast (reporte minuto a minuto de un partido), el cual se encuentra en el idioma inglés. El resultado de la anotación semántica son las instancias de una ontología de futbol.

1.2. Objetivos

1.2.1. Objetivo General

Desarrollar un sistema de anotación semántica de partidos de futbol, que tome como entrada la descripción textual (gamecast) de un partido y obtenga como resultado una ontología instanciada con los conceptos encontrados en el gamecast.

1.2.2. Objetivo específicos

Crear una ontología del dominio del futbol.

Extraer palabras relevantes en los comentarios del gamecast.

Definir las reglas de mapeo entre las palabras relevantes y la ontología.

Definir reglas para la creación de instancias y relaciones.

1.3. Estructura de la tesis

La tesis está conformada con la siguiente estructura organizacional:

Capítulo 2 Marco conceptual: En este capítulo se presentan los conceptos utilizados en la investigación.

Capítulo 3 Estado del arte: En este capítulo se presentan las herramientas que realizan anotación semántica. Las herramientas han sido divididas en anotación semántica de recursos multimedia y anotación semántica de textos o páginas Web.

Capítulo 4 Metodología de solución: En este capítulo se describe la metodología

para realizar la anotación semántica de videos deportivos.

Capítulo 5 Herramienta: En este capítulo se muestra el sistema de software de anotación semántica.


4

Capítulo 6 Pruebas y resultados: En este capítulo se presentan los resultados obtenidos de las pruebas con el sistema realizado.

Capítulo 7 Conclusiones: En este capítulo se muestran las conclusiones obtenidas a partir de la Investigación realizada para este proyecto.

Capítulo 2. Marco Teórico

5

Capí tulo 2. Marco Teo rico

En este capítulo se presentan los conceptos que se han sido utilizados en este trabajo de investigación.


6

2.1. Ontologías

El término “ontología”, se toma de la filosofía como “una teoría sobre la naturaleza de la existencia". Este término fue adquirido por el área de Inteligencia Artificia para definir un documento o archivo que define formalmente las relaciones entre los términos (Berners-Lee, Hendler, y Lassila 2001), (Gruber 1993a), (Gruber 1993b).

El término ontología ha recibido diferentes definiciones, una de las más aceptadas por

muchos investigadores establece que una ontología es “una especificación explícita de una conceptualización”, en esta definición la conceptualización es una interpretación simplificada del mundo que queremos representar para algún propósito (Gruber 1993a), (Gruber 1993b).

La definición de Gruber, tuvo una pequeña modificación, la cual establece que ontología

es “una especificación explicita y formal de una conceptualización compartida”, esta definición se refiere a que debe haber un acuerdo sobre la conceptualización que se especifica (Borst 1997). A esta última definición se le ha proporcionado un significado, se dice que la ontología es una especificación explicita debido a que los conceptos, las relaciones, las funciones y axiomas se definen explícitamente; que es formal porque es procesable por una máquina; que es compartida porque es un conocimiento consensuado, es decir, un grupo de expertos determina un conocimiento con base en un acuerdo, y que es conceptualizada debido que es un modelo abstracto de un fenómeno del mundo (Studer, Benjamins, y Fensel 1998).

Las ontologías sirven para representar el conocimiento, esta representación la realizan

mediante una taxonomía y un conjunto de reglas de inferencia. La taxonomía define clases de objetos y de relaciones entre ellos. Las reglas de inferencia por su parte ofrecen la posibilidad de que una ontología pueda expresar condiciones.

2.1.1. Componentes de una ontología

Una ontología está formada por los siguientes cinco elementos (Gómez-Pérez, Fernández-López, y Corcho 2008), (Gruber 1993b):

Conceptos: Son términos técnicos, definiciones de entidades, ideas formalizadas, clases de objetos, métodos, planes, etc.; los cuales se organizan en taxonomías.

Relaciones: Son los enlace entre dos conceptos del dominio, los cuales representan la interacción entre conceptos. Ejemplo: Subclase-de, Conectado a, Parte-de.

Funciones: Son un tipo especial de relaciones donde se identifica un elemento mediante el cálculo de una función.

Axiomas: Son sentencias que siempre son verdaderas y que deben cumplir los elementos de la ontología.

Instancias: Se usan para representar objetos determinados de un concepto.


7

2.1.2. Ontología de dominio

Las “ontologías de dominio” son aquellas ontologías que se encargan de describir un vocabulario relacionado con un dominio especializado (un área o tema determinado) como medicina o automovilismo, futbol, etc.(Guarino 1998).

2.1.3. Lenguajes para ontologías

Algunos lenguajes para ontologías son: RDF y OWL.

2.1.3.1. Marco de Descripción de Recursos

El Marco de Descripción de Recursos (RDF1 por sus siglas en inglés) es un lenguaje para representar metadatos sobre los recursos en la Web, el cual fue desarrollado por el World Wide Web Consortium (W3C).

Este lenguaje tiene características que facilitan la combinación de datos incluso si los

esquemas son diferentes; es por ello, que el RDF también puede utilizarse como un modelo estándar para el intercambio de datos en la Web.

El RDF utiliza los “identificadores uniformes de recursos” o URI para identificar y nombrar

los recursos, así como la relación entre ellos, esto permite crear tripletas, las cuales son notaciones o declaraciones simples, que están formadas de un sujeto (recurso), un objeto (valor) y un predicado (también llamado “propiedad”, que indica una relación).

Las tripletas permiten que los datos se puedan mezclar y compartir a través de las

diferentes aplicaciones (RDF Working Group 2004).

2.1.3.2. Lenguaje de Ontologías Web

Lenguaje de Ontologías Web (OWL2 por sus siglas en inglés) es un lenguaje de marcado

semántica para compartir y publicar en la Web. OWL se desarrolla como un vocabulario que

se extiende de RDF y se deriva de DAML3+ OIL4, los cuales son un lenguaje de marcado

semántico para recursos Web. Este lenguaje se usa para representar el significado de los

términos de un vocabulario y las relaciones entre los términos.

OWL proporciona tres sublenguajes, cada uno es una extensión de su predecesor más simple. Los sublenguajes de OWL son (Bechhofer et al. 2004):

1 Resource Description Framework

2 Web Ontology Language

3 DARPA Agent Markup Language

4 Ontology Inference Layer or Ontology Interchange Language


8

OWL Lite proporciona una clasificación jerárquica y restricciones simples, así como una ruta de migración rápida para tesauros (es la lista de palabras o términos empleados para representar conceptos) y otras taxonomías(es la categorización o clasificación de cosas basado en un sistema predeterminado).

OWL DL recibe su nombre debido a la Lógica de Descripción (DL por sus siglas en inglés), la cual estudia la lógica que compone la base formal del OWL. El OWL DL tiene la máxima expresividad para el usuario conservando la completitud computacional (proporciona soluciones computacionales) y las cuales se obtiene en un tiempo finito. Además, incluye todas las construcciones del lenguaje de OWL bajo ciertas restricciones.

OWL Full permite la máxima expresividad de los usuarios y libertad sintáctica del RDF sin garantías computacionales, por ejemplo: una clase puede ser tratada al mismo tiempo como una colección de individuos y como persona por derecho propio. El OWL Full permite a una ontología aumentar el sentido de lo pre-definido (RDF u OWL).

2.2. Web Semántica

La Web Semántica no es una Web independiente, sino una extensión de la actual, donde la información tiene un significado bien definido, el cual permite que los equipos y personas puedan trabajar en cooperación (Berners-Lee, Hendler, y Lassila 2001).

La Web Semántica se refiere a la Web que está dotada de mayor significado, es decir,

una mayor semántica que permite que los usuarios encuentren respuestas de forma más rápida y sencilla al realizar búsquedas. También permitir que las máquinas puedan entender el significado de la información (W3C 2013), (semanticWeb.org 2012).

2.3. Anotación semántica

“Una anotación puede considerarse como la información sobre las entidades o conceptos de una ontología que aparecen en un texto, también las referencias que hay en un texto sobre un repositorio semántico” (Kiryakov et al. 2004a).

La anotación semántica proporciona información adicional (metadatos) a los datos

existentes, por lo tanto, enriquece los datos. Además, ayuda a reducir la ambigüedad del lenguaje para encontrar información relevante y precisa («Semantic Annotation | Ontotext» 2013).

La anotación semántica incluye tres componentes, los cuales son (Embley et al. 2006):

Una ontología que describe el dominio de interés.

Un proceso de reconocimiento de instancias de datos, este proceso descubre todas las instancias que son interesantes en los documentos Web basado en la ontología definida.


9

Un proceso de generación de anotación, este proceso crea un archivo descrito con contenido semántico para cada de documento anotado.

2.3.1. Tipos de anotaciones semánticas

La anotación semántica puede clasificarse de tres formas; de acuerdo al lugar donde se almacena, al grado de automatización y por estrategia.

La clasificación de acuerdo al lugar donde se almacenan la anotación semántica, se

divide en (Navarro-Galindo y Samos 2011):

Internas o de autor: Son las anotaciones que se guardan en el mismo documento Web donde se realizaron.

Externas: son las anotaciones que se guardan en ficheros o servidores distintos del documento Web que se analizó.

La clasificación de acuerdo al nivel de automatización, se divide en:

Directa o Manual: El usuario realiza las anotaciones en un contenido mediante el

uso de herramientas específicas.

Automática: Es un proceso automático que genera las anotaciones, identificando

entidades semánticas y sus relaciones.

La clasificación de acuerdo al nivel de estrategia de la anotación semántica, se divide en

(Reeve y Han 2005):

Estrategia basada en patrones: Esta estrategia utiliza patrones para encontrar las entidades que existen en un texto o un corpus. Los patrones pueden definirse manualmente o descubrirse (patrones que ya existen).

Estrategia basados en aprendizaje automático: Esta categoría se divide en dos métodos los cuales son:

o Probabilístico: Utilizar modelos estadísticos para predecir las entidades (palabras o frases) dentro del texto en relación a una ontología.

o Inducción: Utilizan la estructura lingüística de los textos para obtener patrones que reconozcan entidades.


10

2.4. Metadatos

El término “metadato” según Howe (1993), fue acuñado por Jack Myers en la década de los 60 para describir conjuntos de datos. La primera acepción que se le dio (y actualmente la más extendida) fue la de “dato sobre el dato”, ya que proporcionaban la información mínima necesaria para identificar un recurso (Senso y de la Rosa Piñero 2003).

Berners-Lee define que “los metadatos son información de la máquina comprensible

sobre los recursos Web u otras cosas”. Además, indica que los metadatos en la actualidad sigue siendo sobre todo, información sobre recursos en la red.

Para Berners-Lee en la red hay tres formas en las que se obtiene los metadatos, las

cuales son (Berners-Lee 2009):

Cuando un metadato están en un documento (contenido o dentro del propio documento) de procesador de textos.

Durante la transferencia http; es cuando un servidor y un cliente envían metadatos sobre un objeto que están transmitiendo.

Cuando un metadato se busca en otro documento.

Los metadatos se usan comúnmente para describir el contenido de la página Web y suelen incluirse en la página como etiquetas (TechTerms 2012). Además, los metadatos están estructurados por elementos tales como: título, autor, fecha de creación, etc. (INEGI 2003).

2.5. Repositorios Audiovisuales

La Real Academia Española (RAE) define el término repositorio como “un lugar donde se guarda algo” y el término “audiovisual” se refiere a las grabaciones acústicas acompañadas de imágenes ópticas («Real Academia Española» 2013). Por lo tanto, el concepto de “repositorios audiovisuales” pueden definirse como archivos o sitios donde se almacena y mantiene información audiovisual como es el caso de los videos.

Capítulo 3: Estado del arte

11

Capí tulo 3. Estado del

Arte En este capítulo se presentan las herramientas que realizan anotación semántica.


12

3.1. Clasificación del estado del arte

En esta investigación las herramientas presentadas realizan anotación semántica de forma semiautomáticamente utilizando diversas técnicas, métodos, algoritmos, etc. Las herramientas se dividen en:

1) Anotación semántica de recursos multimedia.

2) Anotación semántica de textos o páginas Web.

A continuación presentamos los trabajos recopilados para cada una de las categorías de

la clasificación de esta investigación.

3.2. Frameworks para anotación semántica de recursos multimedia

Los frameworks para anotación semántica de recursos multimedia son aquellos que realizan anotación semántica en videos, imágenes y archivos de audio.

El Framework de anotación semántica de vídeo de deportes y recuperación personalizada

y el Método de anotación semántica que usa características visuales, características del habla y patrones frecuentes utilizan las características audiovisuales para realizar la anotación semántica; y Event Description Framework utiliza una ontología para realizar la anotación semántica.

3.2.1. Framework de anotación semántica de vídeo de deportes y recuperación personalizada (Xu et al. 2008)

A) Descripción general

El framework propuesto permite realizar anotación semántica en videos de deportes; toma como entrada las características audio/visuales, así como el análisis del texto del contenido, y como resultado crea resúmenes personalizados en relación con los video.

B) Funcionamiento

El framework utiliza el texto y las características del video para detectar y delimitar eventos o acontecimientos importantes del video. La anotación semántica se realiza con los eventos detectados, además, genera el corpus del evento del video. El framework busca palabras clave en el corpus de texto para generar un resumen.

C) Arquitectura

El framework de anotación semántica cuenta con las siguientes fases:


13

Análisis de Texto: Se utiliza para la detección de eventos, para identificar las palabras clave y detectar la información relacionada con el evento, tales como la hora del evento.

Análisis del Vídeo: Se obtienen los acontecimientos importantes del juego resaltando los sucesos en la emisión del video deportivo.

Texto / Alineación de vídeo: Se realiza la detección del evento en el tiempo exacto cuando ocurrió y se realiza la detección de límites de eventos.

Indexación y anotación de video: El texto está vinculado a los eventos relacionados con el vídeo.

Análisis de consultas: Utiliza el método de reconocimiento de nombre para extraer las palabras clave que infieren las intenciones de los usuarios.

Resumen y recuperación de texto: Las palabras claves se utilizan para recuper los eventos relacionados en el corpus del texto.

Resumen de vídeo: Cada resumen indica el inicio y el número del evento relacionado con el video y se crea sobre la base de la síntesis de texto generado (ver Figura 3.1).

Figura 3.1: Arquitectura del marco de anotación semántica y recuperación personalizada de videos de deportes

(Xu et al. 2008)


14

3.2.2. Método de anotación semántica que usa características visuales, características del habla y patrones frecuentes (Tseng et al. 2008)


El framework realiza anotación semántica de videos mediante un método hibrido, el cual utiliza patrones de frecuencia entre un conjunto de reglas de modelos así como un conjunto de predicciones. Toma como entrada las características visuales y las características del habla de un video, el resultado es el video anotado.

B) Funcionamiento

El video se divide en disparos para extraer sus características, y el audio de cada fragmento del video es transformado a texto para encontrar palabras clave. La anotación del video se realiza utilizando las reglas de coincidencia para buscar las palabras clave asociadas.

C) Arquitectura

La arquitectura del framework propuesto tiene las siguientes fases:

Pre-procesamiento visual: Divide el video en disparos, cada uno está dividido en rectángulos de una región del modelo. La textura homogénea y la escala de colores se extraen para un disparo del segmento y las regiones del segmento.

Pre-procesamiento del habla: El reconocimiento automático del habla (ASR5) se usa para la transformación de las características de audio a texto para cada escena. Se utiliza el JwordNet6 para filtrar palabras clave.

Fase de entrenamiento: Genera cuatro tipos de modelos para las anotaciones de video los cuales son:

o ModelCRM (Modelo de relevancia continua), determina las palabras clave adecuadas en función a la probabilidad generada.

o ModelVasso (Modelo de asociación visual), asociación de reglas con las escenas sin tener en cuenta la continuidad temporal.

o ModelVseq (Modelo de secuencia visual), hace descubrimiento continuo y

temporal de patrones de frecuencia dentro de una escena.

o ModelSasso (Modelo de asociación de voz), realiza asociaciones especiales de reglas dentro de una escena.

5 Automatic Speech Recognition

6 Es un API para acceder WordNet en múltiples formatos, así como la relación de descubrimiento y procesamiento

morfológico.


15

Fase de predicción: crea una predicción del modelo de fusión para integra los diferentes puntos de vista de los cuatro modelos y las reglas de asociación (ver Figura 3.2).

Figura 3.2: Arquitectura del método de anotación semántica que usa características visuales, del habla y patrones

frecuentes (Tseng et al. 2008)

3.2.3. Event Description Framework (EDF) (Natarajan y Nevatia 2005)

A) Descripción General

EDF es la propuesta de un framework para capturar la semántica de los eventos. El EDF permite el almacenamiento, la inferencia y la recuperación de eventos. Toma como entrada un conjunto de clases de datos multimedia y da como resultado un evento semántico.

B) Funcionamiento

La clase de datos multimedia (videos) se dividen en clase entidad y clase acción, cada clase describe sus propiedades o características y establece un orden para la información de las clases. La ontología describe los rasgos semánticos del vídeo por lo cual utiliza inferencias para encontrar la relación entre la entidad y el evento.

C) Arquitectura

La arquitectura de EDF se divide en tres secciones:

Características semánticas básicas: son las descripciones de los datos multimedia y se dividen en tres principales características semánticas que son:


16

o Entidades: Son objetos que pertenecen a un dominio específico. o Acciones: Son las acciones que se toman en el dominio. o Eventos: los eventos se dividen en eventos primitivos los cuales son las

tuplas (actor, acción); y en evento compuesto los cuales son los argumentos específicos definidos que se usan para el predicado del proceso (conjunto de eventos que suceden uno detrás de otro temporalmente que no tiene relación particular temporal entre ellos).

Ontología que describe la relación espacio-temporal: describe la relación temporal -espacial (intervalo de tiempo, la translación, rotación, escala, arriba, abajo y distancia) de un evento-entidad (Cho et al. 2005).

Esquema de razonamiento: permite inferir en los eventos compuestos y las relaciones de los eventos primitivos.

3.3. Frameworks para anotación semántica de texto o páginas Web

Los frameworks para anotación semántica de texto o páginas Web realizan la anotación con información que está dentro de la página o en el texto.

En la Extracción de metadatos de dominio de textos del futbol utiliza algoritmos para

realizar la anotación semántica; y en los frameworks Bayesian Network and Ontology based Semantic Annotation, Cerno, Ontology based Text Annotation y Knowledge and Information Management utilizan una ontología o esquema de anotación para realizar la anotación semántica.

3.3.1. Extracción de metadatos de dominio de textos del futbol (Z. ÖZKAN Gokturk et al. 2008)


Es un sistema que anota automáticamente videos de partidos de futbol, toma como entrada los reportes de futbol descritos en HTML que están en una página Web y da como resultado archivos de video.

B) Funcionamiento

El sistema descarga los reportes de los partidos de los sitios de la UEFA y analiza los documentos. Los reportes se etiquetan para obtener un documento XML. Al documento en XML se le aplica un algoritmo de extracción de la información y reglas establecidas manualmente para obtener eventos. El evento se extrae en otro archivo XML, el cual se convierte en un archivo MPEG-7 y el corpus de los partidos se genera.

Se usa XQuery para buscar los archivos MPEG-7 y se usa la biblioteca XQEngine como

motor de búsqueda de textos para documentos XML.


17

C) Arquitectura

El sistema está formado por los siguientes módulos (Z. Ö Gokturk, Cicekli, y Cicekli 2008):

Crawler Web: Descarga los reportes de los partidos minuto a minuto de la página Web oficial de la UEFA.

EntityExtractor: Realiza el etiquetado de las frases predefinidas de acuerdo con las expresiones regulares.

EventExtractor: Utiliza los reportes de los partidos etiquetados para la extracción de los acontecimientos.

WhiskAlgorithm: Crea reglas de casos etiquetados y estas reglas pueden ser utilizadas para la extracción del evento.

Generador de MPEG-7: Extrae los eventos, hace consultas a los metadatos y sincroniza el contenido audiovisual (AV) para crea los archivos MPEG-7.

Módulo de interfaz de usuario: Proporciona a los usuarios un medio para la búsqueda de eventos si hay un archivo de vídeo asociado a este (ver Figura 3.3).

Figura 3.3: Arquitectura de extracción de metadatos de dominio de textos del futbol (Z. ÖZKAN Gokturk et al.

2008), (Z. Ö Gokturk, Cicekli, y Cicekli 2008).


18

3.3.2. Bayesian Network and Ontology based Semantic Annotation (BNOSA) (Rajput y Haider 2011b)


BNOSA es un framework que realiza anotación semántica en páginas Web y utiliza reglas, redes bayesianas e información de una ontología, para extraer información sobre datos no estructurados y no gramaticales con el objetivo de crear una página Web anotada semánticamente.

B) Funcionamiento

Se crea la ontología con la información importante del dominio y se definen los patrones de extracción. La información de la página Web se extrae de acuerdo a las reglas e información de la ontología. Si no se encuentra la información en la ontología se predice mediante las redes bayesianas. Los datos de la página que fueron extraídos o calculados se anexan a la ontología y se realiza la anotación semántica.

C) Arquitectura

El proceso de anotación semántica realizada por BNOSA, se compone de los siguientes tres pasos:

Desarrollo de las ontologías para la representación del conocimiento y el aprendizaje de la red bayesiana. La ontología almacena las propiedades de los datos de las clases, las características del dominio especificado, define los patrones de extracción y ubica los datos de la página. El aprendizaje de redes bayesianas hace un previo tratamiento de datos donde elimina los registros incompletos y aprende sobre las relaciones entre atributos, de esta forma permite predecir los valores faltantes y/o resolver los conflictos de los valores que se extraen de varios atributos de la ontología (Rajput y Haider 2011a).

Extracción de información con la ayuda de la ontología y la red bayesiana: Se divide en:

o Fase I: la extracción a través de la ontología: Utiliza la información

relevante en un corpus, para generar reglas que permitan que los datos extraídos se asignen al atributo correspondiente.

o Fase II: predicción de falta de valor y la resolución de conflictos

mediante redes bayesianas. Si en la fase-I tiene un valor o ningún valor asignado a un atributo se predicen los valores faltantes para resolver conflictos (Rajput y Haider 2011b).

Etiquetado semántica de la información extraída utilizando tecnologías de Web semántica (OWL / RDF): El framework rellena la ontología con los datos extraídos, utilizando lenguaje OWL o RDF (ver Figura 3.4).


19

Figura 3.4: Arquitectura de BNOSA (Rajput y Haider 2011b)

3.3.3. Cerno (Kiyavitskaya et al. 2009)


Cerno es un framework que realiza anotación semántica de documentos de textos de dominio general. Cerno toma como entrada un documento de texto y utiliza reglas gramaticales para obtener un documento en XML y una base de datos relacional poblada.

B) Funcionamiento

Cerno tiene un motor para separar las palabras del texto. Las palabras del texto forman un árbol según la gramática definida. Las palabras que forma el árbol son anotadas de acuerdo al vocabulario del dominio y la lista de conceptos. Las palabras anotadas se colocan en una plantilla y se guardan en una base de datos.

C) Arquitectura

El framework Cerno consta de tres fases (Kiyavitskaya et al. 2009), (Kiyavitskaya et al. 2007), (Kiyavitskaya et al. 2006).

Analizar: El motor TXL automáticamente tokeniza y analiza la entrada con la gramática especificada para producir el árbol de análisis.

Marcado: Se realiza la anotación de las unidades de texto de acuerdo con un esquema de anotación, además, cuenta con una lista de conceptos y el vocabulario de dominio (los indicadores sintácticos relacionados con cada concepto). Si uno de los indicadores de la lista está en fragmento del texto, el fragmento de texto se marca con el nombre de una etiqueta.


20

Mapeo: Se selecciona las unidades de texto anotadas de acuerdo a una plantilla de la base de datos del esquema predefinido (ver Figura 3.5).

Figura 3.5: Arquitectura Cerno (Kiyavitskaya et al. 2009)

3.3.4. Ontology based Text Annotation (ONTEA) (Laclavík et al. 2009)

A) Descripción General

Ontea es una framework que utiliza modelos semánticos (ontología de dominio)(Laclavík, Seleng, y Babík 2007), patrones, así como una ontología de dominio específico en RDF/OWL para extraer pares de palabras (“clave-valor”) del texto. También busca o crea instancias de la ontología de los pares clave-valor en instancias de la ontología.

B) Funcionamiento

Ontea analiza el texto con patrones y detecta equivalentes semánticos de acuerdo con la ontología de dominio definido, obtiene un conjunto de instancias descubiertas. Si existe una instancia correspondiente, de acuerdo a las propiedades del patrón, se añade a un conjunto de instancias encontradas en la ontología. Si no se encuentra la instancia que coincida con las propiedades del patrón se crea el tipo de clase que contiene la propiedad. El proceso se repite con todas las expresiones regulares para obtener un conjunto de instancias que tienen todas las propiedades posibles de la clase (Laclavík, Seleng, y Babík 2007).

C) Arquitectura

La arquitectura de Ontea permite la construcción y amplía las transformaciones de la cadena par clave-valor de la extracción del texto. Los elementos fundamentales de la arquitectura de Ontea son la siguientes interfaces en Java y extensiones e implementaciones de objetos:


21

Ontea.core.Pattern: Interfaz que permite la búsqueda de diferentes patrones y se usa para la integración de técnicas de anotación semántica existentes.

Ontea.core.Result: Es una clase que representa lo anotación resultante y define el significado individual del concepto o del tipo.

Ontea.transform.ResultTransformer: Es una interfaz contiene diferentes tipos de transformaciones en la anotación resultante.

Herramientas externas que se integran a Ontea: Son herramientas que se integran mediante la transformación de resultados y otras necesidades.

o MapReduce: Realiza la extracción de la información y la anotación basado en

patrones. o Identificación de idiomas: Permite identificar el idioma de uso de las

expresiones regulares u otros modelos. o Lematización: Extra texto que representa a un individuo y se crea su

instancia. o Identificación relevante: Crea o encuentra una nueva instancia. o Transformación de instancias a OWL: Transforma los pares clave-valor en

RDF o instancias OWL. o Conectores de integración: Las transformaciones de los pares clave-valor se

enriquecen por datos externos y se utilizan para crear instancias de ontologías o la búsqueda de las mismas.

3.3.5. Knowledge and Information Management (KIM) (Popov et al. 2003)


KIM es una plataforma que utiliza procesamiento de lenguaje natural, para administrar la infraestructura de la información y del conocimiento, de los servicios de anotación semántica automática, del indexado y de la recuperación de documentos.

B) Funcionamiento

La plataforma KIM realiza la extracción de información basado en una ontología y una base de conocimiento. La información extraída por KIM son los nombres de las entidades, como: los nombres de las personas, las organizaciones, los lugares, etc. Los nombres de las entidades son los conceptos de los documentos. Los conceptos de los documentos se identifican y se extraen de acuerdo de los documentos. La anotación semántica se realiza con los conceptos del documento, la base de conocimiento y la ontología de KIMO. Los documentos anotados se almacena y cuando el usuario realiza una búsqueda utiliza las herramientas que le dan acceso y muestra la información anotada semánticamente.


22

C) Arquitectura

La plataforma consta de:

Servidor KIM (con API de acceso remoto, la incrustación y la integración), proporciona funcionalidad e infraestructura de anotación semántica, indexación, recuperación, administración y navegación de una base de conocimientos.

API de anotación semántica, realizar anotación semántica con respecto a la base de conocimientos y la ontología. Proporciona la infraestructura para la gestión de contenido y anotación.

API de persistencia de documentos, almacena los documentos y las anotaciones asociadas.

API de índice, permitir la indexación con respecto a entidades con nombre, está basado en el motor Lucene.

API de consulta, permite la búsquedas de palabras clave (simples y compuestas), de patrones de entidad y combinando la entidad.

API repositorio semántica, permitiendo el acceso y guarda la base de conocimientos y la ontología KIM, incluyendo RDF, repositorios, y la ontología middleware:

o Ontología KIM (KIMO), es una ontología simple de dominio general, la cual tiene definiciones de conceptos.

o Base de conocimientos (KB), tiene diferentes palabras, definiciones y

significados de entidades con sus clases y alias; ayuda para extraer anotación semántica de forma automática (Kiryakov et al. 2004a).

Entidad de ranking, detectar el nivel de "popularidad" de las entidades específicas de la base de conocimientos KIM.

Encargado de la extracción de la información (IE), se basa en el framework GATE, reconoce las entidades nombradas con respecto a la ontología KIM.

Herramientas Enfrente –atrás, son herramientas que proporcionan acceso a la funcionalidad e infraestructura de la API del servidor KIM.

Interfaz de usuario Web KIM, permite búsqueda de palabras clave, métodos de acceso (búsqueda de entidades semánticas y patrones), indexar y almacenar contenido semánticamente anotado.


23

Plug-in para Internet Explorer entrega anotaciones semánticas para el usuario final. Muestra la jerarquía de tipos de entidad (una rama de la ontología KIM) (ver Figura 3.6).

Figura 3.6: Arquitectura de KIM (Popov et al. 2003).

3.4. Conclusiones del estudio del estado del arte

En esta investigación se realizó el análisis correspondiente de los frameworks para la utilización de la anotación semántica de forma automática y semiautomática.

Los frameworks tiene diversas estrategias para realizar la anotación semántica como: el

uso de patrones, redes bayesianas, procesamiento de lenguaje natural, etc. Además, se puede distinguir que algunos utilizan ontologías para realizar la anotación o etiquetado semántico.

El uso de las ontologías en los frameworks permite que se pueda tener definidos

conceptos, términos, clases, relaciones y atributos de un dominio para identificar información relevante de los textos.

En los frameworks que se analizaron se realizan anotación sobre texto y sobre medios

multimedia como los videos. Los frameworks de anotación semántica sobre recursos multimedia que se analizaron se enfocan en la detección de eventos, y utiliza características visuales y/o audio para realizar la anotación.


24

En la Tabla 3.1 se muestra un cuadro comparativo de las herramientas presentadas.

Tabla 3.1: Cuadro comparativo del estado del arte

Anotación semántica de recursos multimedia

Nombre de la herramienta

Dominio de la Ontología

Lenguaje de la Ontología

Métodos de la herramienta

Descripción General

Framework de anotación semántica de videos deportivos y recuperación personalizada

------

------

*Análisis de texto *Técnica de concordancia de palabras *Modelos ocultos de Markov

Es un framework que realiza anotación semántica semiautomática en videos de deportes, toma como entrada las características audio/visual del video e incorpora el análisis textual que se encuentra en el contenido del video, y como resultado crear un resumen personalizado en relación con el video.

Método de anotación semántica que integra características visuales, del habla y patrones frecuentes

------ ------

*Uso de modelos *Reconocimiento automático del habla (ASR) *Patrones de frecuencia *Conjunto de predicciones.

Es un framework que realizar anotación semántica automática en videos; toma como entrada las características visuales y del habla del video y como resultado da un video anotado.

EDF(Event Description Framework)

Dominio especifico

XML *Lógica de primer orden

Es la propuesta de un framework que captura la semántica de eventos semiautomáticamente, permite el almacenamiento, la inferencia y la recuperación de eventos. Toma como entrada un conjunto de clases de datos multimedia y da como resultado un evento semántico.

Anotación semántica de texto o páginas Web

Extracción de metadatos de dominio de textos del futbol

------

------

*Reglas manuales *Algoritmos de Wisk

Es un sistema que anota automáticamente videos de partidos de futbol, utiliza como entrada los reportes de futbol descritos en HTML que están en una página Web, los transforma y da como resultado archivos de video que se encuentra en un archivo MPEG-7.

BNOSA (Bayesian Network and Ontology based Semantic Annotation)

Específico y definido por el usuario

OWL / RDF

*Aprendizaje de Redes bayesianas *Reglas predefinidas y patrones

Es un framework que realiza anotación semántica semiautomática en páginas Web, extrae información sobre datos no estructurados y no gramaticales; usa la ontología de dominio específico así como una red bayesiana para extraer la información y da como resultado una página Web anotada semánticamente.


25

Cerno General y

definido por el usuario

XML

*Gramáticas libres de contexto *Análisis de texto y heurísticas.

Es un framework que realiza anotación semántica semiautomática, que toma como entrada un documento de texto, en él definen palabras clave y reglas gramaticales basadas en la identificación de instancias de conceptos de texto; también realiza búsqueda de palabras simples para anotar fragmentos de texto importante y usa un conjunto de reglas construidas para guiar el proceso de anotación. El resultado es el documento XML del texto y el poblado de la base de datos relacional.

Ontea Definida por el usuario.

RDF/ OWL *Reglas de patrones

Ontea es una herramienta que realiza anotación semántica semiautomática, que trabaja sobre texto y un modelo de ontología de dominio en RDF/OWL la cual utiliza patrones para identificar las relaciones semánticas de los elementos del texto acorde a los modelos semánticos (ontología). El resultado es una ontología poblada.

KIM (Knowledge and Information Management)

General y predefinida

RDF *Procesamiento de lenguaje natural

Es una plataforma que utiliza procesamiento de lenguaje natural, para la administración de la infraestructura de la información y del conocimiento, así como servicios de anotación semántica automática, indexado y recuperación de documentos.

Capítulo 4: Metodología de solución

26

Capí tulo 4. Metodologí a de solucio n

En este capítulo se describe la metodología de solución para realizar la anotación semántica de videos deportivos, que tienen una descripción textual, la descripción utilizada es el gamecast (reporte minuto a minuto) de un partido de futbol en idioma inglés.


27

4.1. Descripción general del método de anotación semántica de videos deportivos.

El método de anotación semántica (Figura 4.1) está conformado por tres módulos, los cuales son:

Identificación y extracción de palabras relevantes: Este módulo contiene el archivo de texto donde se almacena el gamecast de un partido de futbol, el cual se procesa mediante patrones. Los patrones permiten encontrar y extraer las palabras relevantes como: los nombre de los jugadores, las acciones que se realizan, las sanciones que se indican y los nombres de los equipos.

Mapeo de las palabras relevantes con la ontología de futbol: En este módulo las palabras relevantes se mapean con la ontología de futbol para identificar la clase a la que pertenecen; una vez que se tiene la clase a la que pertenecen, la palabra relevante se clasifica y se extrae su información de Wikipedia la cual se almacena en la base de datos.

Creación de las instancias de la ontología: En este módulo el archivo de texto donde se almacena el gamecast se procesa mediante técnicas de lenguaje natural y reglas de clasificación, con el objetivo de agrupar y marcar las posibles instancias de la ontología. Las palabras que son instancias candidatas se buscan en la base de datos, si las palabras se encuentran almacenadas se recupera la clase a la que pertenecen, así como el resto de su información para crea la instancia. Las relaciones para las instancias se crean, utilizando las reglas para la relación. El resultado de este módulo es el archivo OWL, el cual contiene la anotación semántica del gamecast de un partido de futbol en forma de tripletas.


28

Figura 4.1: Metodología de solución


29

4.2. Módulo 1: Identificación y extracción de palabras relevantes

El propósito de este módulo es obtener las palabras simples y compuestas relevantes del

dominio que se encuentran en el gamecast para determinar las palabras relevantes como

los jugadores, sanciones, y acciones que se realizan en el partido de futbol analizado. En la

Figura 4.2 se muestra el funcionamiento de este módulo.

Figura 4.2: Módulo de identificación y extracción de palabras relevantes

4.2.1. Identificación de palabras relevantes en el gamecast

La identificación de palabras relevantes en el gamecast permite que se obtengan las

palabras simples y compuestas importantes del dominio. Las palabras relevantes son

aquellas palabras que pertenecen al dominio del futbol como son los nombres de los

equipos, los nombres de los jugadores, las sanciones y las acciones que realizan los

jugadores.

Las acciones y sanciones de los comentarios se identifican mediante la información de

una ontología de futbol. La ontología de futbol contiene un total de 25 atributos, 37 relaciones

y 198 clases. La ontología contiene clases como “person” (persona) en la cual se tiene al

“referee” (árbitro), “trainer” (entrenador), “linesman” (juez de línea) y “player ”( jugadores); en

esta última se encuentran las posiciones de los jugadores de futbol soccer “goalkeeper”

(portero), “defender” (defensa), “forward” (delantero), “midfielder” (mediocampista), etc.).

También se tiene la clase “action” (acción) en la cual se encuentran las clases “action

referee” (acciones del árbitro), “action linesman” (acción del juez de línea) y las “other action

player” (acciones de los jugadores), en esta clase se localizan las principales acciones que

se pueden llevar a cabo en un partido de futbol (“throw-in” (saque), “substitute” (sustituir),

“tackle” (atacar), ”foul” (falta), ”free direct” (tiro libre), etc.). También se incluye la clase

sanción “sanction”, así como las clases “minute” (minuto), “team” (equipo), “tournament”

(torneo), “league” (liga) y “match” (partido).


30

Por ejemplo, en siguiente comentario:

“Jose Baxter takes a direct freekick with his right foot from his own half. Outcome: open play.”

Se identifican dos palabras relevantes, la primera palabra relevante es direct freekick (tiro libre directo) es una subclase de la clase “kick” (tiro), la clase “kick” (tiro) pertenece a la clase “Other_player_action” (otras acciones del jugador) que se encuentra en la ontología de futbol. La segunda palabra relevante es Jose Baxter, el cual es un jugador de futbol, y además, ocupa la posición de Attacking Midfielder (centrocampista), Attacking Midfielder (centrocampista) es una subclase de “Midfielder” (mediocampista), la cual pertenece a la clase “player” (jugador).

La identificación de las palabras relevantes del gamecast de un partido de futbol se realiza a partir de definir patrones; los patrones ayudan a indicar las características o datos de las palabras que se desean localizar.

4.2.2. Extracción de palabras relevantes en el gamecast

Las palabras relevantes extraídas del gamecast se mapean en la ontología de dominio,

esto permite realizar las instancias de la ontología.

La identificación y extracción de las palabras relevantes se realiza a través de patrones que permiten realizar búsquedas sobre cadenas de caracteres, para obtener información concreta del gamecast del partido.

Por ejemplo, en el siguiente comentario:

“Substitution, Barcelona. Maxwell replaces Eric Abidal”.

Las palabras en negritas son las palabras que identifican el evento que se realiza (cambio

de jugador). Las palabras en cursiva son aquellas palabras que se buscan para ser extraídas

(son las palabras relevantes que espera obtener el sistema).

En el comentario anterior las palabras relevantes son los jugadores que entran y salen del

campo de juego; es por ello que, si se desea localizar qué jugadores entraron y salieron del

equipo de Barcelona, se utiliza la siguiente sintaxis:

“Substitution, Barcelona. (.*) replaces (.*)”.

La sintaxis general para obtener los nombres de los jugadores que entraron y salieron de

un partido, se representa de la siguiente manera:

“Substitution\\,nombre_del_equipo\\. (.*) replaces (.*).\\”


31

4.3. Módulo 2: Mapear las palabras relevantes con la información de la ontología

El propósito de este módulo es mapear la palabra relevante con la ontología para identificar las clases de la ontología a las que pertenecen las palabras relevantes, así como obtener la información (atributos) de las palabras claves.

En la Figura 4.3 se muestra el funcionamiento de este módulo, el cual utiliza Jena, el API de google, el API de Json, el API de mysql, el API de Jsoup y patrones.

Figura 4.3. Módulo para mapear las palabras relevantes con la ontología

4.3.1. Identificar la clase de la ontología a la que pertenece la palabra relevante

El primer paso para identificar la clase de las palabras relevantes es conocer si la palabra está registrada en la tabla “palabras_relevantes” de la base de datos.

Cuando las palabras relevantes estén registradas se revisa si la información de la base de

datos es reciente, si la información de la palabra relevante no es reciente se actualiza. Si las palabras relevantes no están registradas en la tabla “palabras_relevantes” de la base de datos se extrae la información de Wikipedia y se guarda en la base de datos junto con la clase a la que pertenece.

La primera identificación de las clases de la ontología es la de los equipos. Los nombres

de los equipos se obtienen del nombre del gamecast. Cuando se lee el archivo que contiene al gamecast, se obtienen los nombres de los equipos por medio de un patrón, el cual solicita las palabras que están separadas por un guión (“-“). Ejemplo, los archivos que contiene al gamecast se guardan con el siguiente formato “Cruz Azul-Monterrey-10112012”; la primera palabra (Cruz Azul) es el primer equipo del partido, la segunda palabra (Monterrey) es el segundo equipo del partido y por último (10112012) es la fecha en la que se realizó el partido.


32

Las dos primeras palabras son los nombres de los equipos, los cuales se guardan en la

tabla “palabras_relevantes” de la base de datos especificando que pertenece a la clase team (equipo).

Los nombres de los equipos forman el nombre del partido en el que participan, mediante

un patrón se extrae el nombre del árbitro y la hora en la que inicio el partido, estos datos se guardan en la tabla “partido” de la base de datos, junto con la fecha en que se realizó.

La identificación de las clases de las palabras relevante inicia generando una lista de

todas las acciones y sanciones contenidas en la ontología de futbol. Para generar la lista de las acciones y sanciones se crean un modelo OWL, el modelo creado se llena con la información la ontología (archivo .owl), esto permite que se pueda abrir y leer el contenido de la ontología de futbol, en el modelo OWL se busca y se recuperan las subclases que pertenecen a las clases “action” (acción) y “saction” (sanción). Las clases recuperadas se guardan en una lista a la que llamaremos “acción-sanción”, la cual se compara con cada una de las palabras relevantes. En la Figura 4.4 se muestra un fragmento de las clases “action” (acción) y “saction” (sanción) recuperadas del modelo OWL.

Figura 4.4: Subclases “action” y “saction”

Si la palabra relevante coincide con alguna de las clases de la lista acción-sanción la

palabra se identifica como una acción o sanción y se almacena en la tabla “palabras_relevantes” de la base de datos con el nombre de clase a la que pertenece. Por ejemplo: si la palabra relevante es “Corner kick” la clase a la que pertenece es “corner_kick”.

Si la palabra relevante no coincide con alguna de las clases de la lista acción-sanción se

busca si tiene un sinónimo. El sinónimo de las palabras relevantes se busca en un diccionario, el cual contiene las palabras que pertenecen al dominio del futbol. Por ejemplo, “spot-kick” es igual que "penalty_kick".

Cuando se encuentra una palabra sinónima de la palabra relevante en el diccionario, la

palabra sinónima se compara con la lista acción-sanción. Si la palabra sinónima coincide con alguna de las clases de esta lista acción-sanción, la palabra se identifica como una acción o sanción, y se almacena en la tabla “palabras_relevantes” de la base de datos con el nombre de clase a la que pertenece.

Cuando la palabra relevante no tiene un sinónimo entonces la palabra relevante se

identifica como un jugador.


33

La palabra relevante identificada como jugador se busca en google. El resultado de la

búsqueda en google son las páginas Web relacionadas con la palabra relevante, de la cual se selecciona la página Web de Wikipedia que corresponde a la palabra relevante. Una vez seleccionada la página Web se busca la posición que tiene el jugador.

Si se localiza la posición del jugador, esta es la palabra que se mapea con la información de la ontología para localizar la clase a la que pertenece la palabra relevante. Si no se localiza la posición del jugador se busca nuevamente en google la palabra relevante especificando que se trata del dominio del futbol. El resultado de la búsqueda en google son las páginas Web relacionadas con la palabra relevante, de la cual se selecciona la página Web de Wikipedia que corresponde a la palabra relevante. Una vez seleccionada la página Web se busca la posición que tiene el jugador.

Cuando no se localiza una página Web de Wikipedia de la palabra relevante o no se

localiza la posición que tiene el jugador, la palabra relevante se almacena en la tabla “palabras_relevantes” de la base de datos como person (persona).

La identificación de la clase a la que pertenece un jugador requiere de la lista de las

posiciones de juego de un jugador. Para generar la lista de las posiciones de juego de un jugador se crean un modelo OWL, el modelo OWL creado se llena con la información de la ontología (archivo .owl), en el modelo OWL se busca y se recuperan las subclases que pertenecen a las clase “person” (persona). Las clases recuperadas se guardan en una lista a la que llamaremos “posiciones”, la cual se compara con cada las palabras relevantes identificadas como jugador. En la Figura 4.5 se muestra un fragmento de la clase “person” (persona).

Figura 4.5: Subclases de la clase "person"

Si la posición del jugador coincide con alguna de las clases de la lista “posiciones”, se

almacena en la tabla “palabras_relevantes” de la base de datos con el nombre de clase a la que pertenece. Por ejemplo: si la posición del jugador es “Left back” la clase a la que pertenece es “left_back”.

Cuando la palabra relevante no coincide con alguna de las clases de la lista “posiciones”

se busca si tiene un sinónimo. El sinónimo de las palabras relevantes se busca en un diccionario, el cual contiene las palabras que pertenecen al dominio del futbol. Por ejemplo “strike” es igual que "forward".


34

Cuando se encuentra una palabra sinónima de la posición del jugador en el diccionario, la palabra sinónima se compara con la lista “posiciones”. Si la palabra sinónima coincide con alguna de las clases de la lista “posiciones”, se almacena en la tabla “palabras_relevantes” de la base de datos con el nombre de clase a la que pertenece.

Si la plabra relevante no tiene un sinónimo de la posición del jugador entonces la palabra

relevante se almacena en la tabla “palabras_relevantes” de la base de datos como “player” (jugador).

4.3.2. Extracción de la información de Wikipedia de las palabras relevantes

La extracción de la información de Wikipedia tiene como objetivo obtener información adicional de las palabras relevantes para que se pueda agregar a las instancias en la anotación semántica.

Para obtener la información de las palabras relevantes en Wikipedia se utiliza patrones, el

API de google, el API de JSON y el API de Jsoup. El primer paso para extraer la información de las palabras relevantes es verificar si se

encuentran registradas en la base de datos. Cuando la palabra relevante está registrada en la base de datos, se recupera la clase a la

que pertenece. Si la clase de la palabra relevante pertenece a una subclase de la clase person (persona) o es de la clase team (equipo), se extrae la fecha de la última modificación tanto de la base de datos, como de la página Web. Si la fecha de la página Web es mayor que la base de datos, se actualiza la información de la palabra relevante; si la fecha de la base de datos es igual que la de la página Web se conserva la información.

Cuando la palabra no esté en la base de datos se extrae su información de Wikipedia. Si la palabra relevante se clasifica como equipo, entonces se realiza la conexión con la

página Web de Wikipedia que corresponde a la palabra relevante. Un conjunto de patrones definidos se aplican a la página Web, los cuales permiten

obtener el nombre completo del equipo, los apodos del equipo, fecha de fundación del equipo, estadio del equipo, la liga a que pertenece, el nombre del presidente del equipo, nombre del entrenador del equipo y la última fecha de modificación .

Los datos del equipo que se extraen de Wikipedia se almacenan en la tabla

“atributos_equipos” de la base de datos. Si la palabra relevante se ha identificado como una acción o sanción, la palabra relevante

se busca en un glosario de términos de futbol de Wikipedia (http://en.wikipedia.org/wiki/Glossary_of_association_football_terms).

Se realiza la conexión con el glosario de términos de futbol mediante el API de Jsoup; se

usa la siguiente sintaxis para hacer la conexión:


35

Document doc = Jsoup.connect(url1).get(); Una vez establecida la conexión se realiza un filtro específico del elemento seleccionado

(palabra relevante), se utiliza la siguiente sintaxis.

Elements etiqueta_palabraRelevante = doc.select("li:contains(shoot)"); El filtro permite buscar y recuperar la información que contiene la palabra relevante, esta

puede ser solo el texto (información sin etiquetas html) o en formato html. En la Figura 4.6 se muestra el resultado en texto obtenido del filtrado de una palabra relevante

Figura 4.6: Resultado del filtrado de la palabra relevante

El resultado del filtrado se pasa por un patrón el cual extrae la etiqueta limpia que tiene la

palabra relevante al inicio. El resultado del patrón es las palabras relevantes extraídas, la cual tiene la sintaxis que se muestra a continuación (inciso 1):

1) Palabra relevante: significado de la palabra

Cuando no se obtenga ningún resultado, al buscar la palabra relevante en la página Web, se busca la palabra sinónima de la palabra relevante y se busca nuevamente en el glosario de términos.

El significado de las sanciones y acciones que se extraen del glosario de términos de

futbol de Wikipedia se almacenan en la tabla “atributo_acciones_sanciones” de la base de datos.

Si la palabra relevante se clasifica como jugador, entonces se realiza la conexión con la

página Web de Wikipedia que corresponde a la palabra relevante. Un conjunto de patrones definidos se aplican a la página Web, los cuales permiten

obtener el nombre completo del jugador, su fecha de nacimiento, su estatura, su número, el equipo actual en el que juega, lugar de origen del jugador, equipos anteriores donde jugaba, la posición del jugador y la última fecha de modificación.

En las páginas de Wikipedia, en idioma inglés, no contienen los apodos de los jugadores,

es por ello que se recurre a buscar únicamente los apodos de los jugadores en la página de Wikipedia en idioma español que corresponde a la palabra relevante. Si la palabra relevante tiene una página de Wikipedia en idioma español, se utiliza un patrón definido para obtener los apodos del jugador.

La información del jugador que se extrae de Wikipedia se almacena en la tabla

“atributo_persona” de la base de datos.


36

4.4. Módulo 3: Creación de instancias y relaciones de la ontología

El propósito de este módulo es crear las instancias de la ontología y las relaciones entre ellas, para realizar la anotación semántica. En la Figura 4.7 se muestra el funcionamiento de este módulo, el cual funciona de la siguiente forma:

.

Figura 4.7: Módulo de creación de instancias y relaciones de la ontología

4.4.1. Etiquetado del gamecast

El etiquetado del gamecast permite que se puedan marcar las posibles instancias de la ontología, para realizar el etiquetado se utiliza el API de stanford-postagger y un conjunto de reglas de clasificación.

El etiquetado comienza al aplicar el API de stanford-postagger en al archivo que contiene

gamecast del partido de futbol, el gamecast etiquetado se guarda en un archivo de texto con el nombre de “etiquetado”.

En la Figura 4.8 se muestra un ejemplo de los comentarios etiquetados con el API de

Stanford, los cuales se almacenan en el archivo “etiquetado.

Figura 4.8: Comentario etiquetado con stanford

La información del archivo “etiquetado” se almacena en una estructura de datos y se le asigna un identificador a cada uno de los comentarios.


37

El comentario se divide en palabras para ser procesadas por las reglas de clasificación. Las palabras se seccionan en dos partes la primera es la palabra y la segunda es la abreviatura que indica que tipo de palabra es: verbo, sustantivo, etc.

Las reglas de clasificación permiten agrupar e identificar las instancias candidatas, las

reglas de clasificación son:

Si la primera etiqueta es un número (CD) entonces la palabra se etiqueta como minuto. Ejemplo <min>90</min>

Si la etiqueta actual es un número (CD) y etiqueta anterior es diferente de número (CD) y no este vacío entonces la palabra se etiqueta como número. Ejemplo <numero>2</numero>

Si la etiqueta actual es un nombre propio (NNP) y la etiqueta anterior es un nombre propio (NNP) entonces la palabra se etiqueta como Persona o equipo. Ejemplo <PerEq>Sam Mantom<PerEq>

Si la etiqueta actual es un nombre propio (NNP), la etiqueta anterior es un nombre propio (NNP) y la etiqueta auxiliar es un nombre propio (NNP), entonces la palabra se etiqueta como Persona o equipo. Ejemplo <PerEq>Jesus Manuel Corona<PerEq>

Si la etiqueta actual es un nombre propio (NNP) y la etiqueta anterior es diferente de un nombre propio (NNP) y no es vacío, entonces la palabra se etiqueta como acción. Ejemplo <Ac>corner</Ac>

Si la etiqueta actual es un sustantivo (NN) y la etiqueta anterior es diferente de un sustantivo (NN) y no es vacía, entonces la palabra se etiqueta como acción. Ejemplo <Ac>corner kick</Ac>

Si la etiqueta actual es un sustantivo (NN) y la etiqueta anterior es un sustantivo (NN), entonces la palabra se etiqueta como acción. Ejemplo <Ac>corner kick</Ac>

Si la etiqueta actual es un sustantivo (NN) y la etiqueta anterior es un adjetivo (JJ), entonces la palabra se etiqueta como acción. Ejemplo <Ac>yellow card</Ac>

Si la etiqueta actual es un adjetivo (JJ) y la etiqueta anterior no es un adjetivo (JJ) y no es vacía, entonces la palabra se etiqueta como acción o un adjetivo. Ejemplo <AcAd>red</AcAd>

Si la etiqueta actual es un verbo en presente (VBZ) y la etiqueta anterior no es un verbo en presente (VBZ) y no es vacía, entonces la palabra se etiqueta como acción o un adjetivo. Ejemplo <Verbo> takes</Verbo>

Si la etiqueta actual es un verbo en presente (VBZ) y la etiqueta auxiliar no es un verbo en presente (VBZ) y no es vacía, entonces la palabra se etiqueta como verbo. Ejemplo <Verbo> takes</Verbo>


38

Si la etiqueta actual es un verbo en presente (VBZ) y la etiqueta anterior es un verbo en presente (VBZ) y no es vacía, entonces la palabra se etiqueta como verbo. Ejemplo <Verbo> takes</Verbo>

Si la etiqueta actual es un verbo en infinitivo (VBN), la etiqueta anterior es un verbo en infinitivo (VBN) y la etiqueta auxiliar es verbo en presente (VBZ, entonces la palabra se etiqueta como verbo. Ejemplo <Verbo>is have take</Verbo>

Si la etiqueta actual es un verbo en infinitivo (VBN) y la etiqueta anterior es un verbo en presente (VBZ) y no es vacía, entonces la palabra se etiqueta como verbo. Ejemplo <Verbo>is save</Verbo>

Si la etiqueta actual es un pronombre personal (PRP) y la etiqueta anterior no es un pronombre personal (PRP) y no es vacía, entonces la palabra se etiqueta como pronombre personal. Ejemplo <PronPer> you </PronPer>

Si la etiqueta actual es un pronombre posesivo (PRP$) y la etiqueta anterior no es un pronombre posesivo (PRP$) y no es vacía, entonces la palabra se etiqueta como pronombre posesivo. Ejemplo < PronPos >his < /PronPos>

Si la etiqueta actual es un determinante (DT) y la etiqueta anterior no es un determinante (DT) y no es vacía, entonces la palabra se etiqueta como artículo. Ejemplo < Art >the< / Art>

Si la etiqueta actual es un preposicion (IN) y la etiqueta anterior no es un preposicion (IN) y no es vacía, entonces la palabra se etiqueta como artículo. Ejemplo < Prep >on< / Prep >

Si la etiqueta actual son dos puntos (:) y la etiqueta anterior no son dos puntos (:) y no es vacía, entonces la palabra se etiqueta como signos de puntuación. Ejemplo <SigPunt>:</SigPunt>

Si la etiqueta actual son un puntos (.) y la etiqueta anterior no un puntos (.) y no es vacía, entonces la palabra se etiqueta como signos de puntuación. Ejemplo <SigPunt>.</SigPunt>

Si la etiqueta actual es coma (,) y la etiqueta anterior no es coma (,) y no es vacía, entonces la palabra se etiqueta como signos de puntuación. Ejemplo <SigPunt>,</SigPunt>

Si la etiqueta actual es apostrofe (‘) y la etiqueta anterior no es apostrofe (‘) y no es vacía, entonces la palabra se etiqueta como signos de puntuación. Ejemplo <SigPunt>’</SigPunt>


39

En el momento en que las palabras del comentario se procesan con las reglas de clasificación las etiquetas del API de Stanford desaparecen. Las palabras del comentario tienen las nuevas etiquetas. En la Figura 4.9 se muestra un ejemplo de un comentario etiquetado con las reglas de clasificación.

Figura 4.9: Comentario etiquetado con las reglas de clasificación

4.4.2. Creación de instancias de la ontología

La primera instancia que se crea es la del partido. La instancia partido se realiza a partir del nombre del gamecast. Cuando se lee el archivo que contiene al gamecast, se obtienen los nombres de los equipos y la fecha en que se realizó el partido.

Los nombres de los equipos y la fecha se unen para formar el identificador de la instancia

de la clase match. Por ejemplo: si el nombre del gamecast es “Cruz Azul-Monterrey-10112012”, el identificador de la instancia de la clase match es “Cruz_Azul_vs_Monterrey_10112012”.

El nombre del partido se busca en la base de datos y se recupera su información. El

nombre del árbitro, la hora de inicio del partido y la fecha en la que se realizó el partido de futbol son atributos de la instancia.

Los nombres de los equipos que se obtuvieron del gamecast se utilizan para crear sus

respectivas instancias. El nombre del equipo se busca en la base de datos y se recupera su información (nombre completo, fecha de fundación, apodos, nombre del presidente del equipo, liga, nombre del entrenador del equipo y campo del equipo), los cuales serán los atributos de la instancia. Además, se crea el identificador de cada equipo, el cual tiene el nombre del equipo y la fecha en la que se realizó el partido. Ejemplo: si el equipo es Cruz Azul, y el partido se llevó a cabo el 10 de noviembre del 2012, entonces el identificador es “Cruz Azul _10112012”.

Las instancias de minuto, jugador, persona, acción, sanción, juez de línea, árbitro, torneo,

liga y entrenador se realizan con la información de los comentarios. Se toma el número de la línea del comentario del gamecast para recuperar el comentario etiquetado con las reglas de clasificación.

Las palabras de un comentario se someten a un patrón el cual permite extraer la palabra

sin los marcadores. Si el marcador o etiqueta es “min” se crea un instancia minuto. Si el número del minuto es

mayor que 90 la instancia se crea en la clase “minute_extra; si el número es menor que 90 la instancia se crea en la clase que corresponde al minuto del comentario.

La instancia de minuto crea su identificador de la siguiente manera: "minute_número del

minuto_número del comentario_fecha del partido” Por ejemplo; minute_86_4_08102013.


40

También se crean los atributos de la instancia, el cuales es: el comentario de gamecast, y se conserva el identificador de la instancia minuto.

Las instancias de jugador, personas, acciones, sanciones, árbitro, juez de línea y

entrenador se crean de acuerdo a la información de la base de datos. Las palabras marcadas o etiquetadas se buscan en la base de datos, una vez localizadas se recupera la clase a la que pertenecen.

Si la clase de las palabras del comentario pertenece a la clase “person” (persona), se crea

el identificador de la instancia de la siguiente manera: nombre de la persona_fecha del partido. Ejemplo: Suk_Jang_18122010 y se crea la instancia. Además se crea sus atributos.

Si la clase de la palabra del comentario pertenece a una subclase de player (jugador), se

recupera la información de la palabra del comentario, es decir, se recupera el nombre completo del jugador, la fecha de nacimiento del jugador, estatura del jugador, número del jugador, equipo actual en el que juega, lugar de origen del jugador, equipos anteriores donde jugaba el jugador, la posición del jugador y apodos del jugador. Además, se crea el identificador de la instancia de la siguiente manera: nombre de la persona_fecha del partido. Ejemplo: Alecsandro_18122010, y se crea la instancia. La clase de la instancia es la posición en la que juega el jugador.

En la Figura 4.10 se muestra un ejemplo de una instancia de jugador creada.

Figura 4.10: Ejemplo de una instancia de jugador

Si la clase de la palabra del comentario pertenece a una subclase de action (acción) y

sanction (sanción) se recupera de la información de la palabra del comentario, es decir, se

recupera el significado de la palabra relevante. Además, se crea el identificador de la

instancia de la siguiente manera: nombre de la acción o sanción_fecha del partido. Ejemplo:

red_card_18122010, y se crea la instancia. La clase de la instancia es la acción o sanción

que realiza el jugador.


41

Si la clase de la palabra del comentario pertenece a trainer (entrenador), referee (árbitro)

y linesman (juez de línea), se recupera la información de la palabra del comentario de la

base de datos, es decir, se recupera el nombre completo, la fecha de nacimiento, estatura y

el lugar de origen. La instancia se crea y tiene como identificador el nombre seguido de la

fecha del partido, por ejemplo: Michael_Hester_18122010.

Los identificadores de las instancias se conservan para crear las relaciones.

4.4.3. Creación de las relaciones de la ontología

Las relaciones de las instancias se crean mediante las reglas para la relación. Las reglas para la relación son un conjunto de reglas definidas, las cuales utilizan la estructura del cometario para crear las relaciones.

Los comentarios del gamecast tienen dos estructuras; la primera estructura es aquella en

la cual el cometario tiene un verbo que une a las instancias y la segunda estructura es aquella que tiene dos instancias sin una palabra que las relaciones.

Las reglas de la relación tiene la primera estructuras son:

Si el comentario tiene un jugador, un verbo (commits, concedes, crosses, curls, do, drills, executes, hits, make y takes) y una acción, entonces la relación es el verbo

Si el comentario tiene una acción, un jugador y un verbo (commits, concedes, crosses, curls, do, drills, executes, hits, makes y takes), entonces la relación es el verbo.

Si el comentario tiene un equipo, un verbo (makes) y una acción, entonces la relación es el verbo.

Si el comentario tiene un jugador, un verbo (enters) y un jugador, entonces la relación es el verbo.

Si el comentario tiene un jugador, un verbo (is awarded y has been shown) y una sanción, entonces la relación es el verbo.

Si el comentario tiene una acción, un verbo (performed) y un equipo, entonces la relación es el verbo

Si el comentario tiene un jugador, un verbo (scores) y un equipo, entonces la relación es el verbo

Si el comentario tiene un jugador, un verbo diferente de “enters" y un jugador, entonces la relación es el verbo “enters"

Si el comentario tiene una acción, un verbo diferente de “performed" y un jugador, entonces la relación es el verbo “performed"


42

Si el comentario tiene un jugador, un verbo (diferente de is awarded o has been shown) y una sanción, entonces la relación es “is awarded”.

Cuando en un comentario se tiene la primera estructura (Figura 4.11), la relación será el

verbo de las instancias creadas.

Figura 4.11: Estructuras con verbo

Las reglas de la relación tiene la segunda estructuras son:

Si el comentario tiene un equipo y un partido entonces la relación es “involved”

Si el comentario tiene un minuto y un jugador entonces la relación es “effect”

Si el comentario tiene un minuto y un equipo entonces la relación es “effect”

Si el comentario tiene un minuto y una acción entonces la relación es “occurs”

Si el comentario tiene un jugador y un equipo entonces la relación es “part_of”

Si el comentario tiene un equipo y un jugador entonces la relación es “are_formed”

Si el comentario tiene un minuto y un partido entonces la relación es “belongs”

Si el comentario tiene un acción y un equipo entonces la relación es “do”

Si el comentario tiene un jugador y un partido entonces la relación es “match_play”

Si el comentario tiene una acción y un acción entonces la relación es "performed"

Si el comentario tiene un jugador y al entrenador entonces la relación es “are_directed”

Si el comentario tiene al árbitro y al partido entonces la relación es “are_raffled”

Si el comentario tiene un equipo y al portero entonces la relación es “assigned”

Si el comentario tiene un equipo y un torneo o una liga entonces la relación es “compete”

Si el comentario tiene un equipo y al entrenador entonces la relación es “has”

Si el comentario tiene una acción y un jugador entonces la relación es “performed”


43

Cuando el comentario tenga la segunda estructura (Figura 4.12), la relación será la que tenga asignada de acuerdo con las reglas para la relación.

Figura 4.12: Estructura sin verbo

En la Figura 4.13 se presenta un fragmento de lo ontología de futbol, en la cual se

muestran las instancias y las relaciones que se crearon

Figura 4.13: Fragmento de la ontología

Capítulo 5. Herramienta

44

Capí tulo 5. Herramienta

En este capítulo se muestra el sistema de anotación semántica desarrollado, el cual es la implementación del método creado en esta investigación.


45

5.1. Herramientas utilizadas para implementar el método de anotación semántica

En esta sección se hace una breve descripción de las herramientas utilizadas para el desarrollo y funcionamiento del sistema de anotación semántica.

5.1.1. Patrones en java

Un patrón describe a una cadena de caracteres. A los patrones se les denominan expresiones regulares («Tutoriales gratis - Java - Expresiones regulares» 2013).

Las expresiones regulares se utilizan para realizar búsquedas sobre cadenas de

caracteres, que pueden seleccionar la parte que nos interesa de un texto, de una página Web, o de cualquier otra cosa que represente una cadena (string) (Hopcroft, Motwani, y Ulman 2007), («Expresiones regulares para buscar texto» 2013), (Linsley 2013).

5.1.2. Netbeans IDE 7.0.1

Netbeans es un entorno de desarrollo libre para el lenguaje de programación Java. Netbeans es capaz de integrar la escritura, compilación, depuración y ejecución de programas, y está hecho para el lenguaje de programación Java. («NetBeans IDE - Overview» 2013).

5.1.3. JDK 1.7

Java Development Kit (JDK) es un software que provee herramientas de desarrollo para la creación de programas en Java. JDK incluye un Java Runtime Environment (JRE) completa y herramientas para desarrollar, depurar y monitorear aplicaciones Java. («Java SE Downloads» 2013), («Desarrollo de programas Java con JDK» 2013).

5.1.4. Apache Jena

Apache Jena es un framework Java para crear aplicaciones de Web Semántica, ésta proporciona un conjunto de herramientas y bibliotecas de Java para ayudar a desarrollar la Web semántica y enlazada de datos de aplicaciones, herramientas y servidores.

El Marco de Jena incluye («Apache Jena - Apache Jena» 2013):

Una API para leer, procesar y escribir RDF de datos en XML, N-triples y formatos de tortuga.

Una API para el manejo de la ontología OWL y ontologías RDFS.

Un motor de inferencia basado en reglas para el razonamiento con RDF y OWL fuentes de datos.


46

Un componente para el almacenamiento de RDF y consulta, el componente se llama TDB.

Un motor de consulta compatible con la última especificación SPARQL.

Servidores para permitir que los datos RDF puedan ser publicados en otras aplicaciones que usen una variedad de protocolos, incluyendo SPARQL.

5.1.5. MySQL

MySQL es un sistema de gestión de bases de datos relacional, multihilo y multiusuario de código abierto basado en SQL, éste cuenta con un servidor de base de datos que es muy rápido, fiable, escalable y fácil de usar.(«MySQL :: MySQL 5.1 Reference Manual :: 1.3.1 What is MySQL?» 2013).

MySQL proporciona controladores basados en estándares para JDBC y ODBC, para crear

aplicaciones de bases de datos, en el idioma de su elección(«MySQL :: The world’s most popular open source database» 2013).

5.1.6. JDBC

JDBC (Java Database Connectivity) es una interfaz que permite a un programa java ejecutar instrucciones SQL dentro de bases de datos relacionales(«JDBC.pdf - JDBC.pdf» 2013).

El conector que se utiliza en el sistema es “mysql-connector-java- 5.0.4” es un

controlador Java nativo que convierte JDBC, pone en el protocolo de red utilizado por la base de datos MySQL(«MySQL :: Using MySQL With Java» 2013).

5.1.7. Protégé

Protégé es un editor de ontologías (a través de un cliente Web o un cliente de escritorio), así como un marco de conocimientos libre y de código abierto.

La plataforma Protégé modela y desarrolla Ontologías en una variedad de formatos,

incluyendo OWL, RDF (S), y el esquema XML. Además, Protégé está basado en Java, es extensible, y proporciona un entorno de plug-and-play que hace que sea una base flexible para la creación rápida de prototipos y desarrollo de aplicaciones(«The Protégé Ontology Editor and Knowledge Acquisition System» 2013).

5.1.8. API de Google

Son los métodos que Google ofrece a los desarrolladores para que puedan hacer peticiones a Google, desde sus propias aplicaciones. Se pueden desarrollar tanto aplicaciones en entorno Web, como en aplicaciones de escritorio («Google API» 2013), («google.dirson.com - google API APIs» 2013),(«google-API-java-client - Google APIs Client Library for Java - Google Project Hosting» 2013).


47

5.1.9. JSON

JSON (JavaScript Object Notation o Notación de Objetos de JavaScript) es un formato ligero de intercambio de datos. Está basado en un subconjunto del Lenguaje de Programación JavaScript. JSON está constituido por dos estructuras («JSON» 2013):

Una colección de pares de nombre/valor. En varios lenguajes esto se conoce como un objeto, registro, estructura, diccionario, tabla hash, lista de claves o un arreglo asociativo.

Una lista ordenada de valores. En la mayoría de los lenguajes, esto se implementa como arreglo, vectore, lista o secuencia.

5.1.10. Jsoup

Jsoup es una biblioteca Java para trabajar con el HTML en el mundo real, la cual proporciona una API para la extracción y manipulación de datos. Jsoup puede:

Limpiar y analizar el código HTML en una URL, archivo o cadena.

Buscar y extraer datos, usando DOM Traversal o selectores CSS.

Manipular los elementos atributos y texto HTML.

Limpia el contenido enviado por los usuarios sobre una lista blanca segura, para evitar ataques XSS.

Salida HTML tidy

5.1.11. Stanford-postagger

A Tagger Parte-Of-Speech (POS Tagger) es una pieza de software que lee el texto en un idioma y asigna partes de la oración para cada palabra (y otros token), como sustantivo, verbo, adjetivo, etc.(«The Stanford NLP (Natural Language Processing) Group» 2013).

5.2. Interfaz Gráfica

El sistema de anotación semántica cuenta con una interfaz sencilla de utilizar, la cual tiene tres botones y un cuadro de texto.

El botón “Examinar”: es el botón que permite navegar entre las carpetas y los archivos que contiene el gamecast.

El botón “Leer Archivos”: es el botón que permite leer el archivo que contiene el gamecast, además extrae las palabras relevantes y recupera su información de Wikipedia; y mapea las palabras relevantes con la ontología de futbol.


48

El botón “Crear Instancias”: es el botón que permite realizar las instancias y las relaciones de la ontología para la anotación semántica.

El cuadro de texto “Ruta de archivo”: es un cuadro de texto en el cual se muestra la dirección donde se localiza el archivo que contiene el gamecast.

En la Figura 5.1 se muestra la interfaz del sistema.

Figura 5.1: Interfaz gráfica

5.3. Funcionamiento

El sistema de anotación semántica requiere de algunos prerrequisitos, para iniciar si funcionamiento, y para crear las instancias de la ontología.

5.3.1. Prerrequisito del sistema

Los prerrequisitos son las condiciones o parámetros que se tienen que tener para la realización del funcionamiento del sistema.

5.3.1.1 Archivo que contiene el gamecast

El sistema de anotación semántica toma como entrada un archivo de texto plano (txt), el cual debe contener la información del gamecast (reporte minuto a minuto de un partido de futbol).


49

El archivo que contiene el gamecast debe tener el siguiente formato (Figura 5.2) y se

debe guardar en una carpeta que indique a que liga o torneo pertenece.

Figura 5.2: Formato del gamecast

El nombre del archivo (Figura 5.3) está formado por los nombres de los equipos que participaron y la fecha en la que se realizó el partido. La fecha del partido tiene un formato de 8 dígitos, los dos primeros dígitos representan el día, los otros dos dígitos que siguen representa al mes y los últimos 4 dígitos representan el año. Ejemplo: Crawley Town-Walsall-17112012.

Figura 5.3: Archivo del gamecast (formato de nombre)

5.3.1.2. Diccionario de la base de datos

El sistema de anotación semántica utiliza una base de datos llamada “datospalrelevantes” (Figura 5.4), en la cual se almacena la información de las palabras relevantes que encuentra en el gamecast, a continuación se presenta el diccionario de la base de datos.

Figura 5.4: Diseño de la base de datos


50

partido

Nombre de la columna

Tipo Comentario

idpartido INTEGER Llave primaria(NOT NULL, AUTO_INCREMENT)

nombrepartido VARCHAR(100) Nombre del partido (NOT NULL)

fechapartido VARCHAR(45) Fecha de realización del partido

horainicio VARCHAR(25) Hora de inicio del partido

Horafin VARCHAR(25) Hora de en qué finaliza el partido

palabras_relevantes


Tipo Comentario

palabraclave VARCHAR(100) Nombre de la palabra relevante (NOT NULL)

clasepalabra VARCHAR(45) Clase de la ontología a la que pertenece la palabra clave (NOT NULL)

enlaces


Tipo Comentario


enlaces VARCHAR(200) URL de la palabra clave (NOT NULL)

Atributos_equipos


Tipo Comentario

idequipo INTEGER Llave primaria(NOT NULL, AUTO_INCREMENT)

palabraclave VARCHAR(100) Nombre de los equipo (NOT NULL)

nombreEquipo VARCHAR(200) Nombre completo de los equipo

apodosEquipo VARCHAR(700) Apodos de los equipos

FundacionEquipo VARCHAR(300) Fecha de fundación del equipo

campoEquipo VARCHAR(200) Campo o estadio del equipo

PresidenteE VARCHAR(100) Nombre del presidente del equipo

DirectorE VARCHAR(100) Nombre director técnico del equipo

LigaEquipo VARCHAR(45) Nombre de la liga en la que participa el equipo

fechaModE VARCHAR(45) Fecha de la última actualización de la página Web

atributo_acciones_sanciones


Tipo Comentario


significado VARCHAR(500) Descripción o significado de la acción o sanción

fechaModA VARCHAR(45) Fecha de la última actualización de la página Web


51

atributo_persona


Tipo Comentario

idJug INTEGER Llave primaria(NOT NULL, AUTO_INCREMENT)

palabraclave VARCHAR(200) Nombre simple de la persona (NOT NULL)

nombrecompleto VARCHAR(200) Nombre completo de la persona

fechacumple VARCHAR(45) Fecha de nacimiento de la persona

lugarorigen VARCHAR(100) Lugar de origen de la persona

posicion VARCHAR(100) Posición que tiene la persona

estatura VARCHAR(20) Estatura de la persona

Equipo VARCHAR(100) Nombre del equipo actual a la que pertenece la persona

numerojug VARCHAR(4) Número del jugador

EquiposAnteriores VARCHAR(400) Los nombres de los equipos donde un jugador ha participado

fechamoden VARCHAR(4) Fecha de la última modificación de la página Web en inglés

Apodos VARCHAR(4) Apodos de la persona

fechamodes VARCHAR(4) Fecha de la última modificación de la página Web en español

5.3.1.3. Ontología de futbol

Para esta investigación se creó una nueva ontología de futbol en OWL, para diseñarla se utilizaron términos de una ontología en DAML que cuenta con términos de futbol y basquetbol.

Las clases de la ontología futbol-basquetbol existente son 213 clases, de estas clases se

seleccionaron 112 clases. También se quitaron clase que significaran lomismo como, por ejemplo, tarjeta roja es igual que send off, se eliminaron clases que no pertenece al dominio como fans. Las clases seleccionadas se integraron a la nueva ontología.

El proceso de anotación semántica utiliza una ontología de futbol para mapear los

términos relevantes, así como crear las instancias y relaciones. La ontología de futbol (Figura 5.5) tiene un total de 197 clases, 37 relaciones y 24 atributos. La ontología de futbol se divide principalmente en las clases sanction (sanción), minuto (minuto), match (partido), person (persona), action (acción), team (equipo), tournament (torneo) y league (liga).

La clase team (equipo) tiene siete atributos, los cuales son nick team (apodos del equipo),

manager team (entrenador del equipo), league team (liga del equipo), ground team (estadio del equipo), foundation team (fecha de fundación del equipo), president team (presidente del equipo) y team name nombre del equipo). La clase tournament (torneo) y league (liga) tiene un atributo el cual period (periodo). La clase match (partido) tiene cuatro atributos los cuales son match name (nombre del equipo), match date (fecha del equipo), match hour begin (hora de inicio del equipo), y match hour end (hora en que termina el equipo).


52

Figura 5.5: Clases principales de la ontología de futbol

La clase action (acción) tiene un total de 69 clases y las clases tiene un atributo el cual es mean. La clase action (acción) está dividida en las clases:

goalkeeper action (acciones del portero), la cual tiene las clases block (bloquear), cut down the angle (cortar ángulo), drop kick (cortar tiro), punch out (sacar fuera de la portería) y save (salvar).

linesman action (acciones del juez de línea), la cual tiene la clase rise the flag (levantar bandera).

other player action (otras acciones del jugador) (Figura 5.6), la cual tiene las clases center (centrar), clea (despejar), counter attack (contraataque), cross (cruzar), dangerous play (jugada peligrosa), dive (tirarse al suelo), dribble (evadir al oponente madiante algunos movimientos del cuerpo), foul (falta) , handball (tocar el balón con la mano), hold opponent (esperar al opnente), goal (gol), half volley shot (tirar el balón hacía con la mano), header (pegar al balón con la cabeza ), back header (pegar al balón hacia atrás con la cabeza), diving header (remate de cabeza), flick heade (toque suave del balón con la cabeza), front heade (pegar al balón hacia adelante con la cabeza), hit (golpear), kick (tiro), center kick (tiro de centro), corner kick (tiro de esquina), free kick (tiro libre), direct free kick (tiro libre directo), indirect free kick (tiro libre indirecto), goal kick (tiro de gol), penalty kick (tiro de penalty), scissor kick (chilena), kick of (patada de salida), marking (marcar a un jugador), obstruction (obstruir), offside (fuera de lugar), overlap (pasar a un compañero), pass (pase), long pass (pase largo), outlet pass (pase de salida), penetrating pass (pase profundo), push pass (pase con empuje), wall pass (pase de pared), penétrate (penetrar, clavarse o entrar), play (jugar), run (correr), shield (proteger), shoot (lanzar), stea (robar el balón), stop (detienerse), substitute (sustituir o cambio de jugador), tackle (atacar), back tackle (atacar desde atrás), front tackle (atacar de frente), side tackle (atacar de lado), sliding tackle (ataque deslizante), throw in (saque), trap (trampa), foot trap (trampa de pie), y thigh trap (trampa de muslo).


53

referee action (acciones del árbitro), la cual tiene las clases drop ball (detener balón), timekeeper (tomar tiempo) y whistle (silvar).

Figura 5.6: Subclase de other player action

La clase sanction (sanción) (Figura 5.7) tiene una atributo el cual es mean, y tiene dos clases que son yellow card (tarjeta amarilla) y red card (tarjeta roja).

Figura 5.7: Clase sanction

La clase person (persona) tiene un total de 29 clases y cuatro atributos, los cuales son date

birth (fecha de nacimiento del jugador), full name (nombre completo del jugador), place birth

(lugar de origen del jugador), y height (altura del jugador). La clase person (persona) se

divide en linesman (juez de línea), player (jugador), referee (árbitro) y trainer (entrenador).

La clase player (jugador) (Figura 5.8), además de tener los mimos atributos que la clase person (persona) integra otros atributos como nickname (apodo del jugador), team (equipo), posicion (posición) y number (número).


54

Figura 5.8: Clase player

La clase minute (numero) (Figura 5.9) tiene un total de 91 clases y un atributo, el cual es complement (complemento). La clase minute (numero) está formado la clase minute extra (numero extra), minute 1 (numero 1) a la clase minute 90 (numero 90).

Figura 5.9: Clase minute


55

Las relaciones de la ontología de futbol son: assigned, belongs, blocks, called, commits, compete, concedes, crosses, curls, do, drills, effect, enters, executes, give, has, has been shown, have, hits, involved, is awarded, is control, is responsible, is sanctioned, makes, match play, may, occurs, on, part of, performed, scores, takes y task.

5.3.2. Funcionamiento del sistema

El funcionamiento del sistema se basa en la implementación de los tres módulos del método de anotación semántica desarrollado en esta investigación.

El sistema de anotación semántica tiene como entrada un archivo que contiene el

gamecast de un partido de futbol. Se selecciona uno de los archivos que contiene el gamecast con el botón de examinar. El botón de examinar desplega la ventana Abrir, en la cual se puede navegar entre los archivos que existen en la computadora, con el objetivo de localizar la carpeta donde se localiza los gamecasts y seleccionar el gamecast que se anotará. La dirección del archivo que contiene el gamecast se muestra en el cuadro de texto ruta de dirección (Figura 5.1).

En el Anexo 3 se muestra el diagrama de clases del sistema.

5.3.2.1. Funcionamiento del módulo de identificación y extracción de palabras relevantes

Este módulo implementa la clase expresion, la cual tiene el conjunto de patrones definidos, que permiten identificar y extraer las palabras relevantes.

La clase SASemViD abre y lee el gamecast seleccionado, también llama a la clase

expresion. La clase expresión realiza la identificación y extracción de las palabras relevantes que

están en el gamecast mediante los patrones que se definieron con la información de la ontología. Por ejemplo si en el gamecast está un comentario como el siguiente:

“Dean Bouzanis takes a direct direct freekick with his right foot from his own half.

Outcome: open play.”

La clase expresion aplica un patrón. En la Figura 5.10 muestra la estructura de un patrón, el cual busca todas las palabras mayúsculas o minúsculas o combinadas (letra en negrillas) que están antes de la palabra “takes” y todas las palabras mayúsculas o minúsculas o combinadas (letra en negrillas) que están entre las palabras “a” y la frase “with his right foot from his own half. Out: open play” en el gamecast.

Figura 5.10. Patrón de búsqueda


56

Los patrones realizan la búsqueda sobre cada comentario del gamecast, cuando una cadena (palabra) coincide con el patrón se han identificado (Figura 5. 11) las palabras relevantes.

Figura 5. 11: identificación de palabra relevantes

Una vez identificado el patrón también extrae las palabras relevantes para formar una lista de palabras relevantes.

5.3.2.2. Funcionamiento del módulo para mapear las palabras relevantes con la información de la ontología

En este módulo se implementan las clases Principal, ontología, Google, Sinonimos, Consultas, ATJu, ATEQ, ExAcc y Conexion; las cuales permiten identificar la clase a la que pertenecen las palabras relevantes, así como extraer su información y almacenarla en la base de datos.

La clase Conexion utiliza un conector con MySQL para realizar la conexión con la base de

datos. Además, permite que se ejecuten las sentencias de MySQL. La clase Sinonimos trabaja como un diccionario de sinónimos de términos de futbol,

debido a que busca una palabra sinónima de la palabra relevante que pasa como parámetro. La clase Google utiliza el API de google para realizar la búsqueda en la Web de las

palabras relevantes que han sido clasificadas como jugadores y equipos. El resultado de esta búsqueda se almacena en JSON, en el cual se buscan las direcciones (link) que pertenecen a Wikipedia (en inglés y en español) para realizar la extracción de la información de las palabras relevantes.

La clase ATJug realiza la extracción o actualización de la información del jugador o

persona mediante patrones. La información del jugador o persona puede ser: su nombre completo, su lugar de nacimiento, su fecha de nacimiento, su altura, su número, su posición, su equipo actual del jugador, sus equipos anteriores, sus apodos y su última actualización (en inglés y en español).

Cuando la clase ATJug extrae la información de un jugador o una persona, esta se

almacena en la tabla “atributo_persona” de la base de datos. La clase ATEQ realiza la extracción y actualiza el nombre completo del equipo, los

apodos del equipo, fecha de fundación del equipo, estadio del equipo, la liga a que pertenece, el nombre del presidente del equipo, nombre del entrenador del equipo y la última actualización de la información mediante patrones y almacena la información en la tabla “atributos _equipos” de la base de datos.


57

La clase ExAcc utiliza patrones y el API de Jsoup para realiza la extracción del significado de las palabras relevantes que han sido clasificadas como acciones y las sanciones, así como la última fecha de modificación de la información, las cuales se almacenan en la tabla “atributo_acciones_saciones” de la base de datos.

La clase ontologia utiliza la API de Jena para realizar la conexión con la ontología y

recuperar su información. La recuperación de la información permite crear las listas acciones-sanciones y la lista posiciones; también permite conocer cuál es la superclase de las palabras relevantes y permite clasificar a las palabras relevantes.

La clase Consulta llama a la clase Conexion para realiza la consulta e inserciones de las

palabras relevantes con la base de datos. La clase Principal llama a la clase Google para realizar la consulta en la Web de los

nombres de los jugadores y de los equipos; Además, la clase Principal busca la página de Wikipedia que corresponda con la palabra relevante.

La clase SASemViD muestra la ventana de abrir para seleccionar el gamecast. Cuando se

lee el archivo que contiene al gamecast, se obtienen los nombres de los equipos por medio de un patrón.

Los nombres de los equipos se buscan en la tabla “palabras_relevantes” de la base de

datos para verificar si están registrados con ayuda de la clase Consulta. Si los equipos están registrados en la tabla “palabras_relevantes”, el sistema inicia con la extracción de palabras relevantes, si los equipos no están registrados llama a la clase Principal para que busque en la Web la página de Wikipedia que corresponde a los equipos. El sistema utiliza la página de Wikipedia que corresponde a los equipos y llama a la clase ATEQ, para extraer su información. La información de los equipos se guarda en la tabla “atributos_equipos” de la base de datos y se especifica en la tabla “palabras_relevantes” de la base de datos que pertenece a la clase team (equipo).

Los nombres de los equipos forman el nombre del partido en el que participan. El nombre

del partido se busca en la tabla “partido” de la base de datos para verificar si están registrados con ayuda de la clase Consulta. Si el partido estáregistrado en la tabla “partido”, el sistema inicia con la extracción de palabras relevantes, si el partido no está registrado mediante un patrón se extrae el nombre del árbitro y la hora en la que inicio el partido, estos datos se guardan en la tabla “partido” de la base de datos, junto con la fecha en la que se realizó el partido.

Al finalizar el procesamiento de la información del partido y los nombres de los equipos,

se inicia la extracción de las palabras relevantes que se encuentran en el gamecast. Cuando el sistema tiene la lista de palabras relevantes, se verifica si las palabras relevantes están registradas en la tabla “palabras_relevantes” de la base de datos con ayuda de la clase Consulta. Si la palabra relevante está registrada el sistema extrae la fecha de la última modificación tanto de la base de datos y de la página Web. Cuando la fecha de la página Web es mayor que la base de datos, se actualiza la información de la palabra relevante; si la fecha de la base de datos es igual que la de la página Web se conserva la información.


58

Cuando la palabra relevante no esté en la tabla “palabras_relevantes” de la base de datos el sistema compara la lista acciones-sanciones (que fue creada con la clase ontologia) con las palabras relevantes, si la palabra relevante coincide con alguna de las clases de la lista acciones-sanciones, entonces la palabra relevante se identifica como una acción o sanción. El sistema llama a la clase ExAcc para extraer su información de un glosario de términos de futbol de Wikipedia (http://en.wikipedia.org/wiki/Glossary_of_association_football_terms) y almacenarla en la tabla “atributo_acciones_saciones” de la base de datos con el nombre de clase a la que pertenece.

Si la palabra relevante no coincide con alguna de las clases de la ontología se busca si

tiene un sinónimo con ayuda de la clase Sinonimos. Cuando el sistema recibe el sinónimo de la palabra relevante vuelve a repetir la búsqueda de la clase en la lista acciones-sanciones.

Cuando el sistema no obtenga un sinónimo la palabra relevante se clasifica como jugador,

por lo tanto se crea la lista posiciones. El sistema busca con la clase Principal y Google la página de Wikipedia relacionada con

la palabra relevante. El sistema busca en la página de Wikipedia la posición de juego del jugador, si obtiene un resultado la posición del jugador se compara con la lista posiciones. Si la posición del jugador coincide con algunas de las clases de esta lista entonces se llama a la clase ATJug para obtener el resto de la información del jugador y se almacena en la tabla “atributo_persona” de la base de datos con la clase a la que pertenece.

Si la posición del jugador no coincide con alguna de las clases de la ontología se busca si

tiene un sinónimo con ayuda de la clase Sinonimos. Cuando el sistema recibe el sinónimo de la palabra relevante vuelve a repetir la búsqueda de la clase en la lista posiciones.

Cuando el sistema no obtiene un sinónimo la palabra relevante se almacena en la tabla

“palabras_relevantes” de la base de datos especificada que pertenece a la clase player (jugador) y se obtiene el resto de la información.

Si el sistema no obtiene la página de Wikipedia relacionada con la palabra relevante, la

palabra se clasifica como persona, por lo tanto se almacena en la tabla “palabras_relevantes” de la base de datos especificando que pertenece a la clase person (persona).

5.3.2.3. Funcionamiento del módulo para crear instancias y relaciones

En este módulo se implementan las clases etiquetador, CrearInstancias e Interpretador, las cuales permiten etiquetar, crear las relaciones e instancias y establecer las reglas de clasificación y relación del sistema.

La clase etiquetador utiliza el API de stanford-postagger para separ las palabras del

comentario e indicar el tipo de palabra: nombre propio, verbo, sustantivo, etc.


59

La clase CrearInstancias utiliza el API de Jena para realizar las instancias de jugador, entrenador, árbitro, partido equipo, acción, sanción, juez de línea, liga, torneo, persona y minuto (más información ver Anexo 1), así como las relaciones entre las instancias(más información ver Anexo 2).

La clase Interpretador establece las reglas de clasificación que permiten agrupar y marcar

las posibles instancias de la ontología. También tiene las reglas de la relación, que ayudan a establecer cuál es la relación que se creará de acuerdo a la estructura del comentario.

El sistema lee el archivo que contiene el gamecast y se etiqueta con la clase etiquetador.

El archivo etiquetado con Stanford se guarda con el nombre de etiquetado. La información del archivo del gamecast se almacena en una estructura de datos y se le

asigna un identificador a cada uno de los comentarios. Los comentarios etiquetados se dividen en palabras, las cuales son procesadas por las

reglas de clasificación. Las reglas de clasificación permiten agrupar e identificar las posibles instancias candidatas, las cuales son almacenadas en una estructura de datos y se le asigna un identificador a cada uno de los comentarios.

El sistema obtiene el nombre de los equipos y la fecha en la que se realizó el partido del

nombre del gamecast. Los nombres de los equipos formar el nombre del partido, el cual se busca en la base de datos y se recupera su información (nombre del árbitro, hora de inicio del partido y la fecha en la que se realizó el partido de futbol). La información recuperada de la base de datos son los atributos de la instancia que fue creada.

El sistema toma los nombres de los equipos para crear las instancias. El nombre de los

equipos se busca en la tabla “atributos_equipos” de la base de datos y se recupera su información (nombre completo, fecha de fundación, apodos, nombre del presidente del equipo, liga, nombre del entrenador del equipo y campo del equipo), los cuales son los atributos de la instancia.

El sistema recupera cada uno de los comentarios de la estructura de datos del gamecast

etiquetado. Las palabras de un comentario se someten a un patrón el cual permite extraer la palabra y los marcadores.

Si la palabra tiene el marcador o etiqueta “min” se crea un instancia minuto. Si el número

del minuto es mayor que 90 la instancia se crea en la clase “minute_extra; si el número es menor que 90 la instancia se crea en la clase que corresponde al minuto del comentario.

La instancia de minuto recupera el comentario de la estructura de datos del gamecast

original y crea su atributo. El identificador de la instancia minuto se conserva. Si la palabra tiene el marcador o etiqueta “verbo” se conserva la palabra con la indicación

de verbo. Si la palabra tiene el marcador o etiqueta “PerEq” y “Ac” se busca en la tabla “palabras_relevantes” de la base de datos. Si la palabra está en la tabla “palabras_relevantes” de la base de datos se recupera la clase a la que pertenece.


60

Si la clase a la que pertenece la palabra es player (jugador) o una subclase de player (jugador) se recupera la información (el nombre completo del jugador, la fecha de nacimiento del jugador, estatura del jugador, número del jugador, equipo actual en el que juega, lugar de origen del jugador, equipos anteriores donde jugaba el jugador, la posición del jugador y apodos del jugador) de la tabla “atributo_persona” de la base de datos y se conserva su identificador.

Cuando la clase a la que pertenezca la palabra es subclase de action (acción) se

recupera la información (significado de la acción) de la base de datos y se conserva su identificador. Si la clase a la que pertenezca la palabra es subclase de sanction (sanción) se recupera la información (significado de la sanción) de la tabla “atributo_acciones_saciones” de la base de datos y se conserva su identificador.

Si la clase a la que pertenece la palabra es person (persona), trainer (entrenador), referee

(árbitro) y linesman (juez de línea) se buscan en la tabla “atributo_persona” de la base de datos. Si la palabra se localiza en la base de datos se recupera su información (el nombre completo, la fecha de nacimiento, estatura y el lugar de origen) para crear la instancia con sus respectivos atributos y se conserva su identificador.

Los identificadores indican la estructura que posee el comentario. El sistema toma la

estructura del comentario y verifica a cual se las reglas de relación pertenece, de acuerdo con las reglas se crean las relaciones entre las instancias del comentario.

El resultado de módulo para crear instancias y relaciones es el archivo .owl llamado

“Futbol1”, el cual contiene la instancias y relaciones creadas por el sistema.

Capítulo 6. Pruebas y resultados

61

Capí tulo 6. Pruebas y

resultados En este capítulo se presentan el plan utilizado para la evaluación del método de anotación

semántica, así como los resultados obtenidos de las pruebas con el sistema realizado. El plan de evaluación consiste en calcular la precisión con la cual se crearon las

instancias y las relaciones de la ontología de futbol, calcular el recall de la información que se obtuvo de las palabras relevantes y calcular el porcentaje de palabras relevantes recuperadas en el sistema. También se midió el tiempo de duración del proceso de anotación semántica.

A continuación se describen las métricas de evaluación utilizadas para el método de

anotación semántica.


62

6.1. Evaluación

Las medidas de evaluación utilizadas para esta investigación son precisión y recall.

6.1.1. Precisión

Precisión es el porcentaje de los elementos relevantes obtenidos para el total de elementos relevantes recuperados e irrelevantes, el porcentaje indica que tan cerca están los valores medidos el uno al otro, es por ello, que la precisión mide la capacidad de un sistema para presentar únicamente los elementos relevantes. La ecuación para calcular la precisión es:

Los elementos a evaluar son las instancias y relaciones de la ontología, se considera un

elemento relevantes si la instancia se creó en la clase de la ontología a la que pertenece y si la relación que tiene forman la tripleta.

6.1.2. Recall

Recall es el porcentaje de casos obtenidos que se predijeron correctamente; es por ello, que recall mide la capacidad de un sistema para presentar todos los elementos relevantes. La ecuación para calcular el recall es:

Los elementos relevantes son aquellos elementos palabras que representan las

sanciones, acciones que realizan el jugador, los nombres de los equipos y los nombres de los jugadores en un gamecast.

6.2. Casos de estudio

El método propuesto se aplicó a los gamecast de dos ligas y un torneo. Los gamecast se obtuvieron de la página de ESPN con el objetivo de probar el método de anotación semántica.

A continuación se presentan las pruebas realizadas para probar el método de anotación y

los resultados obtenidos.


63

6.2.1. Caso de estudio 1: Gamecast de la liga “English League One”

En este caso de estudio se evalúa el método de anotación semántica con cinco gamecast, los cuales corresponden a los partidos “Crawley Town vs Walsall”, “Doncaster Rovers vs Oldham Athletic”, “Hartlepool United vs Oldham Athletic” “Swindon Town vs Yeovil Town” y “Tranmere Rovers vs Milton Keynes Dons”.

Los resultados obtenidos en este caso de estudio se presentan a continuación: En la Tabla 6.1 se muestra los valores obtenidos por el sistema de anotación en la

extracción de las palabras relevantes.

Tabla 6.1: Resultados de la extracción de las palabras relevante caso 1

En la Tabla 6.2 se muestran el total de las instancias y relaciones creadas por el sistema

de anotación semántica.

Tabla 6.2: Resultado de las instancias y relaciones del caso 1

Palabras relevantes

Nombre del partido del gamecast No. Reales

No. Recuperado

% de palabras

Crawley Town vs Walsall 47 42 89.36%

Doncaster Rovers vs Oldham Athletic 48 38 79.17%

Hartlepool United vs Oldham Athleti 51 45 88.24%

Swindon Town vs Yeovil Town 46 33 71.74%

Tranmere Rovers vs Milton Keynes Dons 42 31 73.81%

Instancias y relaciones de la ontología

Nombre del partido del gamecast Total de

instancias Total de

relaciones

Crawley Town vs Walsall 246 546

Doncaster Rovers vs Oldham Athletic 259 479

Hartlepool United vs Oldham Athleti 323 625

Swindon Town vs Yeovil Town 262 326

Tranmere Rovers vs Milton Keynes Dons 288 531


64

En la Tabla 6.3 se muestra la precisión y el recall, además se muestra el tiempo de duración del sistema total de proceso de anotación semántica.

Tabla 6.3: Cálculos de recall, precisión y tiempo del caso 1

Duración del proceso de anotación semántica, cálculo de recall y precisión

Nombre del partido del gamecast Recall Precisión Tiempo

Crawley Town vs Walsall 91.97% 100.00% 152 min. y 45 seg.

Doncaster Rovers vs Oldham Athletic 78.60% 99.45% 155 min. y 33 seg.

Hartlepool United vs Oldham Athleti 83.07% 99.47% 165 min. y 18 seg.

Swindon Town vs Yeovil Town 88.37% 99.31% 186 min. y 24 seg.

Tranmere Rovers vs Milton Keynes Dons 89.79% 99.63% 146 min. y 44 seg.

En la Figura 6.1 se muestra un ejemplo de la instancia jugador, así como sus atributos.

El ejemplo es un fragmento del archivo OWL del gamecast del partido “Swindon Town vs Yeovil Town”.

Figura 6.1: Instancia de jugador del partido “Swindon Town vs Yeovil Town”


65

En la Figura 6.2 se muestra un fragmento del OWL del partido “Crawley Town vs Walsall”. En el fragmento OWL las instancias creadas están en negritas, los atributos de las instancias se encuentran en letras cursivas y negritas, y las relaciones creadas entre las instancias se muestran subrayadas.

Figura 6.2: Fragmento del OWL del partido “Crawley Town vs Walsall”


66

En la Figura 6.3 se muestra una representación gráfica del fragmento de la ontología resultante del gamecast del partido “Crawley Town vs Walsall” obtenida con el visualizador de ontologías de NeOn Toolkit7.

Figura 6.3: Fragmento de ontología (clase midfielder)

En este caso de estudio el tiempo aproximado para la realización de la anotación semántica fue de 160.8’’ 32.8’; el porcentaje de la palabras relevantes recuperadas fueron de 84.46%, el porcentaje de recall fue de 86.36% y el porcentaje de precisión fue de 99.57%. Además, en promedio se crearon 275.6 instancias y 501.4 relaciones en la ontología.

6.2.2. Caso de estudio 2: Gamecast de la “Liga MX”

En este caso de estudio se evalúa el método de anotación semántica con cinco gamecast, los cuales corresponden a los paridos “Cruz Azul vs Monterrey”, “Morelia vs Santos Laguna”, “Pachuca vs Jaguares de Chiapas”, “Pumas UNAM vs Atlante” y “Toluca vs América”.

Los resultados obtenidos en este caso de estudio se presentan a continuación:

7 Visualizador de ontologías de NeOn Toolkit: neon-toolkit.org


67

En la Tabla 6.4 se muestra los valores obtenidos por el sistema de anotación en la extracción de las palabras relevantes.


Palabras relevantes

Nombre del partido del gamecast No.

Reales

No.

Recuperado

% de

palabras

Cruz Azul vs Monterrey 42 38 90.48%

Morelia vs Santos Laguna 45 39 84.44%

Pachuca vs Jaguares de Chiapas 44 32 72.73%

Pumas UNAM vs Atlante 44 35 79.55%

Toluca vs América 45 37 82.22%

En la Tabla 6.5 se muestran el total de las instancias y relaciones creadas por el sistema

de anotación semántica.

Tabla 6.5: Cálculo de las instancias del caso 2



instancias Total de relaciones

Cruz Azul vs Monterrey 146 346

Morelia vs Santos Laguna 151 342

Pachuca vs Jaguares de Chiapas 144 284

Pumas UNAM vs Atlante 153 311

Toluca vs América 135 218


68

En la Tabla 6.6 se muestra el porcentaje obtenido del cálculo de la precisión y el recall, además se muestra el tiempo de duración del sistema total de proceso de anotación semántica.

Tabla 6.6: Cálculos de recall, precisión y tiempo del caso 2



Cruz Azul vs Monterrey 89.75% 99.59% 148 min. y 42 seg.

Morelia vs Santos Laguna 91.53% 99.39% 159 min. y 25 seg.

Pachuca vs Jaguares de Chiapas 87.41% 99.53% 100 min. y 17 seg.

Pumas UNAM vs Atlante 89.47% 99.13% 173 min. y 58 seg.

Toluca vs América 89.29% 99.15% 162 min. y 58 seg.

En la Figura 6.4 se muestra un ejemplo de la instancia sanción, así como sus atributos.

Figura 6.4: Instancia sanción


69

En la Figura 6.5 se muestra un fragmento del OWL del partido “Pumas UNAM vs Atlante”.

En el fragmento OWL las instancias creadas están en negritas, los atributos de las instancias se encuentran en letras cursivas y negritas, y las relaciones creadas entre las instancias se muestran subrayadas.

Figura 6.5: Fragmento de ontología “Pumas UNAM vs Atlante”


70

En la Figura 6.6 se muestra una representación gráfica del fragmento de la ontología resultante del gamecast del partido “Pumas UNAM vs Atlante”.

Figura 6.6: Fragmento de ontología (clase forward)

En este caso de estudio el tiempo aproximado para la realización de la anotación semántica fue de 148.4’’ 32.8’; el porcentaje de la palabras relevantes recuperadas fueron de 81.81%, el porcentaje de recall fue de 89.49% y el porcentaje de precisión fue 99.36%. Además, en promedio se crearon 145.8 instancias y 300.2 relaciones en la ontología.

6.2.3. Caso de estudio 3: Gamecast de la “FIFA CLUB WORLD CUP”

En este caso de estudio se evalúa el método de anotación semántica con cinco gamecast, los cuales corresponden a los partidos “Al Sadd vs Barcelona”, “Internacional vs Seongnam Ilhwa”, “Kashiwa Reysol vs Auckland Cit”, “Monterrey vs Esperance ST” y “Sanfrecce Hiroshima vs Al Ahly”.

Los resultados obtenidos en este caso de estudio se presentan a continuación:


71

En la Tabla 6.7 se muestra los valores obtenidos por el sistema de anotación en la extracción de las palabras relevantes.


En la Tabla 6.8 se muestran el total de las instancias y relaciones creadas por el sistema de anotación semántica.

Tabla 6.8: Cálculo de las instancias del caso 3



instancias

Total de

relaciones

Al Sadd vs Barcelona 246 546

Internacional vs Seongnam Ilhwa 259 479

Kashiwa Reysol vs Auckland City 323 625

Monterrey vs Esperance ST 262 326

Sanfrecce Hiroshima vs Al Ahly 288 531

Palabras relevantes

Nombre del partido del gamecast No.

Reales

No.

recuperado

% de

palabras

Al Sadd vs Barcelona 38 31 81.58%

Internacional vs Seongnam Ilhwa 40 31 77.50%

Kashiwa Reysol vs Auckland City 38 27 85.37%

Monterrey vs Esperance ST 46 33 71.05%

Sanfrecce Hiroshima vs Al Ahly 41 39 95.12%


72

En la Tabla 6. 9 se muestra el porcentaje obtenido del cálculo de la precisión y el recall, además se muestra el tiempo de duración del sistema total de proceso de anotación semántica.

Tabla 6. 9: Cálculos de recall, precisión y tiempo del caso 3



Al Sadd vs Barcelona 85.21% 100.00% 114 min. y 43 seg.

Internacional vs Seongnam Ilhwa 86.29% 100.00% 139 min. y 45 seg.

Kashiwa Reysol vs Auckland City 87.36% 100.00% 175 min. y 19 seg.

Monterrey vs Esperance ST 85.93% 100.00% 105 min. y 13 seg.

Sanfrecce Hiroshima vs Al Ahly 88.44% 100.00% 135 min. y 47 seg.

En la Figura 6.7 se muestra un fragmento del archivo OWL donde hay una instancia

acción.

Figura 6.7: Instancia de acción


73

En la Figura 6.8 se muestra un fragmento del OWL del partido “Internacional vs Seongnam Ilhwa”. En el fragmento OWL las instancias creadas están en negritas, los atributos de las instancias se encuentran en letras cursivas y negritas, y las relaciones creadas entre las instancias se muestran subrayadas.

. Figura 6.8: Fragmento de ontología del partido “Internacional vs Seongnam Ilhwa”


74

En la Figura 6.9 se muestra una representación gráfica del fragmento de la ontología resultante del gamecast del partido “Internacional vs Seongnam Ilhwa”.

Figura 6.9: Fragmento de ontología (clase goalkeeper)

En este caso de estudio el tiempo aproximado para la realización de la anotación semántica fue de 133.6’’ 32.8’; el porcentaje de la palabras relevantes recuperadas fueron de 82.12%, el porcentaje de recall fue de 86.65% y el porcentaje de precisión fue 100%. Además, en promedio se crearon 137.4 instancias y 330.4 relaciones en la ontología.

6.3. Conclusiones de las pruebas y resultados obtenidos

Los resultados de las pruebas son bastante favorables debido a que los valores obtenidos en cada una de las pruebas son mayores de 80%. En la Tabla 6.10 se muestran los resultados de recall y precisión de cada una de las pruebas realizadas a los gamecast de los partidos.


75

Tabla 6.10: Resultados del método de anotación semántica

Nombre del partido del gamecast Recall Precisión

Crawley Town vs Walsall 91.97% 100.00%

Doncaster Rovers vs Oldham Athletic 78.60% 99.45%

Hartlepool United vs Oldham Athleti 83.07% 99.47%

Swindon Town vs Yeovil Town 88.37% 99.31%

Tranmere Rovers vs Milton Keynes Dons 89.79% 99.63%

Cruz Azul vs Monterrey 89.75% 99.59%

Morelia vs Santos Laguna 91.53% 99.39%

Pachuca vs Jaguares de Chiapas 87.41% 99.53%

Pumas UNAM vs Atlante 89.47% 99.13%

Toluca vs America 89.29% 99.15%

Al Sadd vs Barcelona 85.21% 100.00%

Internacional vs Seongnam Ilhwa 86.29% 100.00%

Kashiwa Reysol vs Auckland City 87.36% 100.00%

Monterrey vs Esperance ST 85.93% 100.00%

Sanfrecce Hiroshima vs Al Ahly 88.44% 100.00%

Promedio 87.50% 98.19%

Los resultados obtenidos de las pruebas muestran que el proceso de anotación semántica

dura aproximadamente 147.6’’ 35.4’, que tiene en promedio de recall (extracción y recupera de la información de las palabras relevantes) un 87.50% y un promedio de 99.64 % en precisión (la creación de las instancias y relaciones). Además, tiene un 81.84% de promedio en la extracción de las palabras relevantes.

Capítulo 7. Conclusiones y trabajos futuros

76

Capí tulo 7. Conclusiones y trabajos futuros

En este capítulo se muestran las conclusiones obtenidas a partir de la Investigación realizada para este proyecto.


77

7.1. Conclusiones

En este trabajo de investigación se presentó un método para realizar anotación semántica de partidos de futbol utilizando el gamecast (reporte minuto a minuto de un partido de futbol). El gamecast de los partidos debe encontrarse en idioma inglés.

El propósito del método desarrollado es reducir el tiempo y el costo de la anotación

semántica de los partidos de futbol. Además, de ayudar a los buscadores en la interpretación de la información multimedia, para obtener mejores resultados.

El método de anotación semántica se implementó en un sistema de software, el cual tiene

como entrada el gamecast de un partido y como salida presenta el gamecast anotado semánticamente en forma de instancias en la ontología de futbol.

El sistema de software que tiene el método de anotación semántica se probó con 15

gamecast, los cuales pertenecen a dos ligas (English League One y Liga MX) y un torneo (FIFA CLUB WORLD CUP), obteniendo los siguientes resultados:

El proceso de anotación semántica duró aproximadamente 147.6 min y 35.4 segundos.

El promedio de recall del sistema fue de 87.50%

El promedio de precisión del sistema fue de 99.64%

El promedio de palabras relevantes recuperadas por el sistema fue de 81.48%

El promedio de instancias creadas por el sistema fue de 186.26

El promedio de relaciones creadas por el sistema fue de 377.33

De acuerdo a los datos presentados anteriormente se puede concluir que sistema de anotación semántica funciona correctamente y que los resultados obtenidos son favorables al momento de recuperar palabras relevantes, extraer información de las palabras, así como crear las instancias y relaciones de un partido de futbol ya que son mayores al 80%.

7.2. Contribuciones

Las principales contribuciones de esta investigación son:

Un método que permite realizar anotación semántica de los partidos de futbol (soccer), la cual toma los gamecast y crea tripletas con la información.

La creación de una ontología de futbol (soccer) en OWL que contiene los minutos del partido, las posiciones de los jugadores, las acciones que realiza un jugador, las sanciones que se les indica a los jugadores, la liga a la que pertenecen, partido y equipos.


78

Un método para buscar las palabras sinónimas de algunos términos de futbol, así como sinónimos de jugadores y de equipos.

Un conjunto de patrones para la identificación y extracción de palabras del dominico del futbol.

Un conjunto de reglas para crear relaciones entre las instancias creadas.

El desarrollo de la herramienta de anotación semántica, el cual implementa el método definido en esta tesis.

La publicación del método de anotación semántica: Hugo Estrada, Elizabeth Cadenas, Alicia Martínez and José Ruíz (2013) “Anotación semántica de videos de futbol utilizando un gamecast”. Workshop on Semantic Web and Linked Open Data SW-LOD 2013 Proceedings in the Mexican International Conference on Computer Science (ENC 2013); page 79-84;October 30, 31, November 1th; Morelia Michoacán, México.

Segundo lugar en la Etapa local del concurso “Evento Nacional de Innovación Tecnológica 2013”.

Semifinalista en la Etapa Regional del concurso “Evento Nacional de Innovación Tecnológica 2013”.

Participación en la Etapa Nacional del concurso “Evento Nacional de Innovación Tecnológica 2013”.

7.3. Trabajos futuros

Este proyecto de investigación permite identificar un conjunto de trabajos futuros, los cuales mejorarán o ampliarán este trabajo:

Desarrollar un método para integrar el video del partido de futbol con la anotación semántica de la ontología de futbol.

La integración del método de anotación semántica con la herramienta (CrawNet) para recuperar los gamecast de los partidos de futbol.

Desarrollar un método que permita realizar consultas a la información que se encuentra en la ontología de futbol. Este método interpretará la información escrita por un usuario en lenguaje natural y mapeará dicha información en consultas en SPARQL esto permitirá buscar y recuperar la información de la ontología de futbol.

Extender el sistema para que se pueda observar en forma visual las instancias y relaciones creadas en la ontología de futbol.

Anexos

79

Anexos

Anexo 1: Instrucciones para instancias y asignar atributos

Para crear las instancias de la ontología se tiene un método para la clase jugador, para la clase acción, para la clase sanción, para la clase juez de línea, para la clase partido, para la clase, equipo, para torneo, para la clase liga, para la clase entrenador y para la clase minuto; en la cual se le agrega los atributos de la case.

Para crear las instancias y agregar los atributos a las clases de la ontología se crea un

modelo OWL para la ontología (1), donde “r” es el razonador del modelo:

(1) OntModel model = ModelFactory.createOntologyModel(r); Al crearse el modelo se establece el administrador de la ontología en forma local (2), el

cual permite cargar la información de la ontología (la primera dirección es la URI de la ontología y la segunda es la dirección donde se encuentra el archivo .owl):

(2) model.getDocumentManager().addAltEntry("http://www.owl- ontologies.com/SoccerFootball.owl", "file:"+rutaOWL+"Futbol1.owl");

La lectura de la información de la ontología, se realiza con la sentencia (3), La variable

uriBase es la URI de la ontología (http://www.owl-ontologies.com/SoccerFootball.owl): (3) model.read(uriBase); Para crear las instancias se recupera la clase a la cual pertenece la instancia, con la

sentencia (4): (4) OntClass claseOnto = model.getOntClass( uriOnto + clase ); Ontoclass representa una clase en Jena, el método getOntClass() recupera la URI de la

clase, la uriOntClass es el namespace de la ontología (http://www.owl-ontologies.com/SoccerFootball.owl#) y “clase” es el nombre de la clase que se desea recuperar.

La instancia de la clase se crea con la sentencia (5): (5) Individual NuevoInd = model.createIndividual( uriOnto + IDInstancia,claseOnto); Individual representa el individuo en Jena, createIndividual () es un método que

permite crea la instancia en la ontología, la uriOnto es “http://www.owl-ontologies.com/SoccerFootball.owl#”, IDInstancia es el identificador de la instancia y claseOnto es la clase en donde se creara la instancia.

Anexos

80

Los atributos de la clase se recuperan con la sentencia (6):

(6) DatatypeProperty atribNomP = model. getDatatypeProperty (uriOnto+"match_name");

DatatypeProperty representa los atributos que tiene la clase en Jena, el método

getDatatypeProperty() permite recurar el DatatypeProperty que se solicita, la uriOnto es http://www.owl-ontologies.com/SoccerFootball.owl# y match_name es el DatatypeProperty que se desea recuperar

Para que la instancia creada pueda tener sus respectivos atributos; el atributo se asocia

con el valor que se desea agregar (7): (7) NuevoInd.addProperty(atribNomP, NombrePartido); NuevoInd es la instancia a la que se le agregara el atributo, addProperty() es el

método que permite asociar el atributo y el valor del atributo, atribNomP es el atributo recuperado y NombrePartido es el valor que se coloca en el atributo.

Las instancias y atributos creados se guardar en un archivo, con la siguiente sentencia: (8) File file= new File ("C:"+rutaOWL+"Futbol1.owl");

La información que tiene el modelo se escribe en un archivo .owl (9) model.write(new PrintWriter(file)); El proceso de crear y asignar los atributos termina al cerrar el modelo OWL (10) model.close();

Anexos

81

Anexo 2: Instrucciones para crear una relación

Para crear las relaciones de la ontología se crea un modelo OWL para la ontología (1), donde “r” es el razonador del modelo:

(1) OntModel model = ModelFactory.createOntologyModel(r); Al crearse el modelo se establece el administrador de la ontología en forma local (2), el

cual permite cargar la información de la ontología (la primera dirección es la URI de la ontología y la segunda es la dirección donde se encuentra el archivo .owl):

(2) model.getDocumentManager().addAltEntry("http://www.owl- ontologies.com/SoccerFootball.owl", "file:"+rutaOWL+"Futbol1.owl"); La lectura de la información de la ontología, se realiza con la sentencia (3), La variable

uriBase es la URI de la ontología (http://www.owl-ontologies.com/SoccerFootball.owl): (3) model.read(uriBase); Para crear la relación primero se recupera la primera instancia: (4) Individual RelOrigen = model.getIndividual( uriOnto + IDInstanciaOrigen); Individual representa el individuo en Jena, getIndividual () es un método que permite

recuperar la primera instancia en la ontología, la uriOnto es “http://www.owl-ontologies.com/SoccerFootball.owl#”, IDInstanciaOrigen es el identificador de la instancia origen. La instancia origen es la primera palabra que aparece en la oración.

Después de haber recuperado la primera instancia se recupera la segunda instancia: (5) Individual RelDestino = model.getIndividual( uriOnto + IDInstanciaDestino); Individual representa el individuo en Jena, getIndividual () es un método que permite

recuperar la segunda instancia en la ontología, la uriOnto es “http://www.owl-ontologies.com/SoccerFootball.owl#”, IDInstanciaDestino es el identificador de la instancia destino. La instancia destino es la segunda palabra que aparece en la oración y es distinta de los verbos.

La relación (ObjectProperty) se recupera con la sentencia (6), es decir, se revisa que la

relación exista en la ontología: (6) ObjectProperty NuevaPropiedad=model.getObjectProperty(uriOnto+relacion); ObjectProperty representa una ObjectProperty en Jena, getObjectProperty() es el método

que recupera la relación (ObjectProperty), la uriOnto es http://www.owl-ontologies.com/SoccerFootball.owl# y relación puede ser el verbo o la palabra establecida de acuerdo con la regla.

Anexos

82

Al recuperarse la relación esta se asociar con las instancias mediante la sentencia (7): (7) RelOrigen.addProperty(NuevaPropiedad, RelDestino);

RelOrigen es la URI de la instancia origen, el método addProperty() permite asociar las

instancias mediante la relación, NuevaPropiedad es la relación que se está utilizando para enlazar las instancias y RelDestino es la URI de la instancia destino y es con la que se relaciona la instancia origen.

Las relaciones creados se guardar en un archivo, con la siguiente sentencia: (8) File file= new File ("C:"+rutaOWL+"Futbol1.owl");

La información que tiene el modelo se escribe en un archivo .owl (9) model.write(new PrintWriter(file)); El proceso de crear y asignar los atributos termina al cerrar el modelo OWL (10) model.close();

Anexos

83

Anexo 3: Diagrama de clases

Figura Anexo 3. 1: Diagrama de clases del sistema

ATEQ

+VNUmMesIng: string+fechaModE1: string+NombE: string+apodos: string+FechaFund: string+NEstadio: string+PresEq: string+manager: string+league: string+atributoEquipo: string+actEquipo: string

+cambioMesIng(String ValorMesIng): string+FechaUModEq(String linea, String url1): string+ObNobEq(String linea, String url1): string+ObApodosEq(String linea, String url1): string+ObFechaFudEq(String linea, String url1): string+ObNCampoEq(String linea, String url1): string+ObNPresEq(String linea, String url1): string+ObNManagerEq(String linea, String url1): string+ObNLigaEq(String linea, String url1): string+String ExtraerAEq1(String url, String PalCEq): string+String actualizarAE(String url, String PalCEq): string

ATJug

+VNUmMesIng: string+VNUmMesEs: string+VNUmMesIngEs: string+fechaLIng: string+fechaUEs: string+NomCJug: string+fJug: string+LoJug: string+EqJug: string+posJug: string+numJug: string+altJug: string+apJug: string+atJ: string+ActJug: string+AtribPersona: string

+cambioMesIng(String ValorMesIng): string+cambioMesEs(String ValorMesEs): string+cambioMesIngEs(String ValorMesIng): string+FechaLastModJug(String linea, String url1): string+FechaUlModJug(String url1, String url2, String palabra1): string+NombreComJug(String linea, String url1): string+FechaNac(String linea, String url1): string+LugarOr(String linea, String url1)+EquipoJug(String linea, String url1): string+PosJug(String linea, String url1): string+NumJug(String linea, String url1): string+AltJug(String linea, String url1): string+nickJug(String url2, String palabra): string+EquiposAnt(String linea, String url1): string+ExAtJug(String url, String palabra): string+actulizarAJug(String url, String palabra): string+PersonaAtrib(String url, String palabra): string

Conexion

+bd: string+login: string+password: string+direccion: string+conn: Connection+insertar: Statement+buscar: Statement+in: BufferedReader+connURL: URLConnection+u: URL

+ConectarURL(String url): void+conectarBD(): void

Consultas

+enlace: string+RespuestaCons: string+ClasePalC: string+ConEq: string+palabralimpia: string+enlaceSen: string+PAgregada: string+InvPAgregada: string

+Consultaenlaces(String palabraC1, String url): string+ConPalClaveSencillo(String palabraC1): string+ConPalClave(String palabraC1, String claseP): string+ConsultaEquipo(String palabraC1): string+EliminaPalRepetidas(String palabra3): string+ConsultaSencillaEn(String palabraC1): string+AgregaCaracter(String POriginal): string+InvertirAgCaracter(String POriginal1): string

CrearInstancias

+uriBase: string+uriOnto: string+rutaOWL: string+InsPartido: string+InsJug: string+leerOnto: string+InsEq: string+InsAc: string+InsJL: string+InsLiga: string+InsTorneo: string+InsSan: string+InsEnt: string+propiedad: string+InsMin: string+InsPersona: string

+InstanciasPartido(String IDInstancia, String NombrePartido, String fechaP, String HrInicio, String HrFin, String JuezL, String arbitro): string+InstanciasJugadores(String nombSencillo, String Clase, String IDInstancia, String NomJugador, String fechaNacJ, String LugarNacJ, String AlturaJ, String PosicionJ, String EquipoJ, String NumbJ, String apoJ, String ParG): string+InstanciasPersona(String IDInstancia, String nombSencillo): string+InstanciasEquipo(String nombSencillo, String IDInstancia, String NomEquipo, String NickEq, String FechaFundacion, String CampoE, String presidentEq, String manager, String ligaEq, String idPartido): string+InstanciasAccion(String nombSencillo, String Clase, String IDInstancia, String SignificadoAC): string+InstanciasArbitro(String nombSencillo, String Clase, String IDInstancia, String Nom, String fechaNac, String LugarNac, String apo): string+InstanciasEntrenador(String nombSencillo, String Clase, String IDInstancia, String Nom, String fechaNac, String LugarNac, String Altura, String apo, String EquipoE): string+InstanciasJuezLinea(String nombSencillo, String Clase, String IDInstancia, String Nom, String fechaNac, String LugarNac, String Altura, String apo): string+public String InstanciasLiga(String nombSencillo, String IDInstancia, String periodo): string+propiedades(String IDInstanciaOrigen, String IDInstanciaDestino, String relacion): string+Minuto(String Clase, String IDInstancia, String minuto, String complemento, String IDPartido): string

ExAcc

+VNUmMesIng: string+fechaModA1: string+nueva_cadena: string+AccSin: string+act: string+PC: string

+String EliminaCaracteres(String s_cadena, String s_caracteres): string+cambioMesIng(String ValorMesIng): string+FechaUModAC(String linea, String url1): string+BusquedaAccSinonima(String url1, String palabraC): string+BuscaAccion(String url1, String palabraC): string+String ATAC(String palabra, String palabra1, String URL): string

Google

+numkey: int+termino1: string+URLkeyC1: string+valorURL: string+resBusqueda11: string+URlLocIN: string+valorURLE: string+url: URL+resBusqueda1: string+URLFiltradaE: string+URlLocES: string

+BuscarIn(String termino, int posicion): string+mostarResultados(BufferedReader bufferedReader): string+filtroURL(String cadenaURL): string+BuscarES(String terminoE, int posicionE): string+mostarResultadosEs(BufferedReader bufferedReaderE): string+filtroURLE(String cadenaURL): string+BuscarEsp(String palabra): string

Interpretador

+interp: string+path: string+IDEQL: string+NEqL1: string+IDEQV: string+NEqV2: string+tablaEq: Hashtable+etiquetaAuxiliar: string+etiquetaAnterior: string+etiquetaActual: string+clave: string+oracion: string+fraseAuxiliar: string+fraseAnterior: string+fraseActul: string+palabraDivoracion: string+etiqPO: string+palabraInst.string+IDIN: string+FraseSep: string+claseIn: string+DatosRecAc: ResultSet+ConsultaDI: string+NombreRecP: string+FechaCumpRecP: string+LugarORecP: string+PosicionRecP: string+EstaturaRecP: string+EquipoRecP: string+NumeroRecP: string+ApodoroRecP: string+EQAnteriorRecP: string+SignificadoRec: string+ConsultaDA: string+etq1: string+etq2: string+etq3: string+etqAnt1: string+etqAnt2: string+etqAnt3: string+etqAux1: string+etqAux2: string+etqAux3: string

+interpreta3(String IDINSPartido, String partido, String InfoEqLoc, String InfoEqVis, String linea, int a): string

Principal

+urlEquipos3: string+CenlaceEquipos: string+urlEquipos: string+urlEquipos2: string+IDEq: int+ObIdPartido: ResultSet+ClaseUJ: string+ClaseBuJ: string+ProcJug: string+BusquedaUrl: string+PosjJG: string+BusquedaUrl2: string+BusquedaUrl3: string+jugador: string

+Equipos(String equipos): void+ProcesaJug(String url, String palabra): string+Jugadores(String palabra): string

SASemViD

+ruta: string+EqLocal: string+EqVis: string+fechaSi: string+fechaPartido: string+Partido: string+MatchExiste: ResultSet+Partidoex: int+IDPartido: int+comentario: string+palabraclave: string+PalabrasRep: string+claLoc: string+urlAcSan: string+SignificadoPCA: string+mensaje: string+ChecarArch: JFileChooser+path: string+CajaText: JTextField+fr: FileReader+br: BufferedReader+texto: string+BtnExaminar: JButton+BtnLeerArch: JButton+Eti1NSis: JLabel+Eti2NSis: JLabel+EtiRuta: JLabel+PanelTitSis: JPanel+SiglasSistema: JLabel+instancias: JButton

+Ejecucion(String comentarios, String path1, BufferedReader br): string+BtnExaminarActionPerformed(java.awt.event.ActionEvent evt): void+BtnLeerArchActionPerformed(java.awt.event.ActionEvent evt): void+instanciasActionPerformed(java.awt.event.ActionEvent evt): void

Sinonimos

+sinonimo: string+SinCom: string+SinPersona: string+SinEquipo: string

+BuscaSinonimo(String palabra1): string+SininimosCom(String palabra): string+SininimoPersona(String palabra): string+SininimoEquio(String palabra): string

etiquetador

+valorEt1: string+tagger: MaxentTagger+br: BufferedReader+texto: string+sample: string+tagged: string+archivo: File+escribir: FileWriter

+etiqueta(String path): string

expresion

+r1: string+arb: string+hrI: string+br: BufferedReader+1-91: Pattern+1-91: Matcher+comentarioUEFAMXEngOne: string

+ExpFIFA(String solotextcom1): string+ExpUEFAMXEngOne(String solotextcom2): string+ExpComunes(String solotextcom): string+Exarbitro(String path): string+hrInico(String path): string

ontologia

+owlBase: string+baseURI: string+NS: string+model: OntModel+action1: OntClass+sanction1: OntClass+Clase: string+Clase1: string+SumaClase: string+clase: string+palabraSin: string+buscaClaseS: string+buscaClase: string+ClaseJ: string+SumaClaseJ: string+buscaClaseJ: string+palabraJ: string+palabraSinJ: string+buscaClaseSJ: string+claseJ: string+accion-sancion: ArrayList+pocision: ArrayList+SuperC: string+BClaseS: string+persona: string

+BuscarClases(String palabraC): string+BuscarClasesJug(String palabraC): string+BuscaClaseID(String palabra): string

Anexos

84

Figura Anexo 3. 2: Diagrama de clases del módulo 1

Anexos

85

Figura Anexo 3. 3: Diagrama de clases del módulo 2

Anexos

86

Figura Anexo 3. 4: Diagrama de clases módulo 3

87

Referencias

Abburu, Sunitha, y R. J. Anandhi. 2010. «Concept Ontology Construction for Sports Video». En Proceedings of the 1st Amrita ACM-W Celebration on Women in Computing in India, 50:1–50:6. A2CWiC ’10. New York, NY, USA: ACM. doi:10.1145/1858378.1858428. http://doi.acm.org/10.1145/1858378.1858428.

«Apache Jena - Apache Jena». 2013. Accedido junio 8. http://jena.apache.org/.

Bechhofer, Sean, Frank van Harmelen, Jim Hendler, Ian Horrocks, Deborah L. McGuinness, Peter F. Patel-Schneider, y Lynn Andrea Stein. 2004. «OWL Web Ontology Language Reference». W3C Recommendation. OWL Web Ontology Language Reference. febrero 10. http://www.w3.org/TR/owl-ref/.

Berners-Lee, Tim. 2009. «Web architecture: Metadata». Informativa. Axioms of Web Architecture: Metadata. agosto 27. http://www.w3.org/DesignIssues/Metadata.html.

Berners-Lee, Tim, James Hendler, y Ora Lassila. 2001. «The Semantic Web A new form of Web content that is meaningful to computers will unleash a revolution of new possibilities». Scientific American. 284 (mayo): 34-43. doi:10.1038/scientificamerican0501-34.

Borst, Willem Nico. 1997. «Construction of Engineering Ontologies for Knowledge Sharing and Reuse». Thesis, Enschede: Dutch research school for Information and Knowledge Systems (SIKS). http://doc.utwente.nl/17864/.

Cho, Miyoung, Dan Song, Juhyun Shin, Hanil Kim, y Pankoo Kim. 2005. «An event-description framework for video application using spatio-temporal relations». An event-description framework for video application using spatio-temporal relations (enero 17).

«Desarrollo de programas Java con JDK». 2013. Accedido junio 8. http://www.java.com/es/download/faq/develop.xml.

Embley, David W., Stephen W. Liddle, Deryle W. Lonsdale, Yuri A. Tijerino, Troy Walker, Alan Wessman, y Li Xu. 2006. «Semantic Annotation for the Semantic Web». Proyecto de investigación. Semantic annotation for the semantic web. abril. http://www.deg.byu.edu/ding/research/SemanticAnnotation.html.

«Expresiones regulares para buscar texto». 2013. Accedido junio 7. http://docs.bentley.com/es/PowerDraft/drafthelp1174.html#nowhere.

Gokturk, Z. Ö, N.K. Cicekli, y I. Cicekli. 2008. «Metadata extraction from text in soccer domain». Computer and Information Sciences, 2008. ISCIS ’08. 23rd International Symposium on: 1-6. doi:10.1109/ISCIS.2008.4717935.

Gokturk, Z. ÖZKAN, Ilyas Cicekli, Nihan Kesim Cicekli, Volkan Atalay, y Canan Özgen. 2008. «Metadata extraction from text in soccer domain». Thesis-The degree of master of science in computer engineering, Turkey: Middle East Technical University. https://etd.lib.metu.edu.tr/upload/12609871/index.pdf.

Gokturk, Z.O., N.K. Cicekli, y I. Cicekli. 2008. «Metadata extraction from text in soccer domain». Computer and Information Sciences, 2008. ISCIS ’08. 23rd International Symposium on: 1-6. doi:10.1109/ISCIS.2008.4717935.

Gómez-Pérez, Asunción, Mariano Fernández-López, y Oscar Corcho. 2008. Ontological Engineering : With Examples from the Areas of Knowledge Management, E-Commerce and the Semantic Web. London, Goldaming: Springer.

«google.dirson.com - google API APIs». 2013. Accedido junio 8. http://google.dirson.com/api.php.

88

«google-api-java-client - Google APIs Client Library for Java - Google Project Hosting». 2013. Accedido junio 9. https://code.google.com/p/google-api-java-client/.

Gruber, Thomas R. 1993a. «A translation approach to portable ontology specifications». Knowledge Acquisition 5 (2) (junio): 199-220. doi:10.1006/knac.1993.1008.

Gruber, Thomas R. 1993b. «Toward Principles for the Design of Ontologies Used for Knowledge Sharing». Technical Report KSL 93-04. International Workshop on Formal Ontology,Padova, Italy: Stanford University.

Guarino, N. 1998. «Formal ontology in information systems : proceedings of the first international conference (FOIS’98), June 6-8,Trento, Italy». En FOIS’98, 3-15. Frontiers in artificial intelligence and applications. Trento, Italy: IOS Press ; Omsha.

Hopcroft, J.E., R. Motwani, y J.D: Ulman. 2007. Introducción a la teoría de autómatas, lenguajes y computación. Tercera Edición. Madrid: PEARSON EDUCACIÓN S.A. http://computacion.cs.cinvestav.mx/~efranco/docencia/teoriacomputacional/files/books/TeoriaDeAutomatas,lenguajesYComputacion-Hopcroft.pdf.

INEGI. 2003. «Metadatos». Consulta. Metadatos. marzo 3. http://antares.inegi.org.mx/metadatos/metadat1.htm.

«Java SE Downloads». 2013. Accedido junio 8. http://www.oracle.com/technetwork/java/javase/downloads/index.html.

«JDBC.pdf - JDBC.pdf». 2013. Accedido junio 8. http://cs.mty.itesm.mx/profesores/raul.perez/DAD/JDBC.pdf.

«JSON». 2013. Accedido junio 9. http://www.json.org/.

Kiryakov, Atanas, Borislav Popov, Ivan Terziev, Dimitar Manov, y Damyan Ognyanoff. 2004. «Semantic annotation, indexing, and retrieval». Web Semantics: Science, Services and Agents on the World Wide Web 2 (1) (diciembre 1): 49-79. doi:10.1016/j.websem.2004.07.005.

Kiyavitskaya, Nadzeya, Nicola Zeni, Travis D. Breaux, Annie I. Antón, James R. Cordy, Luisa Mich, y John Mylopoulos. 2007. «Extracting rights and obligations from regulations: toward a tool-supported process». En Proceedings of the twenty-second IEEE/ACM international conference on Automated software engineering, 429-432. Atlanta, Georgia, USA: ACM.

Kiyavitskaya, Nadzeya, Nicola Zeni, James R. Cordy, Luisa Mich, y John Mylopoulos. 2009. «Cerno: Light-weight tool support for semantic annotation of textual documents». Including Special Section: 21st IEEE International Symposium on Computer-Based Medical Systems (IEEE CBMS 2008) – Seven selected and extended papers on Biomedical Data Mining 68 (12) (diciembre): 1470-1492. doi:10.1016/j.datak.2009.07.012.

Kiyavitskaya, Nadzeya, Nicola Zeni, Luisa Mich, JamesR. Cordy, y John Mylopoulos. 2006. «Text Mining Through Semi Automatic Semantic Annotation». En Practical Aspects of Knowledge Management, editado por Ulrich Reimer y Dimitris Karagiannis, 4333:143-154. Lecture Notes in Computer Science. Springer Berlin Heidelberg. http://dx.doi.org/10.1007/11944935_13.

Laclavík, Michal, Martin Seleng, y Marían Babík. 2007. «OnTeA Semi-automatic Ontology based Text Annotation Method». En Tools for acquisition, organisation and presenting of information and knowledge : proceedings in informatics and information technologies, 119-129. Bratislava: Vydavatelstvo STU.

89

Laclavík, Michal, Martin Šeleng, Marek Ciglan, y Ladislav Hluchý. 2009. «Ontea: Platform for Pattern Based Automated Semantic Annotation». Computing and Informatics 28 (4) (mayo 13): 1000-1024.

Linsley, Peter. 2013. «Using Regular Expressions in Database Applications». Oracle. Accedido junio 7. http://www.oracle.com/technetwork/es/articles/sql/expresiones-regulares-base-de-datos-1569340-esa.html.

«MySQL :: MySQL 5.1 Reference Manual :: 1.3.1 What is MySQL?» 2013. Accedido junio 8. http://dev.mysql.com/doc/refman/5.1/en/what-is-mysql.html.

«MySQL :: The world’s most popular open source database». 2013. Accedido junio 8. http://www.mysql.com/.

«MySQL :: Using MySQL With Java». 2013. Accedido junio 8. http://dev.mysql.com/usingmysql/java/.

Natarajan, P., y R. Nevatia. 2005. «EDF: A framework for Semantic Annotation of Video». Computer Vision Workshops, 2005. ICCVW’05. Tenth IEEE International Conference on: 1876–1876. doi:10.1109/ICCV.2005.255.

Navarro-Galindo, José L., y José Samos. 2011. «FLERSA: Soporte a la Definición de Anotaciones y Búsquedas Semánticas en un CMS». En JISBD 2011. A Coruña. http://www.sistedes.es/Actas/2011_coruna/JISBD/tabla-contenidos.html;

«NetBeans IDE - Overview». 2013. Accedido junio 7. https://netbeans.org/features/index.html.

Popov, Borislav, Atanas Kiryakov, Angel Kirilov, Dimitar Manov, Damyan Ognyanoff, y Miroslav Goranov. 2003. «KIM – Semantic Annotation Platform». En The Semantic Web - ISWC 2003, 2:834-849. Lecture Notes in Computer Science -Second International Semantic Web Conference, Sanibel Island, FL, USA,2003. Germany: Springer Berlin Heidelberg. http://link.springer.com/chapter/10.1007%2F978-3-540-39718-2_53?LI=true#page-1.

Rajput, Quratulain, y Sajjad Haider. 2011a. «A comparison of ontology-based and reference-set-based semantic annotation frameworks». World Conference on Information Technology 3 (0): 1535-1540.

Rajput, Quratulain, y Sajjad Haider. 2011b. «BNOSA: A Bayesian network and ontology based semantic annotation framework». Provenance in the Semantic Web 9 (2) (julio): 99-112.

RDF Working Group. 2004. «RDF - Semantic Web Standards». W3C Recommendations. Resource Description Framework (RDF). febrero 10. http://www.w3.org/RDF/.

«Real Academia Española». 2013. Dictionary. Real Academia Española. http://www.rae.es/rae.html.

Reeve, Lawrence, y Hyoil Han. 2005. «Survey of semantic annotation platforms». En SAC ’05, 1634-1638. New York, NY, USA: Lorie M. Liebrock. doi:10.1145/1066677.1067049. http://doi.acm.org/10.1145/1066677.1067049.

«Semantic Annotation | Ontotext». 2013. Ontotext. http://www.ontotext.com/kim/semantic-annotation.

Senso, José A., y Antonio de la Rosa Piñero. 2003. «El concepto de metadato. Algo más que descripción de recursos electrónicos». Ciência da Informação, agosto.

Studer, Rudi, V.Richard Benjamins, y Dieter Fensel. 1998. «Knowledge engineering: Principles and methods». Data & Knowledge Engineering 25 (1–2) (marzo): 161-197. doi:10.1016/S0169-023X(97)00056-6.

90

TechTerms. 2012. «Metadata Definition». Dictionary. TechTerms.com. Accedido noviembre 27. http://www.techterms.com/definition/metadata.

«The Protégé Ontology Editor and Knowledge Acquisition System». 2013. Accedido junio 8. http://protege.stanford.edu/.

«The Stanford NLP (Natural Language Processing) Group». 2013. Accedido junio 9. http://nlp.stanford.edu/software/tagger.shtml.

Tseng, V.S., Ja-Hwung Su, Jhih-Hong Huang, y Chih-Jen Chen. 2008. «Integrated Mining of Visual Features, Speech Features, and Frequent Patterns for Semantic Video Annotation». Multimedia, IEEE Transactions on 10 (2) (febrero): 260–267. doi:10.1109/TMM.2007.911832.

«Tutoriales gratis - Java - Expresiones regulares». 2013. Accedido junio 7. http://www.tutorial-es.com/programacion/java/52-java-expresiones-regulares.

Xu, Changsheng, Jinjun Wang, Hanqing Lu, y Yifan Zhang. 2008. «A Novel Framework for Semantic Annotation and Personalized Retrieval of Sports Video». IEEE Transactions on Mmultimedia 10 (abril): 421 - 436. doi:10.1109/TMM.2008.917346.

Documents

Centro Nacional de Investigación y Desarrollo Tecnológico · Cuernavaca, Morelos, México. Diciembre de 2013. Centro Nacional de Investigación y Desarrollo Tecnológico Subdirección