TRAINING AND EXTRACTION OF FUZZY FINITE STATE AUTOMATA IN

RECURRENT NEURAL NETWORKS

Rohitash Chandra and Christian W. Omlin

School of Science and Technology
University of Fiji

Faculty of Science and Technology

University of the South Pacific
Fiji Islands
rohitashc@unifiji.ac.fj , omlin_c@usp.ac.fj

ABSTRACT were used for inducing FFA by Trakhtenbrot-Barzdin

We present a machine learning approach for the
extraction of fuzzy finite-state automata (FFAs) from
recurrent neural networks. After successful training on
strings with fuzzy membership µ є [0,1], we apply a
generalisation of the Trakhtenbrot-Barzdin algorithm to
extract FFAs in symbolic form from the trained network
using the string labelling assigned by the trained network.
Our results demonstrate that the approach successfully
extracts the correct deterministic equivalent automata for
strings much shorter than the longest string in the training
set.
KEY WORDS
Recurrent neural network, knowledge extraction, fuzzy
finite-state automata, Trakhtenbrot-Barzdin algorithm
1. Introduction
In the past, knowledge extraction from RNNs was aimed
at finding the underlying models of the learned
knowledge typically in the form of finite state machines.
Recurrent neural networks have been trained on
deterministic finite-state automata (DFAs) and knowledge
extraction methods have been applied to explore the
knowledge representation in the weights of the trained
network. Recently, machine learning methods have been
applied to the extraction of symbolic knowledge from
recurrent neural networks. In this paper, we apply a
machine learning method to induce FFAs from the input–
output mappings of trained recurrent neural networks. We
use the observed input-output behaviour of the trained
network to label strings that were not part of the training
set, i.e. we use the trained network’s generalization
capability for string classification. The unlabelled strings
from the training set along with the newly classified
corresponding output state labels by the trained network
algorithm, thus the input-output mapping become a means
for knowledge extraction.
Recurrent neural networks have been an important focus
of research as they can be applied to difficult problems
involving time-varying patterns. Their applications range
from speech recognition and financial prediction to
gesture recognition [1,2,3]. Recurrent neural networks
contain feedback connections. They are composed of an
input layer, a context layer which provides the recurrence,
a hidden layer and an output layer. Each layer contains
one or many single processing units called neurons which
propagate information from one layer to the next by
computing a non-linear function of the weighted sum of
inputs. Recurrent neural networks maintain information
about their past states for the computation of future states
and outputs [4]. We use the backpropagation-through-
time (BPTT) algorithm for training first-order recurrent
neural networks [5]. Recurrent neural networks are
nonlinear dynamical systems and it has been previously
shown that RNN’s can represent FFA states [4]. Other
popular architectures of recurrent neural networks include
second-order recurrent networks [6], NARX networks [7]
and LSTM [8]. A detailed study about the vast variety of
recurrent neural networks is beyond the scope of this
paper.
Fuzzy finite-state automata have been shown to be useful
in application for modelling dynamical fuzzy systems in
conjunction with recurrent neural networks [9-13]. Design
methods for constructing fuzzy finite- state automata with
RNN include the use of a linear output layer for
computing the fuzzy string membership [14] and
assigning multiple neurons, one each for every distinct
membership in the training set [4]. In the latter case, the
number of neurons in the output layer is equal to the
number of distinct fuzzy membership values that occur in
the training set as shown in Figure 1
Knowledge extraction from recurrent neural network aims
at finding or building a formal computational model that
mimic the network to a certain degree [15]. A recurrent
neural network processes information by using its internal
continuous state space as an implicit memory of past
input patterns [5]. Two major forms of knowledge
extraction methods are: 1) looking at the observation of
the internal states of the network which includes
algorithms that construct clusters that corresponds to the
finite state behaviour of the network[16] and 2) machine
learning methods where the extraction relies solely on the
input-output behaviour of the network in which the
technique is not confined to a particular neural network
architecture[17].
Output
layer
Context layer Input layer
Figure 1: Recurrent Neural Network
Architecture. The fuzzy output state
membership is represented by a multiple number
of neurons in the output layer which is equal to
the distinct number of fuzzy states in the training
set.
2. Definitions and Methods
2.1 First Order Recurrent Neural Network
The equation of the dynamics of the change of hidden
state neuron activations in first order recurrent neural
networks is given by:
 K J 
Sit +1 = g  ∑ I kVik + ∑ S tj wij 
 k =1 j =1 
where I k is the k th input neuron, Sit +1 is the output value
of the recurrent state neuron S j at time t . Vik and
wij are the weights connecting input neuron I k and
recurrent state neuron S j to recurrent state neuron Si ,
respectively. g(.) is a sigmoidal discriminant function.
2.2 Regular Languages and Finite Automata
A finite-state automaton is a device that can be in one of a
finite number of states . In certain conditions, it can
switch to another state; this is called a transition . When
the automaton starts processing input, it can be in one of
its initial states. There is also another important subset of
states of the automaton: the final states. If the automaton
is in a final state after processing an input sequence, it is
said to accept its input. Finite-state automata are used as
test beds for training recurrent neural networks.
Presumably, strings used for training do not need to
undergo any feature extraction. They are used to show
that recurrent neural networks can represent dynamical
systems.
In this section, we discuss the transformation of fuzzy
finite-state automata to their equivalent crisp
representation, known as deterministic acceptors.
Definition 2.1: A fuzzy finite-state automaton M is a 6-
tuple M = ( ∑, Q, R, Z, δ, ω ), where ∑ and Q are the
input alphabet and the set of finite states, respectively, R є
Q is the automaton’s fuzzy start state, Z is a finite output
alphabet, δ: ∑ × Q × [0,1] →Q is the fuzzy transition
map, and ω: Q → Z is the output map.
We consider a restricted type of fuzzy automata whose
initial state is not fuzzy, and ω is a function from F to Z,
where F is a non-fuzzy set of states, called finite states.
Any fuzzy automaton as described in Definition 2.1 is
equivalent to a restricted fuzzy automaton [18]. Notice
that a FFA reduces to a conventional DFA by restricting
the transition weights to 1.
Figures 2 and 3 show examples of an FFA and its
corresponding deterministic acceptor, respectively.
Figure 2: Fuzzy Finite-State Automaton with
Weighted State Transitions. State 1 is the
automaton’s start state; accepting states are drawn
with double circles. Only paths that can lead to an
accepting state are shown (transitions to garbage
are not shown explicitly). A transition from state
 qj to qi on input symbols ak with weight θ is
represented as a direct arc from qj to qi labelled
ak / θ.
Figure 3: Equivalent Deterministic Acceptor. The
diagram above is the corresponding deterministic
acceptor from the FFA in Figure 2 which computes
the membership function strings. The accepting
states are labelled with a degree of membership.
Notice that all transitions in the DFA have weight 1.
2.3 Knowledge Extraction from Recurrent Neural
Networks
Neural networks were once considered black boxes, i.e. it
was believed to be difficult to understand the knowledge
or its representation in the weights as part of the
information processing in the network. Knowledge
extraction is the process of finding the meaning of the
internal weight representation of the network. There are
two main approaches for knowledge extraction from
trained recurrent neural networks: inducing finite
automata by clustering the activation values of hidden
state neurons [19] and the application of machine learning
methods to induce automaton from the observation of
input-output mappings of the recurrent neural network. In
this paper, we introduce a generalization of a machine
learning method for symbolic knowledge extraction;
whereas the original method was conceived to extract
DFAs from trained recurrent neural networks, this new
method allows the extraction of fuzzy finite-state
automata.
2.4 Trakhtenbrot- Barzdin Algorithm
The Trakhtenbrot-Barzdin algorithm [20] extracts
minimal DFAs from a data set of input strings and their
respective output states. The algorithm is guaranteed to
induce DFA in polynomial time. A restricting premise of
the TB algorithm is that we must know the labels of all
strings up to certain length L if the desired DFA is to be
extracted correctly. In this paper, we apply the
Trakhtenbrot-Barzdin algorithm to the extraction of FFAs
instead of DFAs from trained recurrent neural networks
and induce a minimal state. The algorithm requires that
the labels of all strings up to length L be known in order
for a DFA to be extracted unambiguously; these strings
can be represented in a so-called prefix tree. This prefix
tree is collapsed into a smaller graph by merging all pairs
of nodes that represent compatible mappings from
suffixes to labels. The algorithm visits all nodes of the
prefix tree in breadth-first order, all pairs (i,j) of nodes are
evaluated for compatibility by the subtrees rooted at i and
j, respectively. The subtrees are compatible if the nodes in
corresponding positions in the respective trees are
identical. If all corresponding labels are the same, then the
edge from i’s parent to i is changed to point at j instead.
Nodes which become inaccessible are discarded. The
result is smallest automaton consistent with the data set.
The original Trakhtenbrot-Barzdin only operated on
prefix trees whose nodes contain binary labels; here, we
generalize the algorithm to allow for labels of nodes in the
prefix tree to correspond to the fuzzy memberships that
occur in the training set. The algorithm is summarised as
follows:
Algorithm 1: Let T be a complete prefix tree with n nodes
1,…,n
for i = 1 to n by 1 do
for j = 1 to i - 1 by 1 do
if subtree(i) ≡ subtree(j)
parent(j) ← parent(i)
Using the above algorithm, we generate a complete prefix
tree for strings of up to lengths L=1. For each successive
string length, we extract a FFA from the corresponding
prefix trees of increasing depth using the Trakhtenbrot-
Barzdin algorithm. The algorithm checks if the extracted
FFA is consistent with the entire training data set, i.e. the
input–output labels of the entire training data set must be
explained by the extracted FFA. If the FFA is consistent,
then the algorithm terminates. The algorithm for running
the extraction process is summarised as follows:
Algorithm 2 : Let M be the universal FFA that rejects
(or accepts) all strings, and let string L =0.
Repeat
L← L+1
Generate all strings of up to L
Extract ML using Trakhtenbrot-Barzdin(L)
Until ML is consistent with the test set
3. Experimentation
3.1 Training Recurrent Neural Networks
The network topology consisted of two input neurons, one
for each of the input symbols 0 and 1, respectively, ten
hidden neurons and four output neurons where each of the
output neurons represents the fuzzy membership of the
fuzzy memberships that occur in the training data set. The
labels of the training strings were generated by the
automaton shown in Figure 3. We used an incremental
training approach when we initialised a working set with
a subset of short string and trained the network on it. We
then expanded the working set and repeated these steps
until the network converged.
Upon successful training, i.e. the network correctly
classifies 100% of the training set on FFA strings of
length 1-10, we tested the network on all strings of length
1-15. We observed that the network was able to correctly
classify 100% of the testing data. This clearly
demonstrates that recurrent neural networks are capable
of representing FFA states internally.
3.2 Knowledge Extraction
As discussed in the previous section, we applied the
knowledge extraction method where the extraction
depends on the input-out mapping of the FFA string
obtained by the generalisation made by the trained
network. Upon successfully training and testing of the
network, we proceeded with the step of knowledge
extraction in order to identify the knowledge represented
in the weights of the network. We recorded the prediction
made by the network for increasing lengths of string as
discussed in Section 2.2. We transformed the string
classification represented by the four output neurons into
their corresponding fuzzy string membership values.
Once all the strings in the data set recorded the network’s
string, the data set with input-output mappings made by
the network was ready for FFA induction. A prefix tree
was built from each sample of the input string and
corresponding fuzzy string membership value. We
applied the FFA extraction algorithm has shown in
Algorithm 2; for each string length L, we recorded the
extracted FFAs fuzzy string classification performance on
the training set.
4. Results and Discussion
The recorded classification performance of the FFAs
extracted with increasing string length L are shown in
Table 1. We note that the FFAs extracted from lengths
L=2,…,4 show 0% accuracy. The fuzzy string
classification accuracy jumps to 92.8% for L=5 and
remains at 100% for all prefix trees with larger depth than
L=5.
We also ran experiments where the training set consisted
of 50%, 30% and 10% of all strings up to length 10, i.e.
the training data itself certainly no longer embodied the
knowledge about the fuzzy membership values necessary
in order to induce FFAs. In this case, the trained network
had to rely on its generalization capability in order to
assign the fuzzy membership values missing in the prefix
tree. Our experiments show that, even when “holes” are
present in the training set, it is possible to extract the ideal
deterministic finite-state acceptor by making use of the
neural network for missing fuzzy membership values.
String Percentage correctly
Length consistent with testing set
2 0%
3 0%
4 0%
5 92.8%
6 100%
7 100%
8 100%
9 100%
10 100%
Table 1: FFA Induction. The table above shows
the percentage of data consistent with the entire
training set with their corresponding string
lengths.
5. Conclusions
We have successfully trained crisp representations of
FFAs with recurrent neural networks. We have seen that
recurrent neural networks can represent FFA in their
internal state representation of the weights. We used a
network architecture with the number of output neurons
equal to the number of distinct fuzzy outputs in the FFA.
This particular architecture was successful in training and
gave a 100% generalisation prediction on a large testing
data set. We used the Trakhtenbrot-Barzdin algorithm for
knowledge extraction. This method has proven favourable
and in general can be applied to various recurrent network
architectures without having constraints. The knowledge
extraction results show that the ideal deterministic
acceptor for a FFA could be extracted from prefix trees
from depth of at least 6, i.e. the extracted acceptor could
explain the entire training data. In this paper, we show
that the Trakhtenbrot-Barzdin algorithm can induce crisp
respresentations of FFAs in similar way in which it has
been applied to DFA induction. It also demonstrates that
recurrent neural networks can represent fuzzy finite-state
automata in similar ways in which they represent
deterministic finite-state automata.
References
[1] A.J Robinson, An application of recurrent nets to
phone probability estimation, IEEE transactions on
Neural Networks, 5(2), 1994, 298-305.
[2] C.L. Giles, S. Lawrence & A.C. Tsoi, Rule inference
for financial prediction using recurrent neural networks,
Proc. of the IEEE/IAFE Computational Intelligence for
Financial Engineering, New York City, USA, 1997, 253-
259
[3] K. Marakami & H Taguchi, Gesture recognition using
recurrent neural networks, Proc. of the SIGCHI
conference on Human factors in computing systems:
Reaching through technology, Louisiana, USA, 1991,
237-242.
[4] C. Lee Giles, C.W Omlin & K. Thornber, Equivalence
in Knowledge Representation: Automata, Recurrent
Neural Networks, and dynamical Systems, Proc. of the
IEEE, 87(9), 1999, 1623-1640
[5] J. L. Elman, Finding structure in time, Cognitive
Science, 14, 1990, 179-211.
[6] R. L. Watrous & G. M. Kuhn, Induction of finite-state
languages using second-order recurrent networks, Proc. of
Advances in Neural Information Systems, California,
USA, 1992, 309-316.
[7] T. Lin, B.G. Horne, P. Tino, & C.L. Giles, Learning
long-term dependencies in NARX recurrent neural
networks. IEEE Transactions on Neural Networks, 7(6),
1996, 1329-1338.
[8] S. Hochreiter & J. Schmidhuber, Long short-term
memory, Neural Computation, 9(8), 1997, 1735-1780.
[9] E. B. Kosmatopoulos and M. A. Christodoulou,
Neural networks for identification of fuzzy dynamical
systems: An application to identification of vehicle
highway systems, Proc. of the 4th IEEE Mediterranean
Symposium, New Directions in Control and Automation,
1996, 23–38.
networks for identification of dynamical systems, IEEE
Trans. Neural Networks, 6, 1995, 422–431.
[13] E. B. Kosmatopoulos and M. A. Christodoulou,
Recurrent neural networks for approximation of fuzzy
dynamical systems, Int. J. Intell. Control Syst., 1(2), 1996,
223–233.
[14] C. W. Omlin, K. K. Thornber, & C. L. Giles, Fuzzy
finite state automata can be deterministically encoded into
recurrent neural networks, IEEE Trans. Fuzzy Syst., 6,
1998, 76–89.
[15] H. Jacobsson, Rule extraction from recurrent neural
networks: A taxonomy and review, Neural Computation,
17 (6), 2005,1223-1263.
[16] S. Das & R. Das, Induction of discrete state-machine
by stabalising a continuous recurrent neural network
using clustering. Journal of Computer Science and
Informatics, 21(2), 1991, 35-40.
[17] A. Vahed & C. W Omlin, Rule extraction from
recurrent neural networks using a symbolic machine
learning algorithm, Proc. of the 6th International
Conference on Neural Information Processing, Dunedin,
New Zealand, 1999, 712-717.
[18] D. Dubois & H. Prade, Fuzzy sets and systems:
theory and applications, Mathematics in science and
engineering, 14, 1980, 220-226.
[19] C. Omlin & C. L. Giles, Extraction of rules from
discrete time recurrent neural networks, Journal of the
ACM, 43(6), 1996, 937-972.
[20] B. Trakhenbrot & Y. Barzdin, Finite automata:
Behaviour and synthesis, North- Holland, Amsterdam,
1973.

[10] F. E. Cellier & Y. D. Pan, Fuzzy adaptive recurrent

counter propagation neural networks: A tool for efficient
implementation of qualitative models of dynamic
processes, J. Syst. Eng., 5(4), 1995, 207–222 .

[11] E. B. Kosmatopoulos & M. A. Christodoulou,

Structural properties of gradient recurrent high-order
neural networks, IEEE Trans. Circuits Syst., 42, 1995,
592–603.

[12] E. B. Kosmatopoulos, M. M. Polycarpou, M. A.

Christodoulou, & P. A. Ioannou, High-order neural