G LOBAL - TO - LOCAL M EMORY P OINTER N ETWORKS FOR T ASK -O RIENTED D IALOGUE
A BSTRACT
End-to-end task-oriented dialogue is challenging since knowledge bases are usually large, dynamic and hard to incorporate into a learning framework.
We propose the global-to-local memory pointer (GLMP) networks to address this issue.
In our model, a global memory encoder and a local memory decoder are proposed to share external knowledge.
The encoder encodes dialogue history, modiﬁes global contextual representation, and generates a global memory pointer.
The decoder ﬁrst generates a sketch response with unﬁlled slots.
Next, it passes the global memory pointer to ﬁlter the external knowledge for relevant information, then instantiates the slots via the local memory pointers.
We empirically show that our model can improve copy accuracy and mitigate the common out-of-vocabulary problem.
As a result, GLMP is able to improve over the previous state-of-theart models in both simulated bAbI Dialogue dataset and human-human Stanford Multi-domain Dialogue dataset on automatic and human evaluation.
I NTRODUCTION
Task-oriented dialogue systems aim to achieve speciﬁc user goals such as restaurant reservation or navigation inquiry within a limited dialogue turns via natural language.
Traditional pipeline solutions are composed of natural language understanding, dialogue management and natural language generation (Young et al., 2013; Wen et al., 2017), where each module is designed separately and expensively.
In order to reduce human effort and scale up between domains, end-to-end dialogue systems, which input plain text and directly output system responses, have shown promising results based on recurrent neural networks (Zhao et al., 2017; Lei et al., 2018) and memory networks (Sukhbaatar et al., 2015).
These approaches have the advantages that the dialogue states are latent without hand-crafted labels and eliminate the needs to model the dependencies between modules and interpret knowledge bases (KB) manually.
However, despite the improvement by modeling KB with memory network (Bordes & Weston, 2017;
Madotto et al., 2018), end-to-end systems usually suffer from effectively incorporating external KB into the system response generation.
The main reason is that a large, dynamic KB is equal to a noisy input and hard to encode and decode, which makes the generation unstable.
Different from chit-chat scenario, this problem is especially harmful in task-oriented one, since the information in
KB is usually the expected entities in the response.
For example, in Table 1 the driver will expect to get the correct address to the gas station other than a random place such as a hospital.
Therefore, pointer networks (Vinyals et al., 2015) or copy mechanism (Gu et al., 2016) is crucial to successfully generate system responses because directly copying essential words from the input source to the output not only reduces the generation difﬁculty, but it is also more like a human behavior.
For example, in Table 1, when human want to reply others the Valero ’s address, they will need to “copy” the information from the table to their response as well.
Therefore, in the paper, we propose the global-to-local memory pointer (GLMP) networks, which is composed of a global memory encoder, a local memory decoder, and a shared external knowledge.
Unlike existing approaches with copy ability (Gulcehre et al., 2016; Gu et al., 2016; Eric &
[Table]
Manning, 2017; Madotto et al., 2018), which the only information passed to decoder is the encoder hidden states, our model shares the external knowledge and leverages the encoder and the external knowledge to learn a global memory pointer and global contextual representation.
Global memory pointer modiﬁes the external knowledge by softly ﬁltering words that are not necessary for copying.
Afterward, instead of generating system responses directly, the local memory decoder ﬁrst uses a sketch RNN to obtain sketch responses without slot values but sketch tags, which can be considered as learning a latent dialogue management to generate dialogue action template.
Then the decoder generates local memory pointers to copy words from external knowledge and instantiate sketch tags.
We empirically show that GLMP can achieve superior performance using the combination of global and local memory pointers.
In simulated out-of-vocabulary (OOV) tasks in the bAbI dialogue dataset (Bordes & Weston, 2017), GLMP achieves 92.0% per-response accuracy and surpasses existing end-to-end approaches by 7.5% in full dialogue.
In the human-human dialogue dataset (Eric et al., 2017), GLMP is able to surpass the previous state of the art on both automatic and human evaluation, which further conﬁrms the effectiveness of our double pointers usage.
GLMP M ODEL
Our model 1 is composed of three parts: global memory encoder, external knowledge, and local memory decoder, as shown in Figure 1(a).
The dialogue history X =
( x 1 , . .
, x n ) and the KB information B = ( b 1 , . .
, b l ) are the input, and the system response Y =
( y 1 , . . .
, y m ) is the expected output, where n, l, m are the corresponding lengths.
First, the global memory encoder uses a context RNN to encode dialogue history and writes its hidden states into the external knowledge.
Then the last hidden state is used to read the external knowledge and generate the global memory pointer at the same time.
On the other hand, during the decoding stage, the local memory decoder ﬁrst generates sketch responses by a sketch RNN.
Then the global memory pointer and the sketch
RNN hidden state are passed to the external knowledge as a ﬁlter and a query.
The local memory pointer returns from the external knowledge can copy text from the external knowledge to replace the sketch tags and obtain the ﬁnal system response.
2. E XTERNAL K NOWLEDGE
Our external knowledge contains the global contextual representation that is shared with the encoder and the decoder.
To incorporate external knowledge into a learning framework, end-to-end memory networks (MN) are used to store word-level information for both structural KB (KB memory) and temporal-dependent dialogue history (dialogue memory), as shown in Figure 1(b).
In addition, the MN is well-known for its multiple hop reasoning ability (Sukhbaatar et al., 2015), which is appealing to strengthen copy mechanism.
Global contextual representation.
In the KB memory module, each element b i ∈ B is represented in the triplet format as (Subject, Relation, Object) structure, which is a common format used to represent KB nodes (Miller et al., 2016; Eric et al., 2017).
For example, the KB in the Table 1 will be denoted as { ( Tom’s house, distance, 3 miles), ..., (Starbucks, address, 792 Bedoin St) } .
On the other hand, the dialogue context X is stored in the dialogue memory module, where the speaker and temporal encoding are included as in Bordes & Weston (2017) like a triplet format.
For instance, the ﬁrst utterance from the driver in the Table 1 will be denoted as { ( $ user, turn1, I), ( $ user, turn1, need), ( $ user, turn1, gas) } .
For the two memory modules, a bag-of-word representation is used as the memory embeddings.
During the inference time, we copy the object word once a memory position is pointed to, for example, 3 miles will be copied if the triplet (Toms house, distance,miles) is selected.
We denote Object ( . ) function as getting the object word from a triplet.
[Figure]
Knowledge read and write.
Our external knowledge is composed of a set of trainable embedding matrices C
=
( C 1 , . . .
, C K +1 ) , where C k ∈ R | V |× d emb , K is the maximum memory hop in the
MN, | V | is the vocabulary size and d emb is the embedding dimension.
We denote memory in the external knowledge as M =
[ B ; X ] =
( m 1 , . . .
, m n + l ) , where m i is one of the triplet components mentioned.
To read the memory, the external knowledge needs a initial query vector q 1 .
Moreover, it can loop over K hops and computes the attention weights at each hop k using
[Equation]
where c ki = B ( C k
( m i ))
∈
R d emb is the embedding in i th memory position using the embedding matrix C k , q k is the query vector for hop k , and B ( . ) is the bag-of-word function.
Note that p k ∈ R n + l is a soft memory attention that decides the memory relevance with respect to the query vector.
Then, the model reads out the memory o k by the weighted sum over c k +1 and update the query vector q k +1 .
Formally,
[Equation]
In Figure 2(a), a context RNN is used to model the sequential dependency and encode the context
X .
Then the hidden states are written into the external knowledge as shown in Figure 1(b).
Afterward, the last encoder hidden state serves as the query to read the external knowledge and get two outputs, the global memory pointer and the memory readout.
Intuitively, since it is hard for MN architectures to model the dependencies between memories (Wu et al., 2018), which is a serious drawback especially in conversational related tasks, writing the hidden states to the external knowledge can provide sequential and contextualized information.
With meaningful representation, our pointers can correctly copy out words from external knowledge, and the common OOV challenge can be mitigated.
In addition, using the encoded dialogue context as a query can encourage our external knowledge to read out memory information related to the hidden dialogue states or user intention.
Moreover, the global memory pointer that learns a global memory distribution is passed to the decoder along with the encoded dialogue history and KB information.
Context RNN.
A bi-directional gated recurrent unit (GRU) (Chung et al., 2014) is used to encode dialogue history into the hidden states H
= ( h e 1 , . .
h e 1 ) , and the last hidden state h en is used to query the external knowledge as the encoded dialogue history.
In addition, the hidden states H are written into the dialogue memory module in the external knowledge by summing up the original memory representation with the corresponding hidden states.
In formula,
[Equation]
Global memory pointer.
Global memory pointer G =
( g 1 , . .
. , g n + l ) is a vector containing real values between 0 and 1.
Unlike conventional attention mechanism that all the weights sum to one,
[Figure]
each element in G is an independent probability.
We ﬁrst query the external knowledge using h en until the last hop, and instead of applying the Softmax function as in (1), we perform an inner product followed by the Sigmoid function.
The memory distribution we obtained is the global memory pointer G , which is passed to the decoder.
To further strengthen the global pointing ability, we add an auxiliary loss to train the global memory pointer as a multi-label classiﬁcation task.
We show in the ablation study that adding this additional supervision does improve the performance.
Lastly, the memory readout q K +1 is used as the encoded KB information.
In the auxiliary task, we deﬁne the label G label =
( g l 1 , . . .
, g ln + l ) by checking whether the object words in the memory exists in the expected system response Y .
Then the global memory pointer is trained using binary cross-entropy loss Loss g between G and G label .
In formula,
[Equation]
2. L OCAL MEMORY DECODER
Given the encoded dialogue history h
en , the encoded KB information q K +1 , and the global memory pointer G , our local memory decoder ﬁrst initializes its sketch RNN using the concatenation of h en and q K +1 , and generates a sketch response that excludes slot values but includes the sketch tags.
For example, sketch RNN will generate “ @poi is @distance away ”, instead of “ Starbucks is 1 mile away. ”
At each decoding time step, the hidden state of the sketch RNN is used for two purposes:
1) predict the next token in vocabulary, which is the same as standard sequence-to-sequence (S2S)
learning; 2) serve as the vector to query the external knowledge.
If a sketch tag is generated, the global memory pointer is passed to the external knowledge, and the expected output word will be picked up from the local memory pointer.
Otherwise, the output word is the word that generated by the sketch RNN.
For example in Figure 2(b), a @poi tag is generated at the ﬁrst time step, therefore, the word Starbucks is picked up from the local memory pointer as the system output word.
Sketch RNN.
We use a GRU to generate a sketch response Y s =
( y s 1 , . . .
, y sm ) without real slot values.
The sketch RNN learns to generate a dynamic dialogue action template based on the encoded dialogue ( h en ) and KB information ( q K +1 ).
At each decoding time step t , the sketch RNN hidden state h dt and its output distribution P vocabt are deﬁned as
[Equation]
We use the standard cross-entropy loss to train the sketch RNN, we deﬁne Loss v as.
[Equation]
We replace the slot values in Y into sketch tags based on the provided entity table.
The sketch tags
ST are all the possible slot types that start with a special token, for example, @address stands for all the addresses and @distance stands for all the distance information.
Local memory pointer.
Local memory pointer L =
( L 1 , . . .
, L m ) contains a sequence of pointers.
At each time step t , the global memory pointer G ﬁrst modify the global contextual representation using its attention weights, [Equation]
[Equation]
and then the sketch RNN hidden state h
dt queries the external knowledge.
The memory attention in the last hop is the corresponding local memory pointer L t , which is represented as the memory distribution at time step t .
To train the local memory pointer, a supervision on top of the last hop memory attention in the external knowledge is added.
We ﬁrst deﬁne the position label of local memory pointer L label at the decoding time step t as [Equation] ∃
[Equation]
otherwise
[Equation]
The position n + l +1 is a null token in the memory that allows us to calculate loss function even if y t does not exist in the external knowledge.
Then, the loss between L and L label is deﬁned as
[Equation]
Furthermore, a record R ∈ R n + l is utilized to prevent from copying same entities multiple times.
All the elements in R are initialized as 1 in the beginning.
During the decoding stage, if a memory position has been pointed to, its corresponding position in R will be masked out.
During the inference time, ˆ y t is deﬁned as
[Equation]
where (cid:12) is the element-wise multiplication.
Lastly, all the parameters are jointly trained by minimizing the weighted-sum of three losses ( α, β, γ are hyper-parameters):
[Equation]
E XPERIMENTS 3. D ATASETS
We use two public multi-turn task-oriented dialogue datasets to evaluate our model: the bAbI dialogue (Bordes & Weston, 2017) and Stanford multi-domain dialogue (SMD)
(Eric et al., 2017).
The bAbI dialogue includes ﬁve simulated tasks in the restaurant domain.
Task 1 to 4 are about calling API calls, modifying API calls, recommending options, and providing additional information, respectively.
Task 5 is the union of tasks 1-4.
There are two test sets for each task: one follows the same distribution as the training set and the other has OOV entity values.
On the other hand, SMD is a human-human, multi-domain dialogue dataset.
It has three distinct domains: calendar scheduling, weather information retrieval, and point-of-interest navigation.
The key difference between these two datasets is, the former has longer dialogue turns but the regular user and system behaviors, the latter has few conversational turns but variant responses, and the KB information is much more complicated.
3. T RAINING DETAILS
The model is trained end-to-end using Adam optimizer (Kingma & Ba, 2015), and learning rate annealing starts from 1 e − 3 to 1 e − 4 .
The number of hop K is set to 1,3,6 to compare the performance difference.
The weights α, β, γ summing up the three losses are set to 1.
All the embeddings are initialized randomly, and a simple greedy strategy is used without beam-search during the decoding stage.
The hyper-parameters such as hidden size and dropout rate are tuned with grid-search over
[Table] [Table]
the development set (per-response accuracy for bAbI Dialogue and BLEU score for the SMD).
In addition, to increase model generalization and simulate OOV setting, we randomly mask a small number of input source tokens into an unknown token.
The model is implemented in PyTorch and the hyper-parameters used for each task and the dataset statistics are reported in the Appendix.
3. R ESULTS
bAbI Dialogue.
In Table 2, we follow Bordes & Weston (2017) to compare the performance based on per-response accuracy and task-completion rate.
Note that for utterance retrieval methods, such as QRN, MN, and GMN, cannot correctly recommend options (T3) and provide additional information (T4), and a poor generalization ability is observed in OOV setting, which has around 30% performance difference in Task 5.
Although previous generation-based approaches (Ptr-Unk,
Mem2Seq) have mitigated the gap by incorporating copy mechanism, the simplest cases such as generating and modifying API calls (T1, T2) still face a 6-17% OOV performance drop.
On the other hand, GLMP achieves a highest 92.0% task-completion rate in full dialogue task and surpasses other baselines by a big margin especially in the OOV setting.
No per-response accuracy loss for
T1, T2, T4 using only the single hop, and only decreases 7-9% in task 5.
Stanford Multi-domain Dialogue.
For human-human dialogue scenario, we follow previous dialogue works (Eric et al., 2017; Zhao et al., 2017; Madotto et al., 2018) to evaluate our system on two automatic evaluation metrics, BLEU and entity F1 score 2 .
As shown in Table 3, GLMP achieves a highest 14.79 BLEU and 59.97% entity F1 score, which is a slight improvement in BLEU but a huge gain in entity F1.
In fact, for unsupervised evaluation metrics in task-oriented dialogues, we argue that the entity F1 might be a more comprehensive evaluation metric than per-response accuracy or BLEU, as shown in Eric et al.
(2017) that humans are able to choose the right entities but have very diversiﬁed responses.
Note that the results of rule-based and KVR are not directly comparable because they simpliﬁed the task by mapping the expression of entities to a canonical form using named entity recognition and linking 3 .
[Table]
Moreover, human evaluation of the generated responses is reported.
We compare our work with previous state-of-the-art model Mem2Seq 4 and the original dataset responses as well.
We randomly select 200 different dialogue scenarios from the test set to evaluate three different responses.
Amazon Mechanical Turk is used to evaluate system appropriateness and human-likeness on a scale from 1 to 5.
As the results shown in Table 3, we see that GLMP outperforms Mem2Seq in both measures, which is coherent to previous observation.
We also see that human performance on this assessment sets the upper bound on scores, as expected.
More details about the human evaluation are reported in the Appendix.
Ablation Study.
The contributions of the global memory pointer G and the memory writing of dialogue history H are shown in Table 4.
We compare the results using GLMP with K = 1 in bAbI OOV setting and SMD.
GLMP without H means that the context RNN in the global memory encoder does not write the hidden states into the external knowledge.
As one can observe, our model without H has 5.3% more loss in the full dialogue task.
On the other hand, GLMP without G means that we do not use the global memory pointer to modify the external knowledge, and an 11.47% entity F1 drop can be observed in SMD dataset.
Note that a 0.4% increase can be observed in task 5, it suggests that the use of global memory pointer may impose too strong prior entity probability.
Even if we only report one experiment in the table, this OOV generalization problem can be mitigated by increasing the dropout ratio during training.
Visualization and Qualitative Evaluation.
Analyzing the attention weights has been frequently used to interpret deep learning models.
In Figure 3, we show the attention vector in the last hop for each generation time step.
Y-axis is the external knowledge that we can copy, including the KB information and the dialogue history.
Based on the question “ what is the address? ”
asked by the driver in the last turn, the gold answer and our generated response are on the top, and the global memory pointer G is shown in the left column.
One can observe that in the right column, the ﬁnal memory pointer successfully copy the entity chevron in step 0 and its address 783 Arcadia Pl in step 3 to ﬁll in the sketch utterance.
On the other hand, the memory attention without global weighting is reported in the middle column.
One can ﬁnd that even if the attention weights focus on several point of interests and addresses in step 0 and step 3, the global memory pointer can mitigate the issue as expected.
More dialogue visualization and generated results including several negative examples and error analysis are reported in the Appendix.
R ELATED W ORKS
Task-oriented dialogue systems.
Machine learning based dialogue systems are mainly explored by following two different approaches: modularized and end-to-end.
For the modularized systems (Williams & Young, 2007; Wen et al., 2017), a set of modules for natural language understanding (Young et al., 2013; Chen et al., 2016), dialogue state tracking (Lee & Stent, 2016; Zhong et al., 2018), dialogue management (Su et al., 2016), and natural language generation (Sharma et al., 2016) are used.
These approaches achieve good stability via combining domain-speciﬁc knowledge and slot-ﬁlling techniques, but additional human labels are needed.
On the other hand, end-to-end approaches have shown promising results recently.
Some works view the task as a next utterance retrieval problem, for examples, recurrent entity networks share parameters between RNN (Wu et al., 2017), query reduction networks modify query between layers (Seo et al., 2017), and memory networks (Bordes & Weston, 2017; Liu & Perez, 2017; Wu et al., 2018) perform multi-hop design to strengthen reasoning ability.
In addition, some approaches treat the task as a sequence generation problem.
Lei et al.
(2018) incorporates explicit dialogue states tracking into a delexicalized sequence generation.
Serban et al.
; Zhao et al.
(2017) use recurrent neural networks to generate ﬁnal responses and achieve good results as well.
Although it may increase the search space,
[Figure]
[Figure] [Figure] [Figure] these approaches can encourage more ﬂexible and diverse system responses by generating utterances token-by-token.
Pointer network.
Vinyals et al.
(2015) uses attention as a pointer to select a member of the input source as the output.
Such copy mechanisms have also been used in other natural language processing tasks, such as question answering (Dehghani et al., 2017;
He et al., 2017), neural machine translation (Gulcehre et al., 2016; Gu et al., 2016), language modeling (Merity et al., 2017), and text summarization (See et al., 2017).
In task-oriented dialogue tasks, Eric & Manning (2017) ﬁrst demonstrated the potential of the copy-augmented Seq2Seq model, which shows that generationbased methods with simple copy strategy can surpass retrieval-based ones.
Later, Eric et al.
(2017) augmented the vocabulary distribution by concatenating KB attention, which at the same time increases the output dimension.
Recently, Madotto et al.
(2018) combines end-to-end memory network into sequence generation, which shows that the multi-hop mechanism in MN can be utilized to improve copy attention.
These models outperform utterance retrieval methods by copying relevant entities from the KBs.
Others.
Zhao et al.
(2017) proposes entity indexing and Wu et al.
(2018) introduces recorded delexicalization to simplify the problem by record entity tables manually.
In addition, our approach utilized recurrent structures to query external memory can be viewed as the memory controller in Memory augmented neural networks (MANN) (Graves et al., 2014; 2016).
Similarly, memory encoders have been used in neural machine translation (Wang et al., 2016) and meta-learning applications (Kaiser et al., 2017).
However, different from other models that use a single matrix representation for reading and writing, GLMP leverages end-to-end memory networks to perform multiple hop attention, which is similar to the stacking self-attention strategy in the Transformer (Vaswani et al., 2017).
C ONCLUSION
In the work we present an end-to-end trainable model called global-to-local memory pointer networks for task-oriented dialogues.
The global memory encoder and the local memory decoder are designed to incorporate the shared external knowledge into the learning framework.
We empirically show that the global and the local memory pointer are able to effectively produce system responses even in the out-of-vocabulary scenario and visualize how global memory pointer helps as well.
As a result, our model achieves state-of-the-art results in both the simulated and the human-human dialogue datasets, and holds potential for extending to other tasks such as question answering and text summarization.
A T ABLES A. T RAINING PARAMETERS
[Table]
A. D ATASET S TATISTICS
[Table]
[Figure]
[Figure]
Wrong
wrong logic wrong dialogue
wrong entity provided Human-
The utterance is 100% like what a person will say 4: The utterance is 75% like what a person will say 3: The utterance is 50% like what a person will say 2: The utterance is 25% like what a person will say 1: The utterance is 0% like what a person will say
B E RROR A NALYSIS
For bAbI dialogues, the mistakes are mainly from task 3, which is recommending restaurants based on their rating from high to low.
We found that sometimes the system will keep sending those restaurants with the higher score even if the user rejected them in the previous turns.
On the other hand, SMD is more challenging for response generation.
First, we found that the model makes mistakes when the KB has several options corresponding to the user intention.
For example, once the user has more than one doctor appointment in the table, the model can barely recognize.
In addition, since we do not include the domain speciﬁc and user intention supervision, wrong delexicalized responses may be generated, which results in an incorrect entity copy.
Lastly, we found that the copied entities may not be matched to the generated sketch tags.
For example, an address tag may result in a distance entity copy.
We leave the space of improvement to future works.
C A DDITIONAL D ISCUSSION
One of the reviewers suggested us to compare our work to some existing dialogue framework such as PyDial 5 .
To the best of our knowledge, in the PyDial framework, it requires to have the dialogue acts labels for the NLU module and the belief states labels for the belief tracker module.
The biggest challenge is we do not have such labels in the SMD and bAbI datasets.
Moreover, the semi tracker in PyDial is rule-based, which need to re-write rules whenever it encounters a new domain or new datasets.
Even its dialogue management module could be a learning solution like policy networks, the input of the policy network is still the hand-crafted state features and labels.
Therefore, without the rules and labels predeﬁned in the NLU and belief tracker modules, PyDial could not learn a good policy network.
Truly speaking, based on the data we have (not very big size) and the current state-of-the-art machine learning algorithms and models, we believe that a well and carefully constructed task-oriented dialogue system using PyDial in a known domain using human rules (in NLU and Belief Tracker) with policy networks may outperform the end-to-end systems (more robust).
However, in this paper, without additional human labels and human rules, we want to explore the potential and the advantage of end-to-end systems.
Besides easy to train, for multi-domain cases, or even zero-shot domain cases, we believe end-to-end approaches will have better adaptability compared to any rule-based systems.
D V ISUALIZATION
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure] [Table] [Figure] [Table]
[Figure] [Table] [Figure] [Table]
[Figure]
[Table] [Figure] [Table] [Figure]
[-set my reminder for dinner at 7pm , for the_6th of this month with my beloved marie 0 1 2 3 4 5 6 7 
-][Table] [Figure] [Table] [Figure]
[-Pointer w/o G 0 1 2 3 4 5 6 7 
-][Table] [Figure] [Table] [Figure]
[Table]
[Figure]
[Table] [Figure] [Table] [Figure]
[Table]
[Figure] [Table] [Figure] [Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure] [Table] [Figure] [Figure]
[Figure]
[Table]
[Figure]
[Table]
[Figure] [Table] [Figure] [Figure]
[Figure] [Figure] [Figure] [Figure]
G
[Figure] [Figure]