Module A3SOM ============ :: A3SOM(input_dim, n_classes, n=8, n_hidden=3, Tmax=1.0, Tmin=0.5, dropout_rate=0.0, act='none', abstained=False, dense_block=[], normalization='none') Implementation of an abstained semi-supervised self-organizing map, based on Keras models. The data is first projected onto a SOM, where best-matching units (BMUs) are found (closest neuron for each data point). The activation pattern of the neurons is then fed into fully-connected dense layers to find out class-membership probabilities. The loss function includes both the SOM error and the classification error. Arguments ---------- input_dim: int. Number of features in the input data. n_classes: int. Number of classes in the input data. n: int, default=8. Number of neurons along one axis of the self-organizing map (SOM). The dimension of the map will be n\*n. Prioritize values between 4 and 15. n_hidden: int, default=3. Number of hidden layers in the dense block. Tmax: float, default=1. Starting temperature (radius) of the neighborhood function for the SOM. Temperature is slowly reduced using exponential decay. Tmin: float, default=.5. End temperature (radius) of the neighborhood function for the SOM. Tmin <= Tmax. dropout_rate: float, default=0. Rate of dropout applied after dense layers. act: {'none', 'relu', 'sigmoid', 'softmax', 'softplus', 'softsign', 'tanh', 'selu', 'elu', 'exponential'}, default='none'. Activation function to apply to the output of the SOM layer. abstained: bool, default=False. If True, the abstained mode of A3SOM is used. If False, the standard classification mode is used. dense_block: list of layers, default=[]. To replace the predefined organization of dense layers with a custom list of succeeding layers. Overrides `n_hidden` and `dropout_rate`. normalization: {'none', 'batch', 'layer', 'both'}, default='none'. Apply batch normalization, layer normalization, or both after each dense layer. Methods --------- compile() ~~~~~~~~~~~~~~ :: compile(self, learning_rates={'som': 0.001, 'dense': 0.0001}, loss_weights={'gamma': 0.6, 'eta': 0.0001}, metrics=['accuracy'], **kwargs) Configures the model for training. Args: learning_rates, default={'som': 0.001, 'dense': 0.0001}. Dictionary with the learning rates to use for the SOM's optimizer ('som') and the dense layers' optimizer ('dense'). loss_weights, default={'gamma': 0.6, 'eta': 0.0001}. Optional dictionary specifying scalar coefficients (Python floats) to weight the loss contributions of different model outputs. ``gamma`` is the weight associated to the SOM loss (distortion), and ``eta`` is the weight associated to the regularization term. These two terms are scaled in comparison to the categorical cross-entropy loss, which has a weight of 1. The loss value that will be minimized by the model will then be the *weighted sum* of all individual losses, weighted by the `loss_weights` coefficients. metrics: List of metrics to be evaluated by the model during training and testing. Each of this can be a string (name of a built-in function), function or a `tf.keras.metrics.Metric` instance. See `tf.keras.metrics`. fit() ~~~~~~ :: fit(self, X, y, **kwargs) Trains the model for a fixed number of epochs (iterations on a dataset). Args: x: Input data. It could be: - A Numpy array (or array-like), or a list of arrays (in case the model has multiple inputs). - A TensorFlow tensor, or a list of tensors (in case the model has multiple inputs). y: Target data. Like the input data `x`, it could be either Numpy array(s) or TensorFlow tensor(s). It should be consistent with `x` (you cannot have Numpy inputs and tensor targets, or inversely). If `x` is a dataset, generator, or `keras.utils.Sequence` instance, `y` should not be specified (since targets will be obtained from `x`). batch_size: Integer or `None`. Number of samples per gradient update. If unspecified, `batch_size` will default to 32. Do not specify the `batch_size` if your data is in the form of datasets, generators, or `keras.utils.Sequence` instances (since they generate batches). epochs: Integer. Number of epochs to train the model. An epoch is an iteration over the entire `x` and `y` data provided (unless the `steps_per_epoch` flag is set to something other than None). Note that in conjunction with `initial_epoch`, `epochs` is to be understood as "final epoch". The model is not trained for a number of iterations given by `epochs`, but merely until the epoch of index `epochs` is reached. verbose: 'auto', 0, 1, or 2. Verbosity mode. 0 = silent, 1 = progress bar, 2 = one line per epoch. 'auto' defaults to 1 for most cases, but 2 when used with `ParameterServerStrategy`. Note that the progress bar is not particularly useful when logged to a file, so verbose=2 is recommended when not running interactively (eg, in a production environment). callbacks: List of `keras.callbacks.Callback` instances. List of callbacks to apply during training. See `tf.keras.callbacks`. validation_split: Float between 0 and 1. Fraction of the training data to be used as validation data. The model will set apart this fraction of the training data, will not train on it, and will evaluate the loss and any model metrics on this data at the end of each epoch. If both `validation_data` and `validation_split` are provided, `validation_data` will override `validation_split`. validation_data: Data on which to evaluate the loss and any model metrics at the end of each epoch. The model will not be trained on this data. Thus, note the fact that the validation loss of data provided using `validation_split` or `validation_data` is not affected by regularization layers like noise and dropout. `validation_data` will override `validation_split`. `validation_data` is formatted:`(x_val, y_val)` of Numpy arrays or tensors. class_weight: Optional dictionary mapping class indices (integers) to a weight (float) value, used for weighting the loss function (during training only). This can be useful to tell the model to "pay more attention" to samples from an under-represented class. workers: Integer. Used for generator or `keras.utils.Sequence` input only. Maximum number of processes to spin up when using process-based threading. If unspecified, `workers` will default to 1. Returns: A `History` object. Its `History.history` attribute is a record of training loss values and metrics values at successive epochs, as well as validation loss values and validation metrics values (if applicable). predict() ~~~~~~ :: predict(self, X, distances=False, **kwargs) Predicts the samples in X and returns their class probabilities. Args: x: Input data. It could be: - A Numpy array (or array-like), or a list of arrays (in case the model has multiple inputs). - A TensorFlow tensor, or a list of tensors (in case the model has multiple inputs). distances: bool, default = False. If False, only proba_classes will be returned. If True, a tuple will be returned. The first element is proba_classes, and the second is distances, the distance matrix between data and the SOM neurons. Returns: proba_classes: a list of predicted probabilites for each class, for each sample in X. distances: a distance matrix between each sample in X and the SOM neurons. summary() ~~~~~~~~~~ :: summary(self) Returns the summary of the model. get_params() ~~~~~~~~~~ :: get_params(self) Returns the parameters used to train the model.