[Pellet-users] ranking in matchmaking..

[Krishna]

Hi,
  
  I tried to add more jobs and persons in your example. After a long try  could get more than a single job in the query result. The problem was  that I did not specify minimum requirement for additional jobs, which  seems  must. Am I right?
  
  Would you explain little more how this query acertain that the person in the result  have fulfilled minimum requirements. 
  
  Thanks again for your valuable response. 
  
  Krishna
  
  

"Ibach, Brandon L" <brandon.l.ibach at lmco.com> wrote:          Hi, Krishna...
      It looks like you're using approximately the   approach I demonstrated with my example a while back, so I've attached an   extended version that example that demonstrates a possible solution for   ranking.  The solution makes use of the "punning" feature of OWL 1.1,   which allows you to have a class, property and individual (or any combination of   those) all with the same name, but having no effect on the semantics of each   other.  Having the same name, though, allows you to tie them together at   the RDF level, so queries such as with SPARQL can integrate data across these   lines.
      As before, the example job has qualifications of   1) Person must be a citizen of Vietnam or Thailand, 2) Computer Science degree   and 3) skill in Object Oriented programming.  Each of these qualifications   is modeled with a separate class (citOfVOrT, degCS and sklOO,   respectively).  I've chosen to make the citizenship qualification an   absolute requirement, such that those persons who are not citizens will not be   considered at all.  Therefore, the class representing this job,   jobCSOOVOrT, is made equivalent to the class representing the citizenship   qualification.  The ontology uses intersectionOf, for this, even though   there is only the one required qualification, but I left it in to show how   multiple qualifications could be included.
      For the other qualifications (CS degree and OO   skill), I created a Qualification class whose members will be individuals with   the same name as qualification classes (degCS and sklOO, in our example).    A floating-point weight value must be specified for each   desired qualification.  This allows emphasis to be placed on certain   qualifications over others when ranking CVs.  Each job class will have a   datatype property created which will be a sub-property of   qualificationWeight.  Each desired qualification will use this property to   specify the weight for that qualification.
      This sub-property mechanism is a means   of getting around the lack of higher arity relations in OWL, as the property   itself carries the knowledge of which job class it relates to.  To make   this knowledge explicit so that the query can operate on it, a hasQual property   relates an individual with the same name as the job class to an individual with   the same name as the datatype property.  As a side note, a similar   technique could be used to, for example, specify for a CV the number of years of   experience in a particular skill.  A base datatype property, such as   hasExperience, would setup the domain and range, then a sub-property of that for   each skill would be used to specify the value for an individual CV.    Another property, similar to hasQual in our example, would relate the skill   to an individual with the same name as the property that represents   experience in the skill.  OWL 1.1's user-defined datatype mechanisms could   then be used to define
 qualification classes for different ranges of experience   in a given skill.
      Back to the example, the following query will   produce results listing a person (CV), job, qualification and ranking weight   value for those who meet the minimum requirements for the job and some   additional qualifications.
   
  PREFIX rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX   rdfs: <http://www.w3.org/2000/01/rdf-schema#>
PREFIX   jobs: <http://www.owl-ontologies.com/jobs.owl#>
   
  SELECT ?pers ?job ?qual ?weight
WHERE { ?pers rdf:type   jobs:Person .
        ?job rdfs:subClassOf   jobs:Job .
        ?pers rdf:type ?job   .
        ?job jobs:hasQual ?prop   .
        ?qual ?prop ?weight   .
        ?pers rdf:type ?qual   }

      Summing the weight values for each   combination of CV and job will produce a ranking.  I think this is probably   the least programming-intensive way to do something like this, since OWL (and   therefore Pellet) doesn't provide a way to talk about partial matches to a   class, nor a reasoner would decide which partial match is better than   another.  Of course, there's probably some good papers out there about   general approaches and how such a mechanism could be added directly to a   language like OWL, but that's a little beyond my scope, at the moment.   :)
      Note that this query and the attached ontology   have been tested with Pellet 1.4.  I'm fairly sure this version is   required, as it provides the support for OWL 1.1 punning.  On that note,   though (hey, Evren!), I did get the following warnings when running this query   at the command line:
   
  Non OWL-DL features used:
Multiple Types: Resource   jobs:degCS  is defined both as Class and Individual
Multiple Types:   Resource jobs:jobCSOOVOrT  is defined both as Class and   Individual
Multiple Types: Resource jobs:sklOO  is defined both as an   individual and a class
Multiple Types: Resource jobs:hasQual  is used as   an individual but defined as aclass

      I assume this is just Pellet not   handling species determination in the presence of OWL 1.1 feature   use very well (a known problem in 1.4)?  Naturally, the use of punning   DOES make this non-OWL-DL, so the warnings are correct.  However, the last   one struck me as odd, since hasQual is not used as an individual, but does cause   jobCSOOVOrT-q, which is defined as a datatype property, to also be used as   an individual.
      I hope this example and explanation are   reasonably clear and helpful.  Kudos to the OWL 1.1 gang for including   punning in the new features!
  -Brandon :) 
   

    
---------------------------------
  From: pellet-users-bounces at lists.owldl.com   [mailto:pellet-users-bounces at lists.owldl.com] On Behalf Of   Krishna
Sent: Monday, May 14, 2007 1:01 PM
To:   Pellet-users at lists.owldl.com
Subject: [Pellet-users] ranking in   matchmaking..


  
Hi all,
After getting some idea from this group and some study, I   have learnt to match job with CV. In my ontology  I have CV as individual   of class PERSON and jobs as subclasses of JOB class. with this approach I can   only decide if certain CV matches with a job or not. But I can't rank them.   

If I had modelled CV as subclasses, I  could have divided them into   match classes( exact, full, plugin,  intersection or disjoint). But still I   can't make rank of CVs? can I do so?

Is there someway to do it (with some   coding)  or what can be  done for getting rank in a same match group   ?

Thanks in advance.
Krishna
    

---------------------------------
  Yahoo! oneSearch: Finally, mobile   search that gives answers, not web links. 

       
---------------------------------
Luggage? GPS? Comic books? 
Check out fitting  gifts for grads at Yahoo! Search.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://lists.owldl.com/pipermail/pellet-users/attachments/20070624/35833551/attachment.htm