Main idea:
  • a predictor has an input vector (I = {i0, i1, ..., in})
  • a predictor learns patterns appearing on these inputs. A pattern can be:
    • I
    • a subset of I
    • a sequence of I's
    • a sequence of a subset of I
    • a shifted/broken up sequence of a subset of I
  • The patterns recognized are assigned a new symbol
  • a predictor has an output vector (O={o0, o1, ..., on})
  • if an input signal matches a learned pattern, the predictor outputs a new symbol representing the pattern
  • otherwise it outputs the original signal
  • the predictor also outputs a special signal to tell if it's an unrecognized or a recognized pattern on it's output vector
  • a predictor can receive a pattern which tells him what to expect on it's input (P={po, p1, ..., pn})
Some restrictions:
  • the new symbols assigned to the patterns detected must be transmitted to the output, so it's format and the output width is closely linked
  • the input must be copied to the output so we have another link
  • the prediction must be compared to the input and differences must be transmitted to the output so these also are linked
  • the width of the output vector is somehow linked also to the size of the dictionary of learned patterns, as each symbol representing a pattern must be outputtable to the output
  • Predictors are networked: one's output is directed to the input of several others.
  • The link between predictors changes dynamically: the input slots of a predictor might change (adding new inputs, removing existing ones)
  • Patterns learned:
    • one set of inputs
    • temporal sequence of inputs
    • temporal sequence of input fragments (sub-patterns: e.g. 101xxx001)
  • Signal symbol sets can be:
    • bit {0,1}
    • int {0, 1, ..., n}
    • range [0..1]
    • big range (a..b)


Post a Comment

Links to this post:

Create a Link

<< Home