predicado RDF ponderado (owl: ObjectProperty)

Question

en RDF una sentencia se representa con S, P y O; En OWL, owl: ObjectProperty representa la lógica de predicados.

(S) (P) (O) 
    I like dog 

<owl:Class rdf:about="Person" /> 
<owl:NamedIndividual rdf:about="I"> 
    <rdf:type rdf:resource="Person"/> 
    <like rdf:resource="Dog"/> 
</owl:NamedIndividual> 

<owl:Class rdf:about="Pet" /> 
<owl:NamedIndividual rdf:about="Dog"> 
    <rdf:type rdf:resource="Pet"/> 
</owl:NamedIndividual> 

<owl:ObjectProperty rdf:about="like"> 
    <rdfs:domain> 
     <owl:Restriction> 
      <owl:onProperty rdf:resource="like"/> 
      <owl:someValuesFrom rdf:resource="Person"/> 
     </owl:Restriction> 
    </rdfs:domain> 
    <rdfs:range> 
     <owl:Restriction> 
      <owl:onProperty rdf:resource="like"/> 
      <owl:someValuesFrom rdf:resource="Pet"/> 
     </owl:Restriction> 
    </rdfs:range> 
</owl:ObjectProperty> 

Pero ¿qué tal si se describe "el grado" que me gustan los perros? ¿Cómo puedo dar una propiedad o valor a un predicado? Una solución que obtuve es extender una declaración (S, P, O) a 3 declaraciones. Por ejemplo,

(S)    (P)  (O) 
Person  isSrcOf LikeRelation 
Pet   isTargetOf LikeRelation 
LikeRelation hasValue [0~100] 

Se debe trabajar, pero, obviamente, que permitirá a la ontología 3 veces más grande :(

Agradezco cualquier sugerencia

Answer 1

No utilizaría RDF reification, no en este caso y casi en ningún caso. La reificación de RDF simplemente hace las cosas siempre más complicadas. Como ha comentado, inflará su ontología, pero no solo eso, también hará que su ontología sea muy difícil para aplicar el razonamiento de OWL.

He tratado el mismo escenario que ha presentado y la mayoría de veces he terminado con el siguiente diseño.

(S) (P) [(P) (O) (P) (O)]
me gusta [ 'lo que me gusta' Dog, 'cuánto me gusta' 'mucho']

Class: LikeLevel //it represents class of things a person likes with a degree factor. 

ObjectProperty: likeObject 
    Domain: LikeLevel 
    Range: Pet //(or Thing) 

ObjectProperty: likeScale 
    Domain: LikeLevel 
    Range: xsd:int //(or an enumeration class i.e: 'nothing', 'a bit', 'very much',...) 

ObjectProperty: like 
    Domain: Person 
    Range: LikeLevel 

Si desea representar algunos datos de la instancia con este modelo (en RDF/sintaxis tortuga):

:I :like [ a :LikeLevel; 
    :likeObject :dogs; 
    :likeScale 5.7] . 

en este caso estoy creando un nodo en blanco para el objeto LikeLevel pero se puede crear una objeto de tierra también, a veces es posible que desee/necesite evitar bNodes. En ese caso:

:I :like :a0001 . 
:a0001 a :LikeLevel; 
    :likeObject :dogs; 
    :likeScale 5.7. 

Este diseño puede ser considerar un caso a la luz de la cosificación, la principal diferencia con RDF reificación es que mantiene el diseño de la ontología en el modelo del usuario.

Answer 2

Su sugerencia es válida uno;! Se llama reificación y es la forma estándar de representar propiedades inherentes a una relación entre dos elementos en una ontología o gráfico RDF, donde las declaraciones se realizan de forma pareja entre los elementos; es una limitación del modelo de datos en sí que hace que la reificación sea necesaria a veces.

Si te preocupa que la cosificación se inflará su ontología, puede probar con el siguiente en su lugar, pero son generalmente menos deseable y vienen con sus propios problemas:

1. Crear propiedades específicas, tales como somewhatLikes, doesntLike , loves; esto puede ser adecuado si tiene un conjunto limitado de alternativas, y no le importa crear las propiedades adicionales. Esto se vuelve tedioso y engorroso (y llegaría a sugerir incorrecto) si tiene la intención de codificar el 'grado de similitud' con un número entero (o cualquier amplia gama de alternativas) - siguiendo este enfoque, usted tienen propiedades como likes0, likes1, ..., likes99, likes100. Este método también evitaría consultar, por ejemplo, todos los perros que a una persona le gusta dentro de un rango de valores de grado, lo cual es posible en SPARQL con el enfoque de reificación que ha especificado, pero no con este enfoque.
2. Acople la propiedad likesDogs a la Person ejemplo, si la afirmación se puede hacer contra la persona en todas tipos/instancias de Dog, y no casos individuales. Esto, por supuesto, dependerá de lo que intente capturar aquí; si es el último, entonces esto tampoco será apropiado.

¡Buena suerte!

Answer 3

Una frase del documento de Jena me llama la atención.

...OWL Full allows ... state the following .... construction: 

<owl:Class rdf:ID="DigitalCamera"> 
    <rdf:type owl:ObjectProperty /> 
</owl:Class> 
.. 

¿OWL Full realmente permite que ObjectProperty sea una clase también? Si un ObjectProperty podría ser una clase, y podría tener individuos entonces podría describir una declaración con

S_individual P_individual O_individual 

y podría tener otras propiedades en P_individual. ¿Es correcto? o me faltan algunos puntos?

dado que el siguiente RDF es válido, se debe poder obtener un TIMO correspondiente.

<rdf:RDF 
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" 
    xmlns:j.0="http://somewhere/" > 

    <rdf:Description rdf:about="http://somewhere/Dog_my_dog"> 
    <j.0:name>Lucky</j.0:name> 
    </rdf:Description> 
    <rdf:Description rdf:about="http://somewhere/like_dog"> 
    <j.0:degree>80</j.0:degree> 
    </rdf:Description> 

    <rdf:Description rdf:about="http://somewhere/Cat_my_cat"> 
    <j.0:name>Catty</j.0:name> 
    </rdf:Description> 
    <rdf:Description rdf:about="http://somewhere/like_cat"> 
    <j.0:degree>86</j.0:degree> 
    </rdf:Description> 

    <rdf:Description rdf:about="http://somewhere/Person_I"> 
    <j.0:name>Bob</j.0:name> 
    <j.0:like_dog rdf:resource="http://somewhere/Dog_my_dog"/> 
    <j.0:like_cat rdf:resource="http://somewhere/Cat_my_cat"/> 
    </rdf:Description> 

</rdf:RDF> 

Answer 4

Creo que @msalvadores se equivoca.

Olvidémonos de los perros y me gusta. Lo que realmente estamos haciendo aquí es:

a x b 
axb y c 
axb z d 

donde axb es el identificador de la declaración a x b, a, b, c, d son sujetos u objetos y x, y, z son predicados. Lo que necesitamos es vincular los recursos de a, x, b a la declaración axb de alguna manera.

Esta es la forma en la cosificación lo hace:

axb subject a 
axb predicate x 
axb object b 

que creo que es muy fácil de entender.

Vamos a ver lo que msalvadores hace:

:I :like [ a :LikeLevel; 
    :likeObject :dogs; 
    :likeScale 5.7] . 

podemos traducir fácilmente esto a axb términos

a x w 
w type AxbSpecificObjectWrapper 
w object b 
w y c 

que se acaba imitando la cosificación con herramientas de baja calidad y más esfuerzo (se necesita una clase contenedora y define una propiedad del objeto). La declaración a x w no tiene sentido para mí; Me gusta un nivel similar, ¿qué objetos son perros?

¿Pero cómo describir "el grado" que me gustan los perros?

Hay dos maneras de hacerlo, por lo que puedo decir, con mi conocimiento de RDF muy limitado.

1.) utilizan la cosificación

stmt_1 
    a LikeStatement 
    subject I 
    predicate like 
    object dogs 
    how_much "very much" 

2.) una instancia de una clase de predicados

I like_1 dogs 
like_1 
    a Like 
    how_much "very much" 

Depende de su gusto y su vocabulario real que uno elija.

¿Cómo puedo dar una propiedad o valor a un predicado?

No creo que entienda la diferencia entre un predicado y un enunciado. Un gran ejemplo de ello está disponible aquí: Simple example of reification in RDF

Tolkien wrote Lord of the rings 
Wikipedia said that 

La declaración aquí:

that: [Tolkien, wrote, LotR] 

Si estamos haciendo declaraciones acerca de la declaración, se escribe así:

[Wikipedia, said, that] 

Si estamos haciendo afirmaciones sobre el predicado, escribimos algo como esto:

[Wikipedia, said, wrote] 

Creo que hay una gran diferencia. La reificación se trata de hacer afirmaciones sobre afirmaciones no sobre predicados ...