The `initSOM`

function returns a `paramSOM`

class object that
contains the parameters needed to run the SOM algorithm.

```
initSOM(
dimension = c(5, 5),
topo = c("square", "hexagonal"),
radius.type = c("gaussian", "letremy"),
dist.type = switch(match.arg(radius.type), letremy = "letremy", gaussian = "euclidean"),
type = c("numeric", "relational", "korresp"),
mode = c("online"),
affectation = c("standard", "heskes"),
maxit = 500,
nb.save = 0,
verbose = FALSE,
proto0 = NULL,
init.proto = switch(type, numeric = "random", relational = "obs", korresp = "random"),
scaling = switch(type, numeric = "unitvar", relational = "none", korresp = "chi2"),
eps0 = 1
)
# S3 method for paramSOM
print(x, ...)
# S3 method for paramSOM
summary(object, ...)
```

- dimension
Vector of two integer points corresponding to the x dimension and the y dimension of the

`myGrid`

class object. Default values are:`(5,5)`

. Other data-driven defaults are set by function`trainSOM`

.- topo
The topology to be used to build the grid of the

`myGrid`

class object. Accept values`"square"`

(Default) or`"hexagonal"`

.- radius.type
The neighborhood type. Default value is

`"gaussian"`

, which corresponds to a Gaussian neighborhood. The annealing of the neighborhood during the training step is similar to the one implemented in yasomi. The alternative value corresponds to an piecewise linear neighborhood as implemented by Patrick Letrémy in his SAS scripts.- dist.type
The neighborhood relationship on the grid. One of

`c("letremy", "euclidean", "maximum", "manhattan", "canberra", "minkowski")`

. When`radius.type`

is`letremy`

, default value is`letremy`

which is the original implementation by Patrick Letrémy. When`radius.type`

is`gaussian`

, default value is`euclidean`

. The other possible values are passed to`method`

in function`dist`

.`dist.type = "letremy"`

is not permitted with`radius.type = "gaussian"`

. Only`euclidian`

is allowed with hexagonal topology.- type
The SOM algorithm type. Possible values are:

`numeric`

(default value),`korresp`

and`relational`

.- mode
The SOM algorithm mode. Default value is

`online`

.- affectation
The SOM affectation type. Default value is

`standard`

which corresponds to a hard affectation. Alternative is`heskes`

which corresponds to Heskes's soft affectation.- maxit
The maximum number of iterations to be done during the SOM algorithm process. Default value is

`500`

. Other data-driven defaults are set by function`trainSOM`

.- nb.save
The number of intermediate back-ups to be done during the algorithm process. Default value is

`0`

.- verbose
The boolean value which activates the verbose mode during the SOM algorithm process. Default value is

`FALSE`

.- proto0
The initial prototypes. Default value is

`NULL`

.- init.proto
The method to be used to initialize the prototypes, which may be

`"random"`

(randomization),`"obs"`

(each prototype is assigned a random observation) or`"pca"`

. In`pca`

the prototypes are initialized to the observations closest to a grid along the two first principal components of the data (`numeric`

case) or along a two-dimensional multidimensional scaling (`relational`

case, equivalent to a`relational`

PCA). Default value is`random`

for the`numeric`

and`korresp`

types, and`obs`

for the`relational`

type.`pca`

is not available for`korresp`

SOM.- scaling
The type of data pre-processing. For

`numeric`

SOM, possibilities are`unitvar`

(data are centered and scaled; this is the default value for a`numeric`

SOM),`none`

(no pre-processing), and`center`

(data are centered but not scaled). For`korresp`

SOM, the only available value is`chi2`

. For`relational`

SOM, possibilities are`none`

(no pre-processing, default value for`relational`

SOM) and`cosine`

. This last one first turns the dissimilarity into a similarity using the suggestion in (Lee and Verleysen, 2007). Then, a cosine normalization as described in (Ben-Hur and Weston, 2010) is applied to the kernel, that is finally turned back into its induced distance. For further details on this processing, have a look at the corresponding documentation in the directory "doc" of the package's installation directory.- eps0
The scaling value for the stochastic gradient descent step in the prototypes' update. The scaling value for the stochastic gradient descent step is equal to \(\frac{0.3\epsilon_0}{1+0.2t/\textrm{dim}}\) where \(t\) is the current step number and \(\textrm{dim}\) is the grid dimension (width multiplied by height).

- x
an object of class

`paramSOM`

.- ...
not used

- object
an object of class

`paramSOM`

.

The `initSOM`

function returns an object of class
`paramSOM`

which is a list of the parameters passed to the
`initSOM`

function, plus the default parameters for the ones not
specified by the user.

Ben-Hur A., Weston J. (2010) A user's guide to support vector machine. In:
*Data Mining Techniques for the Life Sciences*, Springer-Verlag,
223-239.

Heskes T. (1999) Energy functions for self-organizing maps. In: *Kohonen
Maps*, Oja E., Kaski S. (Eds.), Elsevier, 303-315.

Lee J., Verleysen M. (2007) *Nonlinear Dimensionality Reduction*.
Information Science and Statistics series, Springer.

Letrémy P. (2005) Programmes basés sur l'algorithme de Kohonen et dediés à l'analyse des données. SAS/IML programs for 'korresp'.

Rossi F. (2013) yasomi: Yet Another Self-Organising Map Implementation. R package, version 0.3. https://github.com/fabrice-rossi/yasomi

See `initGrid`

for creating a SOM prior structure
(grid).

```
# create a default 'paramSOM' class object
default.paramSOM <- initSOM()
summary(default.paramSOM)
#>
#> Summary
#>
#> Class : paramSOM
#>
#> Parameters of the SOM
#>
#> SOM mode : online
#> SOM type : numeric
#> Affectation type : standard
#> Grid :
#> Self-Organizing Map structure
#>
#> Features :
#> topology : square
#> x dimension : 5
#> y dimension : 5
#> distance type: euclidean
#>
#> Number of iterations : 500
#> Number of intermediate backups : 0
#> Initializing prototypes method : random
#> Data pre-processing type : unitvar
#> Neighbourhood type : gaussian
#>
```