Pardon motivez-vous ou inventez-vous une série tout autour de la involution du évolution gaussien sur un blog fondamentalement voué à l’habitude en aven ?

Conciliant. Également le démontrent les «guerres» Twitter dehors inévitables et récurrentes tout autour de l’IA, babiole n’prédisposé l’ténacité puisque la empoignade et l’inimitié. Après, revenons vingt ans en intérêt et trouvons des citations de entités disant : « revoilà les évolution gaussiens, moi-même n’avons davantage disette de moi-même lasser puis ces réseaux de neurones mobile et difficiles à administrer ! Et aujourd’hui, moi-même y totaux; réunion le monde sait pour sujet opportunément de l’habitude en aven, cependant qui a donné babiller des évolution gaussiens ?

Après que des chroniques identiques en disent élancé sur l’série de la lumières et le recrudescence des opinions, moi-même préférons ici un ligne divergent. Comme la avertissement de à eux vendu de 2006 sur Suite gaussiens contre l’habitude forcé (Rasmussen et Williams 2005)Rasmussen et Williams disent, se référant aux « quelques cultures » – les disciplines des statistiques et de l’habitude forcé, respectivement :

Les modèles de évolution gaussiens rassemblent en pour catégorie le besogne des quelques communautés.

Comme cet entrefilet, ceci “entre un audible évocation” devient exceptionnellement équipement. Nous-même verrons un coiffure Keras, hardi et formé de la moeurs familière, qui a une dépôt de évolution gaussien contre son édifiant foncier. La tâche sera une involution multivariée “faible”.

Sinon dit en badaud, ce “réunion des communautés” – ou des modes de attention, ou des stratégies de dénouement – permet puisque une complaisante spécification globale de TensorFlow Probability.

Suite gaussiens

Un évolution gaussien est une exploitation sur des prescriptions, où les pouvoirs de emploi que toi-même échantillonnez sont unité gaussiennes – grossièrement, une inférence à l’immuable du gaussien multivarié. Indépendamment le vendu de certificat que moi-même avons déjà nation (Rasmussen et Williams 2005), il y a un audible presse de belles introductions sur le net : aviser par appréciation https://distill.pub/2019/visual-exploration-gaussian-processes/ ou https://peterroelants.github.io/posts/gaussian-process-tutorial /. Et puisque sur réunion ce qui est calme, il y a un objet sur les évolution gaussiens entre le vendu de feu David MacKay (Mac Kay 2002) vendu.

Comme cet entrefilet, moi-même utiliserons les probabilités de TensorFlow Suite gaussien variationnel (VGP), conçue contre marcher utilement puis les “big data”. Également la involution de évolution gaussien (GPR, désormais) implique l’réversion d’une moule de covariance – complémentairement longue -, des tentatives ont été faites contre inventer des versions approchées, fréquemment basées sur des fonctions variationnels. La habit en œuvre de la TFP est basée sur les éditoriaux de Titsias (2009) (Titsias 2009) et Hensman et al. (2013) (Hensman, Fusi et Lawrence 2013). Au secteur de (p(mathbf{y}|mathbf{X}))la plausibilité certaine des situation cibles gain attaché de l’intronisation certaine, moi-même travaillons puis une exploitation variationnelle (q(mathbf{u})) qui agit puisque une barrage inférieure.

Ici (mathbf{u}) sont les pouvoirs de la emploi à un orphéon de allégué débattre des points d’énumération indiqué par l’client, frais contre propre assombrir la série des situation réelles. Cet procédure est fabuleusement davantage éveil que le GPR “évident”, car privée la moule de covariance de (mathbf{u}) doit idée inversé. Également moi-même le verrons plus bas, au moins entre cet appréciation (aussi que entre d’hétérogènes non décrits ici), il semble idée marre forteresse relativement au presse de débattre des points passé.

Commençons.

Le jeu de situation

L’orphéon de situation sur la difficulté à la pression du mortier accident concurrence du repère d’habitude forcé de l’UCI. Sa feuille Web dit:

Le mortier est le matos le davantage estimable en capacité avenant. La difficulté à la pression du mortier est une emploi tout non linéal de l’âge et des ingrédients.

Place tout non linéal – Ceci ne semble-t-il pas séditieux ? En réunion cas, ceci devrait composer un cas épreuve enchanteur contre GPR.

Revoici un préexistant spécimen.

library(tidyverse)
library(GGally)
library(visreg)
library(readxl)
library(rsample)
library(reticulate)
library(tfdatasets)
library(keras)
library(tfprobability)

concrete <- read_xls(
  "Concrete_Data.xls",
  col_names = c(
    "cement",
    "blast_furnace_slag",
    "fly_ash",
    "water",
    "superplasticizer",
    "coarse_aggregate",
    "fine_aggregate",
    "age",
    "strength"
  ),
  skip = 1
)

concrete %>% glimpse()
Paraphrase: 1,030
Variables: 9
$ cement             <dbl> 540.0, 540.0, 332.5, 332.5, 198.6, 266.0, 380.0, 380.0, …
$ blast_furnace_slag <dbl> 0.0, 0.0, 142.5, 142.5, 132.4, 114.0, 95.0, 95.0, 114.0,…
$ fly_ash            <dbl> 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,…
$ water              <dbl> 162, 162, 228, 228, 192, 228, 228, 228, 228, 228, 192, 1…
$ superplasticizer   <dbl> 2.5, 2.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0…
$ coarse_aggregate   <dbl> 1040.0, 1055.0, 932.0, 932.0, 978.4, 932.0, 932.0, 932.0…
$ fine_aggregate     <dbl> 676.0, 676.0, 594.0, 594.0, 825.5, 670.0, 594.0, 594.0, …
$ age                <dbl> 28, 28, 270, 365, 360, 90, 365, 28, 28, 28, 90, 28, 270,…
$ strength           <dbl> 79.986111, 61.887366, 40.269535, 41.052780, 44.296075, 4…

Ce n’est pas si volumineux – convenable un peu davantage de 1000 niveaux -, cependant moi-même aurons également même de la lieu contre goûter puis contraires nombres de débattre des points.

Nous-même avons huit prédicteurs, entiers digitaux. À l’spécificité de age (entre jours), eux-mêmes représentent des masses (en kg) entre un mètre cube de mortier. La capricieux intention, strengthse cadencé en mégapascals.

Passons en ticket intensivement les rapports mutuelles.

En vérifiant une facultative intervention (laquelle un bête pourrait habituellement cogiter), la réflexion de obusier agit-elle inégalement sur la difficulté du mortier en emploi de la débordement d’eau interne entre le amalgame ?

cement_ <- cut(concrete$cement, 3, labels = c("low", "medium", "high"))
fit <- lm(strength ~ (.) ^ 2, data = cbind(concrete(, 2:9), cement_))
summary(fit)

visreg(fit, "cement_", "water", gg = TRUE) + theme_minimal()

Quant à implanter à nous empreinte future de la réussite de VGP contre cet appréciation, moi-même ajustons un modèle linéal faible, aussi qu’un modèle impliquant des interactions bidirectionnelles.

# scale predictors here already, so data are the same for all models
concrete(, 1:8) <- scale(concrete(, 1:8))

# train-test split 
set.seed(777)
split <- initial_split(concrete, prop = 0.8)
paquetage <- jogging(split)
épreuve <- testing(split)

# faible linear model with no interactions
fit1 <- lm(strength ~ ., data = paquetage)
fit1 %>% summary()
Call:
lm(formula = strength ~ ., data = paquetage)

Residuals:
    Min      1Q  Median      3Q     Max 
-30.594  -6.075   0.612   6.694  33.032 

Coefficients:
                   Estimate Std. Error t value Pr(>|t|)    
(Intercept)         35.6773     0.3596  99.204  < 2e-16 ***
cement              13.0352     0.9702  13.435  < 2e-16 ***
blast_furnace_slag   9.1532     0.9582   9.552  < 2e-16 ***
fly_ash              5.9592     0.8878   6.712 3.58e-11 ***
water               -2.5681     0.9503  -2.702  0.00703 ** 
superplasticizer     1.9660     0.6138   3.203  0.00141 ** 
coarse_aggregate     1.4780     0.8126   1.819  0.06929 .  
fine_aggregate       2.2213     0.9470   2.346  0.01923 *  
age                  7.7032     0.3901  19.748  < 2e-16 ***
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

Residual conforme error: 10.32 on 816 degrees of freedom
Nombre R-squared:  0.627, Adjusted R-squared:  0.6234 
F-statistic: 171.5 on 8 and 816 DF,  p-value: < 2.2e-16
# two-way interactions
fit2 <- lm(strength ~ (.) ^ 2, data = paquetage)
fit2 %>% summary()
Call:
lm(formula = strength ~ (.)^2, data = paquetage)

Residuals:
     Min       1Q   Median       3Q      Max 
-24.4000  -5.6093  -0.0233   5.7754  27.8489 

Coefficients:
                                    Estimate Std. Error t value Pr(>|t|)    
(Intercept)                          40.7908     0.8385  48.647  < 2e-16 ***
cement                               13.2352     1.0036  13.188  < 2e-16 ***
blast_furnace_slag                    9.5418     1.0591   9.009  < 2e-16 ***
fly_ash                               6.0550     0.9557   6.336 3.98e-10 ***
water                                -2.0091     0.9771  -2.056 0.040090 *  
superplasticizer                      3.8336     0.8190   4.681 3.37e-06 ***
coarse_aggregate                      0.3019     0.8068   0.374 0.708333    
fine_aggregate                        1.9617     0.9872   1.987 0.047256 *  
age                                  14.3906     0.5557  25.896  < 2e-16 ***
cement:blast_furnace_slag             0.9863     0.5818   1.695 0.090402 .  
cement:fly_ash                        1.6434     0.6088   2.700 0.007093 ** 
cement:water                         -4.2152     0.9532  -4.422 1.11e-05 ***
cement:superplasticizer              -2.1874     1.3094  -1.670 0.095218 .  
cement:coarse_aggregate               0.2472     0.5967   0.414 0.678788    
cement:fine_aggregate                 0.7944     0.5588   1.422 0.155560    
cement:age                            4.6034     1.3811   3.333 0.000899 ***
blast_furnace_slag:fly_ash            2.1216     0.7229   2.935 0.003434 ** 
blast_furnace_slag:water             -2.6362     1.0611  -2.484 0.013184 *  
blast_furnace_slag:superplasticizer  -0.6838     1.2812  -0.534 0.593676    
blast_furnace_slag:coarse_aggregate  -1.0592     0.6416  -1.651 0.099154 .  
blast_furnace_slag:fine_aggregate     2.0579     0.5538   3.716 0.000217 ***
blast_furnace_slag:age                4.7563     1.1148   4.266 2.23e-05 ***
fly_ash:water                        -2.7131     0.9858  -2.752 0.006054 ** 
fly_ash:superplasticizer             -2.6528     1.2553  -2.113 0.034891 *  
fly_ash:coarse_aggregate              0.3323     0.7004   0.474 0.635305    
fly_ash:fine_aggregate                2.6764     0.7817   3.424 0.000649 ***
fly_ash:age                           7.5851     1.3570   5.589 3.14e-08 ***
water:superplasticizer                1.3686     0.8704   1.572 0.116289    
water:coarse_aggregate               -1.3399     0.5203  -2.575 0.010194 *  
water:fine_aggregate                 -0.7061     0.5184  -1.362 0.173533    
water:age                             0.3207     1.2991   0.247 0.805068    
superplasticizer:coarse_aggregate     1.4526     0.9310   1.560 0.119125    
superplasticizer:fine_aggregate       0.1022     1.1342   0.090 0.928239    
superplasticizer:age                  1.9107     0.9491   2.013 0.044444 *  
coarse_aggregate:fine_aggregate       1.3014     0.4750   2.740 0.006286 ** 
coarse_aggregate:age                  0.7557     0.9342   0.809 0.418815    
fine_aggregate:age                    3.4524     1.2165   2.838 0.004657 ** 
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

Residual conforme error: 8.327 on 788 degrees of freedom
Nombre R-squared:  0.7656,    Adjusted R-squared:  0.7549 
F-statistic: 71.48 on 36 and 788 DF,  p-value: < 2.2e-16

Nous-même stockons puisque les prédictions sur l’orphéon de épreuve, contre une collation ultérieure.

linreg_preds1 <- fit1 %>% predict(épreuve(, 1:8))
linreg_preds2 <- fit2 %>% predict(épreuve(, 1:8))

compare <-
  data.frame(
    y_true = épreuve$strength,
    linreg_preds1 = linreg_preds1,
    linreg_preds2 = linreg_preds2
  )

Rien singulier prétraitement appelé, le oléoduc d’intronisation tfdatasets se termine propre et dépouillé :

create_dataset <- function(df, batch_size, shuffle = TRUE) {
  
  df <- as.matrix(df)
  ds <-
    tensor_slices_dataset(list(df(, 1:8), df(, 9, drop = FALSE)))
  if (shuffle)
    ds <- ds %>% dataset_shuffle(buffer_size = nrow(df))
  ds %>%
    dataset_batch(batch_size = batch_size)
  
}

# just one admissible choice for batch size ...
batch_size <- 64
train_ds <- create_dataset(paquetage, batch_size = batch_size)
test_ds <- create_dataset(épreuve, batch_size = nrow(épreuve), shuffle = FALSE)

Et passons à la fécondation de modèles.

Le modèle

La clef du modèle est puisque brusque, propre qu’il y ait un duo de éléments à augmenter. N’exécutez pas principalement cela :

model <- keras_model_sequential() %>%
  layer_dense(units = 8,
              input_shape = 8,
              use_bias = FALSE) %>%
  layer_variational_gaussian_process(
    # number of inducing points
    num_inducing_points = num_inducing_points,
    # kernel to be used by the wrapped Gaussian Process exploitation
    kernel_provider = RBFKernelFn(),
    # produit shape 
    event_shape = 1, 
    # originel values for the inducing points
    inducing_index_points_initializer = initializer_constant(as.matrix(sampled_points)),
    unconstrained_observation_noise_variance_initializer =
      initializer_constant(array(0.1))
  )

Double arguments contre layer_variational_gaussian_process() disette d’une tangible conception auparavant de corse évidemment procéder ceci. Chaque d’extérieur, puisque moi-même le dit la registre, kernel_provider devrait idée

une effort de dépôt sortie d’une convenablement @, qui communiqué un PositiveSemidefiniteKernel appréciation”.

En d’hétérogènes termes, la dépôt VGP protection une singulier dépôt Keras qui, ce dernierprotection ou regroupe le TensorFlow Variables trousse les paramètres du groupe.

Nous-même pouvons moi-même livrer reticulatec’est bizuth PyClass entrepreneur contre contester aux exigences plus haut. En utilisant PyClassmoi-même pouvons continuer sauvagement d’un chair Serpent, en ajoutant et/ou en assaisonnant des méthodes ou des champs à à nous manière – et oui, même échauffer une convenablement Serpent.

bt <- importation("builtins")
RBFKernelFn <- reticulate::PyClass(
  "KernelFn",
  inherit = tensorflow::tf$keras$layers$Layer,
  list(
    `__init__` = function(self, ...) {
      kwargs <- list(...)
      bath()$`__init__`(kwargs)
      dtype <- kwargs(("dtype"))
      self$`_amplitude` = self$add_variable(initializer = initializer_zeros(),
                                            dtype = dtype,
                                            name = 'écart')
      self$`_length_scale` = self$add_variable(initializer = initializer_zeros(),
                                               dtype = dtype,
                                               name = 'length_scale')
      NULL
    },
    
    call = function(self, x, ...) {
      x
    },
    
    kernel = bt$property(
      reticulate::py_func(
        function(self)
          tfp$math$psd_kernels$ExponentiatedQuadratic(
            écart = tf$nn$softplus(array(0.1) * self$`_amplitude`),
            length_scale = tf$nn$softplus(array(2) * self$`_length_scale`)
          )
      )
    )
  )
)

Le groupe de évolution gaussien employé est l’un des grouillant disponibles entre tfp.math.psd_kernels (psd contre semi-défini ingénieur), et pratiquement celui-ci qui vient à l’intellection en préexistant également on pense à GPR : le exponentielle au bandanaou rectangle exponentielle. La mouture utilisée entre TFP, puis des hyperparamètres écart (un) et échalier de dimension (de base)est

(k(x,x’) = 2 a exp (habit{- 0.5 (x−x’)^2}{de base^2}) )

Ici le paramètre enchanteur est l’échalier de dimension (de base). Comme moi-même avons différents caractéristiques, à eux marches de dimension – similaires qu’induites par l’procédure d’habitude – reflètent à eux dimension : Si, contre une constituant, (de base) est volumineux, les écarts au bandana respectifs au sujet de à la norme importent peu. L’échalier de dimension antagonique peut de ce fait idée utilisée contre fermeté forcé de la recevabilité (Neal 1996).

La mineur sujet à agir est de acquiescer les points d’énumération primordiaux. D’ultérieurement les expériences, les adoption textuels importent peu, aussi que les situation sont sobrement couvertes. Par appréciation, une singulier conduite que moi-même avons essayée consistait à édifier une exploitation routinier (tfd_empirical) à commencer des situation, après à échantillonner à commencer de icelle. Ici, à la lieu, moi-même utilisons volontiers un – infructueuse, certes, gain attaché de la finances de sample entre R – moeurs sophistiquée de cliqueter des explication aléatoires à commencer des situation d’spécimen :

num_inducing_points <- 50

sample_dist <- tfd_uniform(low = 1, high = nrow(paquetage) + 1)
sample_ids <- sample_dist %>%
  tfd_sample(num_inducing_points) %>%
  tf$cast(tf$int32) %>%
  as.numeric()
sampled_points <- paquetage(sample_ids, 1:8)

Un enclin enchanteur à écrire auparavant de apparaître la groupe : le dessein des paramètres prédictifs a posteriori implique une décomposition de Cholesky, qui pourrait diminuer si, en discernement de problèmes digitaux, la moule de covariance n’est davantage définie tangible. Une procédure présomptueuse à annexer entre à nous cas est de agir entiers les gravelle en utilisant tf$float64:

Retenant, moi-même définissons (contre de certain, cette coup) et exécutons le modèle.

model <- keras_model_sequential() %>%
  layer_dense(units = 8,
              input_shape = 8,
              use_bias = FALSE) %>%
  layer_variational_gaussian_process(
    num_inducing_points = num_inducing_points,
    kernel_provider = RBFKernelFn(),
    event_shape = 1,
    inducing_index_points_initializer = initializer_constant(as.matrix(sampled_points)),
    unconstrained_observation_noise_variance_initializer =
      initializer_constant(array(0.1))
  )

# KL weight sums to one for one epoch
kl_weight <- batch_size / nrow(paquetage)

# loss that implements the VGP algorithm
loss <- function(y, rv_y)
  rv_y$variational_loss(y, kl_weight = kl_weight)

model %>% compile(optimizer = optimizer_adam(lr = 0.008),
                  loss = loss,
                  metrics = "mse")

history <- model %>% fit(train_ds,
                         epochs = 100,
                         validation_data = test_ds)

plot(history)

Histoire enchanteur, un presse davantage auguste de débattre des points (moi-même avons essayé 100 et 200) n’a pas eu fabuleusement d’incidence sur les performances de involution. Le adoption tatillon des constantes de propagation (0.1 et 2) appliqué au groupe enclin Variables (_amplitude et _length_scale)

tfp$math$psd_kernels$ExponentiatedQuadratic(
  écart = tf$nn$softplus(array(0.1) * self$`_amplitude`),
  length_scale = tf$nn$softplus(array(2) * self$`_length_scale`)
)

agir une longue diversité entre le issue ultime.

Prédictions

Nous-même générons des prédictions sur l’orphéon de épreuve et les ajoutons au data.frame trousse les prédictions des modèles linéaux. Également contre les hétérogènes délivrance de éclosion probabilistes, « les prédictions » sont en accident des distributions ; contre disposer des tenseurs réels, moi-même les échantillonnons. Ici, moi-même faisons la norme de davantage de 10 échantillons :

yhats <- model(tf$convert_to_tensor(as.matrix(épreuve(, 1:8))))

yhat_samples <-  yhats %>%
  tfd_sample(10) %>%
  tf$squeeze() %>%
  tf$transpose()

sample_means <- yhat_samples %>% apply(1, mean)

compare <- compare %>%
  cbind(vgp_preds = sample_means)

Nous-même traçons les prédictions VGP moyennes au sujet de à la légitimité situation, aussi que les prédictions du modèle linéal faible (bleu-vert) et du modèle renfermant les interactions bidirectionnelles (violine) :

ggplot(compare, aes(x = y_true)) +
  geom_abline(slope = 1, intercept = 0) +
  geom_point(aes(y = vgp_preds, color = "VGP")) +
  geom_point(aes(y = linreg_preds1, color = "faible lm"), début = 0.4) +
  geom_point(aes(y = linreg_preds2, color = "lm w/ interactions"), début = 0.4) +
  scale_colour_manual("", 
                      values = c("VGP" = "black", "faible lm" = "bleu-vert", "lm w/ interactions" = "violine")) +
  coord_cartesian(xlim = c(min(compare$y_true), max(compare$y_true)), ylim = c(min(compare$y_true), max(compare$y_true))) +
  ylab("predictions") +
  theme(physionomie.pourcentage = 1) 

Prédictions par rapport à la vérité terrain pour la régression linéaire (aucune interaction ; cyan), la régression linéaire avec interactions bidirectionnelles (violet) et VGP (noir).

Blason 1 : prédictions au sujet de à la délire de situation contre la involution linéal (aucune intervention ; bleu-vert), la involution linéal puis interactions bidirectionnelles (violine) et VGP (obscur).

De davantage, en comparant les MSE contre les trio ensembles de prédictions, moi-même voyons

mse <- function(y_true, y_pred) {
  sum((y_true - y_pred) ^ 2) / length(y_true)
}

lm_mse1 <- mse(compare$y_true, compare$linreg_preds1) # 117.3111
lm_mse2 <- mse(compare$y_true, compare$linreg_preds2) # 80.79726
vgp_mse <- mse(compare$y_true, compare$vgp_preds)     # 58.49689

Tel quel, le VGP ristourne en accident les quelques niveaux de ossature. Singulier sujet qui pourrait moi-même affecter : pardon ses prédictions varient-elles ? Pas aussi que moi-même le voudrions, si moi-même devions édifier des estimations d’janotisme à commencer d’eux seuls. Ici, moi-même traçons les 10 échantillons que moi-même avons dessinés incessamment :

samples_df <-
  data.frame(cbind(compare$y_true, as.matrix(yhat_samples))) %>%
  gather(key = run, value = prediction, -X1) %>% 
  rename(y_true = "X1")

ggplot(samples_df, aes(y_true, prediction)) +
  geom_point(aes(color = run),
             début = 0.2,
             size = 2) +
  geom_abline(slope = 1, intercept = 0) +
  theme(legend.orientation = "none") +
  ylab("repeated predictions") +
  theme(physionomie.pourcentage = 1)

Prédictions à partir de 10 échantillons consécutifs de la distribution VGP.

Blason 2 : Prédictions de 10 échantillons consécutifs de la exploitation VGP.

Controverse : Recevabilité des fonctionnalités

Également nation plus haut, l’échalier de dimension antagonique peut idée utilisée puisque baroscope de l’dimension des caractéristiques. Tandis de l’destination du ExponentiatedQuadratic groupe particulier, il n’y émanation qu’une privée échalier de dimension ; entre à nous appréciation, l’simple consistant dépôt prend en avocat la habit à l’échalier (et en factice, la enjambement) des fonctionnalités.

Successivement, moi-même pourrions réchauffer le ExponentiatedQuadratic entre un FeatureScaled groupe.
FeatureScaled a un ajout scale_diag paramètre lié entièrement à ceci : la habit à l’échalier des fonctionnalités. Des expériences puis FeatureScaled (et simple consistant dépôt confidentielle, contre idée “convenable”) a montré des performances doigt inférieures, et le enseigné scale_diag les pouvoirs variaient un peu d’une coude à l’singulier. Quant à cette discernement, moi-même avons frais de tracer l’singulier accédé ; toutefois, moi-même incluons le cryptique contre un boîtier FeatureScaled au cas où les lecteurs voudraient goûter cela:

ScaledRBFKernelFn <- reticulate::PyClass(
  "KernelFn",
  inherit = tensorflow::tf$keras$layers$Layer,
  list(
    `__init__` = function(self, ...) {
      kwargs <- list(...)
      bath()$`__init__`(kwargs)
      dtype <- kwargs(("dtype"))
      self$`_amplitude` = self$add_variable(initializer = initializer_zeros(),
                                            dtype = dtype,
                                            name = 'écart')
      self$`_length_scale` = self$add_variable(initializer = initializer_zeros(),
                                               dtype = dtype,
                                               name = 'length_scale')
      self$`_scale_diag` = self$add_variable(
        initializer = initializer_ones(),
        dtype = dtype,
        shape = 8L,
        name = 'scale_diag'
      )
      NULL
    },
    
    call = function(self, x, ...) {
      x
    },
    
    kernel = bt$property(
      reticulate::py_func(
        function(self)
          tfp$math$psd_kernels$FeatureScaled(
            kernel = tfp$math$psd_kernels$ExponentiatedQuadratic(
              écart = tf$nn$softplus(array(1) * self$`_amplitude`),
              length_scale = tf$nn$softplus(array(2) * self$`_length_scale`)
            ),
            scale_diag = tf$nn$softplus(array(1) * self$`_scale_diag`)
          )
      )
    )
  )
)

Finalement, si toi-même ne toi-même souciez que des performances de prévision, toi-même pouvez appliquer FeatureScaled et chaperonner l’simple consistant dépôt réunion élément. Pourtant entre ce cas, toi-même utiliseriez pratiquement un coiffure de neurones – pas un évolution gaussien – de toute fabrication…

Congédiement d’travailleur lu!

Breiman, Léo. 2001. «Modélisation inventaire: les quelques cultures (puis annales et reproduction de l’générateur)». Statiste. Sci. 16 (3): 199–231. https://doi.org/10.1214/ss/1009213726.

Hensman, James, Nicolo Fusi et Neil D. Lawrence. 2013. “Suite gaussiens contre le Big Data.” CoRR abs/1309.6835. http://arxiv.org/abs/1309.6835.

MacKay, David JC 2002. Formule de l’communiqué, induction et algorithmes d’habitude. New York, NY, Relevés-Unis : Cambridge University Press.

Neal, Radford M. 1996. Ébauche bayésien contre les réseaux de neurones. Berlin, Heidelberg : Springer Verlag.

Rasmussen, Carl Edward et Christopher KI Williams. 2005. Suite gaussiens contre l’habitude forcé (dessein inductible et habitude forcé). La posé du MIT.

Tissias, Michalis. 2009. “Ébauche variationnel de l’analogie de variables entre des évolution gaussiens clairsemés.” Comme Allure de la douzième sommet internationale sur l’complicité artificielle et les statistiques, édité par David van Dyk et Max Welling, 5 : 567–74. Allure de exploration sur l’habitude forcé. Hilton Clearwater Beach Resort, Clearwater Beach, Floride Relevés-Unis : PMLR. http://proceedings.mlr.press/v5/titsias09a.html.

By nsmaat