Print Email Download Reference This Send to Kindle Reddit This
submit to reddit

Knowledge Representation In A Artificial Intelligence Context Computer Science Essay

Artificial Intelligence is a way to produce software/ machinery that is able to execute operations on its own, that is, for an input the system will know how to manipulate the input and performs the corresponding actions as to achieve the desired result. Artificial intelligence usage is increasing over time, as now days one can find it is present in appliances, computers and machinery, Example in an car assembly line a machine today can be used to install doors and then it can be used to fit bumpers. Even in cutting machinery, now a day's exist machines that are inputted an image and will imprints the image to a material, where it auto detects the material, the patter and so on. Artificial Intelligence is the study to replace human’s manual work by computers, which will end up faster and more reliable. So artificial intelligence is helping us to do tasks that require human intelligence to perform the operation as stated, "Artificial intelligence (AJ) may be defined as the branch of computer science that is concerned with the automation of intelligent behavior." (Luger, 2005). The current issues with artificial applications is that they are only capable to do one things, example the "super chess machine" which implements AI, only knows and gathers information on how to play and win chess but the machine is not able to, cook a simple burger. With artificial intelligence one can also step over nature, as artefacts can be build example for medicine testing where the artifact can simulate if the new medicine works or not.

Figure 1How data is translated to knowledge (Dopico, et al., 2009)

Knowledge is the base for a artificial intelligent application, where this knowledge is used as for the application to mange and execute the operations as most efficiently and correct as possible. As shown in figure 1, knowledge is "learnt" or injected, where relevant data is gathered, which then it is manipulated to become information. Which then the information is fed to the knowledge system and it will adopt and add the new information to its knowledge. The knowledge then it is used as to take decision according to the current knowledge. This means that the system will perform the actions on the information provided in depended if the information is correct of not. Building up the knowledge for a system is a hard task as there as one should be able to distinguish between good and bad knowledge, how the knowledge will be represented and what will happen if there is not enough information to come up with a result.

There are different types of ways of how to represent knowledge where the best ones are declarative and procedural (JONES, 2008). Declarative representation represents facts like all insects have 6 legs, facts that are static in nature. Procedural knowledge is the knowledge of what to do and how will it do it best to get the most correct answer, by following steps/rules.

A good knowledge representation is characterized by representing and supports all sort of knowledge that is deemed necessary for the application and will be easily adopted to new knowledge. A good knowledge representation is also that knowledge that evolves by itself like the chess machine developed by IBM where its capable to store its players moves and analyse them for new tactics and what will be the best next move to win.

There are multiple approaches on how to represent knowledge -

Predicate logic – Is a mathematical approach as to represent knowledge. Predicate logic consists of statements, where these will be marked as true or false. The statements will be marked true and false by the system it, self as it checks its current knowledge and checks whether the statement is correct or not. A predicate logic “knowledge is built up from constants (the objects of the knowledge), a set of predicates (relationships between the knowledge), and some number of functions (indirect references to other knowledge).” (JONES, 2008).

With the use of simple predicate logic one can form logical sentences, by using the 3 properties for predicate logic. Constants are objects that reside in the knowledge, example Matthew, computer, Sunday, sunny. With predicate logic one can relate the constants to each other by having predicates like Sunny, owns, uses and with functions once can perform action as to retrieve or manipulate a constant like age, pet. (JONES, 2008). Below are some examples of what one can get once merging the constants with the predicates and functions –

Sunny(Sunday) = Sunday is sunny

Owns(matthew,computer) = Matthew owns a computer

Owns(matthew,pets(matthew))= Matthew owns a dog.

The examples above showed how to construct simple sentences but one can also concatenate more than one function or add constraints to the compound sentence by adding logical operators as per Table1.

Sign

Description

^

And (all)

v

Or (either or)

¬

Not (negation)

<=>

Bi-implies (similar to ‘=’)

=>

Implies (similar to if-then)

For all (true for all clause defined before the function)

There exist(there should be at least one instance that is true)

Table 1 –Some Predicate logic operators and quantifiers

Example

Friend(Matthew, Carmen) ^ ¬Friend(Matthew,Joe) = Matthew is friend with Carmen and Matthew is not friend with Joe.

Friend(Matthew, Joe) => ¬Friend(Matthew, Carmen) = If Matthew is friend with Joe then Matthew is not friend with Carmen.

Friend(Matthew,Carmen) <=> Friend(Carmen,Matthew) = If Matthew is friends with Carmen implies that Carmen is also friend with Matthew.

∃ a Friend(a,Matthew) = There exist a person(defined by a) that is friend with Matthew

∀ p HasNose(p) = For All people (defined by p )have a nose.

Production rules- Production rules are if condition and action statement, like java if-then-else statements, where you have multiple rules and then for each rule a corresponding action is mapped. The code below shows the structure for a rule, where there can be multiple conditions and then these will be linked by a logical operator.

If <Condition> <logic operator> <Condition> then

<action/deductions>

Figure 2 Production Rules syntax

As the above seem to be very similar to normal if-then statements that are present in programming languages they differ because “Production rules are relatively independent of one another.” (Kurfess, 2002), “Production rules can be based on heuristics or experiential reasoning.” (Kurfess, 2002),”Production rules can accept uncertainty in the reasoning process.” (Kurfess, 2002),”Conditional statements combine the `knowledge' and the `reasoning' in the one structure.” (Kurfess, 2002) and “Production rules simply represent the knowledge --- the inferencing or reasoning is separate.” (Kurfess, 2002)

There are 2 methods on how rules can be validated either by forward chaining or by backward Chaining. Forward Chaining means that the system is fed data/sentences and then the system will search for in the knowledge base to see if any production rules match the data and if it matched the output. With forward chaining the system will search in the knowledge as to extract more detailed information. Example the system is fed “Matthew” and it will return “Matthew is a Man who lives in Birkirkara and is human”. On the other hand backward chaining works the other way round, where the user selects the rules and then the system will search the knowledgebase for the data that satisfy the rules selected by the user. Example the system is asked to find where Matthew lives, then the system will try to find the rules that match and gathers their data and verify their details, example it picks up that Matthew lives in Birkirkara. With backward chaining the system picks up data along the way while it goes through the rules and then it tries matches these to the rules and gathers up data/information until it gets to the result.

Production rules are used in rule-based expert systems, example to find a pattern, which offers initiate more demand to be products. Also another example is for a manufacturing company, where the expert system auto orders and schedule resources, so with the help of production rules the system will identify the pattern on what time is the best time to order new stock (example in summer prices go down).

Production rules are very easy understood as the knowledge is visible and one also can not the flow and order of the statements and so it makes it easier to understand and maintain. On the other hand production rules will grow a lot and so there will be lots of rules which make it very difficult to maintain. The only structure that is present by the production rule representation is trough rule chaining. (Kurfess, 2002)

Non monotonic systems – Logic is monotonic in the sense that once a statement has been added to the knowledge base, it is not deleted. In ES based on monotonic logic the number of statements known to be true is strictly increasing over time. However, where data is incomplete or uncertain, knowledge cannot be easily represented as true or false predicates whose truthfulness is constant over time.

Non monotonic logic has been proposed as to handle reasoning under uncertainty. It is concerned with reasoning that allows making of assumptions that are not guaranteed to be correct, but at least are consistent with the statements in the knowledge base. When new or more complete information is added, we may change our assumptions and make different decisions,(much human learning is non-monotonic).

If we allow non-monotonic reasoning in as system, it will be necessary to

Check each new statement with consistency of other statements in the knowledge base.

If there is an inconsistency, same means of dealing with it must be incorporated in the syst3em control structure.

When a statement is deleted, from the knowledge base, the control system must go back over the statement whose proofs depend on the deleted statement, and either eliminate them or find new proofs with the new knowledge base.

Therefor a knowledge representation that uses production rules is very easy to build but then it is very difficult to manipulate

Statistical reasoning systems

Semantic networks - This representation are very useful when coming to describe the relationship between objects. Where these are represented by boxes connected by labeled lines. Generally the repletion between objects uses the keywords " “IS_A” and “AKO” (A Kind Of) " (JONES, 2008). As you can see from figure 2, the relationships can be easily read, Matthew is part of a band, Matthew is a person, Matthew is a mammal and a person is a mammal. Semantic nets also implement inheritance and multiple inheritances, where from Matthew you can conclude directly that is a mammal. Semantic network can be used as to abstract from textual to a processable text by computers. Semantic nets are mostly used in linguistic applications, where one can build a synonyms dictionary by filling the knowledge source with all the words and then building up relations. It also is used for translations, example English - Maltese, where one will point the Maltese words to their translation in English. This is not an easy task as same words can have more than 1 definition depending on the context. An advantage of semantic networks is that object can be saved only once and then add multiple relations to it, where this will save a lot on storage space. As I mentioned above the semantic nets uses inheritance which this could evolve in issues as there could be instances where inheritance should not apply. If there exist any incorrect mapping, this can cause critical problems as it does not just affect that mapping but the entire instance that inherit from the mapping. Another issue is that there is a lack of standardization on the nodes and arcs values (Chowdhary, 2011).

Figure 3 Semantic Nets example

Frames- Frames build up on Semantic nets where "frames are structured and follow a more object-oriented abstraction with greater structure" (JONES, 2008). A frame consists of objects which support properties called slots where these can store any information that is redeemed necessary. The frame slots can be a primitive type (like string and integer values)or pointer to another frame (inheritance/ dependencies/ reference) and procedures and constraints can be attached to slots. One can say that frames are like classes (example in java) with variables, where these variables can be a complex type (i.e. maps to other frames) or primitive types and a class can contain procedures. Figure 3 is showing a game represented using Frames where the mapping of Frames can be easily identified as of the arcs that the frames are connected with to each other. Inheritance is still present within frame, this can be seen between the archer frame and that of the Longbowman frame where even though the armour and weapon slots are not defined in the Longbowman`s frame these are inherited. Instances of fames can be also noted within frame "john" which is a player of the game which is of type Longbowman. Default values can be identified for frames values. The connection arcs represent the Frame they are referencing / inheriting.

Figure 4 Showing a game strategy using Frames (JONES, 2008)

What makes Frames to differ from semantic networks is that Frames support Demons which are sort of a triggers what can one can use as to cater for any actions mentioned in Figure 4. Frames makes the Frame more clearer as with the help of the slots it makes it more understandable and more structured and complex objects can be easily represented with frames rather than Semantic nets, as with semantic nets a big structure needs to be built as to represent a complex object in frames.

Demon Action

if_new

Triggered when a new frame is added.

if_added

Triggered when a new value is placed into a slot.

if_removed.

Triggered when a value is removed from a slot

if_replaced

Triggered when a value is replaced in a slot.

if_needed

Triggered when a value must be present in an instance frame.

Figure 5 Demons (JONES, 2008)

Conceptual dependency – “Is a theory of representation designed to represent the meaning of sentences based on a small set of primitives” (Way, 1991), where this CD represents events that are present in natural language (like give, buy sell). The goal for this representation is to make it easier to make correct conclusions from sentences, where this approach makes it possible that new words are learnt and added to the Knowledge. This representation will take care that sentences that have the same meaning are only stored once, and then the parser will map the original input with the corresponding stored sentences(as per below) as in the knowledge base a vocabulary will be stored with the all the words.

“John sold Mary a book.

Mary bought a book from John.

Mary gave John a check for the book .”

Figure 6 Conceptual Dependency Example (2004)

The system is also language independent, which means that the conceptual structure only have to defined once then the vocabulary is looked up to match the structure for the inputted sentence. Conceptual dependency comes with rules as how to represent a sentence which these can be found in - (2004) where there is a list of rules that are required to follow as to the system to be successfully implemented. One also can represent the tense of a sentence by adding the P as showing in Figure 6 which identifies the past tense. Apart from rules it also consists of primitive ACTs that represent actions as you can see the ACT ATRANS was used, which represents give, PTRANS represent the action of location example the right part (from Figure 6) where the transaction of the book is carried out, where R is representing the Receive concept and much more where a full list can also be found at (Schank).

On the other hand as knowledge must be decomposed to low levels, which will arise problems as to represent a complex concept it will be very hard to representation will be very large and it’s very difficult to choose the best primitive to fit the representation (Way, 1991).

This representation is mostly used in Natural language processing like MARGIE (Meaning Analysis, Response Generation and Inference on English) where this model is inputted a request where then the system will derive conclusions from the inputted request, like John has a girlfriend, MARGIE may return John might get married.

Scripts – Scripts are an extension to Frames and extends the conceptual dependency, as with scripts one can represents a flow of events, and can link from one action to another. So basically script is a ‘plugin’ from frames. These enable frames to have a sequence of events and with scripts it enables that defaults can be set and are considered true if the input is within the same event. Example if a person is reading on aeroplanes and at a sudden a paragraph concerning how to cook is present, it will be very difficult for the person to understand and relate the reading to the aeroplanes as was expecting that he will remain in the context of aeroplanes. So the person has to change the context of his thinking, same with scripts when an event is proceeding and an input changes the whole event context, another script will take over (Luger, 2005). A script will identify the paths of the next actions/tasks that should take to end up with a conclusion.

A script is made up of

Entry conditions – This will describe the ambient where the event is taking place, like raining, no umbrella, and running. (Luger, 2005)

Results – This defined the final outcome of the script once its completed, like wet, exhausted, sheltering under in a phone booth. (Luger, 2005)

Props – This describes the ambient where the event is taking place, the default things that any one would expect to see/find at the current ambient, like water pools, deserted roads. (Luger, 2005)

Roles – this identifies the participants and what will their role be in the event, example dog chasing the man in the rain, the person running slips. (Luger, 2005)

Scenes – this will define the flow of events, the connection between one scene and another, where this 3will identify when to proceed to the next scene, like representing the man running and then the man slipping in the pond. (Luger, 2005)

As you can note, this is similar to a film script, where defines what the actors will do and what scenes are present in the film. With scripts one can predict what will be next event that will happen, example if the above examples were to be implemented in a script called “running in rain” the system from the script can predict that the men without umbrella and not in a phone booth will get wet, but it may script may contain more than one outcome. As this approach provides space for the system to make assumptions and has defined defaults for actions the system will be able to process unexpected inputs, and if the context of the input is changed abruptly the system will figure this out automatically and executes the new context corresponding script.

The drawback of scripts that if we take in consideration the “running in rain” script and a new entry or prop is added to the input the system will not be able to use the same script but a new script has to be implemented.

An example of this implementation is SAM(Script Applier Mechanis)

CYC

Knowledge representation is the base for a good artificial intelligence application, where knowledge is the source for the application as to execute the appropriate actions for an input. r input for the application

what types of representation

conclusion

Print Email Download Reference This Send to Kindle Reddit This

Share This Essay

To share this essay on Reddit, Facebook, Twitter, or Google+ just click on the buttons below:

Request Removal

If you are the original writer of this essay and no longer wish to have the essay published on the UK Essays website then please click on the link below to request removal:

Request the removal of this essay.


More from UK Essays

Doing your resits? We can help!