Warning: fopen(111data/log202001282212.log): failed to open stream: No space left on device in /home/pde321/public_html/header.php on line 107
Warning: flock() expects parameter 1 to be resource, boolean given in /home/pde321/public_html/header.php on line 108
Warning: fclose() expects parameter 1 to be resource, boolean given in /home/pde321/public_html/header.php on line 113 Anwendungsunabhängige Sprachmodelle für sprachunabhängige Anwendungen - Dokument EP1067465
Anwendungsunabhängige Sprachmodelle für sprachunabhängige Anwendungen
This invention relates to arrangements for automatically generating
messages, such as voice and text announcements, in any of multiple variations,
Background of the Invention
Automated message-generating arrangements have a wide range of applications.
For example, in interactive voice-response systems, they are used to generate messages
for playback to a user which either provide the user with information or prompt
the user for action.
The design and use of the message-generating arrangement is relatively
simple if only one language is supported. For example, the sentence structure required
for any announcement is known a-priori, thereby making the construction of announcements
relatively simple. However, even if only one language is supported, there is still
a problem of entering information that is context-dependent or user-dependent
into the announcements. An example of context-dependent information is singular
versus plural terms. An example of user-dependent information is date information:
"day/month" order in some cultures versus "month/day" order in others.
As a result of language-, culture-, or market-specific variations
in representing information, the design of the message-generating arrangement usually
is language-, culture-, or market-specific. But this limits use of the arrangement
to only the particular market, culture, or language for which it was designed,
and different designs must be created for each market, culture and language. This
is very expensive and highly inefficient.
To avoid this problem, efforts have been made to design message-generating
arrangements that are language-, culture-, or market-independent. For example,
U.S. patent no. 5,375,164 discloses a voice-messaging system whose design is based
upon "semantic expressions" that are used to evaluate language-, culture-, or market-specific
data. While effective, this design still does not separate the "semantic expressions"
from associated application code to the extent needed to make the design completely
application-independent and therefore completely versatile and generic.
Summary of the Invention
This invention is directed to solving these and other problems and
disadvantages of the prior art. Generally according to the invention, there is
provided an application-independent language module for language-independent applications.
The language module responds to a request identifying a concept that is generic
to a plurality of languages and also identifying the language that the concept
is to be expressed in by generating and returning an expression of the identified
concept in the identified language. All grammar and syntax of the concept in the
identified language is defined by the language module. The language module thus
separates and hides all language dependencies from applications, while preferably
the language module is application-independent. The term "language" is used broadly
throughout to include culture and market as well as other contexts that affect
the expression of concepts.
According to one aspect of the invention, a communications method
comprises the following steps. The language module receives identification of a
concept that is generic to a plurality of languages, and of a language that the
concept is to be expressed in, from an application that needs to communicate the
identified concept in the identified language. In response, the language module
generates an expression of the identified concept in the identified language from
stored information, and provides the generated expression to the application for
communicating the expression. The application is consequently independent of languages
including the identified language, and may be used to express the concept in any
language for which the language module has the stored information. Preferably,
the language module is also independent of applications including this application,
and may be used with any application that can identify to the language module a
concept and a language for which the language module has the stored information.
Illustratively, the provided expression identifies stored media fragments and
their order that form a communicable version of the concept, and the application
obtains the identified media fragments from a database of stored media fragments
and communicates them in the identified order. The language module is thus made
media-independent and can be used to generate expressions of concepts in any media
(e.g., voice, text, etc.)
According to another aspect of the invention, the language module
comprises a plurality of stored concept definitions each defining a concept that
is generic to a plurality of languages in a language-dependent manner and pointing
to parsers each for expressing a portion of an expression of the concept in the
language of the concept definition, and further associating any variables that
are involved in the concept with the parsers. The language module also comprises
a plurality of the stored parsers for expressing portions of the expressions of
the concepts in the languages of the corresponding concept definitions and for
expressing values of any variables associated with the parsers in the languages
of the corresponding concept definitions. The language module further includes
a means (a program interface, for example) for receiving identifications of any
one of the concepts and of a language that the concept is to be expressed in, and
values of any variables involved in the concept, and in response for returning
an expression of the identified concept in the identified language. A further means
(a processing engine, for example) of the language module responds to the received
identifications by accessing a stored concept definition that corresponds to the
received identifications, responds to the accessed concept definition by using
the parsers pointed to by the accessed concept definition to express the portions
of the expression in the identified language, including expressing any values of
any said variables in the identified language by using any said parsers associated
with any said variables. Illustratively, the language module is implemented in
object-oriented programming form where the above-characterized stored entities
are object instances of foundation classes (prototype objects) that are also included
in the language module.
The language module further preferably comprises a plurality of stored
concept objects each representing a different one of the concepts in a language-independent
manner and pointing to the concept definitions that define the corresponding concept
in language-dependent manners. The processing engine responds to the received concept
and language identifications by accessing a concept object that corresponds to
the identified concept and determining therefrom the concept definition that corresponds
to the identified concept and language.
According to yet another aspect of the invention, a communications
method involving an application that uses the language module comprises the following
steps. The application identifies to the language module a concept that is generic
to a plurality of languages and a language that the concept is to be expressed
in, in response to needing to communicate the identified concept in the identified
language. In response, the application receives from the language module an expression
of the identified concept in the identified language, and in response the application
communicates the received expression of the concept. The application is thus independent
of languages, including the identified language. Illustratively, the received expression
identifies media fragments and their order that form a communicable version of
the concept, and the application obtains the identified media fragments from a
database of media fragments and communicates those media fragments in the identified
The invention encompasses both methods that comprise the above-characterized
steps and apparatuses that include the above-characterized elements or effect the
method steps. The latter apparatus preferably includes an effector-any entity that
effects the corresponding step, unlike a means―for each step. Further, the
invention encompasses computer-readable media containing instructions which, when
executed in a computer, either cause the computer to perform the method or cause
the computer to embody the apparatus.
These and other features and advantages of the invention will become
more apparent from the following description of an illustrative embodiment of the
invention considered together with the drawing.
Brief Description of the Drawing
FIG. 1 is a block diagram of a message-generation arrangement that includes
an illustrative embodiment of the invention;
FIG. 2 is a functional diagram of two illustrative prior-art applications that
implement the same functionality in two different languages;
FIG. 3 is a functional diagram of a single illustrative application constructed
according to the invention that implements the functionality of the two applications
of FIG. 2;
FIG. 4 is a functional flow diagram of interactions between the application
of FIG. 3 and the language module of the arrangement of FIG. 1;
FIG. 5 is a block diagram of the language module of the arrangement of FIG.
FIG. 6 is a functional flow diagram of the process of developing language data
contents of the language module of the arrangement of FIG. 1;
FIGS. 7A-C are a functional flow diagram of a language developer's illustrative
portion of the language module development process of FIG. 6; and
FIGS. 8A-B are a functional flow diagram of an illustrative parse method of
the runtime API of the arrangement of FIG. 1.
FIG. 1 shows a message-generation arrangement that includes an illustrative
embodiment of the invention. The arrangement includes a server 100 that provides
services to users through their communications terminals 101-102, such as telephones
101 and data terminals or personal computers 102. Terminals 101-102 are connected
to server 100 via a communications network 103, such as a local area network (LAN),
the Internet, or a public or a private telephone network. Server 100 is a stored
program-controlled device. It comprises hardware 110, including a processor for
executing programs and a memory for storing the programs, an operating system 111
that controls the operation of server 100, platform software 112 that provides
basic, generic, services to users and to application software, and application
software 114 which implements the high-level services provided by server 100 to
users. Users' terminals 101-1 02 interact with server 100 through a user interface
115, such as a telephony user interface (TUI) comprising telephone line and trunk
port circuits and associated signaling, or a graphical user interface (GUI).
As described so far, server 100 is conventional. For example, elements
110-112 and 115 together comprise the Lucent Technologies Inc. Conversant®
voice information system, and elements 110-112 and 114-115 together comprise the
Lucent Technologies Inc. Intuity™ messaging system.
Additionally, server 100 comprises a run-time application program
interface (API) 113, a run-time language module 116, and a speech database (DB)
117. Alternatively, database 117 may define another medium, e.g., text, or a plurality
of media. Run-time API 113 interfaces application software 114 to run-time language
module 116. Application software 114 is also interfaced to speech database 117
by the platform software 112. Elements 116 and 117 can be located at any level
of the software hierarchy (i.e., at the level of any of elements 111, 112, and
114). During normal operation, when application software 114 determines the concept
(any information, including any prompt for user input) that it needs to communicate
to a user, it requests run-time language module 116 via run-time API 113 to provide
the precise expression of the concept that will properly convey that information.
After run-time language module 116 specifies the expression, application software
114 accesses speech DB 117 via platform software 112 and retrieves therefrom the
speech, text, or other media fragments specified by module 116 that are needed
to compose a communicable version of the concept's expression and causes the expression
to be sent to the user. Elements 113 and 116-117 are described in more detail further
The message-generation arrangement of FIG. 1 further includes a development
platform 150 which is used to develop run-time language module 116 and speech DB
117 of server 100. Development platform 150 is a stored program-controlled device,
It comprises hardware 160, including a processor for executing programs and a
memory for storing the programs, an operating system 161 that controls the operation
of platform 150, and a graphical user interface (GUI) 165 through which a developer's
terminal or computer 155 interacts with platform 150. As described so far, platform
150 is conventional. Illustratively, hardware 160 comprises a personal computer
(PC) or a workstation, and operating system 161 and GUI 165 together comprise a
Windows-type operating system.
Additionally, platform 150 includes a development API 170, database
administration 171, a language DB 172, speech tools 173, and compiler 174. Database
administration 171 is a conventional database manager that is a function of which
databases (e.g., Oracle, Informix, etc.) are selected for databases 117 and 172.
Speech tools 173 are conventional tools that are conventionally used to develop
a speech DB of speech fragments from which voice messages are composed at run-time.
If the messages are desired to be in a medium other than voice, e.g., text, graphics,
video, or multi-media, speech tools 173 change accordingly so as to facilitate
the development of a database of fragments of the desired medium or media. A developer
interfaces with speech tools 173 via GUI 165 in order to generate the contents
of speech DB 117.
Language DB 172 stores all rules needed to construct expressions
of concepts in each language and/or for each culture or market that have been defined
by language DB 172 developers. Run-time language module 116 is an executable version
of language DB 172 compiled by compiler 174. Language DB 172 is composed of a
framework, which is a database representation of the structure of languages, and
of language data, which are the data that define individual languages. Significantly,
the framework is language-, culture-, and market-independent. The framework of
language DB 172 thus presents a model of a language in which any language and any
culture- or market-dependent variants thereof can be represented.
Turning now to FIG. 2, an application 114a or 114b may be viewed
as comprising two major distinct types of information: application logic and culture
logic. Application logic is the approach used to provide the desired functionality
to end-users (e.g., interact with a caller to a bank to provide the caller with
an account balance). It is represented in FIG. 2 by the numbered statements. It
includes the implementation of business rules (the need that the application is
filling). It is coded and developed by an application specialist (a programmer).
The culture logic is the approach used to communicate with end-users (e.g., U.S.
English or Mandarin). It is represented in FIG. 2 by the indented statements. It
includes user-interface standards (e.g., Graphical User Look Listen and Feel (GULLF)).
It is developed by a language specialist (a linguist). Each one of these types
of information has its own dynamics for development, reuse, and maintenance. So,
although they are inter-dependent, they should not be intra-dependent (i.e., they
are components of the same application, but the application logic should not be
intertwined or directly interact with the culture logic, and vice versa). How this
objective is met is illustrated in FIG. 3.
To meet this objective, we provide a self-contained language module
116 that contains all language-dependent, culture-dependent and market-dependent
logic, designated as 116 a and b in FIG. 3, and no application logic (i.e., the
contents of module 116 are language-dependent but application-independent) so that
application 114 contains only application logic and no culture logic (i.e., application
114 is language-independent but application-dependent), as shown in FIG. 3. Application
114 provides all context information to the language module 116, and language module
116 provides all language information back to application 114. A usage example,
showing how this is accomplished, is given in FIG. 4. Via runtime API 113, application
114 provides a request 400 to language module 116 identifying a particular concept
(4400), the language in which that concept is to be expressed (English), the medium
in which the concept is to be expressed (recorded speech), and values of variables
($today_date and $balance_1) used by the concept. Concepts are generic to a plurality
(illustratively all) languages. Via runtime API 113, language module 116 provides
a response 401 that lists a sequence of fragment identifiers in speech database
117 which, when they are retrieved via platform software 112 from speech database
117 and are voiced in the indicated sequence, result in the appropriate announcement
being communicated, e.g., "On April 15, 1998, you have three hundred dollars in...".
Shown in FIG. 5, language module 116 comprises a repository 500,
foundation classes 501, and an engine 502. Repository 500 is a store (e.g., a database)
of object instances that contains all language-related information (language resources)
for use by one or more applications, and a conventional database manager. All
grammar and syntax information for all defined concepts in all defined languages
is stored in repository 500. Foundation classes 501 are definitions of prototype
objects that can be instantiated to allow the developer of the language module
(e.g., a language developer) to describe the language resources. They enable the
developer to represent language-dependent information in object-oriented programming
form, in a way that facilitates use by different applications, to map external
representations of information into corresponding representations internal to
repository 500, and to access the language resources in repository 500. Engine
502 is either a library or a stand-alone processing program that allows either
the developer to manipulate the contents of repository 500 or an application 114
to access the contents of repository 500 through an application programming interface
(API) without directly using foundation classes 501. Optionally, language module
116 may further include add-ons 503, such as libraries or stand-alone programs
that extend the basic language-module functionality to allow a developer to perform
repository and media-related information creation and management. Add-ons 503
may implement one or more of the following capabilities. Application simulation,
which allows a developer to test the repository prior to its use with an application,
and supports language resource development without requiring an actual application
to support the resource development. Media check, which verifies that all media-dependent
information accessed by an application is actually available in the run-time environment.
Repository migration, which enables the repository and all media-related information
to be moved between and managed in different development environments and installed
in the run-time environment. Media conversion, which converts media-dependent language
resources from a variety of different formats into a format suitable for use in
the run-time environment. Support of batching, which batches a list of media-dependent
information that is to be presented to the user simultaneously. Media proxy, which
allows the application simulation to obtain and use media-dependent information
obtained through a network. And support for speech recording (e.g., a sound card),
which permits a developer to generate media-dependent language resources, such
as speech files.
The following is a brief description of the process through which
the repository gets populated with language resources as illustrated in FIG. 6.
From a description 600 of what an application 114 needs to accomplish, an application
specialist 601 specifies the language-related knowledge 602 comprising language
elements (e.g., prompts, announcement) that are required by the application and
the languages (e.g., English, Spanish, French, Japanese) that the application will
use. A language specialist 603 defines a language-specific representation 604 of
the language elements in each language that will be used by the application. The
developer 605 of the language module 116 structures the language-specific information
604 in a language-module (LM) representation 606 that is reusable by (i.e., is
generic to) all of the languages used by the application. The language module developer
605 then stores the results in language database 172 (see FIG. 1).
Language database 172 has an associated manager-database administration
171―which is dependent upon the particular database being used and which
performs conventional database management functions (e.g., manages accesses to
the language resources). The language resources that populate language database
172 include instances of the following foundation class objects 501:
A language, which posits, or defines the existence of, a language in the repository.
It comprises a language ID and a language name, both of which are preferably defined
consistently with ISO 639/ISO 3166.
A concept, which posits, or defines the existence of, a concept in a language-independent
manner. It comprises a concept ID, a concept description which is a text description
of the purpose of the concept, a concept scope that defines who has access rights
to this concept (e.g., application developers, language developers, or both), and
a concept variable list that lists the variables that are used as input and output
parameters by this concept and the order in which the variables must be presented
to this concept. Via the concept ID, it identifies or points to all language-specific
definitions of the posited concept.
A concept definition, which defines how to implement a specific concept in
a specific language; it ties a language and a concept together. It comprises a
concept definition component list which lists the language components (e.g., words,
phrases) that are used to implement the concept and their order, and a concept
definition-to-component-variable mapping that maps the language components to
the corresponding variables in the corresponding concept variable list. Not every
language component needs to correspond to a variable; a variable can correspond
to only one language component. The language components are expressed by parsers,
and the concept definition component list points to the specific parsers that implement
the expression of the corresponding concept in the corresponding language.
A parser, which defines how to convert input data (a portion, e.g., a phrase,
of the concept expression, including the value of any input variable) to language
fragments of a specific language (and vice versa). A parser may (but may not) accept
an input, and generates a syntactically and semantically correct output in the
target language and data type that it represents. As in other computer science
contexts, a parser here is an entity that determines the syntactic structure of
a language unit by decomposing it into more elementary sub-units and establishing
the relationships among the sub-units. For example, to decompose blocks into statements,
statements into expressions, and expressions into operators and operands. In this
illustrative example, the output takes the form of a sequence of one or more fragment
identifiers of fragments in speech database 117. A parser can also be viewed as
a dynamic-concept definition.
A data type, which defines a type of data (e.g., integer, character, undefined,
etc.) in the same manner as is common in computer programming languages.
A variable, which defines a variable ID and its data type, in the same manner
as is common in computer programming languages.
In language database 172, languages are constructed from concept
definitions, Individual concept definitions may in turn be constructed from other,
simpler, concepts. Concepts are in turn constructed from concept definitions, data
types, and variables.
In its simplest form, an object is a unit of information. In an object-oriented
programming environment, an object contains both attributes and method describing
how the content is to be interpreted and/or operated on.
Foundation class objects 501 provide the framework to development
API 170 for creating the language resources and populating language database 172
therewith. With respect to each foundation class, the API 170 provides functions
to create, modify, or remove (delete) instances of the foundation class object.
The create functions check if the identified instance already exists, and if so,
deny permission to create it. The modify functions and the remove functions guarantee
referential integrity between the candidate for modification or removal, respectively,
and any other entities that refer to it. If other entities do refer to it, the
developer is forced to modify or remove them before modifying or removing the
The development API 170 includes the following basic functions.
FIG. 7 illustrates the use of the development API 170 to create in language database
172 the language resources needed for the announcement "On (today's date) you have
(balance) in your savings account" in U.S. English.
Once the developer has created language DB 172 for a particular language,
the developer causes compiler 174 to compile language DB 172 into executable code,
which populates repository 500 of runtime language module 116 (see FIG. 5). For
example, if language DB 172 is an object-orientated database, the compilation is
as simple as a direct data dump (copy) of language DB 172 into repository 500 of
Once runtime language module 116 has been created, it is available
for use by application software 114. Interaction between the two is via runtime
API 113, which is supported by engine 502 and includes the following basic functions.
Function Runtime API 113 Definition manager_id.getLanguages()Returns all available languages for this manager instance manager_id.getConcepts(Language)Returns all available concepts for this manager instance manager_id.getMedia()Returns all available media for this manager instance. manager_id.parse(Language, Concept, Medium, VariablesValuesList)Returns a list of fragments of the given medium that represent
an expression of the given concept in the given language. If the concept has variables,
these variables' values are provided in the order specified in the concept. The
parse accomplishes this by passing the variables values list to the method parse
of the concept definition instance corresponding to the specified language. The
result is then converted to the specified medium.
The first three functions (method calls) apply only to manager instances,
and involve communication from application 114 to the manager and back again. The
fourth function, representing the parse method, involves at the highest level communication
from application 114 to the manager, from the manager to the indicated concept
definition, from the concept definition to a parser, from the parser back to the
concept definition and therefrom to the manager, and finally from the manager
back to application 114. An example of the parse method implementing the usage
example of FIG. 4 is shown in FIGS. 8A-B.
Of course, various changes and modifications to the illustrative
embodiment described above will be apparent to those skilled in the art. For example,
definitions, naming of functions, and passing of parameters in the APIs may be
changed as necessary to adapt to a particular programming environment. The media
may change as desired, and the information passed back by the language module may
change accordingly: for example, it can pass back text directly instead of fragment
pointers. Also, the database structure may be changed; for example, to add legacy
information for backwards compatibility. Such changes and modifications can be
made within the scope of the invention and without diminishing its attendant advantages,
It is therefore intended that such changes and modifications be covered by the
following claims except insofar as limited by the prior art.
A communications method CHARACTERISED BY:
receiving an identification (400) of a concept (4400) that is generic to a
plurality of languages and of a language (EN_US) that the concept is to be expressed
in from an application (114) needing to communicate the identified concept in the
in response, a language module (116) generating (FIG. 8) an expression of the
identified concept in the identified language from stored information (500) including
a language-specific concept definition (4392 EN_US, 3400 EN_US) of the identified
concept for the identified language; and
providing the generated expression (401) to the application for communicating
The method of claim 1 wherein:
the application is independent of languages including the identified language;
the language module is independent of applications including said application.
The method of claim 1 wherein:
the stored information includes definitions of a plurality of concepts (1000,
2500, 4400), including the identified concept, each for an individual language;
the definition (4392_EN) of the identified concept (4392) identifies at least
one parser (1323, 1324) included in the stored information; and
the language module uses the identified at least one parser to express the
identified concept in the identified language.
The method of claim 1 wherein:
the stored information includes definitions of a plurality of concepts (1000,
2500, 4400), including the identified concept, for a plurality of languages, including
the identified language; and the stored information includes a plurality of concept
objects (4392, 3400, 4400) each defining a different one of the concepts in a language-independent
manner and identifying the concept definitions (4392 EN_US, 3400 EN_US) of the
represented concept for different languages.
The method of claim 1 wherein:
receiving an identification of a concept includes
receiving a value ($TODAY_DATE; $BALANCE_1) of a variable (2425; 2430) that
has a corresponding parser (1324; 1002) included in the stored information;
composing (FIG. 8) an expression of the value of the variable in the identified
language by the corresponding parser; and
the communicating includes
communicating (401) the expression of the value of the variable.
A language module (116) that enables applications (114) to communicate concepts
in language-independent manner,
storage means (500) storing
a plurality of concept definitions (4400 EN_US, 4392 EN_US, 3400 EN_US) each
defining a concept (4400) that is generic to a plurality of languages in a language-dependent
manner and pointing to parsers (1323, 1324, 1001, 1002, 1010, 1021, 1022) each
for expressing a portion of an expression of the concept in the language of the
concept definition and further associating any variables (2425, 2430) that are
involved in the concept with the parsers, and
a plurality of said parsers for expressing portions of the expressions of the
concepts in the languages of the corresponding concept definitions and for expressing
values of any variables associated with the parsers in the languages of the corresponding
means (113) for receiving identification of any one of the concepts and of
a language that the concept is to be expressed in and also receiving values of
any variables involved in the concept, and in response returning an expression
of the identified concept in the identified language; and
means (502) cooperative with the receiving means and the storage means, responsive
to the received identifications for accessing a stored concept definition that
corresponds to the received identifications, responsive to the accessed concept
definition for using the parsers pointed to by the accessed concept definition
to express the portions of the expression of the identified concept in the identified
language, including expressing any values of any said variables in the identified
language by using any said parsers associated with any said variables.
The language module of claim 6 wherein: the stored information includes a plurality
of concept objects (4400, 4392, 3400) each representing a different one of the
concepts in a language-independent manner and identifying the concept definitions
(4400 EN_US, 4392 EN_US, 3400 EN_US) of the represented concept for different
the accessing means respond (FIG. 8) to the received identification of the
concept and the language by accessing the concept object that corresponds to the
identified concept and determining therefrom the object definition that corresponds
to the identified concept and language.
The language module of claim 6 wherein:
the storage means further stores
a plurality of variable objects (2425, 2430) each defining one of the variables
as corresponding to a particular data type;
a plurality of data type objects each defining a particular type of data; and
at least one language objects (EN_US) each defining an individual language.
The language module of claim 6 in combination with a database (117) of media
the returned expression (401) identifies the media fragments and their order
forming a communicable version of the identified concept in the identified language.
An apparatus (100) CHARACTERISED IN THAT it is adapted for carrying out the
method of any one of the claims 1-5.