FYI according to FrameNet,

https://framenet2.icsi.berkeley.edu/fnReports/data/frameIndex.xml?frame=Create_sensation

a frame-based rendering of "Ben appears ridiculous" would be

EvaluationLink
    Phenomenon
    ListLink
       appear_88
       Ben

EvaluationLink
   Appraisal
   ListLink
      appear_88
      ridiculous

Inheritance appear_88 appear

Inheritance appear Perception

...

so in this case instead of Agent/Patient we have Phenomenon/Appraisal ...

Of course FrameNet is not all-knowing and an OpenCog system could use a
different method for disambiguation of semantic roles...

-- Ben




On Thu, Jun 5, 2014 at 8:48 AM, Ben Goertzel <ben@goertzel.org> wrote:

>
> Sebastian,
>
> You raise a good point regarding the use of frame-based versus
> non-frame-based representations.
>
> We have been using a non-frame-based approach for Subjects and Objects of
> verbs....   However I have now suggested using more of a frame-based
> approach for other verb arguments.   This raises the question of whether it
> might be better to use a frame-based approach for Subjects and Objects as
> well.
>
> Indeed it might be.  I can think of two arguments against the frame-based
> approach:
>
> 1)  It uses more Atoms
>
> 2)  We already have a bunch of RelEx2Logic rules written using the
> non-frame-based approach, and it would be a pain for Ruiting and Rodas and
> others to rewrite them into a frame-based approach ;p
>
> In the end the two approaches are semantically equivalent and are both
> fairly simple, so it doesn't seem a huge deal...
>
> ...
>
> I will elaborate a bit further, so others understand the issue fully and
> can express their own views...
>
> In an OpenCog predecessor system,  instead of  e.g.
>
> EvaluationLink
>     eat
>     ListLink
>          Ben
>          stir-fried caterpillar
>
>
> we  used a frame-based format like
>
> EvaluationLink
>      Agent
>      ListLink
>          eat99
>          Ben
>
> EvaluationLink
>      Patient
>      ListLink
>          eat99
>          stir-fried caterpillar
>
> Inheritance eat99 eat
>
> This is OK.... However, apart from using more Atoms, the problem w/ this
> is that in many cases, disambiguating whether the first argument (the
> subject of a verb, say) is really an "agent" or not becomes tricky....
> For instance in the case
>
> EvaluationLink
>      appear
>      ListLink
>            Ben
>            ridiculous
>
> Ben is not the Agent and ridiculous the Patient ...
>
> So figuring out the right semantic role label for the subject and object
> of a verb gets tricky, meaning that before one does (PLN-based?) semantic
> disambiguation one will have a lot of Atoms like
>
> EvaluationLink
>      map_of_Subject
>      ListLink
>          eat99
>          Ben
>
> EvaluationLink
>      map_of_Object
>      ListLink
>          eat99
>          stir-fried caterpillar
>
> Inheritance eat99 eat
>
> EvaluationLink
>      map_of_Subject
>      ListLink
>          appear44
>          Ben
>
> EvaluationLink
>      map_of_Object
>      ListLink
>          appear44
>          ridiculous
>
> Inheritance appear44 appear
>
> ...
>
> This frame-based approach is not really wrong and could possibly be a
> better approach...   But it doesn't add any meaning over the style where
> one says
>
> EvaluationLink
>     eat
>     ListLink
>          Ben
>          stir-fried caterpillar
>
> EvaluationLink
>      appear
>      ListLink
>            Ben
>            ridiculous
>
> and it does introduce a bunch of extra Atoms...
>
> In either case once one finds out the actual role played by the subject
> and object one has to create new Atoms....  So in the non frame based case,
> if one find out Ben is the Agent and stir-fried caterpillar is the Patient,
> one can still create
>
> EvaluationLink
>      Agent
>      ListLink
>          eat99
>          Ben
>
> EvaluationLink
>      Patient
>      ListLink
>          eat99
>          stir-fried caterpillar
>
> Note that, to do the semantic disambiguation, the Atomspace could contain
> general knowledge of the form
>
> Implication
>    Evaluation
>        eat
>        ListLink
>            $X
>            $Y
>    ThereExists $Z
>         ANDLink
>             Inheritance $Z eat
>             EvaluationLink Agent (ListLink $Z $X)
>             EvaluationLink Patient (ListLink $Z $Y)
>
> expressing knowledge about the semantic roles of the subject and object of
> "eat", or
>
>
> Implication
>    ANDLink
>        Evaluation
>           map_from_Subject
>           ListLink
>              $X
>              $Y
>        InheritanceLink $X eat
>    Evaluation
>        Agent
>        ListLink
>            $X
>            $Y
>
>
> Implication
>    ANDLink
>        Evaluation
>           map_from_Object
>           ListLink
>              $X
>              $Y
>        InheritanceLink $X eat
>    Evaluation
>        Patient
>        ListLink
>            $X
>            $Y
>
>
> In this case the disambiguation is easy -- the subject of "eat" is pretty
> much always the Agent, and the object the Patient.  In many cases, it's
> less obvious and the disambiguation requires some context...
>
> In short, you may be right that it's inelegant to treat the Subject and
> Object of a verb using non-frame-based representation, and the other
> arguments of the verb (e.g. expressed via prepositions or relative
> clauses)  using frame-based representation.   Using frame-based
> representation for everything would be more consistent.   On the other
> hand, it doesn't seem to matter much, because if PLN can't effectively
> convert btw these sorts of similar representations, it won't be able to do
> any interesting conceptual inferences either....
>
> Also, we note that in the case where the function-argument relation is
> defined by, say, a preposition rather than a subject or object slot, we
> usually have a little more information about the meaning, e.g. we my have
>
> EvaluationLink
>      in
>      ListLink
>           Ben999
>           house
>
> Here we have "in" instead of something even vaguer like "map_of_Subject"
> because the syntax of English uses the word "in" to denote the
> function-argument relationship, rather than just using the position in the
> sentence (as in the case of Subject).
>
> Note that I am using "map_of_Subject" as a PredicateNode name here instead
> of "Subject" to emphasize the point that Subject is a syntax-level
> relationship, vs. Agent and Patient which are semantics-level
> relationships...   Of course this is a fuzzy distinction, and e.g. "in" is
> being used in both semantic and syntactic forms.
>
> In the end language is a mess, and there is always gonna be some mess in
> mapping language into any formal system.  As long as the mappings used are
> relatively simple, and are mutually consistent with each other, a suitably
> powerful reasoning engine should be able to sort out the mess.....
> Ultimately the hard problem is inferring contextual knowledge from the mass
> of mess, and using it to guide judgments; and the hardness of this is
> probably not dependent on the particular choices of how to arrange the
> representations of individual semantic features...
>
> -- Ben
>
>
>
> On Wed, Jun 4, 2014 at 1:14 AM, Sebastian Ruder <notifications@github.com>
> wrote:
>
>> In tests/python/test_pln/scm/relex2logic_pln_examples/context-link.scm:
>>
>> > +        ; "I like eating bass."
>> > +        ; RelEx at the moment delivers the wrong output for this sentence.
>> > +        ; Eating is interpreted as an adjective:
>> > +        ; _obj(like, bass)
>> > +        ; _subj(like, I)
>> > +        ; _amod(bass, eating)
>> > +        ; The output produced by RelEx2Logic should be:
>> > +        (EvaluationLink
>> > +            (PredicateNode "like")
>> > +            (ListLink
>> > +                (ConceptNode "I")
>> > +                (EvaluationLink
>> > +                    (PredicateNode "eat")
>> > +                    (ListLink
>> > +                        (ConceptNode "I")
>> > +                        (ConceptNode "bass@12345")))))
>>
>> @bgoertzel <https://github.com/bgoertzel>, I understand the logic behind
>> it: I think this is the most consistent way and preempts other, more
>> difficult cases where the subject of the subordinate clause isn't the same
>> as for the main clause and makes the representation analogous to
>> that-clauses. Even so, I would appreciate it if you could comment briefly
>> why you didn't choose to use a link for such cases containing only verb and
>> object:
>>
>> (EvaluationLink
>>     (PredicateNode "like ")
>>     (ListLink
>>         (ConceptNode "I")
>>         (TodoLink/GerundLink
>>             (PredicateNode "eat")
>>             (ConceptNode "bass@12345"))))
>>
>> Or why you didn't choose to make like, say, ternary, as kind of a thought
>> experiment:
>>
>> (EvaluationLink
>>     (PredicateNode "like ")
>>     (ListLink
>>         (ConceptNode "I")
>>         (PredicateNode "eat")
>>         (ConceptNode "bass@12345"))))
>>
>> Anyway, I pushed a partial explanation for this as requested by Linas.
>>
>> —
>> Reply to this email directly or view it on GitHub
>> <https://github.com/opencog/opencog/pull/776/files#r13346447>.
>>
>
>
>
> --
> Ben Goertzel, PhD
> http://goertzel.org
>
> "In an insane world, the sane man must appear to be insane". -- Capt.
> James T. Kirk
>
> "Emancipate yourself from mental slavery / None but ourselves can free our
> minds" -- Robert Nesta Marley
>



-- 
Ben Goertzel, PhD
http://goertzel.org

"In an insane world, the sane man must appear to be insane". -- Capt. James
T. Kirk

"Emancipate yourself from mental slavery / None but ourselves can free our
minds" -- Robert Nesta Marley