cortex: thesis/cortex.org comparison

comparison thesis/cortex.org @ 452:f339e3d5cc8c

finish draft of chapter 3.

author	Robert McIntyre <rlm@mit.edu>
date	Wed, 26 Mar 2014 22:17:42 -0400
parents	0a4362d1f138
children	6db37c4aa1ee

comparison

equal deleted inserted replaced

-:0a4362d1f138
+:f339e3d5cc8c
 #+caption: Body-centerd actions are best expressed in a body-centered
 #+caption: language. This code detects when the worm has curled into a
 #+caption: full circle. Imagine how you would replicate this functionality
 #+caption: using low-level pixel features such as HOG filters!
 #+name: grand-circle-intro
-#+begin_listing clojure
+#+attr_latex: [htpb]
+#+begin_listing clojure
 #+begin_src clojure
 (defn grand-circle?
 "Does the worm form a majestic circle (one end touching the other)?"
 [experiences]
 (and (curled? experiences)
 :touch (touch! model)
 :proprioception (proprioception! model)
 :muscles (movement! model)}))
 #+end_src
 #+end_listing
 ** Embodiment factors action recognition into managable parts
 Using empathy, I divide the problem of action recognition into a
 recognition process expressed in the language of a full compliment
 of senses, and an imaganitive process that generates full sensory
 #+caption: of sensory experience, and only uses proprioceptive data. Even
 #+caption: this simple predicate, however, is automatically frame
 #+caption: independent and ignores vermopomorphic differences such as
 #+caption: worm textures and colors.
 #+name: curled
-#+begin_listing clojure
+#+attr_latex: [htpb]
+#+begin_listing clojure
 #+begin_src clojure
 (defn curled?
 "Is the worm curled up?"
 [experiences]
 (every?
 #+end_listing
 #+caption: Program for summarizing the touch information in a patch
 #+caption: of skin.
 #+name: touch-summary
-#+begin_listing clojure
+#+attr_latex: [htpb]
+#+begin_listing clojure
 #+begin_src clojure
 (defn contact
 "Determine how much contact a particular worm segment has with
 other objects. Returns a value between 0 and 1, where 1 is full
 contact and 0 is no contact."
 #+caption: uses a summary of the tactile information from the underbelly
 #+caption: of the worm, and is only true if every segment is touching the
 #+caption: floor. Note that this function contains no references to
 #+caption: proprioction at all.
 #+name: resting
-#+begin_listing clojure
+#+attr_latex: [htpb]
+#+begin_listing clojure
 #+begin_src clojure
 (def worm-segment-bottom (rect-region [8 15] [14 22]))
 (defn resting?
 "Is the worm resting on the ground?"
 #+caption: Program for detecting whether the worm is curled up into a
 #+caption: full circle. Here the embodied approach begins to shine, as
 #+caption: I am able to both use a previous action predicate (=curled?=)
 #+caption: as well as the direct tactile experience of the head and tail.
 #+name: grand-circle
-#+begin_listing clojure
+#+attr_latex: [htpb]
+#+begin_listing clojure
 #+begin_src clojure
 (def worm-segment-bottom-tip (rect-region [15 15] [22 22]))
 (def worm-segment-top-tip (rect-region [0 15] [7 22]))
 #+caption: wiggling this way also gives the worm an opportunity to learn
 #+caption: and recognize ``frustrated wiggling'', where the worm tries to
 #+caption: wiggle but can't. Frustrated wiggling is very visually different
 #+caption: from actual wiggling, but this definition gives it to us for free.
 #+name: wiggling
-#+begin_listing clojure
+#+attr_latex: [htpb]
+#+begin_listing clojure
 #+begin_src clojure
 (defn fft [nums]
 (map
 #(.getReal %)
 (.transform
 all the worm's senses.
 #+caption: Use the action predicates defined earlier to report on
 #+caption: what the worm is doing while in simulation.
 #+name: report-worm-activity
-#+begin_listing clojure
+#+attr_latex: [htpb]
+#+begin_listing clojure
 #+begin_src clojure
 (defn debug-experience
 [experiences text]
 (cond
 (grand-circle? experiences) (.setText text "Grand Circle")
 mistake.
 #+caption: Program to convert an experience vector into a
 #+caption: proprioceptively binned lookup function.
 #+name: bin
-#+begin_listing clojure
+#+attr_latex: [htpb]
+#+begin_listing clojure
 #+begin_src clojure
 (defn bin [digits]
 (fn [angles]
 (->> angles
 (flatten)
 #+caption: Program to calculate empathy by tracing though \Phi-space
 #+caption: and finding the longest (ie. most coherent) interpretation
 #+caption: of the data.
 #+name: longest-thread
-#+begin_listing clojure
+#+attr_latex: [htpb]
+#+begin_listing clojure
 #+begin_src clojure
 (defn longest-thread
 "Find the longest thread from phi-index-sets. The index sets should
 be ordered from most recent to least recent."
 [phi-index-sets]
 fill in the gaps.
 #+caption: Fill in blanks in sensory experience by replicating the most
 #+caption: recent experience.
 #+name: infer-nils
-#+begin_listing clojure
+#+attr_latex: [htpb]
+#+begin_listing clojure
 #+begin_src clojure
 (defn infer-nils
 "Replace nils with the next available non-nil element in the
 sequence, or barring that, 0."
 [s]
 ** Efficient action recognition with =EMPATH=
 To use =EMPATH= with the worm, I first need to gather a set of
 experiences from the worm that includes the actions I want to
-recognize. The =generate-phi-space= program (listint
+recognize. The =generate-phi-space= program (listing
 \ref{generate-phi-space} runs the worm through a series of
 exercices and gatheres those experiences into a vector. The
 =do-all-the-things= program is a routine expressed in a simple
-muscle contraction script language for automated worm control.
+muscle contraction script language for automated worm control. It
+causes the worm to rest, curl, and wiggle over about 700 frames
+(approx. 11 seconds).
 #+caption: Program to gather the worm's experiences into a vector for
 #+caption: further processing. The =motor-control-program= line uses
 #+caption: a motor control script that causes the worm to execute a series
 #+caption: of ``exercices'' that include all the action predicates.
 #+name: generate-phi-space
-#+attr_latex: [!H]
+#+attr_latex: [htpb]
 #+begin_listing clojure
 #+begin_src clojure
 (def do-all-the-things
 (concat
 curl-script
 [[300 :d-ex 40]
 #+end_listing
 #+caption: Use longest thread and a phi-space generated from a short
 #+caption: exercise routine to interpret actions during free play.
 #+name: empathy-debug
-#+begin_listing clojure
+#+attr_latex: [htpb]
+#+begin_listing clojure
 #+begin_src clojure
 (defn init []
 (def phi-space (generate-phi-space))
 (def phi-scan (gen-phi-scan phi-space)))
 action predicates as the real sensory experience.
 #+caption: Determine how closely empathy approximates actual
 #+caption: sensory data.
 #+name: test-empathy-accuracy
-#+begin_listing clojure
+#+attr_latex: [htpb]
+#+begin_listing clojure
 #+begin_src clojure
 (def worm-action-label
 (juxt grand-circle? curled? wiggling?))
 (defn compare-empathy-with-baseline [matches]
 73%. This is based on very limited worm experience. By training the
 worm for longer, the accuracy dramatically improves.
 #+caption: Program to generate \Phi-space using manual training.
 #+name: manual-phi-space
+#+attr_latex: [htpb]
 #+begin_listing clojure
 #+begin_src clojure
 (defn init-interactive []
 (def phi-space
 (let [experiences (atom [])]
 #+end_src
 #+end_listing
 After about 1 minute of manual training, I was able to achieve 95%
 accuracy on manual testing of the worm using =init-interactive= and
-=test-empathy-accuracy=. The ability of the system to infer sensory
+=test-empathy-accuracy=. The majority of errors are near the
-states is truly impressive.
+boundaries of transitioning from one type of action to another.
+During these transitions the exact label for the action is more open
+to interpretation, and dissaggrement between empathy and experience
+is more excusable.
 ** Digression: bootstrapping touch using free exploration
+In the previous section I showed how to compute actions in terms of
+body-centered predicates which relied averate touch activation of
+pre-defined regions of the worm's skin. What if, instead of recieving
+touch pre-grouped into the six faces of each worm segment, the true
+topology of the worm's skin was unknown? This is more similiar to how
+a nerve fiber bundle might be arranged. While two fibers that are
+close in a nerve bundle /might/ correspond to two touch sensors that
+are close together on the skin, the process of taking a complicated
+surface and forcing it into essentially a circle requires some cuts
+and rerragenments.
+In this section I show how to automatically learn the skin-topology of
+a worm segment by free exploration. As the worm rolls around on the
+floor, large sections of its surface get activated. If the worm has
+stopped moving, then whatever region of skin that is touching the
+floor is probably an important region, and should be recorded.
+#+caption: Program to detect whether the worm is in a resting state
+#+caption: with one face touching the floor.
+#+name: pure-touch
+#+begin_listing clojure
+#+begin_src clojure
+(def full-contact [(float 0.0) (float 0.1)])
+(defn pure-touch?
+"This is worm specific code to determine if a large region of touch
+sensors is either all on or all off."
+[[coords touch :as touch-data]]
+(= (set (map first touch)) (set full-contact)))
+#+end_src
+#+end_listing
+After collecting these important regions, there will many nearly
+similiar touch regions. While for some purposes the subtle
+differences between these regions will be important, for my
+purposes I colapse them into mostly non-overlapping sets using
+=remove-similiar= in listing \ref{remove-similiar}
+#+caption: Program to take a lits of set of points and ``collapse them''
+#+caption: so that the remaining sets in the list are siginificantly
+#+caption: different from each other. Prefer smaller sets to larger ones.
+#+name: remove-similiar
+#+begin_listing clojure
+#+begin_src clojure
+(defn remove-similar
+[coll]
+(loop [result () coll (sort-by (comp - count) coll)]
+(if (empty? coll) result
+(let  [[x & xs] coll
+c (count x)]
+(if (some
+(fn [other-set]
+(let [oc (count other-set)]
+(< (- (count (union other-set x)) c) (* oc 0.1))))
+xs)
+(recur result xs)
+(recur (cons x result) xs))))))
+#+end_src
+#+end_listing
+Actually running this simulation is easy given =CORTEX='s facilities.
+#+caption: Collect experiences while the worm moves around. Filter the touch
+#+caption: sensations by stable ones, collapse similiar ones together,
+#+caption: and report the regions learned.
+#+name: learn-touch
+#+begin_listing clojure
+#+begin_src clojure
+(defn learn-touch-regions []
+(let [experiences (atom [])
+world (apply-map
+worm-world
+(assoc (worm-segment-defaults)
+:experiences experiences))]
+(run-world world)
+(->>
+@experiences
+(drop 175)
+;; access the single segment's touch data
+(map (comp first :touch))
+;; only deal with "pure" touch data to determine surfaces
+(filter pure-touch?)
+;; associate coordinates with touch values
+(map (partial apply zipmap))
+;; select those regions where contact is being made
+(map (partial group-by second))
+(map #(get % full-contact))
+(map (partial map first))
+;; remove redundant/subset regions
+(map set)
+remove-similar)))
+(defn learn-and-view-touch-regions []
+(map view-touch-region
+(learn-touch-regions)))
+#+end_src
+#+end_listing
+The only thing remining to define is the particular motion the worm
+must take. I accomplish this with a simple motor control program.
+#+caption: Motor control program for making the worm roll on the ground.
+#+caption: This could also be replaced with random motion.
+#+name: worm-roll
+#+begin_listing clojure
+#+begin_src clojure
+(defn touch-kinesthetics []
+[[170 :lift-1 40]
+[190 :lift-1 19]
+[206 :lift-1  0]
+[400 :lift-2 40]
+[410 :lift-2  0]
+[570 :lift-2 40]
+[590 :lift-2 21]
+[606 :lift-2  0]
+[800 :lift-1 30]
+[809 :lift-1 0]
+[900 :roll-2 40]
+[905 :roll-2 20]
+[910 :roll-2  0]
+[1000 :roll-2 40]
+[1005 :roll-2 20]
+[1010 :roll-2  0]
+[1100 :roll-2 40]
+[1105 :roll-2 20]
+[1110 :roll-2  0]
+])
+#+end_src
+#+end_listing
+#+caption: The small worm rolls around on the floor, driven
+#+caption: by the motor control program in listing \ref{worm-roll}.
+#+name: worm-roll
+#+ATTR_LaTeX: :width 12cm
+[[./images/worm-roll.png]]
+#+caption: After completing its adventures, the worm now knows
+#+caption: how its touch sensors are arranged along its skin. These
+#+caption: are the regions that were deemed important by
+#+caption: =learn-touch-regions=. Note that the worm has discovered
+#+caption: that it has six sides.
+#+name: worm-touch-map
+#+ATTR_LaTeX: :width 12cm
+[[./images/touch-learn.png]]
+While simple, =learn-touch-regions= exploits regularities in both
+the worm's physiology and the worm's environment to correctly
+deduce that the worm has six sides. Note that =learn-touch-regions=
+would work just as well even if the worm's touch sense data were
+completely scrambled. The cross shape is just for convienence. This
+example justifies the use of pre-defined touch regions in =EMPATH=.
 * Contributions

Mercurial > cortex

comparison thesis/cortex.org @ 452:f339e3d5cc8c