Matrix Factorization Algorithms

.github/workflows/update-deps-lock.yaml

@@ -6,6 +6,7 @@ on:
 
 jobs:
   update-lock:
+    if: startsWith(github.ref, 'refs/heads/')
     runs-on: ubuntu-latest
 
     steps:

README.md

@@ -39,6 +39,7 @@ much more.
    3. [triadic-exploration](doc/Triadic-Exploration.org)
    4. [protoconcepts](doc/Protoconcepts.org)
    5. [Incomplete Contexts](doc/IncompleteContexts.org)
+   6. [Factorization of Formal Contexts](doc/MatrixFactorization.org)
 6. [API documentation](doc/API.md)
 7. [Development](doc/Development.org)
 

doc/MatrixFactorization.org

@@ -0,0 +1,91 @@
+#+property: header-args :wrap src text
+#+property: header-args:text :eval never
+
+* Boolean Matrix Factorization
+
+The goal of Boolean matrix factorization is to decompose a binary matrix, in this case a formal context into two smaller contexts, in such a way that the Boolean matrix product of these contexts is equal or at least similar to the original context. 
+The first context represents the relationship of the objects to so called *factors*, and the second represents the relationship of these factors to the attributes. The number of factors should be as low as possible. 
+Since this is an NP-hard problem, a variety of approximative algorithms have been proposed. Those algorithms offer different tradeoffs between accuracy and the number of factors.
+
+
+~conexp-clj~ offers the following algorithms for Boolean matrix factoriation:
+
+The algorithms are available via the ~matrix-factorizations~ namespace:
+
+#+begin_src clojure
+(use 'conexp.fca.matrix-factorizations)
+(def water-ctx (read-context "testing-data/Living-Beings-and-Water.ctx"))
+#+end_src
+
+The following algorithms are available:
+
+The ~hyper~-algorithm computes an errorless decomposition but is not optimal with respect to the amount of factors. In addition to the context, it takes one additional argument. The argument is the minimum support for all candidates considered by the algorithm. 
+Decreasing this value may yield a decomposition with fewer values, but increases the running time. 
+A detailed description of the algorithm can found here: 
+https://doi.org/10.1007/s10618-010-0203-9
+
+#+begin_src clojure
+(hyper water-ctx 0.7)
+#+end_src
+
+The ~topFiberM~-algorithm takes as argument the context to be decomposed, the maximum number of factors, the precision threshold and the search limit. The search limit is the maximum number of iterations of the algorithm. 
+If it exceeds the specified number of factors, already selected factors may be replaced by better ones. A detailed explanation can be found here:
+https://doi.org/10.48550/arXiv.1903.10326
+
+#+begin_src clojure
+(topFiberM water-ctx 3 0.7 5)
+#+end_src
+
+The ~PaNDa~-algorithm computes a Boolean matrix factorization based on the specified Context and the number of factors:
+https://doi.org/10.1137/1.9781611972801.15
+
+#+begin_src clojure
+(PaNDa water-ctx 5)
+#+end_src
+
+The ~tiling~-algorithm is loosely based on the following paper: 
+https://doi.org/10.1007/978-3-540-30214-8_22
+
+It also computes a factorization based on the context, and the number of factors:
+
+#+begin_src clojure
+tiling water-ctx 5)
+#+end_src
+
+~grecond~ computes a Boolean matrix factorization, that is optimal with respect to coverage:
+https://doi.org/10.1016/j.jcss.2009.05.002
+
+#+begin_src clojure
+(grecond water-ctx)
+#+end_src
+
+The ~GreEss~-algorithm computes a factorization that is accurate in terms of coverage with a specified permitted error. The algorithm only commits undercoverage errors. A detailed description can be found here:
+https://doi.org/10.1016/j.jcss.2015.06.002
+
+#+begin_src clojure
+(GreEss water-ctx 3)
+#+end_src
+
+The ~ASSO~-algorithm requires the following arguments:
+- the context to be decomposed 
+- the number of factor 
+- a threshold value that controls the precition of the result
+- a weight that controls how much correctly covered entries are rewarded
+- a weight that controls how much fals positives are penalized
+
+A detailed description of the algorithm can be found here:
+https://doi.org/10.1109/TKDE.2008.53
+
+#+begin_src clojure
+(ASSO water-ctx 5 0.7 1 1)
+#+end_src
+
+
+All of the above algorithms contain a factorization object, that contains the two contexts resulting from the decompositions. Calling ~context~ on this object returns the Boolean matric product of those two contexts:
+
+#+begin_src clojure
+(def factorization (hyper water-ctx 0.7))
+(context factorization 
+#+end_src
+
+

src/main/clojure/conexp/analysis.clj

@@ -24,7 +24,8 @@
     [protoconcepts :refer :all]
     [random-contexts :refer :all]
     [simplicial-complexes :refer :all]
-    [triadic-exploration :refer :all]]
+    [triadic-exploration :refer :all]
+    [matrix-factorizations :refer :all]]
    [conexp.math
     [algebra :refer :all]
     [markov :refer :all]

src/main/clojure/conexp/base.clj

@@ -913,4 +913,9 @@ metadata (as provided by def) merged into the metadata of the original."
         reducer-fn (fn [c d] (union (make-set c) (make-set d)))]
     (fn [A] (reduce reducer-fn #{} (map m A)))))
 ;;;
+
+(defn argmax [function coll]
+  "Returns the value in *coll* for which (function coll) returns the highest value."
+  (apply max-key function coll)
+)
 nil

src/main/clojure/conexp/fca/contexts.clj

@@ -276,6 +276,16 @@
   (let [objs (aprime ctx #{m})]
     [objs (oprime ctx objs)]))
 
+(defn object-concepts [ctx]
+  "Returns a set of all object-concepts of the specified context."
+  (set (for [obj (objects ctx)] (object-concept ctx obj)))
+)
+
+(defn attribute-concepts [ctx]
+   "Returns a set of all attribute-concepts of the specified context."
+  (set (for [attr (attributes ctx)] (attribute-concept ctx attr)))
+)
+
 (defn clarify-objects
   "Clarifies objects in context ctx."
   [ctx]
@@ -765,6 +775,17 @@
                         (I_2 [g_2,m_2])))]
     (make-context-nc new-objs new-atts new-inz)))
 
+(defn context-boolean-matrix-product [ctx1 ctx2]
+  "Computes a context in the form of the boolean matrix product of both contexts.
+   The contexts need to have appropriate dimensions and the set of attributes of *ctx1*
+   must be equal to the set of objects of *ctx2*."
+  (make-context (objects ctx1)
+                (attributes ctx2)
+                (fn [g m] (not= (intersection (object-derivation ctx1 #{g})
+                                              (attribute-derivation ctx2 #{m}))
+                                #{})))
+)
+
 ;;; Neighbours in the concept lattice with Lindig's Algorithm
 
 (defn direct-upper-concepts

src/main/clojure/conexp/fca/implications.clj

@@ -628,7 +628,7 @@
     (/ (absolute-support ctx [(union premise conclusion) #{}])
        (absolute-support ctx [conclusion #{}]))))
 
-(defn- frequent-itemsets
+(defn frequent-itemsets
   "Returns all frequent itemsets of context, given minsupp as minimal support."
   ;; UNTESTED!
   [context minsupp]

src/main/clojure/conexp/fca/matrices.clj

@@ -0,0 +1,100 @@
+;; Copyright ⓒ the conexp-clj developers; all rights reserved.
+;; The use and distribution terms for this software are covered by the
+;; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+;; which can be found in the file LICENSE at the root of this distribution.
+;; By using this software in any fashion, you are agreeing to be bound by
+;; the terms of this license.
+;; You must not remove this notice, or any other, from this software.
+
+(ns conexp.fca.matrices
+  "Provides the implementation of formal contexts and functions on them."
+  (:require [conexp.base :refer :all]))
+
+
+(defn transpose [M]
+  "Returns a transposed matrix."
+  (into [] (apply map vector M))
+)
+
+(defn matrix-row [M index]
+  "Returns the indicated row of the matrix."
+    (M index)
+)
+
+(defn add-row [M row]
+  "Returs the matrix with the new row added."
+  (if (and (not= (count M) 0)
+           (not= (count row) (count (first M))))
+    (throw (Exception. "Row does not have the correct length. "))
+    (conj M row))
+)
+
+(defn set-row [M pos row]
+  "Replaces the row of *M* at index *pos* with *row*."
+  (assoc M pos row)
+)
+
+(defn row-number [M]
+  "Returns the number of rows of the matrix."
+  (count M)
+)
+
+(defn matrix-column [M index]
+  "Returns the indicated column of the matrix."
+  (into [] (for [row M] (row index)))
+)
+
+(defn add-column [M col]
+  "Returns the matrix with the new column added."
+  (if (= M []) (transpose [col])
+    (if (not= (count col) (count M))
+      (throw (Exception. "Column does not have the correct length."))
+      (transpose (add-row (transpose M) col))))
+)
+
+(defn set-column [M pos col]
+  "Replaces the column of *M* at index *pos* with *col*."
+  (map #(assoc %1 pos %2) M col)
+)
+
+(defn col-number [M]
+  "Returns the number of columns of the matrix."
+  (count (first M))
+)
+
+(defn scalar-product [V1 V2]
+  "Computes the scalar/dot product of two vectors"
+  (reduce + (map * V1 V2))
+)
+
+(defn boolean-matrix-product [M1 M2]
+  "Computes the product of two matrices with addition being interpreted as boolean OR."
+  (transpose (for [c (range (col-number M2))]
+    (for [r (range (row-number M1))]
+      (min (scalar-product (matrix-column M2 c)
+                           (matrix-row M1 r))
+           1))))
+)
+
+(defn matrix-boolean-difference [M1 M2]
+  "Computes a new matrix from two boolean matrices of the same dimension by subtracting
+   each of their entries pairwise, with 0 - 1 = 0"
+  (into [] (for [r (range (row-number M1))]
+    (into [] (for [c (range (col-number M1))]
+               (max (- ((M1 r) c) ((M2 r) c))
+               0)))))
+)
+
+(defn matrix-entrywise-product [M1 M2]
+  "Computes a new matrix from two matrices of the same dimension by multiplying
+   each of their entries pairwise."
+  (into [] (for [r (range (row-number M1))]
+    (into [] (for [c (range (col-number M1))]
+               (* ((M1 r) c) ((M2 r) c))))))
+)
+
+(defn outer-prod [v1 v2]
+  "Computes the outer product of two vectors."
+  (into [] (for [x v1]
+    (into [] (for [y v2] (* x y)))))
+)