4
$\begingroup$

I recently wrote an open-source application that lets you practice Chinese writing and the decisions I made about its inner workings were related to my theories of how human memory works. I'm not sure which facts specifically are relevant, so I'll explain it all in context (scroll down to the the "question" section if you don't believe it's relevant):

The goal of the application is to help user remember the writing of Chinese characters and their pronunciation. The assumption is that the user would input a set of Chinese characters, most of which are non-trivial to write with aid, let alone from memory. Moreover, there is the concept of stroke order which is useful to remember: each character is made of strokes which should be written in a specific shape, position and order. This makes it pretty complex. I heard that the way Chinese people cope with learning this is that they repeat writing of each character 1000 times, but I believe this is not the best use of time, given the number of characters.

The way my program works is that for each input character, user is taught each stroke four times - 1) alone, 2) with all strokes introduced so far, 3) in context and 4) in context but with no aid -- like in this example:

example output of my program

In this example, user is exposed to first four digits in Chinese and should fill in the highlighted strokes, as well as ones already introduced. In each fourth tile, user is expected to fill in all already introduced strokes with no aid, forcing them to focus on geometry.

As you can see, tiles are split into groups that have thicker borders. After introducing the first two characters, there is a special group of tiles at the end of second and beginning of third line: it is blank and contains a pronunciation hint. The user is expected to try to recall the character and write it in its entirety in those tiles.

Question

This is the part I have a question about: the goal of those specific tiles is to try to get the user to try to recall the characters hoping they eventually land in long-term memory, which should already not be in the working memory because it usually takes more than five minutes to write two characters. Then user is expected to practice next two characters and the drill repeats. Then, user is expected to recall all four characters introduced so far, as shown in the graphic above. This pattern repeats and for characters ABCDEFGH would look like following - hopefully you can deduce how it works:

A
B
AB
C
D
CD
ABCD
E
F
EF
G
H
EFGH
ABCDEFGH

I showed it to a person interested in psychology and she immediately said: "this reminds me of spaced repetition"! I read about this and also found SuperMemo, and a program that implements it: Anki flashcards.

The problem is that both those programs are based on a formula that prognosticates if the user has already memorized a certain item; with that, they assign relative importance to review this item.

Is there another statistical model of human memory I could use for my application that doesn't have this requirement, but - for example - assumes an "average person" and a certain expected probability that this character will be at a given time remembered?

$\endgroup$
  • $\begingroup$ The current program described sounds good enough. Spaced repetition is based on feedback. If users are printing these worksheets, feedback with an algorithm can't happen. To see for yourself, try Anki: ankiweb.net/shared/decks/chinese (It's free for Android and desktop.) Cards that the user gets wrong are repeated in the same session (same day). Additionally, writing characters alone does not need to be memorized. It would be better to provide short quizzes involving sentences from the corpus. No man is an island; no character...should be isolated from real-world practice. $\endgroup$ – Adam Uraynar Aug 22 '18 at 19:44
1
+50
$\begingroup$

Spaced repetition is based off the forgetting curve. Each review per day strengthens the memory:

enter image description here

Both Anki flashcards and SuperMemo also utilize the Leitner (box) system:

Leitner system animation.gif
(Animation by Zirguezi - CC0.)

Other freeware, such as Cram or Quizlet, do not have these enhanced features. They're more for the quick and dirty academic game. The material is only meant to linger for a semester or two. Then it essentially becomes lost in the abyss.

Yet, that's not quite the same breakdown for learning how to write Chinese characters correctly. Using the metaphor that the brain is a muscle: It flexes more when writing. See Writing Strengthens Orthography and Alphabetic-Coding Strengthens Phonology in Learning to Read Chinese. Writing is more active than reading. The more senses engaged the better. SuperMemo and Anki have algorithms based primarily from seeing the information. (Granted, Anki does have the feature where you can write directly on the application.)

At the end of the day there still is a hierarchy based on the user's "history" with the each item. (Also, easier material or material with less chunks will strengthen, therefore lengthen the time until subsequent review.) Memory has a natural atrophy. There is no avoiding this (aside from abnormal exceptions). Think of normal brains as having a half-life, a natural rate of decay.

To answer you directly: There are only a few ways: brute repetition, spaced repetition, chunking and the Leitner system. Your app involves repetition with chunking. You could improve from there with different combinations of the current design with spaced repetition and the Leitner system. EDIT: You can approximate a rough spaced-repetition interval, but this will depend on if the user actually completes the worksheet in one sitting and how serious they keep up a consistent practice.

Furthermore, different users will have different obligations and habit forming tendencies. Having added functions, will improve user's experience. For example, a tag feature in Anki allows users to study only cards with the same tag. This is useful for, say, having an exam come up involving a large deck. I recommend sifting though Anki's user manual for more ideas.


Bonus

I actually was developing my own Android app based on using spaced repetition to remember larger bodies of information (opposed to simple flashcards). The spacing effect for memory is roughly triple the time (immediately again, 3 min, 9 min, 30 min, 90 min, etc). Needless to say, I put that project on the backburner. However, there is a similar app for memorizing music pieces. (I am not involved, no kickbacks.)

$\endgroup$
  • $\begingroup$ Thanks - a lot of useful information here! I'm just a bit confused about how could I apply Leitner system in an offline environment - basically on an exercise set printed on paper. Any ideas here? $\endgroup$ – d33tah Aug 22 '18 at 16:37
  • $\begingroup$ The animation displays the Leitner system, offline. If the user gets it correct, then it moves to the next box. en.wikipedia.org/wiki/Leitner_system $\endgroup$ – Adam Uraynar Aug 22 '18 at 17:47
  • $\begingroup$ It's offline but interactive - I can't apply it to the program that generates a printable sheet unless I split it by character (or characters) and the user handles the box manually. What I'm looking for is an an approximate prediction on how the boxes would behave upfront, for an average user. $\endgroup$ – d33tah Aug 22 '18 at 19:23
  • 2
    $\begingroup$ It can't be done upfront. It's based on feedback. Foresight has no place. I've never heard of non-causal learning software (en.wikipedia.org/wiki/Causal_system). It would be better to just scrap the Leitner system idea. $\endgroup$ – Adam Uraynar Aug 22 '18 at 19:37
2
$\begingroup$

So basically [for me] this question is whether there exists a learning model informed by the structure and usage of the Chinese writing.

The answer is yes, see for example Loach & Wang (2016):

The question we address is the optimum order in which Chinese characters should be learned.

There are two orders that make intuitive sense: in order of usage frequency, from high to low, and in order of network hierarchy, starting with primitives and building up compound characters using components that have already been learned. The first of these follows directly from the goal of the learner but the second merits further discussion. In general terms, the desirability of learning characters in hierarchal order follows from a broad principle of human cognition, that mastery of a complex system rests on mastery of the relevant features of its sub-components [14, 15]. This applies to Chinese characters if one assumes that it is productive to treat them as a complex system rather than as a set of unrelated symbols to be learned by rote. A number of experimental studies indicate that this assumption is valid. They show that orthographic awareness is of critical importance to skilled native readers and in learning to read by both Chinese children and second language learners [16–22]. These also show that orthographic awareness is present whether or not it is taught explicitly and, among learners, that the extent of the awareness is correlated with performance [23]. We consider learning characters in order of hierarchy to be desirable because we infer that a learning order that explicitly reflects orthographic principles is more likely to generate accurate and productive orthographic awareness in students.

There is, however, necessarily a tension between learning by usage frequency and learning by hierarchy, because frequency is only weakly correlated with character complexity. [...] Learning characters in order of frequency would therefore often mean learning characters before their components had been learned, whereas learning them in order of hierarchy would often mean learning rarer characters in advance of more common ones.

When devising a learning order one can choose either of the extremes, of frequency or hierarchy, or attempt to find a balance between them in which some common characters are learned in advance of their components. One previous approach that searched for such a balance was a network theory-based approach by Yan et al. [24]. They demonstrated that an algorithmically-optimized, balanced order can be substantially more efficient than one that follows frequency. [...]

The tension between frequency and hierarchy is a dominant consideration in determining the learning order but it is not the only one. Small-scale character-to-character patterns are also known to be important, especially for encouraging orthographic awareness [25–27]. Patterns can be chosen to emphasize the logic of character construction, by introducing components directly before their compounds, or to emphasize the functional role of components, by presenting their compounds in sets. These patterns are often found in human-curated orders, and especially in books on learning Chinese characters (for example, those of Heisig and Richardson [28, 29]). They embody sound educational principles, which can be understood in terms of Marton’s variation theory [30–33]. [...]

Our algorithm is built on the fundamental assumption that hierarchal orders are the pedagogically desirable way to accumulate usage frequency and we search among this subset of orders for the one that is most efficient. The algorithm is implemented using the conceptual framework of network theory, within which we conceive the network of Chinese characters as a directed analytic graph [34]. The nodes in the graph represent characters and the edges represent the structural relationships between them. We devise a measure of node centrality that relates each character’s usage frequency to the effort required to learn it, and order the characters by this measure to provide a first approximation to the optimal learning order. We then sort this list into topological (hierarchal) order using an algorithm designed to minimally disturb the starting order. The algorithm can be applied to any scheduling task where nodes have intrinsic differences in importance and must be visited in topological order.

Looking at the quantitative evaluation section of this paper though, the prior work of Yan et. al seems "good enough" though, and it might less work to implement. I don't know if either of that is suitable for your application or not, as it might require you to redesign it from the ground up. (Also, beware that I can't write in Chinese myself.)

$\endgroup$
  • $\begingroup$ Thanks! That's at least a part of the answer. I think that the question still stands though - given a list of characters and no way to change the order, how should I decide the ordering of the repetitions, as in my example described in the question? $\endgroup$ – d33tah Aug 21 '18 at 16:29
  • $\begingroup$ You should not change the sequence of writing the character. It's the same with playing an instrument. You should not change figuring, halfway though, when learning a piano piece. $\endgroup$ – Adam Uraynar Aug 22 '18 at 17:48
  • $\begingroup$ @d33tah: I'm not sure I understand your premises. Are you trying to write a completely stateless app? Is that why you can't/won't record what the user managed or didn't manage to remember? $\endgroup$ – Fizz Aug 23 '18 at 0:19
  • 2
    $\begingroup$ @Fizz: in a way. It's stateless because it creates a worksheet that you're supposed to print it out. I came up with one compatible learning scheme, but feel it could be made more efficient. $\endgroup$ – d33tah Aug 23 '18 at 6:37

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.