mlange-42 / kohonen

A Self-organizing Maps (SOM) / Kohonen networks library and command line tool in Rust.

My projects and featured contributions:

Modelling	Developer tools
Arche — Go entity component system Finam — Python model coupling framework rs-ecs — Rust entity component system	git-graph — Clear Git graphs. See for yourself! git-igitt — Interactive TUI version of git-graph yarner — Literate Programming in Markdown

Command line apps	Games
track — Personal (work) time tracking dirstat — Analyze and visualize disk usage xwrd — Anagrams and word matching tool chrono-photo — Chrono-photography tool	Tiny World — Tiny, slow-paced world building game Cataclysm-DDA — Post-apocalyptic survival game Planetary Defense — Colonize and defend a planet Graviton — Puzzle with unique gravity mechanics

kohonen's Issues

[Feature] Bi-directional SOM implementation

In addition to Y-X-fused Super-SOMs (XYF), implement bi-direction SOMs (BDK).

• Check if the BDK algorithm can be used for more than 2 layers

[Feature] Add progress indicator / progress bar

[Feature] PLSOM implementation (The Parameterless Self-Organizing Map Algorithm)

Test an implementation of the algorithm described in:
Berglund & Sitte 2006: The Parameterless Self-Organizing Map Algorithm

Label propagation for semi-supervised learing

Implement label propagation

[Help] GodotNative: accessing Rust nodes from Rust nodes - Liftime problem

Trying to get a sibling node as Rust struct. Scene:

Node
 |- Kohonen
 '- Mapping

Trying to get the Rust Script attached to Kohonen, from Mapping:

use crate::Kohonen;
use gdnative::{Instance, Node2D, NodePath};

#[derive(gdnative::NativeClass)]
#[inherit(gdnative::Node2D)]
pub struct Mapping;

#[gdnative::methods]
impl Mapping {
    fn _init(_owner: gdnative::Node2D) -> Self {
        Mapping
    }

    #[export]
    fn _ready(&mut self, owner: gdnative::Node2D) {}

    #[export]
    pub fn _process(&mut self, owner: Node2D, _delta: f64) {}

    fn get_kohonen<'a>(&self, owner: &'a gdnative::Node2D) -> Option<&'a Kohonen> {
        let node = unsafe { owner.get_node(NodePath::from_str("../Kohonen")) };
        let koh: Option<&'a Kohonen> = node.and_then(|node| {
            Instance::<Kohonen>::try_from_base(node).map(|inst| inst.map(|koh, _| koh).unwrap())
        });
        koh
    }
}

Compiler errors:

error[E0495]: cannot infer an appropriate lifetime due to conflicting requirements
  --> kohvis\src\mapping_gd.rs:23:83
   |
23 |             Instance::<Kohonen>::try_from_base(node).map(|inst| inst.map(|koh, _| koh).unwrap())
   |                                                                                   ^^^
   |
note: first, the lifetime cannot outlive the anonymous lifetime #2 defined on the body at 23:74...
  --> kohvis\src\mapping_gd.rs:23:74
   |
23 |             Instance::<Kohonen>::try_from_base(node).map(|inst| inst.map(|koh, _| koh).unwrap())
   |                                                                          ^^^^^^^^^^^^
note: ...so that the expression is assignable
  --> kohvis\src\mapping_gd.rs:23:83
   |
23 |             Instance::<Kohonen>::try_from_base(node).map(|inst| inst.map(|koh, _| koh).unwrap())
   |                                                                                   ^^^
   = note: expected  `&kohonen_gd::Kohonen`
              found  `&kohonen_gd::Kohonen`
note: but, the lifetime must be valid for the lifetime `'a` as defined on the method body at 20:20...
  --> kohvis\src\mapping_gd.rs:20:20
   |
20 |     fn get_kohonen<'a>(&self, owner: &'a gdnative::Node2D) -> Option<&'a Kohonen> {
   |                    ^^
note: ...so that the expression is assignable
  --> kohvis\src\mapping_gd.rs:22:40
   |
22 |           let koh: Option<&'a Kohonen> = node.and_then(|node| {
   |  ________________________________________^
23 | |             Instance::<Kohonen>::try_from_base(node).map(|inst| inst.map(|koh, _| koh).unwrap())
24 | |         });
   | |__________^
   = note: expected  `std::option::Option<&'a kohonen_gd::Kohonen>`
              found  `std::option::Option<&kohonen_gd::Kohonen>`

error: aborting due to previous error

Scripting for filtering and transforming training data

Implement CLI options:

• --query: filter training data by some script expression
• --calc: calculate new columns in training data, e.g. log transform

Prediction: apply trained SOM to data.

SOM & units to file.

• De-normalized / classified units to CSV file (DONE in 8a41ce9)
• Raw SOM to file for re-reading and prediction/classification (DONE in 21da965 / version 0.2.0)
• Find nearest unit for training data, and write to file