AI App That Can Edit Photos

AI App That Can Edit Photos — independent reviews, comparisons, pricing and step-by-step guides on Aizhi.

  • Level-set method

    Level-set method

    The Level-set method (LSM) is a conceptual framework for using level sets as a tool for numerical analysis of surfaces and shapes. LSM can perform numerical computations involving curves and surfaces on a fixed Cartesian grid without having to parameterize these objects. LSM makes it easier to perform computations on shapes with sharp corners and shapes that change topology (such as by splitting in two or developing holes). These characteristics make LSM effective for modeling objects that vary in time, such as an airbag inflating or a drop of oil floating in water. == Overview == The figure on the right illustrates several ideas about LSM. In the upper left corner is a bounded region with a well-behaved boundary. Below it, the red surface is the graph of a level set function φ {\displaystyle \varphi } determining this shape, and the flat blue region represents the X-Y plane. The boundary of the shape is then the zero-level set of φ {\displaystyle \varphi } , while the shape itself is the set of points in the plane for which φ {\displaystyle \varphi } is positive (interior of the shape) or zero (at the boundary). In the top row, the shape's topology changes as it is split in two. It is challenging to describe this transformation numerically by parameterizing the boundary of the shape and following its evolution. An algorithm can be used to detect the moment the shape splits in two and then construct parameterizations for the two newly obtained curves. On the bottom row, however, the plane at which the level set function is sampled is translated upwards, on which the shape's change in topology is described. It is less challenging to work with a shape through its level-set function rather than with itself directly, in which a method would need to consider all the possible deformations the shape might undergo. Thus, in two dimensions, the level-set method amounts to representing a closed curve Γ {\displaystyle \Gamma } (such as the shape boundary in our example) using an auxiliary function φ {\displaystyle \varphi } , called the level-set function. The curve Γ {\displaystyle \Gamma } is represented as the zero-level set of φ {\displaystyle \varphi } by Γ = { ( x , y ) ∣ φ ( x , y ) = 0 } , {\displaystyle \Gamma =\{(x,y)\mid \varphi (x,y)=0\},} and the level-set method manipulates Γ {\displaystyle \Gamma } implicitly through the function φ {\displaystyle \varphi } . This function φ {\displaystyle \varphi } is assumed to take positive values inside the region delimited by the curve Γ {\displaystyle \Gamma } and negative values outside. == The level-set equation == If the curve Γ {\displaystyle \Gamma } moves in the normal direction with a speed v {\displaystyle v} , then by chain rule and implicit differentiation, it can be determined that the level-set function φ {\displaystyle \varphi } satisfies the level-set equation ∂ φ ∂ t = v | ∇ φ | . {\displaystyle {\frac {\partial \varphi }{\partial t}}=v|\nabla \varphi |.} Here, | ⋅ | {\displaystyle |\cdot |} is the Euclidean norm (denoted customarily by single bars in partial differential equations), and t {\displaystyle t} is time. This is a partial differential equation, in particular a Hamilton–Jacobi equation, and can be solved numerically, for example, by using finite differences on a Cartesian grid. However, the numerical solution of the level set equation may require advanced techniques. Simple finite difference methods fail quickly. Upwinding methods such as the Godunov method are considered better; however, the level set method does not guarantee preservation of the volume and shape of the set level in an advection field that maintains shape and size, for example, a uniform or rotational velocity field. Instead, the shape of the level set may become distorted, and the level set may disappear over a few time steps. Therefore, high-order finite difference schemes, such as high-order essentially non-oscillatory (ENO) schemes, are often required, and even then, the feasibility of long-term simulations is questionable. More advanced methods have been developed to overcome this; for example, combinations of the leveling method with tracking marker particles suggested by the velocity field. == Example == Consider a unit circle in R 2 {\textstyle \mathbb {R} ^{2}} , shrinking in on itself at a constant rate, i.e. each point on the boundary of the circle moves along its inwards pointing normally at some fixed speed. The circle will shrink and eventually collapse down to a point. If an initial distance field is constructed (i.e. a function whose value is the signed Euclidean distance to the boundary, positive interior, negative exterior) on the initial circle, the normalized gradient of this field will be the circle normal. If the field has a constant value subtracted from it in time, the zero level (which was the initial boundary) of the new fields will also be circular and will similarly collapse to a point. This is due to this being effectively the temporal integration of the Eikonal equation with a fixed front velocity. == Applications == In mathematical modeling of combustion, LSM is used to describe the instantaneous flame surface, known as the G equation. Level-set data structures have been developed to facilitate the use of the level-set method in computer applications. Computational fluid dynamics Trajectory planning Optimization Image processing Computational biophysics Discrete complex dynamics (visualization of the parameter plane and the dynamic plane) == History == The level-set method was developed in 1979 by Alain Dervieux, and subsequently popularized by Stanley Osher and James Sethian. It has since become popular in many disciplines, such as image processing, computer graphics, computational geometry, optimization, computational fluid dynamics, and computational biology.

    Read more →
  • D3web

    D3web

    d3web is a free, open-source platform for knowledge-based systems (expert systems). Its core is written in Java using XML and/or Office-based formats for the knowledge storage. All of its components are distributed under the terms of the Lesser General Public Licence (LGPL). The d3web diagnostic core implements reasoning and persistence components for problem-solving knowledge including decision trees, (heuristic) rules, set-covering models and diagnostic flowcharts. The software can be integrated into foreign applications (embedded or OEM), but a number of off-the-shelf components already exist. == Components == d3web is a component-based software platform providing applications for authoring and using/executing problem-solving knowledge. The following applications are primarily using d3web: KnowWE (Knowledge Wiki Environment): A semantic wiki building on JSPWiki. Problem-solving knowledge can be authored and executed through the wiki interface. Developed knowledge bases can be exported to be used in OEM or embedded reasoners. Additionally, knowledge exchange via OWL ontologies is provided. KnowME (Knowledge Modelling Environment): A rich-client application for the development of d3web knowledge bases. Problem-solving knowledge can be authored and executed within the desktop application. Developed knowledge bases can be used in OEM or embedded reasoners. The software KnowME is no longer under active development. It is replaced by the KnowWE component (see above). Dialog2: A web-based application for demonstrating the capabilities of the d3web core reasoner. The web servlet is based on Java Server Faces. It can be used out of box or as a starting point for own developments for building knowledge-based interview systems. == Application Domains == A number of industrial and academic projects already used or are currently using the d3web platform. The main application domains are: medical diagnosis, documentation, and therapy: technical fault diagnosis monitoring of technical devices. Some applications (both, commercial and free) created using the d3web diagnostic engine: SmartCare(c): a medical closed-loop system for weaning mechanically ventilated patients, created by Dräger SonoConsult Archived 2011-12-16 at the Wayback Machine: a medical support system for evaluating sonographic examinations (German only) eDOC: a web-based system for self-diagnosing various medical issues (German only) == History == The development of d3web originates from the research work of Prof. Dr. Frank Puppe (University Würzburg, Germany) going back to the 1980s, starting with the medical expert systems MED1 and MED2 . Whereas the original systems were focussed on medical diagnosis the applicability of the approach was generalized by the successor D3 . As the predecessors were implemented in the LISP programming language, d3web is a full Java re-implementation.

    Read more →
  • Project Joshua Blue

    Project Joshua Blue

    Joshua Blue is a project under development by IBM that focuses on advancing the artificial intelligence field by designing and programming computers to emulate human mental functions. == Goals == According to researchers at IBM's Thomas J. Watson Research Center, the main goal of Joshua Blue is "to achieve cognitive flexibility that approaches human functioning". In short, IBM is aiming to design Joshua Blue to 'think like a human', mainly in terms of emotional thought. == How it will work == A model of Joshua Blue's learning pattern has been created. Similar to how young children learn human traits through interacting with their surroundings, Joshua Blue will acquire knowledge through external stimuli present in its environment. IBM believes that if computers evolve to learn in this way and then comprehend and analyze the knowledge gained using reason, computers could begin to possess a "mind", of sorts, capable of demonstrating complex social behaviors similar to those of humans. Thus far, IBM has revealed that Joshua Blue will be a computer with a network of wires and input nodes that function as a computer nervous system. This nervous system will be used by Joshua Blue to perceive affect or personal emotional feelings. Not only will this network of input nodes help Joshua Blue discover things physically, but it will also allow Joshua Blue to interpret the significance of events. The input nodes, or proprioceptors, will enable Joshua Blue to be aware of things that happen around itself, as well as recognize and attach meaning to the emotional effect produced by interacting with an object in a certain way. In addition, Joshua Blue's proprioceptors will function as pain and pleasure sensors, allowing Joshua Blue to employ a similar "reward and punishment" system that humans use to form behaviors.

    Read more →
  • Information Processing Language

    Information Processing Language

    Information Processing Language (IPL) is a programming language created by Allen Newell, Cliff Shaw, and Herbert A. Simon at RAND Corporation and the Carnegie Institute of Technology about 1956. Newell had the job of language specifier-application programmer, Shaw was the system programmer, and Simon had the job of application programmer-user. IPL included features to facilitate AI programming, specifically problem solving. such as lists, dynamic memory allocation, data types, recursion, functions as arguments, generators, and cooperative multitasking. IPL also introduced the concepts of symbol processing and list processing. Unfortunately, all of these innovations were cast in a difficult assembly-language style. Nonetheless, IPL-V (the only public version of IPL) ran on many computers through the mid 1960s. == Basics of IPL == An IPL computer has: A set of symbols. All symbols are addresses, and name cells. Unlike symbols in later languages, symbols consist of a character followed by a number, and are written H1, A29, 9–7, 9–100. Cell names beginning with a letter are regional, and are absolute addresses. Cell names beginning with "9-" are local, and are meaningful within the context of a single list. One list's 9-1 is independent of another list's 9–1. Other symbols (e.g., pure numbers) are internal. A set of cells. Lists are made from several cells including mutual references. Cells have several fields: P, a 3-bit field used for an operation code when the cell is used as an instruction, and unused when the cell is data. Q, a 3-valued field used for indirect reference when the cell is used as an instruction, and unused when the cell is data. SYMB, a symbol used as the value in the cell. A set of primitive processes, which would be termed primitive functions in modern languages. The data structure of IPL is the list, but lists are more intricate structures than in many languages. A list consists of a singly linked sequence of symbols, as might be expected—plus some description lists, which are subsidiary singly linked lists interpreted as alternating attribute names and values. IPL provides primitives to access and mutate attribute value by name. The description lists are given local names (of the form 9–1). So, a list named L1 containing the symbols S4 and S5, and described by associating value V1 to attribute A1 and V2 to A2, would be stored as follows. 0 indicates the end of a list; the cell names 100, 101, etc. are automatically generated internal symbols whose values are irrelevant. These cells can be scattered throughout memory; only L1, which uses a regional name that must be globally known, needs to reside in a specific place. IPL is an assembly language for manipulating lists. It has a few cells which are used as special-purpose registers. H1, for example, is the program counter. The SYMB field of H1 is the name of the current instruction. However, H1 is interpreted as a list; the LINK of H1 is, in modern terms, a pointer to the beginning of the call stack. For example, subroutine calls push the SYMB of H1 onto this stack. H2 is the free-list. Procedures which need to allocate memory grab cells off of H2; procedures which are finished with memory put it on H2. On entry to a function, the list of parameters is given in H0; on exit, the results should be returned in H0. Many procedures return a Boolean result indicating success or failure, which is put in H5. Ten cells, W0-W9, are reserved for public working storage. Procedures are "morally bound" (to quote the CACM article) to save and restore the values of these cells. There are eight instructions, based on the values of P: subroutine call, push/pop S to H0; push/pop the symbol in S to the list attached to S; copy value to S; conditional branch. In these instructions, S is the target. S is either the value of the SYMB field if Q=0, the symbol in the cell named by SYMB if Q=1, or the symbol in the cell named by the symbol in the cell named by SYMB if Q=2. In all cases but conditional branch, the LINK field of the cell tells which instruction to execute next. IPL has a library of some 150 basic operations. These include such operations as: Test symbols for equality Find, set, or erase an attribute of a list Locate the next symbol in a list; insert a symbol in a list; erase or copy an entire list Arithmetic operations (on symbol names) Manipulation of symbols; e.g., test if a symbol denotes an integer, or make a symbol local I/O operations "Generators", which correspond to iterators and filters in functional programming. For example, a generator may accept a list of numbers and produce the list of their squares. Generators could accept suitably designed functions—strictly, the addresses of code of suitably designed functions—as arguments. == History == IPL was first utilized to demonstrate that the theorems in Principia Mathematica which were proven laboriously by hand, by Bertrand Russell and Alfred North Whitehead, could in fact be proven by computation. According to Simon's autobiography Models of My Life, this application was originally developed first by hand simulation, using his children as the computing elements, while writing on and holding up note cards as the registers which contained the state variables of the program. IPL was used to implement several early artificial intelligence programs, also by the same authors: the Logic Theorist (1956), the General Problem Solver (1957), and their computer chess program NSS (1958). Several versions of IPL were created: IPL-I (never implemented), IPL-II (1957 for JOHNNIAC), IPL-III (existed briefly), IPL-IV, IPL-V (1958, for IBM 650, IBM 704, IBM 7090, Philco model 212, many others. Widely used). IPL-VI was a proposal for an IPL hardware. A co-processor “IPL-VC” for the CDC 3600 at Argonne National Libraries was developed which could run IPL-V commands. It was used to implement another checker-playing program. This hardware implementation did not improve running times sufficiently to “compete favorably with a language more directly oriented to the structure of present-day machines”. IPL was soon displaced by Lisp, which had much more powerful features, a simpler syntax, and the benefit of automatic garbage collection. == Legacy to computer programming == IPL arguably introduced several programming language features: List manipulation—but only lists of atoms, not general lists Property lists—but only when attached to other lists Higher-order functions—while assembly programming had always allowed computing with the addresses of functions, IPL was an early attempt to generalize this property of assembly language in a principled way Computation with symbols—though symbols have a restricted form in IPL (letter followed by number) Virtual machine Many of these features were generalized, rationalized, and incorporated into Lisp and from there into many other programming languages during the next several decades.

    Read more →
  • Smartphone kill switch

    Smartphone kill switch

    A smartphone kill switch is a software-based security feature that allows a smartphone's owner to remotely render it inoperable if it is lost or stolen, thereby deterring theft. There have been a number of initiatives to legally require kill switches on smartphones. Smartphones have high resale value, and are therefore often the target of theft, with thieves selling them to cartels for resale. A kill switch can deter theft by making devices worthless. == Legal requirements == In the United States, Minnesota was the first state to pass a bill requiring smartphones to have such a feature, and California was the first to require that the feature be turned on by default. The California law requires the kill switch to be resistant to reinstallation of the phone's operating system. The CTIA initially resisted the legislation, fearing that it would make phones easier to hack, but later supported kill switches. There is evidence that this legislation has been effective, with smartphone theft declining by 50% between 2013 and 2017 in San Francisco. Secure Our Smartphones (S.O.S.), a New York State and San Francisco initiative started by New York State Attorney General Eric Schneiderman and San Francisco District Attorney George Gascón. The initiative is co-chaired by Schneiderman, Gascón and Boris Johnson, and has 105 members. == Examples == An Android phone signed into a Google account can be remotely locked and erased via Google's Find My Device service, as long as it is connected to the Internet. To prevent this, a thief must sign the device out of Google before the owner locks or erases it. iPhones have a similar service.

    Read more →
  • Semantic parameterization

    Semantic parameterization

    Semantic parameterization is a conceptual modeling process for expressing natural language descriptions of a domain in first-order predicate logic. The process yields a formalization of natural language sentences in Description Logic to answer the who, what and where questions in the Inquiry-Cycle Model (ICM) developed by Colin Potts and his colleagues at the Georgia Institute of Technology. The parameterization process complements the Knowledge Acquisition and autOmated Specification (KAOS) method, which formalizes answers to the when, why and how ICM questions in Temporal Logic, to complete the ICM formalization. The artifacts used in the parameterization process include a dictionary that aligns the domain lexicon with unique concepts, distinguishing between synonyms and polysemes, and several natural language patterns that aid in mapping common domain descriptions to formal specifications. == Relationship to other theories == Semantic Parameterization defines a meta-model consisting of eight roles that are domain-independent and reusable. Seven of these roles correspond to Jeffrey Gruber's thematic relations and case roles in Charles Fillmore's case grammar: The Inquiry-Cycle Model (ICM) was introduced to drive elicitation between engineers and stakeholders in requirements engineering. The ICM consists of who, what, where, why, how and when questions. All but the when questions, which require a Temporal Logic to represent such phenomena, have been aligned with the meta-model in semantic parameterization using Description Logic (DL). == Introduction with Example == The semantic parameterization process is based on Description Logic, wherein the TBox is composed of words in a dictionary, including nouns, verbs, and adjectives, and the ABox is partitioned into two sets of assertions: 1) those assertions that come from words in the natural language statement, called the grounding, and 2) those assertions that are inferred by the (human) modeler, called the meta-model. Consider the following unstructured natural language statement (UNLS) (see Breaux et al. for an extended discussion): UNLS1.0 The customer1,1 must not share2,2 the access-code3,3 of the customer1,1 with someone4,4 who is not the provider5,4. The modeler first identifies intensional and extensional polysemes and synonyms, denoted by the subscripts: the first subscript uniquely refers to the intensional index, i.e., the same first index in two or more words refer to the same concept in the TBox; the second subscript uniquely refers to the extensional index, i.e., two same second index in two or more words refer to the same individual in the ABox. This indexing step aligns words in the statement and concepts in the dictionary. Next, the modeler identifies concepts from the dictionary to compose the meta-model. The following table illustrates the complete DL expression that results from applying semantic parameterization.

    Read more →
  • Reification (computer science)

    Reification (computer science)

    In computer science, reification is the process by which an abstract idea about a program is turned into an explicit data model or other object created in a programming language. A computable/addressable object—a resource—is created in a system as a proxy for a non computable/addressable object. By means of reification, something that was previously implicit, unexpressed, and possibly inexpressible is explicitly formulated and made available to conceptual (logical or computational) manipulation. Informally, reification is often referred to as "making something a first-class citizen" within the scope of a particular system. Some aspect of a system can be reified at language design time, which is related to reflection in programming languages. It can be applied as a stepwise refinement at system design time. Reification is one of the most frequently used techniques of conceptual analysis and knowledge representation. == Reflective programming languages == In the context of programming languages, reification is the process by which a user program or any aspect of a programming language that was implicit in the translated program and the run-time system, are expressed in the language itself. This process makes it available to the program, which can inspect all these aspects as ordinary data. In reflective languages, reification data is causally connected to the related reified aspect such that a modification to one of them affects the other. Therefore, the reification data is always a faithful representation of the related reified aspect . Reification data is often said to be made a first class object. Reification, at least partially, has been experienced in many languages to date: in early Lisp dialects and in current Prolog dialects, programs have been treated as data, although the causal connection has often been left to the responsibility of the programmer. In Smalltalk-80, the compiler from the source text to bytecode has been part of the run-time system since the very first implementations of the language. The C programming language reifies the low-level detail of memory addresses.Many programming language designs encapsulate the details of memory allocation in the compiler and the run-time system. In the design of the C programming language, the memory address is reified and is available for direct manipulation by other language constructs. For example, the following code may be used when implementing a memory-mapped device driver. The buffer pointer is a proxy for the memory address 0xB8000000. Functional programming languages based on lambda-calculus reify the concept of a procedure abstraction and procedure application in the form of the Lambda expression. The Scheme programming language reifies continuations (approximately, the call stack). In C#, reification is used to make parametric polymorphism implemented in the form of generics as a first-class feature of the language. In the Java programming language, there exist "reifiable types" that are "completely available at run time" (i.e. their information is not erased during compilation). REBOL reifies code as data and vice versa. Many languages, such as Lisp, JavaScript, and Curl, provide an eval or evaluate procedure that effectively reifies the language interpreter. Smalltalk and Actor languages permit the reification of blocks and messages, which are equivalent of lambda expressions in Lisp, and thisContext in Smalltalk, which is a reification of the current executing block. Homoiconic languages reify the syntax of the language as data that is understood by the language itself. This allows the user to write programs whose inputs and outputs are code (see macros, eval). Common representations of code include S-expressions (e.g. Clojure, Lisp), and abstract syntax trees (e.g. Rust). == Data reification vs. data refinement == Data reification (stepwise refinement) involves finding a more concrete representation of the abstract data types used in a formal specification. Data reification is the terminology of the Vienna Development Method (VDM) that most other people would call data refinement. An example is taking a step towards an implementation by replacing a data representation without a counterpart in the intended implementation language, such as sets, by one that does have a counterpart (such as maps with fixed domains that can be implemented by arrays), or at least one that is closer to having a counterpart, such as sequences. The VDM community prefers the word "reification" over "refinement", as the process has more to do with concretising an idea than with refining it. For similar usages, see Reification (linguistics). == In conceptual modeling == Reification is widely used in conceptual modeling. Reifying a relationship means viewing it as an entity. The purpose of reifying a relationship is to make it explicit, when additional information needs to be added to it. Consider the relationship type IsMemberOf(member:Person, Committee). An instance of IsMemberOf is a relationship that represents the fact that a person is a member of a committee. The figure below shows an example population of IsMemberOf relationship in tabular form. Person P1 is a member of committees C1 and C2. Person P2 is a member of committee C1 only. The same fact, however, could also be viewed as an entity. Viewing a relationship as an entity, one can say that the entity reifies the relationship. This is called reification of a relationship. Like any other entity, it must be an instance of an entity type. In the present example, the entity type has been named Membership. For each instance of IsMemberOf, there is one and only one instance of Membership, and vice versa. Now, it becomes possible to add more information to the original relationship. As an example, we can express the fact that "person p1 was nominated to be the member of committee c1 by person p2". Reified relationship Membership can be used as the source of a new relationship IsNominatedBy(Membership, Person). For related usages see Reification (knowledge representation). == In Unified Modeling Language (UML) == UML provides an association class construct for defining reified relationship types. The association class is a single model element that is both a kind of association and a kind of class. The association and the entity type that reifies are both the same model element. Note that attributes cannot be reified. == On Semantic Web == === RDF and OWL === In Semantic Web languages, such as Resource Description Framework (RDF) and Web Ontology Language (OWL), a statement is a binary relation. It is used to link two individuals or an individual and a value. Applications sometimes need to describe other RDF statements, for instance, to record information like when statements were made, or who made them, which is sometimes called "provenance" information. As an example, we may want to represent properties of a relation, such as our certainty about it, severity or strength of a relation, relevance of a relation, and so on. The example from the conceptual modeling section describes a particular person with URIref person:p1, who is a member of the committee:c1. The RDF triple from that description is Consider to store two further facts: (i) to record who nominated this particular person to this committee (a statement about the membership itself), and (ii) to record who added the fact to the database (a statement about the statement). The first case is a case of classical reification like above in UML: reify the membership and store its attributes and roles etc.: Additionally, RDF provides a built-in vocabulary intended for describing RDF statements. A description of a statement using this vocabulary is called a reification of the statement. The RDF reification vocabulary consists of the type rdf:Statement, and the properties rdf:subject, rdf:predicate, and rdf:object. Using the reification vocabulary, a reification of the statement about the person's membership would be given by assigning the statement a URIref such as committee:membership12345 so that describing statements can be written as follows: These statements say that the resource identified by the URIref committee:membership12345Stat is an RDF statement, that the subject of the statement refers to the resource identified by person:p1, the predicate of the statement refers to the resource identified by committee:isMemberOf, and the object of the statement refers to the resource committee:c1. Assuming that the original statement is actually identified by committee:membership12345, it should be clear by comparing the original statement with the reification that the reification actually does describe it. The conventional use of the RDF reification vocabulary always involves describing a statement using four statements in this pattern. Therefore, they are sometimes referred to as the "reification quad". Using reification according to this convention, we could record the fact that pe

    Read more →
  • Computational theory of mind

    Computational theory of mind

    In philosophy of mind, the computational theory of mind (CTM), also known as computationalism, is a family of views that hold that the human mind is an information processing system and that cognition and consciousness together are a form of computation. It is closely related to functionalism, a broader theory that defines mental states by what they do rather than what they are made of. == History == Warren McCulloch and Walter Pitts (1943) were the first to suggest that neural activity is computational. They argued that neural computations explain cognition. A version of the theory was put forward by Peter Putnam and Robert W. Fuller in 1964. The theory was proposed in its modern form by Hilary Putnam in 1960 and 1961, aided by his then PhD student, philosopher and cognitive scientist Jerry Fodor, who continued the research as a post-doc in the 1960s, 1970s, and 1980s. It was later criticized by Putnam himself, John Searle, and others. == Classical computational theory of mind == The CTM holds that the human mind is a computational system that is realized (i.e., physically implemented) by neural activity in the brain. The theory can be elaborated in many ways and varies largely based on how the term computation is understood. In classical computational theory of mind (CCTM), computation is modeled in terms of Turing machines which manipulate symbols according to a rule, in combination with the internal state of the machine. A Turing machine is an abstract machine with unlimited time and storage. CCTM does not pretend that the mind looks like a Turing machine, but instead uses Turing machines as a formalism. Alan Turing argued that any symbolic algorithm executed by a human brain can in theory be replicated on a Turing machine. The critical aspect of such a computational model is that it allows to abstract away from particular physical details of the machine that is implementing the computation. For example, the appropriate computation could be implemented either by silicon chips or biological neural networks, so long as there is a series of outputs based on manipulations of inputs and internal states, performed according to a rule. Computational theories of mind are often said to require mental representation because 'input' into a computation comes in the form of symbols or representations of other objects. A computer cannot compute an actual object but must interpret and represent the object in some form and then compute the representation. Unlike CTM, the representational theory of mind shifts the focus to the symbols being manipulated. This approach better accounts for systematicity and productivity. In Fodor's view, the mind is a computational system that processes the language of thought. == Variants == Connectionist computationalism models the mind as a neural network. Steven Pinker and Alan Prince distinguish two types of connectionists: eliminative and implementationist. Eliminative connectionists generally reject classical CTMs and the idea of a structured, symbolic mind, whereas implementationists view neural networks and Turing machines as two potentially complementary levels of analysis. It is indeed possible in theory to implement a neural network in a Turing machine, or a Turing machine in a neural network. Building from the tradition of McCulloch and Pitts, the computational theory of cognition (CTC) states that neural computations explain cognition. The computational theory of mind asserts that not only cognition, but also phenomenal consciousness or qualia, are computational. That is to say, CTM entails CTC. While phenomenal consciousness could fulfill some other functional role, computational theory of cognition leaves open the possibility that some aspects of the mind could be non-computational. CTC, therefore, provides an important explanatory framework for understanding neural networks, while avoiding counter-arguments that center around phenomenal consciousness. == "Computer metaphor" == Computational theory of mind is not the same as the computer metaphor, comparing the mind to a modern-day digital computer. While the computer metaphor draws an analogy between the mind as software and the brain as hardware, CTM is the claim that the mind is literally a computational system. "Computational system" is not intended to mean a modern-day electronic computer. == Pancomputationalism == CTM raises a question that remains a subject of debate: what does it take for a physical system (such as a mind, or an artificial computer) to perform computations? A very straightforward account is based on a simple mapping between abstract mathematical computations and physical systems: a system performs computation C if and only if there is a mapping between a sequence of states individuated by C and a sequence of states individuated by a physical description of the system. Putnam (1988) and Searle (1992) argue that this simple mapping account (SMA) trivializes the empirical import of computational descriptions. As Putnam put it, "everything is a Probabilistic Automaton under some Description". Even rocks, walls, and buckets of water—contrary to appearances—are computing systems. Gualtiero Piccinini identifies different versions of pancomputationalism. Searle wrote:the wall behind my back is right now implementing the WordStar program, because there is some pattern of molecule movements that is isomorphic with the formal structure of WordStar. But if the wall is implementing WordStar, if it is a big enough wall it is implementing any program, including any program implemented in the brain.In response to the trivialization criticism, and to restrict SMA, philosophers of mind have offered different accounts of computational systems. These typically include causal account, semantic account, syntactic account, and mechanistic account. Instead of a semantic restriction, the syntactic account imposes a syntactic restriction. The mechanistic account was first introduced by Gualtiero Piccinini in 2007. == Criticism == A range of arguments have been proposed against physicalist conceptions used in computational theories of mind. An early, though indirect, criticism of the computational theory of mind comes from philosopher John Searle. In his thought experiment known as the Chinese room, Searle attempts to refute the claims that artificially intelligent agents can be said to have intentionality and understanding and that these systems, because they can be said to be minds themselves, are sufficient for the study of the human mind. Searle asks us to imagine that there is a man in a room with no way of communicating with anyone or anything outside of the room except for a piece of paper with symbols written on it that is passed under the door. With the paper, the man is to use a series of provided rule books to return paper containing different symbols. Unknown to the man in the room, these symbols are of a Chinese language, and this process generates a conversation that a Chinese speaker outside of the room can actually understand. Searle contends that the man in the room does not understand the Chinese conversation. This was originally written as a repudiation of the idea that computers work like minds. Objections like Searle's might be called insufficiency objections. They claim that computational theories of mind fail because computation is insufficient to account for some capacity of the mind. Arguments from qualia, such as Frank Jackson's knowledge argument, can be understood as objections to computational theories of mind in this way—though they take aim at physicalist conceptions of the mind in general, and not computational theories specifically. Objections have also been put forth that are directly tailored for computational theories of mind. Jerry Fodor himself argues that the mind is still a very long way from having been explained by the computational theory of mind. The main reason for this shortcoming is that most cognition is abductive and global, hence sensitive to all possibly relevant background beliefs to (dis)confirm a belief. This creates, among other problems, the frame problem for the computational theory, because the relevance of a belief is not one of its local, syntactic properties but context-dependent. Putnam himself (see in particular Representation and Reality and the first part of Renewing Philosophy) became a prominent critic of computationalism for a variety of reasons, including ones related to Searle's Chinese room arguments, questions of world-word reference relations, and thoughts about the mind-body problem. Regarding functionalism in particular, Putnam has claimed along lines similar to, but more general than Searle's arguments, that the question of whether the human mind can implement computational states is not relevant to the question of the nature of mind, because "every ordinary open system realizes every abstract finite automaton." Computationalists have responded by aiming to develop criteri

    Read more →
  • Coghead

    Coghead

    Coghead was a web application company based out of Redwood City, California. The company offered a web-based service for building and hosting custom online database applications. Applications were built around custom data collections and were typically designed to facilitate management of, and collaboration on, business data. Examples of Coghead's "gallery" applications include project management, simple Customer relationship management, bug tracking and extreme programming. Coghead's service was available through a limited-access beta program before "going live" for free trial accounts in April, 2007. Coghead launched a paid subscription plans in June, 2007. On February 19, 2009, Coghead announced that its intellectual property assets (its 'service') had been acquired by SAP AG (NYSE:SAP). == Product == Coghead's product was a fully hosted environment for building, accessing, and maintaining applications and the associated business data. Like other so-called "Web 2.0" companies, Coghead built its product around the idea of "software as a service". The product was intended to allow users to design a range of applications from scratch using only a drag and drop, WYSIWYG user interface, with very limited scripting or coding (if any) required. Coghead also offered its paid subscribers the ability to develop and publish "Coglets," web forms that allowed site visitors to view data in, or submit data into, the host's Coghead database. On February 19, 2009, Coghead announced that SAP AG had acquired the Coghead service through an asset purchase. The SAP asset purchase closed in the 1st Quarter 2009. Immediately upon closing the asset purchase, the public-facing service was taken off-line by SAP as they prepared to integrate the Coghead code with other SAP assets. This forced many of Coghead's customers to find alternative solutions.

    Read more →
  • Historical Thesaurus of English

    Historical Thesaurus of English

    The Historical Thesaurus of English (HTE) is the largest thesaurus in the world. It is called a historical thesaurus as it arranges the whole vocabulary of English, from the earliest written records in Old English to the present, according to the first documented occurrence of a word in the entire history of the English language. The HTE was conceived and begun in 1965 by the English Language & Linguistics department of the University of Glasgow, who have ever since continued to compile the thesaurus. From the 1980s onwards the project was moved from paper-based records to a computer database. Today, the HTE is available to the public online, but a print version, the Historical Thesaurus of the Oxford English Dictionary (HTOED), was published in 2009. == Main project: The Historical Thesaurus of English (HTE) == The Historical Thesaurus of English (HTE) is a complete database of all the words in the Oxford English Dictionary and other dictionaries (including Old English), arranged by semantic field and date. In this way, the HTE arranges the whole vocabulary of English, from the earliest written records in Old English to the present, alongside dates of use. It is the first historical thesaurus to be compiled for any of the world's languages and contains 800,000 meanings for 600,000 words, within 230,000 categories. As the HTE website states, "in addition to providing hitherto unavailable information for linguistic and textual scholars, the Historical Thesaurus online is a rich resource for students of social and cultural history, showing how concepts developed through the words that refer to them." === Structure === The work is divided into three main sections: the External World, the Mind, and Society. These are broken down into successively narrower domains. The text eventually discriminates more than 236,000 categories. The second order categories are: === History === The ambitious project was announced at a 1965 meeting of the Philological Society by its originator, Michael Samuels. Work on the HTE started in the same year. In 2017, the University of Glasgow was awarded the Queen's Anniversary Prize for Higher Education for the HTE. A second edition of the online HTE is currently in progress and is expected to be launched in late 2020. Work is released on the freely-available HTE website when available. == Print edition: Historical Thesaurus of the Oxford English Dictionary (HTOED) == On 22 October 2009, after 44 years of work, version 1.0 of the HTE was published by Oxford University Press in a two-volume slipcased set as the Historical Thesaurus of the Oxford English Dictionary (HTOED). The two hardcover volumes together total nearly 4,500 pages.

    Read more →
  • Semantic triple

    Semantic triple

    A semantic triple, or RDF triple or simply triple, is the atomic data entity in the Resource Description Framework (RDF) data model. As its name indicates, a triple is a sequence of three entities that codifies a statement about semantic data in the form of subject–predicate–object expressions (e.g., "Bob is 35", or "Bob knows John"). == Subject, predicate and object == This format enables knowledge to be represented in a machine-readable way. Particularly, every part of an RDF triple is individually addressable via unique URIs—for example, the statement "Bob knows John" might be represented in RDF as: http://example.name#BobSmith12 http://xmlns.com/foaf/spec/#term_knows http://example.name#JohnDoe34. Given this precise representation, semantic data can be unambiguously queried and reasoned about. The components of a triple, such as the statement "The sky has the color blue", consist of a subject ("the sky"), a predicate ("has the color"), and an object ("blue"). This is similar to the classical notation of an entity–attribute–value model within object-oriented design, where this example would be expressed as an entity (sky), an attribute (color) and a value (blue). From this basic structure, triples can be composed into more complex models, by using triples as objects or subjects of other triples—for example, Mike → said → (triples → can be → objects). Given their particular, consistent structure, a collection of triples is often stored in purpose-built databases called triplestores. == Difference from relational databases == A relational database is the classical form for information storage, working with different tables, which consist of rows. The query language SQL is able to retrieve information from such a database. In contrast, RDF triple storage works with logical predicates. No tables nor rows are needed, but the information is stored in a text file. An RDF-triple store can be converted into an SQL database and the other way around. If the knowledge is highly unstructured and dedicated tables aren't flexible enough, semantic triples are used over classic relational storage. In contrast to a traditional SQL database, an RDF triple store isn't created with a table editor. The preferred tool is a knowledge editor, for example Protégé. Protégé looks similar to an object-oriented modeling application used for software engineering, but it's focused on natural language information. The RDF triples are aggregated into a knowledge base, which allows external parsers to run requests. Possible applications include the creation of non-player characters within video games. == Limitations == One concern about triple storage is its lack of database scalability. This problem is especially pertinent if millions of triples are stored and retrieved in a database. The seek time is larger than for classical SQL-based databases. A more complex issue is a knowledge model's inability to predict future states. Even if all the domain knowledge is available as logical predicates, the model fails in answering what-if questions. For example, suppose in the RDF format a room with a robot and table is described. The robot knows what the location of the table is, is aware of the distance to the table and knows also that a table is a type of furniture. Before the robot can plan its next action, it needs temporal reasoning capabilities. Thus, the knowledge model should answer hypothetical questions in advance before an action is taken.

    Read more →
  • Catastrophic interference

    Catastrophic interference

    Catastrophic interference, also known as catastrophic forgetting, is the tendency of an artificial neural network to abruptly and drastically forget previously learned information upon learning new information. Neural networks are an important part of the connectionist approach to cognitive science. The issue of catastrophic interference when modeling human memory with connectionist models was originally brought to the attention of the scientific community by research from McCloskey and Cohen (1989), and Ratcliff (1990). It is a radical manifestation of the 'sensitivity-stability' dilemma or the 'stability-plasticity' dilemma. Specifically, these problems refer to the challenge of making an artificial neural network that is sensitive to, but not disrupted by, new information. Lookup tables and connectionist networks lie on the opposite sides of the stability plasticity spectrum. The former remains completely stable in the presence of new information but lacks the ability to generalize, i.e. infer general principles, from new inputs. On the other hand, connectionist networks like the standard backpropagation network can generalize to unseen inputs, but they are sensitive to new information. Backpropagation models can be analogized to human memory insofar as they have a similar ability to generalize, but these networks often exhibit less stability than human memory. Notably, these backpropagation networks are susceptible to catastrophic interference. This is an issue when modelling human memory, because unlike these networks, humans typically do not show catastrophic forgetting. == Discovery == The term catastrophic interference was originally coined by McCloskey and Cohen (1989) but was also brought to the attention of the scientific community by research from Ratcliff (1990). === The Sequential Learning Problem: McCloskey and Cohen (1989) === McCloskey and Cohen (1989) noted the problem of catastrophic interference during two different experiments with backpropagation neural network modelling. Experiment 1: Learning the ones and twos addition facts In their first experiment they trained a standard backpropagation neural network on a single training set consisting of 17 single-digit ones problems (i.e., 1 + 1 through 9 + 1, and 1 + 2 through 1 + 9) until the network could represent and respond properly to all of them. The error between the actual output and the desired output steadily declined across training sessions, which reflected that the network learned to represent the target outputs better across trials. Next, they trained the network on a single training set consisting of 17 single-digit twos problems (i.e., 2 + 1 through 2 + 9, and 1 + 2 through 9 + 2) until the network could represent, respond properly to all of them. They noted that their procedure was similar to how a child would learn their addition facts. Following each learning trial on the twos facts, the network was tested for its knowledge on both the ones and twos addition facts. Like the ones facts, the twos facts were readily learned by the network. However, McCloskey and Cohen noted the network was no longer able to properly answer the ones addition problems even after one learning trial of the twos addition problems. The output pattern produced in response to the ones facts often resembled an output pattern for an incorrect number more closely than the output pattern for a correct number. This is considered to be a drastic amount of error. Furthermore, the problems 2+1 and 1+2, which were included in both training sets, even showed dramatic disruption during the first learning trials of the twos facts. Experiment 2: Replication of Barnes and Underwood (1959) study In their second connectionist model, McCloskey and Cohen attempted to replicate the study on retroactive interference in humans by Barnes and Underwood (1959). They trained the model on A-B and A-C lists and used a context pattern in the input vector (input pattern), to differentiate between the lists. Specifically the network was trained to respond with the right B response when shown the A stimulus and A-B context pattern and to respond with the correct C response when shown the A stimulus and the A-C context pattern. When the model was trained concurrently on the A-B and A-C items then the network readily learned all of the associations correctly. In sequential training the A-B list was trained first, followed by the A-C list. After each presentation of the A-C list, performance was measured for both the A-B and A-C lists. They found that the amount of training on the A-C list in Barnes and Underwood study that lead to 50% correct responses, lead to nearly 0% correct responses by the backpropagation network. Furthermore, they found that the network tended to show responses that looked like the C response pattern when the network was prompted to give the B response pattern. This indicated that the A-C list apparently had overwritten the A-B list. This could be likened to learning the word dog, followed by learning the word stool and then finding that you think of the word stool when presented with the word dog. McCloskey and Cohen tried to reduce interference through a number of manipulations including changing the number of hidden units, changing the value of the learning rate parameter, overtraining on the A-B list, freezing certain connection weights, changing target values 0 and 1 instead 0.1 and 0.9. However, none of these manipulations satisfactorily reduced the catastrophic interference exhibited by the networks. Overall, McCloskey and Cohen (1989) concluded that: at least some interference will occur whenever new learning alters the weights involved in representing old learning the greater the amount of new learning, the greater the disruption in old knowledge interference was catastrophic in the backpropagation networks when learning was sequential but not concurrent === Constraints Imposed by Learning and Forgetting Functions: Ratcliff (1990) === Ratcliff (1990) used multiple sets of backpropagation models applied to standard recognition memory procedures, in which the items were sequentially learned. After inspecting the recognition performance models he found two major problems: Well-learned information was catastrophically forgotten as new information was learned in both small and large backpropagation networks. Even one learning trial with new information resulted in a significant loss of the old information, paralleling the findings of McCloskey and Cohen (1989). Ratcliff also found that the resulting outputs were often a blend of the previous input and the new input. In larger networks, items learned in groups (e.g. AB then CD) were more resistant to forgetting than were items learned singly (e.g. A then B then C...). However, the forgetting for items learned in groups was still large. Adding new hidden units to the network did not reduce interference. Discrimination between the studied items and previously unseen items decreased as the network learned more. This finding contradicts studies on human memory, which indicated that discrimination increases with learning. Ratcliff attempted to alleviate this problem by adding 'response nodes' that would selectively respond to old and new inputs. However, this method did not work as these response nodes would become active for all inputs. A model which used a context pattern also failed to increase discrimination between new and old items. == Proposed solutions == The main cause of catastrophic interference seems to be overlap in the representations at the hidden layer of distributed neural networks. In a distributed representation, each input tends to create changes in the weights of many of the nodes. Catastrophic forgetting occurs because when many of the weights where "knowledge is stored" are changed, it is unlikely for prior knowledge to be kept intact. During sequential learning, the inputs become mixed, with the new inputs being superimposed on top of the old ones. Another way to conceptualize this is by visualizing learning as a movement through a weight space. This weight space can be likened to a spatial representation of all of the possible combinations of weights that the network could possess. When a network first learns to represent a set of patterns, it finds a point in the weight space that allows it to recognize all of those patterns. However, when the network then learns a new set of patterns, it will move to a place in the weight space for which the only concern is the recognition of the new patterns. To recognize both sets of patterns, the network must find a place in the weight space suitable for recognizing both the new and the old patterns. Below are a number of techniques which have empirical support in successfully reducing catastrophic interference in backpropagation neural networks: === Orthogonality === Many of the early techniques in reducing representational overlap involved making either the input vecto

    Read more →
  • Steerable filter

    Steerable filter

    In image processing, a steerable filter is an orientation-selective filter that can be computationally rotated to any direction. Rather than designing a new filter for each orientation, a steerable filter is synthesized from a linear combination of a small, fixed set of "basis filters". This approach is efficient and is widely used for tasks that involve directionality, such as edge detection, texture analysis, and shape-from-shading. The principle of steerability has been generalized in deep learning to create equivariant neural networks, which can recognize features in data regardless of their orientation or position. == Example == A common example of a steerable filter is the first derivative of a two-dimensional Gaussian function. This filter responds strongly to oriented image features like edges. It is constructed from two basis filters: the partial derivative of the Gaussian with respect to the horizontal direction ( x {\displaystyle x} ) and the vertical direction ( y {\displaystyle y} ). If G ( x , y ) {\displaystyle G(x,y)} is the Gaussian function, and G x {\displaystyle G_{x}} and G y {\displaystyle G_{y}} are its partial derivatives (which measure the rate of change in the x {\displaystyle x} and y {\displaystyle y} directions, respectively), a new filter G θ {\displaystyle G_{\theta }} oriented at an angle θ {\displaystyle \theta } can be synthesized with the formula: G θ = cos ⁡ ( θ ) G x + sin ⁡ ( θ ) G y {\displaystyle G_{\theta }=\cos(\theta )G_{x}+\sin(\theta )G_{y}} Here, the basis filters G x {\displaystyle G_{x}} and G y {\displaystyle G_{y}} are weighted by cos ⁡ ( θ ) {\displaystyle \cos(\theta )} and sin ⁡ ( θ ) {\displaystyle \sin(\theta )} to "steer" the filter's sensitivity to the desired orientation. This is equivalent to taking the dot product of the direction vector ( cos ⁡ θ , sin ⁡ θ ) {\displaystyle (\cos \theta ,\sin \theta )} with the filter's gradient, ( G x , G y ) {\displaystyle (G_{x},G_{y})} . == Generalization in deep learning: Equivariant neural networks == The concept of steerability is foundational to equivariant neural networks, a class of models in deep learning designed to understand symmetries in data. A network is considered equivariant to a transformation (like a rotation) if transforming the input and then passing it through the network produces the same result as passing the input through the network first and then transforming the output. Formally, for a transformation T {\displaystyle T} and a network f {\displaystyle f} , this property is defined as f ( T ( input ) ) = T ( f ( input ) ) {\displaystyle f(T({\text{input}}))=T(f({\text{input}}))} . This built-in understanding of geometry makes models more data-efficient. For example, a network equivariant to rotation does not need to be shown an object in multiple orientations to learn to recognize it; it inherently understands that a rotated object is still the same object. This leads to better generalization and performance, particularly in scientific applications. === Mathematical foundation === Equivariant neural networks use principles from group theory to create operations that respect geometric symmetries, such as the SO(3) group for 3D rotations or the E(3) group for rotations and translations. Instead of learning standard filter kernels, these networks learn how to combine a fixed set of basis kernels. These basis functions are chosen so that they have well-defined behaviors under transformation groups. Spherical harmonics are frequently used as basis functions because they form a complete set of functions that behave predictably under rotation, making them ideal for creating steerable 3D kernels. Features within the network are treated as geometric tensors, which are mathematical objects (like scalars or vectors) that are "typed" by their behavior under transformations. These types correspond to the irreducible representations (irreps) of the group. The tensor product is the fundamental operation used to combine these typed features in a way that preserves equivariance, guaranteeing that the network as a whole respects the desired symmetry. Frameworks like e3nn simplify the construction of these networks by automating the complex mathematics of irreducible representations and tensor products. === Applications === Steerable and equivariant models are highly effective for problems with inherent geometric symmetries. Examples include: Protein structure analysis: SE(3)-equivariant networks can process 3D molecular structures while respecting their rotational and translational symmetries. 3D Point cloud processing: Rotation-equivariant filters built from steerable spherical functions can perform tasks like 3D shape classification. Computational chemistry: E(3)-equivariant graph neural networks are used to model interatomic potentials for molecular dynamics simulations, creating highly accurate and data-efficient models of physical systems.

    Read more →
  • VP-Expert

    VP-Expert

    VP-Expert is an artificial intelligence development tool that gained popularity in the late 1980s and early 1990s. Published by Paperback Software, VP-Expert was designed to facilitate the creation of rule-based expert systems, primarily for applications in business and industry. It was the best-selling expert-system software for microcomputers in the late 1980s. == History == VP-Expert was created by Brian Sawyer and published by Paperback Software in 1987. VP-Expert was widely adopted during the late 1980s. By April 1989, InfoWorld described it as "the best-selling expert-system software for personal computers." In June 1991, ownership of VP-Expert transferred from Paperback Software to WordTech Systems, Inc. following Paperback Software’s liquidation after a legal dispute with Lotus Development Corporation regarding its VP-Planner spreadsheet. VP-Expert continued to receive positive reviews with InfoWorld stating in 1992 "for automatically creating simple expert systems and being able to edit them into more sophisticated applications, hardly a better product exists than VP-Expert". == Features == VP-Expert used an inference engine based on backward chaining to reach conclusions through English-like if/then rules. It operated through a text interface and included an explanation facility that showed the reasoning steps used to justify its conclusions. == Applications == VP-Expert found applications across various domains. In environmental analysis, researchers used VP-Expert to develop a knowledge-based system for analyzing the impact of particulate matter air pollution on human health. In engineering design, VP-Expert was utilized in the creation of a prototype expert system to assist in fishway design. In aviation management, the tool was employed to develop an expert system aimed at maximizing airport capacity while adhering to noise-mitigation plans. == Limitations == While VP-Expert offered certain advantages, it also had limitations. Its rule-based approach could become challenging to manage for large and complex knowledge bases, and the process of eliciting and encoding knowledge from experts could be time-consuming and difficult.

    Read more →
  • Cerebellar model articulation controller

    Cerebellar model articulation controller

    The cerebellar model arithmetic computer (CMAC) is a type of neural network based on a model of the mammalian cerebellum. It is also known as the cerebellar model articulation controller. It is a type of associative memory. The CMAC was first proposed as a function modeler for robotic controllers by James Albus in 1975 (hence the name), but has been extensively used in reinforcement learning and also as for automated classification in the machine learning community. The CMAC is an extension of the perceptron model. It computes a function for n {\displaystyle n} input dimensions. The input space is divided up into hyper-rectangles, each of which is associated with a memory cell. The contents of the memory cells are the weights, which are adjusted during training. Usually, more than one quantisation of input space is used, so that any point in input space is associated with a number of hyper-rectangles, and therefore with a number of memory cells. The output of a CMAC is the algebraic sum of the weights in all the memory cells activated by the input point. A change of value of the input point results in a change in the set of activated hyper-rectangles, and therefore a change in the set of memory cells participating in the CMAC output. The CMAC output is therefore stored in a distributed fashion, such that the output corresponding to any point in input space is derived from the value stored in a number of memory cells (hence the name associative memory). This provides generalisation. == Building blocks == In the adjacent image, there are two inputs to the CMAC, represented as a 2D space. Two quantising functions have been used to divide this space with two overlapping grids (one shown in heavier lines). A single input is shown near the middle, and this has activated two memory cells, corresponding to the shaded area. If another point occurs close to the one shown, it will share some of the same memory cells, providing generalisation. The CMAC is trained by presenting pairs of input points and output values, and adjusting the weights in the activated cells by a proportion of the error observed at the output. This simple training algorithm has a proof of convergence. It is normal to add a kernel function to the hyper-rectangle, so that points falling towards the edge of a hyper-rectangle have a smaller activation than those falling near the centre. One of the major problems cited in practical use of CMAC is the memory size required, which is directly related to the number of cells used. This is usually ameliorated by using a hash function, and only providing memory storage for the actual cells that are activated by inputs. == One-step convergent algorithm == Initially least mean square (LMS) method is employed to update the weights of CMAC. The convergence of using LMS for training CMAC is sensitive to the learning rate and could lead to divergence. In 2004, a recursive least squares (RLS) algorithm was introduced to train CMAC online. It does not need to tune a learning rate. Its convergence has been proved theoretically and can be guaranteed to converge in one step. The computational complexity of this RLS algorithm is O(N3). == Hardware implementation infrastructure == Based on QR decomposition, an algorithm (QRLS) has been further simplified to have an O(N) complexity. Consequently, this reduces memory usage and time cost significantly. A parallel pipeline array structure on implementing this algorithm has been introduced. Overall by utilizing QRLS algorithm, the CMAC neural network convergence can be guaranteed, and the weights of the nodes can be updated using one step of training. Its parallel pipeline array structure offers its great potential to be implemented in hardware for large-scale industry usage. == Continuous CMAC == Since the rectangular shape of CMAC receptive field functions produce discontinuous staircase function approximation, by integrating CMAC with B-splines functions, continuous CMAC offers the capability of obtaining any order of derivatives of the approximate functions. == Deep CMAC == In recent years, numerous studies have confirmed that by stacking several shallow structures into a single deep structure, the overall system could achieve better data representation, and, thus, more effectively deal with nonlinear and high complexity tasks. In 2018, a deep CMAC (DCMAC) framework was proposed and a backpropagation algorithm was derived to estimate the DCMAC parameters. Experimental results of an adaptive noise cancellation task showed that the proposed DCMAC can achieve better noise cancellation performance when compared with that from the conventional single-layer CMAC. == Summary ==

    Read more →