Re: Modeling fictional characters in movies and TV

A tiny bit of correctness from the movie industry...

A Movie or Film has a Story/Screenplay which has the Characters created by
someone typically an Author, where those Characters IN THE STORY are
portrayed IN THE FILM by Actors.

The Film's Story (a Creative Work) is where the Characters could land.

In Freebase we decided however to create a Fictional Character class to
reuse for lots of things like Comics, Books, Video Games, Fictional
Universes, at large.



On Mon, Jan 14, 2013 at 5:00 AM, Richard Wallis <richard.wallis@oclc.org>wrote:

>  Hi Greg,
>
> I think we are sort of generally agreeing ;-)
>
> Firstly I would suggest that character does become a type in its own right
> – to support the wider understanding of the specialness of fictitious
> people.  As you recognised characters appear in many things other than
> movies & TV, so I would suggest the property should be placed upon
> CreativeWork to cover books, plays, poems etc. too.
>
> I also think it would be a missed opportunity, not to enable the
> description of fictional organizations, places, things etc.  How for
> instance would you differentiate the descriptions of MI6 and SMERSH in
> the early bond films/books, or Bristol and Lilliput in Gulliver’s travels?
>
>
> I know this may be a little broader than you intended, but I think it
> would be valuable for this group to work upon.
>
> Not so sure why you think that the ‘referencedIn’ property doesn’t work –
> is it the way I have done it, or you think it is superfluous?  If it is the
> latter I was looking to it as an inverse property of character so that
> starting with a character (or a fictional thing, you could describe the
> books/movies that it appears in.
>
> ~Richard.
>
>
>
>
> On 14/01/2013 10:24, "Gregg Kellogg" <gregg@greggkellogg.net> wrote:
>
> On Jan 14, 2013, at 10:32 AM, Richard Wallis <richard.wallis@oclc.org>
> wrote:
>
> Re: Modeling fictional characters in movies and TV
> Hi Gregg,
>
> Referencing the other current thread on this list about the purpose of
> Schema.org <http://Schema.org>  and the breadth and purpose of the list
> itself, I am looking at this from the point of view of someone marking up
> their web pages.  Using the additionalType property, I come up with
> something like this in Microdata:
>
> <div itemscope itemtype="http://schema.org/Person" <
> http://schema.org/Person%22> >
>
>    <link itemprop="additionalType" href="http://schema.org/FictionalThing"
> />
>    <span itemprop="name">Harry Potter</span>
>    Affiliation:
>    <span itemprop="affiliation">Hogwarts</span>
>    <div itemscope itemtype="http://schema.org/FictionalThing" <
> http://schema.org/FictionalThing%22> >
>
>     From the book:  <span itemprop="referencedIn">Harry Potter and the
> Philosopher’s Stone</span>
>   </div>
> </div>
>
>
> Actually, I don't think you want to nest the "referencedIn" property
> within it's own item.
>
> I am deliberately resisting the urge to create a Character class, as it is
> an approach that will obviously not scale across all the fictitious things
> that we could come across.   How is this different to saying that a thing
>  we are describing is a schema:Book with an additionalType of schema:Offer
> so that we can so that we can describe both its creative work and product
> or sale properties.
>
>
> The reason I proposed a Character type is because I think that a missing
> property from Movie, TVEpisode and so-forth is, in fact, schema:character.
> To say that a Movie has a name, director and actors, but not characters,
> seems to be missing a big part about what people expect from movies, books
> or TV shows. After all, it's the characters that draw people to these
> things, it's just the actors that help realize it. Given the need for a
> character property, what is it's expected range? Thus, my proposal to add a
> Character class.
>
> I acknowledge that Character may be a special case that requires a type –
> after all we have a word in English to describe a fictitious person in a
> creative work, so it may well have enough extra importance to demand one.
>  But using what is a special case to test a generic theory doesn’t work
> very well – lets get generic right and then specialise if it is inadequate.
>
>
> I'm not really trying to solve a generic problem here, and I don't think
> that the schema.org <http://schema.org>  maintainers are that interested
> in generic things. However, I do think that the vocabulary should be able
> to express them; adding a FictionalThing class that can be "mixed-in" seems
> to accomplish this generically.
>
> A bit of turtle always helps me see what I’m modelling, this is what I get
> for the above which would naturally map to RDFa:
> <http://example.com/people/1234>
>     a <http://schema.org/Person>;
>     a <http://schema.org/FictionalThing> ;
>     schema:name "Harry Potter";
>     schema:affiliation "Hogwarts";
>     schema:referencedIn “Harry Potter and the Philosopher’s Stone”.
>
>
> Except for the referencedIn I mentioned above, yes. From this perspective,
> a Character class isn't necessary, but as I mentioned above, if you think
> (as I do) that a character property is required, then you need a way to
> describe what the value of that property can be.
>
> I’m no RDFS expert so the nuances of your explanation are not fully clear
> – however many of our [web page markup] audience are not even aware of RDFS.
>
> The above feels like a simple solution to me (which may be simpler to use,
> than describe using OWL & RDFS).
>
>
> The RDFS Entailment stuff is more intended to motivate what the semantics
> of rangeIncludes and domainIncludes is. This is not something that should
> be exposed in the actual vocabulary, or anything that web developers need
> to know. But for those who want to reason over the vocabularies, we need a
> way of known precisely what is meant by rangeIncludes or domainIncludes.
> However, this is divergent from the main thrust of the proposal, but at
> some point we need to understand the meanings of these annotation
> properties.
>
> Gregg
>
> ~Richard.
>
>
> On 13/01/2013 09:05, "Gregg Kellogg" <gregg@greggkellogg.net <x-msg:
> //335/gregg@greggkellogg.net> > wrote:
>
> Hi Richard,
>
>
> On Jan 11, 2013, at 5:44 PM, Richard Wallis <richard.wallis@oclc.org<x-msg:
> //335/richard.wallis@oclc.org> > wrote:
>
> Re: Modeling fictional characters in movies and TV
> Hi Gregg,
>
> Sorry for replying to this one out of sequence, I have been thinking about
> it and discussing it ;-)
>
> You say “From my understanding of RDFS, if I have a subject with two
> different types, then I'm really saying that the properties associated with
> this subject are the intersection of those two types.”
>
> My understanding is that the result would be the union of the properties
> of the two types, thus achieving the result I was suggesting.
>
>
> Yes, of course you're right, I was confusing this with rdfs:subTypeOf. My
> concern is that if I wanted to describe properties on a fictional person, I
> would need to define a type which is the union of schema:Person and
> schema:FictionalThing, such as the following:
>
> :FictionalPerson a [ a owl:Class; owl:unionOf (schema:Person
> schema:FictionalThing)] .
>
> I am confused by your actor example, as an actor would not normally be a
> fictional Person, the character they portray would be.
>
>
> I was using schema:actor as a property of a schema:Character. When I was
> saying that schema:actor had the domain of wikia:Character, I was saying
> that a Character may have an associated Actor; I think this is okay. If I
> had used rdfs:range instead of rdfs:domain, then it would be a problem.
>
> To satisfy your example of an actor portraying a fictional character, I
> believe we may be looking for a type of Person ‘Actor’ that has a property
> of ‘portrayed’ or ‘created’  that would have an expected type of Person.
>  When encoding your data you could then describe that person (your
> character) as being of type Person and of type FictionalThing.
>
>
> That "portrayed" is an appropriate inverse property of actor, as if a
> character has an Actor, an actor portrays a Character.
>
> To be successful we need to find a generic way of enabling any ‘thing’ to
> be described as a FictionalThing – picking off individual solutions for
> specific types of things such as a character simply won’t scale.
>
>
> Yes, I think that having such a generic mechanism is a good idea, it's
> just that if you want to start to describe properties on the "mixin" of
> Person and FictionalThing, though, you need to be able to describe the
> union type. I believe that this is the intent of
> schema:rangeIncludes/domainIncludes. I think that appropriate rules for
> these could be the following (although expressing it formally will require
> some more work.
>
> For all classes ?c* which have a common subject and rdfs:rangeIncludes
> predicate, construct the following triples:
>
> _:rangeClass a owl:Class; owl:unionOf (?c*)  . # same for domains
>
> Actually constructing these statements is challenging because owl:unionOf
> takes a list rather than multiple repeated statements for each object.
>
> Note that multiple properties having the same set of range/domainIncludes
> will result in multiple blank nodes, which entail each other, but are not
> equivalent nodes. Furthermore, actually using the property in a concrete
> instantiation uses an entailment rule that claims that the range is of an
> equivalent class
>
> <JamesTKirk> schema:actor <WilliamShatner> .
>
> would end up entailing
>
> <JamesTKirk> a [ owl:Class; owl:unionOf (schema:Person
> schema:FictionalThing) ].
>
> due to rule rdfs2
>
> If it is appropriate for schema.org <http://schema.org>  <
> http://schema.org <http://schema.org/> >  to define a something like a
> character property (in addition to the Performance property suggested by
> Yves), then I think it does need to define a schema:Character class, so
> that properties such as schema:actor can be ascribed to it. For schema
> definition purposes, in the spirit of not getting all pedantic about using
> OWL to do this representation, it might require adding something like a
> schema:classIncludes annotation property, similar to rangeIncludes and
> domainIncludes so we could assert:
>
>
> schema:Character schema:classIncludes schema:Person, schema:FictionalThing
> .
>
> Gregg
>
> ~Richard.
>
>
>
>
> On 09/01/2013 21:14, "Gregg Kellogg" <gregg@greggkellogg.net <x-msg:
> //335/gregg@greggkellogg.net>  <x-msg://178/gregg@greggkellogg.net <x-msg:
> //178/gregg@greggkellogg.net> > > wrote:
>
> Hi Richard,
>
>
> On Jan 9, 2013, at 1:38 AM, Richard Wallis <richard.wallis@oclc.org<x-msg:
> //335/richard.wallis@oclc.org>  <x-msg://178/richard.wallis@oclc.org<x-msg:
> //178/richard.wallis@oclc.org> > > wrote:
>
> Re: Modeling fictional characters in movies and TV
> Starting from the point of view that most of the ‘real’ types of things we
> want to describe could have fictional equivalents – fictional people
> (characters), fictional organisations, fictional places, fictional
> products, fictional automobiles, fictional planets, fictional fizzy drinks,
> fictional races, fictional religions, fictional songs, ...., ....
>
> I am thinking perhaps a more generic solution might be appropriate.
>
> What about a FictionalThing type. Probably a sub-type of Intangible,
> having  createdIn and referencedIn properties both having an expected type
> of CreativeWork.
>
> To describe something as fictional you would only have to add
> FictionalThing as an alternativeType, or add a typeOf attribute in RDFa.
>
> That way we would not have to invent a new type for every new thing that
> we find a fictional instance for.
>
>
> I agree that there's a more general need here, and that anything could be
> fictional, but I think just adding another type doesn't really solve the
> problem. From my understanding of RDFS, if I have a subject with two
> different types, then I'm really saying that the properties associated with
> this subject are the intersection of those two types. It actually is sort
> of the reverse of this based on rdfs:domain and rdfs:range semantics. If I
> say the following:
>
> schema:actor a rdf:Property
>   rdfs:domain schema:Person, schema:FictionalThing .
>
> What I'm saying is that the property is on _both_ schema:Person and
> schema:FictionalThing. In general, I don't want 'actor' to be a property of
> either schema:Person or schema:Thing. Dan's introduced the notion of
> schema:rangeIncludes to address this problem, but the semantics haven't
> entirely been worked out yet. This issue is, is there a similar
> schema:typeIncludes that uses something closer to owl:unionOf semantics.
> But, using schema:additionalType (or @typeof with RDFa) won't do this,
> AFAIK.
>
> The way I had actually modeled Character for Wikia was closer to the
> following:
>
> wikia:Character a owl:Class
>   rdfs:subClassOf [ a owl:Class; owl:unionOf schema:CreativeWork,
> schema:Person ] .
>
> This basically allows me to define properties on wikia:Character that done
> "infect" schema:Person or schema:CreativeWork.
>
> Gregg
>
> ~Richard.
>
>
> On 09/01/2013 02:04, "Jason Douglas" <jasondouglas@google.com <x-msg:
> //335/jasondouglas@google.com>  <x-msg://178/jasondouglas@google.com<x-msg:
> //178/jasondouglas@google.com> >  <x-msg://3694/jasondouglas@google.com<x-msg:
> //3694/jasondouglas@google.com>  <x-msg://3694/jasondouglas@google.com<x-msg:
> //3694/jasondouglas@google.com> > > > wrote:
>
>
>
>
> On Tue, Jan 8, 2013 at 6:01 PM, Gregg Kellogg <gregg@greggkellogg.net<x-msg:
> //335/gregg@greggkellogg.net>  <x-msg://178/gregg@greggkellogg.net <x-msg:
> //178/gregg@greggkellogg.net> >  <x-msg://3694/gregg@greggkellogg.net<x-msg:
> //3694/gregg@greggkellogg.net>  <x-msg://3694/gregg@greggkellogg.net<x-msg:
> //3694/gregg@greggkellogg.net> > > > wrote:
>
> On Jan 8, 2013, at 5:43 PM, Jason Douglas <jasondouglas@google.com <x-msg:
> //335/jasondouglas@google.com>  <x-msg://178/jasondouglas@google.com<x-msg:
> //178/jasondouglas@google.com> >  <x-msg://3694/jasondouglas@google.com<x-msg:
> //3694/jasondouglas@google.com>  <x-msg://3694/jasondouglas@google.com<x-msg:
> //3694/jasondouglas@google.com> > > > wrote:
>
>
> > On Tue, Jan 8, 2013 at 3:43 PM, Gregg Kellogg <gregg@greggkellogg.net<x-msg:
> //335/gregg@greggkellogg.net>  <x-msg://178/gregg@greggkellogg.net <x-msg:
> //178/gregg@greggkellogg.net> >  <x-msg://3694/gregg@greggkellogg.net<x-msg:
> //3694/gregg@greggkellogg.net>  <x-msg://3694/gregg@greggkellogg.net<x-msg:
> //3694/gregg@greggkellogg.net> > > > wrote:
> > TL:DR: propose adding schema:Character, schema:Location, and
> schema:FictionalLocation classes, along with a schema:character property.
> >
> > In the work I'm doing with Wikia, we're using extensions to schema.org <
> http://schema.org>  <http://schema.org <http://schema.org/> >  <
> http://schema.org <http://schema.org/>  <http://schema.org/> >  <
> http://schema.org <http://schema.org/>  <http://schema.org/>  <
> http://schema.org/> >  to add structure to Wiki content. Wikia hosts
> hundreds of thousands of wiki's, mostly related to special-interest
> subjects. Important classes of these include sites about Movies, TV
> Shows/Series and Video Games.
> >
> > Cool!!
> >
> >
> > The schema.org <http://schema.org>  <http://schema.org <
> http://schema.org/> >  <http://schema.org <http://schema.org/>  <
> http://schema.org/> >  <http://schema.org <http://schema.org/>  <
> http://schema.org/>  <http://schema.org/> >  vocabulary is pretty useful
> in doing this but lacks some important properties and types:
>
> >
> > Character class: a Character is a subclass of Person, which is intended
> to represent some fictional character. This could include fictional human
> characters, such as Sam Spade, as well as non-human characters, such as
> "The Cat in the Hat". As such, it could also be considered to be a union of
> schema:CreativeWork and schema:Person. Alternatively, it may simply be a
> sub-class of Creative Work which simply has some properties in common with
> Person (birthDate, colleague, gender, ...). Note that books can also have
> characters.
> >
> > Character property: An important characteristic of things such as
> movies, and TV shows is the characters that are in them. For instance,
> TVEpisode has actor, director, producer and so forth, but no way to
> indicate the characters that are in the show. Here is where having
> Character class comes in handy, so that you might have the following:
> >
> > <http://en.memory-alpha.org/wiki/Where_No_Man_Has_Gone_Before_(episode)>
> >   a schema:TVEpisode;
> >   schema:name "Where No Man Has Gone Before"@en;
> >   schema:partOfTVSeries <
> http://en.memory-alpha.org/wiki/Star_Trek:_The_Original_Series>;
> >   schema:character <http://en.memory-alpha.org/wiki/James_T._Kirk>;
> >   schema:actor <http://en.memory-alpha.org/wiki/William_Shatner> .
> >
> > One downside of this is that when you have multiple characters you lose
> the ability to correlate the actor to the character.
>
> In the example below, I set schema:actor on the character
>
>
> ah, missed that.
>
>
> , but it's obviously loosing some temporal information. More complex
> modeling can be more accurate, but within the context of a single graph
> (e.g., for a specific episode), we can probably simplify it that there is a
> signal actor for each character, or at least a set of actors.
>
> > An alternative, that Freebase uses, is to create a class for
> Performance, that has the properties of character (expects Character has
> you defined) and actor (which works the same as actor on today).
>
> This is sort of like an Event, which acts to join various elements
> together (characters and actors in this case), perhaps along with elements
> such as scenes and locations. I like the idea of having a Performance
> class, but there may be times when simpler modeling works.
>
> > Connecting that to TVEpisode could be done with either a new
> "performance" property or by making actor accept Person or Performance.
> >
> >
> > <http://en.memory-alpha.org/wiki/James_T._Kirk> a schema:Character
> >   schema:name "James T. Kirk";
> >   schema:birthDate "2233-03-22"^^xsd:date;
> >   schema:deathDate "2371"^^xsd:gYear;
> >   schema:actor <http://en.memory-alpha.org/wiki/William_Shatner> .
> >
> > Another class of properties generally useful for works of media classes
> is Location. A schema:Location class could be a sub-class of schema:Place,
> intended to describe locations that might not be real, or not at least not
> having geographic coordinates you can get to using Goole Maps. A location
> could also be a Fictional Location, such as Middle Earth.
> >
> > Lastly, many wiki's concern themselves with Video Games, which have
> quite deep structure. Logically, a Video Game is probably a sub-class of
> schema:SoftwareApplication. Of course, there are many other things that
> could be modeled on video games, such as levels, objectives and weapons,
> but having a concrete class for describing them would be quite useful.
> >
> > Since the Wikia communities are the real domain experts here do you
> think there's any chance they could enumerate these in a public schema.org<
> http://schema.org>  <http://schema.org <http://schema.org/> >  <
> http://schema.org <http://schema.org/>  <http://schema.org/> >  <
> http://schema.org <http://schema.org/>  <http://schema.org/>  <
> http://schema.org/> >  extension proposal?
>
>
> This post was an attempt to get that started, and the most obvious missing
> pieces are for Character and Location, along with the character
> relationship.
>
>
> Agreed, those are needed incremental additions.
>
>
>
> Video Games is a deeper subject, and we can share the work we're doing,
> but it will be a more substantive proposal. I'd really like to use it to
> get a conversation with other people who have worked on modeling games. Our
> current focus has been on linear first-person shooter style games, but much
> of the work carries over to open-world/parallel mission environments too.
> We'll come back with more on this in the future.
>
>
> Yeah, Video Games is where I was hoping for a more "substantive proposal"
> as you say.  Sounds good.
>
>
> Gregg
>
> > -jason
> >
> >
> > Gregg Kellogg
> > gregg@greggkellogg.net <x-msg://335/gregg@greggkellogg.net>  <x-msg:
> //178/gregg@greggkellogg.net <x-msg://178/gregg@greggkellogg.net> >
>  <x-msg://3694/gregg@greggkellogg.net <x-msg://3694/gregg@greggkellogg.net>
>  <x-msg://3694/gregg@greggkellogg.net <x-msg://3694/gregg@greggkellogg.net>
> > >
> >
> >
> >
>
>
>
>
>
>
>
>
>
>


-- 
-Thad
http://www.freebase.com/view/en/thad_guidry