added pre-metric-standardise fn

Author: behrica

deps.edn

@@ -2,7 +2,7 @@
  :deps {org.clojure/clojure                     {:mvn/version "1.12.4"}
         org.scicloj/metamorph.ml
         {:git/url "https://github.com/scicloj/metamorph.ml"
-         :git/sha "bbd4d390981fbb77d0f93d489f5ed299d2c80080"}
+         :git/sha "2cac3eff15792462aaf07ebf34f758e694214d45"}
         ;{:mvn/version "1.3.2"}
 
         cheshire/cheshire                       {:mvn/version "6.1.0"}

src/scicloj/ml/tribuo.clj

@@ -4,6 +4,7 @@
    [scicloj.metamorph.ml.loss :as loss]
    [scicloj.metamorph.ml :as ml]
    [tech.v3.dataset :as ds]
+   [tech.v3.dataset.column :as ds-col]
    [tech.v3.dataset.modelling :as ds-mod]
    [tech.v3.datatype :as dt]
    [tech.v3.datatype.errors :as errors]
@@ -196,20 +197,72 @@
                     different-types (frequencies values-1) (frequencies values-2)))))
 
 
+
+(defn- do-harmonize [ds variable-type filter-fn]
+  (let [column (-> ds
+                   filter-fn
+                   (dscat/reverse-map-categorical-xforms)
+                   (ds/columns)
+                   first)]
+    (assert (some? column)
+            (format "No column found matching filter: %s\nmeta of ds columns: %s" 
+                    filter-fn 
+                    (mapv meta (ds/columns ds)))
+            )
+    (case variable-type
+      :discrete
+      (case (-> column meta :datatype)
+        :keyword (vec column)
+        :int64 (vec column)
+        :string (vec column)
+        :boolean (vec column)
+        :float64 (int-array column))
+
+      :continous (ds-col/to-double-array column)))
+  )
+
+
+
+(defn- do-harmonize-trueth [ds discrete-or-continous]
+  (do-harmonize ds discrete-or-continous cf/target))
+
+(defn- do-harmonize-prediction [ds discrete-or-continous]
+  (do-harmonize ds discrete-or-continous cf/prediction))
+
+
+(defn pre-metric-standardise 
+  "converts prediction result and the trueth into either
+   seq of 
+   :discrete     keyword,string,intXX,...
+   :continous   double, float
+   or fails.
+
+   `prediction-ds` and `thrueth-ds` are tabular data, 
+   usualy of type tech.v3.dataset
+
+   returns map of 
+   :prediction (seq)
+   :trueth     (seq)
+
+   I case of :discrete the discrete values in :predicion and :trueth
+   should have semantically identical meaning, as they might get
+   compared via '=' later
+   "
+  [prediction-ds trueth-ds discrete-or-continous]
+  
+  {:prediction (do-harmonize-prediction prediction-ds discrete-or-continous)
+   :trueth (do-harmonize-trueth trueth-ds discrete-or-continous)}
+  )
+
+
 (defn- score 
   ([model scoring-ds options]
+   ;; classificatioon only
    (let [prediction (ml/predict (cf/feature scoring-ds) model)
          trueth (cf/target scoring-ds)
-         prediction-values
-         (->
-          (cf/prediction prediction)
-          (dscat/reverse-map-categorical-xforms)
-          (get (-> model :target-columns first)))
-         trueth-values
-         (->
-          trueth
-          (dscat/reverse-map-categorical-xforms)
-          (get (-> model :target-columns first)))
+         standardised (pre-metric-standardise prediction trueth :discrete)
+         prediction-values (:prediction standardised)
+         trueth-values (:trueth standardised)
          _ (safety-first! prediction-values trueth-values)]
      (loss/classification-accuracy prediction-values trueth-values)))
   ([model scoring-ds](score model scoring-ds nil))
@@ -232,6 +285,7 @@
   predict-classification
   {:thaw-fn thaw
    :score-fn score
+   :pre-metric-standarisation-fn pre-metric-standardise
    })
 
 

test/scicloj/ml/tribuo_test.clj

@@ -10,7 +10,8 @@
    [tech.v3.dataset :as ds]
    [tech.v3.dataset.categorical :as dscat]
    [tech.v3.dataset.modelling :as ds-mod]
-   [tech.v3.dataset.column-filters :as cf]))
+   [tech.v3.dataset.column-filters :as cf]
+   [tech.v3.libs.tribuo :as tribuo]))
 
 
 (def iris-target-raw
@@ -57,16 +58,24 @@
         model (ml/train (:train-ds split) options)
         predictions (->  (ml/predict (:test-ds split) model))
 
+        standardise-fn (:pre-metric-standarisation-fn (ml/options->model-def options))
+
+
+
         accuracy (loss/classification-accuracy (-> split :test-ds
                                                    dscat/reverse-map-categorical-xforms
                                                    :species)
                                                (-> predictions
                                                    dscat/reverse-map-categorical-xforms
                                                    :species))
         score-fn (:score-fn (ml/options->model-def options))
-        score (score-fn model (:test-ds split))]
-
+        score (score-fn model (:test-ds split))
+        standardised (standardise-fn predictions (:test-ds split) :discrete)
+        accuracy-from-standardised (loss/classification-accuracy
+                                    (-> standardised :prediction)
+                                    (-> standardised :trueth))]
 
+    (t/is (< expected-accuracy accuracy-from-standardised))
     (t/is (< expected-accuracy score))
     (t/is (< expected-accuracy accuracy))
     (t/is (= expected-target-val