Abstractor -> Encoder

Author: krukah

src/clustering/abstractor.rs src/clustering/encoding.rs

@@ -20,15 +20,15 @@ use std::collections::BTreeMap;
 /// full game tree, learned by kmeans
 /// rooted in showdown equity at the River.
 #[derive(Default)]
-pub struct Abstractor(BTreeMap<Isomorphism, Abstraction>);
+pub struct Encoder(BTreeMap<Isomorphism, Abstraction>);
 
 /* learning methods
  *
  * during clustering, we're constantly inserting and updating
  * the abstraction mapping. needs to help project layers
  * hierarchically, while also
  */
-impl Abstractor {
+impl Encoder {
     /// only run this once.
     pub fn learn() {
         if Self::done() {
@@ -39,6 +39,8 @@ impl Abstractor {
                 .inner() // cluster turn
                 .save()
                 .inner() // cluster flop
+                .save()
+                .inner() // cluster preflop
                 .save();
         }
     }
@@ -89,7 +91,7 @@ impl Abstractor {
  * by sampling according to a given Profile. here we provide
  * methods for unraveling the Tree
  */
-impl Abstractor {
+impl Encoder {
     /// abstraction methods
     pub fn chance_abstraction(&self, game: &Game) -> Abstraction {
         self.abstraction(&Isomorphism::from(Observation::from(game)))
@@ -145,7 +147,7 @@ use std::io::Write;
  * straightforward to compute on the fly, for different reasons
  */
 
-impl From<Street> for Abstractor {
+impl From<Street> for Encoder {
     fn from(street: Street) -> Self {
         let file = File::open(format!("{}.abstraction.pgcopy", street)).expect("open file");
         let mut buffer = [0u8; 2];
@@ -170,7 +172,7 @@ impl From<Street> for Abstractor {
     }
 }
 
-impl Abstractor {
+impl Encoder {
     /// indicates whether the abstraction table is already on disk
     pub fn done() -> bool {
         [
@@ -230,15 +232,15 @@ mod tests {
     fn persistence() {
         let street = Street::Rive;
         let file = format!("{}.abstraction.pgcopy", street);
-        let save = Abstractor(
+        let save = Encoder(
             (0..100)
                 .map(|_| Observation::from(street))
                 .map(|o| Isomorphism::from(o))
                 .map(|o| (o, Abstraction::random()))
                 .collect(),
         );
         save.save(street);
-        let load = Abstractor::from(street);
+        let load = Encoder::from(street);
         std::iter::empty()
             .chain(save.0.iter().zip(load.0.iter()))
             .chain(load.0.iter().zip(save.0.iter()))

src/clustering/layer.rs

@@ -1,7 +1,7 @@
 use super::abstraction::Abstraction;
-use super::abstractor::Abstractor;
 use super::datasets::AbstractionSpace;
 use super::datasets::ObservationSpace;
+use super::encoding::Encoder;
 use super::histogram::Histogram;
 use super::metric::Metric;
 use super::xor::Pair;
@@ -40,7 +40,7 @@ use std::collections::BTreeMap;
 pub struct Layer {
     street: Street,
     metric: Metric,
-    lookup: Abstractor,
+    lookup: Encoder,
     kmeans: AbstractionSpace,
     points: ObservationSpace,
 }
@@ -56,8 +56,8 @@ impl Layer {
     const fn k(street: Street) -> usize {
         match street {
             Street::Pref => 169,
-            Street::Flop => 8,
-            Street::Turn => 8,
+            Street::Flop => 32,
+            Street::Turn => 32,
             Street::Rive => unreachable!(),
         }
     }
@@ -69,8 +69,8 @@ impl Layer {
     const fn t(street: Street) -> usize {
         match street {
             Street::Pref => 0,
-            Street::Flop => 16,
-            Street::Turn => 16,
+            Street::Flop => 32,
+            Street::Turn => 32,
             Street::Rive => unreachable!(),
         }
     }
@@ -85,7 +85,7 @@ impl Layer {
         Self {
             street: Street::Rive,
             metric: Metric::default(),
-            lookup: Abstractor::default(),
+            lookup: Encoder::default(),
             kmeans: AbstractionSpace::default(),
             points: ObservationSpace::default(),
         }
@@ -97,7 +97,7 @@ impl Layer {
     /// 3. cluster kmeans centroids
     pub fn inner(&self) -> Self {
         let mut layer = Self {
-            lookup: Abstractor::default(),       // assigned during clustering
+            lookup: Encoder::default(),          // assigned during clustering
             kmeans: AbstractionSpace::default(), // assigned during clustering
             street: self.inner_street(),         // uniquely determined by outer layer
             metric: self.inner_metric(),         // uniquely determined by outer layer
@@ -143,7 +143,7 @@ impl Layer {
                     let x = self.kmeans.0.get(a).expect("pre-computed").histogram();
                     let y = self.kmeans.0.get(b).expect("pre-computed").histogram();
                     let distance = self.metric.emd(x, y) + self.metric.emd(y, x);
-                    let distance = distance / 2.0;
+                    let distance = distance / 2.;
                     metric.insert(index, distance);
                 }
             }

src/clustering/mod.rs

@@ -1,7 +1,7 @@
 pub mod abstraction;
-pub mod abstractor;
 pub mod centroid;
 pub mod datasets;
+pub mod encoding;
 pub mod equity;
 pub mod histogram;
 pub mod layer;

src/kmeans/mod.rs

@@ -1,11 +1,44 @@
-pub trait KMeans<P> {
-    fn k(&self) -> usize;
-    fn dataset(&self) -> &[P; N];
-    fn cluster(&self) -> &[P; K];
+pub trait Point: Clone {}
+
+pub trait KMeans<P>
+where
+    P: Point,
+{
+    fn loss(&self) -> f32;
     fn measure(&self, a: &P, b: &P) -> f32;
-    fn average(&self, cluster: &[P]) -> P;
-    fn assignments(&self) -> &[usize; N]; // to what cluster is each point assigned
-    fn frequencies(&self) -> &[usize; K]; // how many points are in each cluster
+    fn average(&self, points: &[P]) -> P;
+    fn dataset(&self) -> &[P; N];
+    fn centers(&self) -> &[P; K];
+    fn distances(&mut self) -> &mut [f32; N];
+    fn neighbors(&mut self) -> &mut [usize; N]; // to what cluster is each point assigned
+    fn densities(&mut self) -> &mut [usize; K]; // how many points are in each cluster
+}
+
+impl<P> Iterator for dyn KMeans<P>
+where
+    P: Point,
+{
+    type Item = f32;
+    fn next(&mut self) -> Option<Self::Item> {
+        // do the inner of Layer::cluster_kmeans() loop
+        // calculate neighbors &self.neighbors()
+        // calculate densities &self.densities()
+        // check against stopping rule(s)
+        Some(self.loss())
+    }
+}
+
+pub enum Initialization {
+    Random,              // chooses random points from dataset
+    Spaced,              // chooses evenly spaced points from dataset
+    FullPlusPlus,        // weights every point inverse distance to the nearest centroid
+    MiniPlusPlus(usize), // weights batch point inverse distance to the nearest centroid
+}
+
+pub enum Termination {
+    Iterations(usize),
+    Convergent(usize, f32),
 }
+
 const N: usize = 1000;
 const K: usize = 10;

src/lib.rs

@@ -1,5 +1,6 @@
 pub mod cards;
 pub mod clustering;
+pub mod kmeans;
 pub mod mccfr;
 pub mod play;
 pub mod players;

src/main.rs

@@ -4,7 +4,7 @@ fn main() {
     // Boring stuff
     logging();
     // The k-means earth mover's distance hand-clustering algorithm.
-    clustering::abstractor::Abstractor::learn();
+    clustering::encoding::Encoder::learn();
     // Monet Carlo counter-factual regret minimization. External sampling, alternating regret updates, linear weighting schedules.
     mccfr::trainer::Blueprint::load().train();
     // After 100s of CPU-days of training in the arena, the CPU is ready to see you.

src/mccfr/trainer.rs

@@ -6,7 +6,7 @@ use super::node::Node;
 use super::player::Player;
 use super::profile::Profile;
 use super::tree::Tree;
-use crate::clustering::abstractor::Abstractor;
+use crate::clustering::encoding::Encoder;
 use crate::play::game::Game;
 use crate::Probability;
 use crate::Utility;
@@ -25,14 +25,14 @@ struct Sample(Tree, Partition);
 
 pub struct Blueprint {
     profile: Profile,
-    encoder: Abstractor,
+    encoder: Encoder,
 }
 
 impl Blueprint {
     pub fn load() -> Self {
         Self {
             profile: Profile::load(),
-            encoder: Abstractor::load(),
+            encoder: Encoder::load(),
         }
     }
 
@@ -81,6 +81,7 @@ impl Blueprint {
         let root = tree.insert(root);
         let root = tree.at(root);
         assert!(0 == root.index().index());
+        self.profile.witness(root);
         if self.profile.walker() == root.player() {
             partition.witness(root);
         }
@@ -92,6 +93,7 @@ impl Blueprint {
             let from = tree.attach(from, tail, root);
             let root = tree.at(tail);
             assert!(1 == root.index().index() - from.index());
+            self.profile.witness(root);
             if self.profile.walker() == root.player() {
                 partition.witness(root);
             }