v 0.5.14

dev

Author: Marco-Congedo

Manifest.toml

@@ -1,7 +1,7 @@
 name = "PosDefManifoldML"
 uuid = "a07f4532-e2c9-11e9-2ea2-6d98fe4a1f21"
 authors = ["Marco-Congedo <marco.congedo@gmail.com>"]
-version = "0.5.13"
+version = "0.5.14"
 
 [deps]
 DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"

Project.toml

@@ -1,5 +1,5 @@
-authors = ["Marco Congedo, Fahim Doumi, Saloni Jain, Anton Andreev"]
-version = "0.5.13"
+authors = ["Marco Congedo, Fahim Doumi"]
+version = "0.5.14"
 
 [deps]
 DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"

docs/Project.toml

@@ -8,14 +8,14 @@ It also reports the documentation of the **fit** and **predict** functions, as t
 
 |     struct       |           description             |
 |:-----------------|:----------------------------------|
-| [`CVres`](@ref)  | Encapsulate the results of cross-validation procedures for estimating accuracy|
+| [`CVres`](@ref)  | encapsulate the results of cross-validation procedures for estimating accuracy|
 
 |         function       |           description             |
 |:-----------------------|:----------------------------------|
-| [`fit`](@ref)     | Fit a machine learning model with training data |
-| [`predict`](@ref) | Given a fitted model, preidct labels, probabilities or scoring functions on test data |
-| [`crval`](@ref)   | Perform a cross-validation and store accuracies, error losses, confusion matrices, the results of a statistical test and other informations|
-| [`cvSetup`](@ref) | Generate indexes for performing cross-validtions |
+| [`fit`](@ref)     | fit a machine learning model with training data |
+| [`predict`](@ref) | given a fitted model, predict labels, probabilities or scoring functions on test data |
+| [`crval`](@ref)   | perform a cross-validation and store accuracies, error losses, confusion matrices, the results of a statistical test and other informations|
+| [`cvSetup`](@ref) | generate indexes for performing cross-validtions |
 
 ```@docs
 CVres

docs/src/cv.md

@@ -3,7 +3,7 @@
 This unit implements several **Suport-Vector Machine (SVM)**
 machine learning models on the tangent space for symmetric positive definite
 (SDP) matrices, *i.e.*, real PD matrices.
-Several models can be obtained with different combinations of the `svmType` and the `kernel` arguments when the model is fit.
+Several models can be obtained with different combinations of the `svmType` and the `kernel` arguments when the model is fitted.
 Optimal hyperparameters for the given training data
 are found using cross-validation.
 

docs/src/svm.md

@@ -1,21 +1,22 @@
 # tools.jl
 
 This unit implements tools that are useful for building Riemannian
-and Euclidean machine learning classifiers.
+and Euclidean machine learning classifiers. For basic usage of the package 
+you won't need these functions.
 
 ## Content
 
 |         function       |           description             |
 |:-----------------------|:----------------------------------|
 | [`tsMap`](@ref)        | project data on a tangent space to apply Euclidean ML models therein |
-| [`tsWeights`](@ref)| generator of weights for tagent space mapping |
+| [`tsWeights`](@ref)| generate weights for tagent space mapping |
 | [`gen2ClassData`](@ref)| generate 2-class positive definite matrix data for testing Riemannian ML models |
-| [`rescale!`](@ref)| Rescale the rows or columns of a real matrix to be in range [a, b] |
-| [`demean!`](@ref)| Remove the mean of the rows or columns of a real matrix |
-| [`normalize!`](@ref)| Normalize the rows or columns of a real matrix |
-| [`standardize!`](@ref)| Standardize the rows or columns of a real matrix |
-| [`saveas`](@ref)| Save a whatever object to a file |
-| [`load`](@ref)| Load a whatever object from a file |
+| [`rescale!`](@ref)| rescale the rows or columns of a real matrix to be in range [a, b] |
+| [`demean!`](@ref)| remove the mean of the rows or columns of a real matrix |
+| [`normalize!`](@ref)| normalize the rows or columns of a real matrix |
+| [`standardize!`](@ref)| standardize the rows or columns of a real matrix |
+| [`saveas`](@ref)| save a whatever object to a file |
+| [`load`](@ref)| load a whatever object from a file |
 
 ```@docs
 tsMap

docs/src/tools.md

@@ -16,8 +16,7 @@ it does not matter if they act directly on the manifold of positive definite mat
 It also features 
 
 - **Pre-conditining pipelines**, which can drastically reduce the execution time
-- **Adaptation** techniques, which, besides being very useful in cross-session and cross-subject settings, 
- are instrumental for implementing on-line modes of operation.
+- **Adaptation** techniques, which, besides being very useful in cross-session and cross-subject settings, are instrumental for implementing on-line modes of operation.
 
 Note that models acting on the tangent space can take as input Euclidean feature vectors instead of positive definite matrices, thus they can be used in many more situations.
 
@@ -138,12 +137,13 @@ See [`CVres`](@ref) for details on the fields of cross-validation objects.
 
 Let's see how to adapt a pre-conditioning pipeline. Suppose you have data from two 
 sessions or two subjects, `s1` and `s2`.
-We want to use `s1` to train a machine learning model on the tanget space and `s2` to test it.
-A pipeline is fitted sor `s1` and we want this pipeline to adapt to `s2` for testing.
+We want to use `s1` to train a machine learning model on the tangent space and `s2` to test it.
+A pipeline is fitted on `s1` and we want this pipeline to adapt to `s2` for testing.
 If the pipeline includes a recentering pre-conditioner, we need to make sure that
-the dimensionality reduction determined on `s2` is that same as in `s1.
+the dimensionality reduction determined on `s2` is the same as in `s1`.
 
 **Get data**
+
 Let us get some simulated data.
 We generate random data and labels for session (or subject) 1 and 2.
 
@@ -184,7 +184,7 @@ predict(m, Ps2, :l; pipeline=p)
 
 ## Examples using the ENLR model
 
-The **elastic net logistic regression (ENLR)** classifier is an example of classifier acting on the tangent space. Besides the **metric** (see above) used to compute a base-point for projecting the data onto the tangent space, it has a parameter **alpha** and an hyperparameter **lambda**. The **alpha** parameter allows to trade off between a pure **ridge** LR model (``α=0``) and a pure **lasso** LR model (``α=1``), which is the default. Given an alpha value, the model is fitted with a number of values for the ``λ`` (regularization) hyperparameter. Thus, differently from the previous example, tuning the ``λ`` hyperparameter is necessary.
+The **elastic net logistic regression (ENLR)** classifier is an example of classifier acting on the tangent space. Besides the **metric** used to compute a base-point for projecting the data onto the tangent space, it has a parameter **alpha** and an hyperparameter **lambda**. The **alpha** parameter allows to trade off between a pure **ridge** LR model (``α=0``) and a pure **lasso** LR model (``α=1``), which is the default. Given an alpha value, the model is fitted with a number of values for the ``λ`` (regularization) hyperparameter. Thus, differently from the previous example, tuning the ``λ`` hyperparameter is necessary.
 
 Also, keep in mind
 that the [`fit`](@ref) and [`predict`](@ref) methods for ENLR models accept optional keyword arguments that are specific to this model.
@@ -339,11 +339,12 @@ This last command can be invoked repeatedly.
 
 First, let's see how to adapt the base point for projecting the data onto
 the tangent space. Suppose you have data from two sessions or two subjects, `s1` and `s2`.
-We want to use `s1` to train a machine learning model on the tanget space and `s2` to test it,
+We want to use `s1` to train a machine learning model on the tangent space and `s2` to test it,
 however, the barycenter `s1` cannot be assumed equal to the barycenter of `s2`.
 The barycenter determines the base point, therefore, we adapt it.
 
 **Get data**
+
 Let us get some simulated data.
 We generate random data and labels for session (or subject) 1 and 2.
 
@@ -373,7 +374,7 @@ with dimensionality reduction. While adapting the pipeline to `s2`,
 we need to make sure that the matrices in `s2` are reduced to the same 
 dimension as the matrices in `s1`, otherwise the 
 machine learning model we fit on `s1` cannot operate 
-on `s2`. For this, we need to set the `eVar` argmument of the [`Recenter`]
+on `s2`. For this, we need to set the `eVar` argmument of the [`Recenter`](@ref)
 pre-conditioner to a integer matching the reduced dimension of `s1`.
 Note that the adaptation may not work well if the class proportions
 is different in `s1` and `s2`.
@@ -435,7 +436,7 @@ By default, a C-Support Vector Classification model is fitted:
 m1 = fit(SVM(), PTr, yTr; w=:b)
 ```
 
-Notice that as for the example above with for ENLR model, we have requested to compute a balanced mean for projecting the matrices in `PTr` onto the tangent space.
+Notice that, as for the example above with for ENLR model, we have requested to compute a balanced mean for projecting the matrices in `PTr` onto the tangent space.
 
 In order to fit a Nu-Support Vector Classification model:
 

docs/src/tutorial.md

@@ -1,5 +1,5 @@
 #   Unit "simulations.jl" of the PosDefManifoldML Package for Julia language
-#   v 0.5.11 - last update June 2025
+#   v 0.5.14- last update July 2025
 #
 #   MIT License
 #   Copyright (c) 2019-2025,

src/PosDefManifoldML.jl

@@ -39,14 +39,14 @@ A call to [`crval`](@ref) results in an instance of this structure.
 
 `.scoring` is the type of accuracy that is computed, given as a string.
 This is controlled when calling [`crval`](@ref).
-Currently *accuracy* and *balanced accuracy* are supported.
+Currently, *accuracy* and *balanced accuracy* are supported.
 
 `.modelType` is the type of the machine learning model used for performing the
 cross-validation, given as a string.
 
-`.nTrials` is the total number of trials entering the cross-validation
+`.nTrials` is the total number of trials entering the cross-validation.
 
-`.matSize` is the size of the input matrices (trials)
+`.matSize` is the size of the input matrices (trials).
 
 `.predLabels` is an `f`-vector of `z` integer vectors holding the vectors of 
 predicted labels. There is one vector for each fold (`f`) and each containes
@@ -84,7 +84,7 @@ If function [`crval`](@ref) has not been compiled yet, the time includes the com
 In any case the provided estimate is subjected to high variability. To get a better estimate use the median or minimum 
 across several runs or call the function using the [BenchmarkTools.jl](https://github.com/JuliaCI/BenchmarkTools.jl) package.
 
-See [`crval`](@ref) for more informations
+See [`crval`](@ref) for more informations.
 """
 struct CVres <: CVresult 
     cvType      :: String
@@ -162,7 +162,7 @@ Any other value will make the function returning the regular **accuracy**.
 Balanced accuracy is to be preferred for unbalanced classes.
 For balanced classes the balanced accuracy reduces to the
 regular accuracy, therefore there is no point in using regular accuracy,
-if not to avoid a few unnecessary computations when the class are balanced.
+if not to avoid a few unnecessary computations when the classes are balanced.
 
 `hypTest` can be `nothing` or a symbol specifying the kind of statistical test to be carried out.
 At the moment, only `:Bayle` is a possible symbol and this test is performed by default.
@@ -189,7 +189,7 @@ If `outModels` is true, return a 2-tuple holding a [`CVres`](@ref) structure
 and a `nFolds`-vector of the model fitted for each fold,
 otherwise (default), return only a [`CVres`](@ref) structure.
 
-If `⏩` the computations are multi-threaded across folds.
+If `⏩`, the computations are multi-threaded across folds.
 It is true by default. Set it to false if there are problems in running
 this function and for debugging.
 
@@ -198,7 +198,8 @@ this function and for debugging.
     the [`fit!`](@ref) and [`predict`](@ref) function that will be called within each fold will
     we run in single-threaded mode. Vice versa, if you pass `⏩=false`, these two functions
     will be run in multi-threaded mode. This is done to avoid
-    overshooting the number of threads to be activated.
+    overshooting the number of threads to be activated. Because of this behavior, 
+    do not call this function in a multi-threaded loop.
 
 `fitArgs` are optional keyword arguments that are passed to the
 [`fit`](@ref) function called for each fold of the cross-validation.
@@ -218,7 +219,7 @@ Note that if they are passed, they will be disabled:
 |          | `folds`   |
 
 If you pass the `meanISR` argument, this must be nothing (default) 
-or I (the identity matrix). If you pass `meanISR=I` for a tangent space model,
+or *I* (the identity matrix). If you pass `meanISR=I` for a tangent space model,
 parallel transport of the points to the identity before projecting
 the points onto the tangent space will not be carried out.
 This can be used if a recentering conditioner is passed in the `pipeline`
@@ -459,12 +460,12 @@ across calls of this function.
 This function is used in [`crval`](@ref). It constitutes the fundamental
 basis to implement customized cross-validation procedures.
 
-Return the 2-tuple (indTr, indTe) where:
+Return the 2-tuple (`indTr`, `indTe`) where:
 
-- indTr is an array of arrays where indTr[i][f] contains the training indices
-  for class i in fold f
-- indTe is an array of arrays where indTe[i][f] contains the test indices
+- `indTr` is an array of arrays where `indTr[i][f]` contains the training indices
   for class i in fold f
+- `indTe` is an array of arrays where `indTe[i][f]` contains the test indices
+  for class i in fold f.
 
 Each array is organized by class and then by fold, ensuring stratified sampling
 across the cross-validation sets.

src/cv.jl

@@ -155,9 +155,6 @@ m2 = fit(ENLR(logEuclidean; alpha=0), PTr, yTr)
 # which is equivalent to
 m2 = fit(ENLR(logEuclidean), PTr, yTr; alpha=0)
 
-# Note that, albeit model `m` has been created as a ridge model,
-# you have passed `m` and overwritten the `alpha` hyperparameter.
-# The metric, instead, cannot be overwritten.
 ```
 """
 mutable struct ENLR <: ENLRmodel
@@ -305,7 +302,7 @@ as argument `meanISR` and in this case this matrix will be used as the ISR of th
 Passed or computed, it will be written in the `.meanISR` field of the 
 model structure created by this function. Notice that passing `I`, the matrices
 will be projected onto the tangent space at the identity without recentering them.
-This is possible if the matrices have been recentered bt a pre-conditioning pipeline
+This is possible if the matrices have been recentered by a pre-conditioning pipeline
 (see [`Pipeline`](@ref)).
 
 If `meanISR` is not provided and the `.metric` field of the `model`