
    0Phx:                         d Z ddlZddlmZmZ ddlZddlmZ	 ddl
mZ ddlmZmZmZmZ ddlmZmZ ddlmZ dd	lmZ dd
lmZmZ  G d deee          ZdS )zRestricted Boltzmann Machine    N)IntegralReal)expit   )BaseEstimatorClassNamePrefixFeaturesOutMixinTransformerMixin_fit_context)check_random_stategen_even_slices)Interval)safe_sparse_dot)check_is_fittedvalidate_datac            	       T    e Zd ZU dZ eeddd          g eeddd          g eeddd          g eeddd          gdgd	gd
Zee	d<   	 ddddddddZ
d Zd Zd Zd Zd Zd Z ed          dd            Zd Zd Z ed          dd            Z fdZ xZS ) BernoulliRBMa  Bernoulli Restricted Boltzmann Machine (RBM).

    A Restricted Boltzmann Machine with binary visible units and
    binary hidden units. Parameters are estimated using Stochastic Maximum
    Likelihood (SML), also known as Persistent Contrastive Divergence (PCD)
    [2].

    The time complexity of this implementation is ``O(d ** 2)`` assuming
    d ~ n_features ~ n_components.

    Read more in the :ref:`User Guide <rbm>`.

    Parameters
    ----------
    n_components : int, default=256
        Number of binary hidden units.

    learning_rate : float, default=0.1
        The learning rate for weight updates. It is *highly* recommended
        to tune this hyper-parameter. Reasonable values are in the
        10**[0., -3.] range.

    batch_size : int, default=10
        Number of examples per minibatch.

    n_iter : int, default=10
        Number of iterations/sweeps over the training dataset to perform
        during training.

    verbose : int, default=0
        The verbosity level. The default, zero, means silent mode. Range
        of values is [0, inf].

    random_state : int, RandomState instance or None, default=None
        Determines random number generation for:

        - Gibbs sampling from visible and hidden layers.

        - Initializing components, sampling from layers during fit.

        - Corrupting the data when scoring samples.

        Pass an int for reproducible results across multiple function calls.
        See :term:`Glossary <random_state>`.

    Attributes
    ----------
    intercept_hidden_ : array-like of shape (n_components,)
        Biases of the hidden units.

    intercept_visible_ : array-like of shape (n_features,)
        Biases of the visible units.

    components_ : array-like of shape (n_components, n_features)
        Weight matrix, where `n_features` is the number of
        visible units and `n_components` is the number of hidden units.

    h_samples_ : array-like of shape (batch_size, n_components)
        Hidden Activation sampled from the model distribution,
        where `batch_size` is the number of examples per minibatch and
        `n_components` is the number of hidden units.

    n_features_in_ : int
        Number of features seen during :term:`fit`.

        .. versionadded:: 0.24

    feature_names_in_ : ndarray of shape (`n_features_in_`,)
        Names of features seen during :term:`fit`. Defined only when `X`
        has feature names that are all strings.

        .. versionadded:: 1.0

    See Also
    --------
    sklearn.neural_network.MLPRegressor : Multi-layer Perceptron regressor.
    sklearn.neural_network.MLPClassifier : Multi-layer Perceptron classifier.
    sklearn.decomposition.PCA : An unsupervised linear dimensionality
        reduction model.

    References
    ----------

    [1] Hinton, G. E., Osindero, S. and Teh, Y. A fast learning algorithm for
        deep belief nets. Neural Computation 18, pp 1527-1554.
        https://www.cs.toronto.edu/~hinton/absps/fastnc.pdf

    [2] Tieleman, T. Training Restricted Boltzmann Machines using
        Approximations to the Likelihood Gradient. International Conference
        on Machine Learning (ICML) 2008

    Examples
    --------

    >>> import numpy as np
    >>> from sklearn.neural_network import BernoulliRBM
    >>> X = np.array([[0, 0, 0], [0, 1, 1], [1, 0, 1], [1, 1, 1]])
    >>> model = BernoulliRBM(n_components=2)
    >>> model.fit(X)
    BernoulliRBM(n_components=2)

    For a more detailed example usage, see
    :ref:`sphx_glr_auto_examples_neural_networks_plot_rbm_logistic_classification.py`.
       Nleft)closedr   neitherverboserandom_staten_componentslearning_rate
batch_sizen_iterr   r   _parameter_constraints   g?
   )r   r   r   r   r   c                Z    || _         || _        || _        || _        || _        || _        d S Nr   )selfr   r   r   r   r   r   s          [/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/sklearn/neural_network/_rbm.py__init__zBernoulliRBM.__init__   s7     )*$(    c                     t          |            t          | |ddt          j        t          j        f          }|                     |          S )ag  Compute the hidden layer activation probabilities, P(h=1|v=X).

        Parameters
        ----------
        X : {array-like, sparse matrix} of shape (n_samples, n_features)
            The data to be transformed.

        Returns
        -------
        h : ndarray of shape (n_samples, n_components)
            Latent representations of the data.
        csrF)accept_sparseresetdtype)r   r   npfloat64float32_mean_hiddens)r#   Xs     r$   	transformzBernoulliRBM.transform   sP     	!5bj"*=U
 
 
 !!!$$$r&   c                 l    t          || j        j                  }|| j        z  }t	          ||          S )aL  Computes the probabilities P(h=1|v).

        Parameters
        ----------
        v : ndarray of shape (n_samples, n_features)
            Values of the visible layer.

        Returns
        -------
        h : ndarray of shape (n_samples, n_components)
            Corresponding mean field values for the hidden layer.
        out)r   components_Tintercept_hidden_r   )r#   vps      r$   r/   zBernoulliRBM._mean_hiddens   s6     At/122	T##QAr&   c                 j    |                      |          }|                    |j                  |k     S )a  Sample from the distribution P(h|v).

        Parameters
        ----------
        v : ndarray of shape (n_samples, n_features)
            Values of the visible layer to sample from.

        rng : RandomState instance
            Random number generator to use.

        Returns
        -------
        h : ndarray of shape (n_samples, n_components)
            Values of the hidden layer.
        size)r/   uniformshape)r#   r8   rngr9   s       r$   _sample_hiddenszBernoulliRBM._sample_hiddens   s2      q!!{{{((1,,r&   c                     t          j        || j                  }|| j        z  }t	          ||           |                    |j                  |k     S )a  Sample from the distribution P(v|h).

        Parameters
        ----------
        h : ndarray of shape (n_samples, n_components)
            Values of the hidden layer to sample from.

        rng : RandomState instance
            Random number generator to use.

        Returns
        -------
        v : ndarray of shape (n_samples, n_features)
            Values of the visible layer.
        r3   r;   )r,   dotr5   intercept_visible_r   r=   r>   )r#   hr?   r9   s       r$   _sample_visibleszBernoulliRBM._sample_visibles   sO      F1d&''	T$$aQ{{{((1,,r&   c                     t          || j                   t          j        dt          || j        j                  | j        z                                 d          z
  S )aF  Computes the free energy F(v) = - log sum_h exp(-E(v,h)).

        Parameters
        ----------
        v : ndarray of shape (n_samples, n_features)
            Values of the visible layer.

        Returns
        -------
        free_energy : ndarray of shape (n_samples,)
            The value of the free energy.
        r   r   axis)r   rC   r,   	logaddexpr5   r6   r7   sum)r#   r8   s     r$   _free_energyzBernoulliRBM._free_energy   sY      4#:;;;blq$"2"4558NN?
 ?

#1#++ 	r&   c                     t          |            t          | d          st          | j                  | _        |                     || j                  }|                     || j                  }|S )aT  Perform one Gibbs sampling step.

        Parameters
        ----------
        v : ndarray of shape (n_samples, n_features)
            Values of the visible layer to start from.

        Returns
        -------
        v_new : ndarray of shape (n_samples, n_features)
            Values of the visible layer after one Gibbs step.
        random_state_)r   hasattrr   r   rM   r@   rE   )r#   r8   h_v_s       r$   gibbszBernoulliRBM.gibbs   sm     	t_-- 	G!3D4E!F!FD!!!T%788""2t'9::	r&   T)prefer_skip_nested_validationc           	         t          | d           }t          | |dt          j        |          }t          | d          st	          | j                  | _        t          | d          s^t          j        | j                            dd| j	        |j
        d         f          d	          | _        | j        j
        d         | _        t          | d
          st          j        | j	                  | _        t          | d          s$t          j        |j
        d                   | _        t          | d          s%t          j        | j        | j	        f          | _        |                     || j                   dS )a  Fit the model to the partial segment of the data X.

        Parameters
        ----------
        X : ndarray of shape (n_samples, n_features)
            Training data.

        y : array-like of shape (n_samples,) or (n_samples, n_outputs), default=None
            Target values (None for unsupervised transformations).

        Returns
        -------
        self : BernoulliRBM
            The fitted model.
        r5   r(   )r)   r+   r*   rM   r   {Gz?r   F)orderr7   rC   
h_samples_N)rN   r   r,   r-   r   r   rM   asarraynormalr   r>   r5   _n_features_outzerosr7   rC   r   rW   _fit)r#   r0   y
first_passs       r$   partial_fitzBernoulliRBM.partial_fit  st   " !}555
!5
*
 
 
 t_-- 	G!3D4E!F!FDt]++ 	=!z"))!TD4Eqwqz3RSS     D $(#3#9!#<D t011 	%'X!& &D" t122 	&(h
' 'D# t\** 	M h9J'KLLDO		!T'(((((r&   c                 $   |                      |          }|                     | j        |          }|                      |          }t          | j                  |j        d         z  }t          |j        |d          j        }|t          j	        |j        |          z  }| xj
        ||z  z  c_
        | xj        ||                    d          |                    d          z
  z  z  c_        | xj        |t          j        |                    d                                                    |                    d          z
  z  z  c_        d||                    |j                  |k     <   t          j        ||          | _        dS )a  Inner fit for one mini-batch.

        Adjust the parameters to maximize the likelihood of v using
        Stochastic Maximum Likelihood (SML).

        Parameters
        ----------
        v_pos : ndarray of shape (n_samples, n_features)
            The data to use for training.

        rng : RandomState instance
            Random number generator to use for sampling.
        r   T)dense_outputrG   g      ?r;   N)r/   rE   rW   floatr   r>   r   r6   r,   rB   r5   r7   rJ   rC   rX   squeezer=   floor)r#   v_posr?   h_posv_negh_neglrupdates           r$   r\   zBernoulliRBM._fit:  sl    ""5))%%dos;;""5))4%&&Q7 %dCCCE"&%(((BK'"		q	(9(9EII1I<M<M(M"NN2Juyyay(())1133eiiQi6G6GG$
 	
 8;ckku{k++e34(5%00r&   c                 <   t          |            t          | |dd          }t          | j                  }t	          j        |j        d                   |                    d|j        d         |j        d                   f}t          j	        |          rd||         z  dz   }t          |t          j                  r8|t          j        |j                                        |f|j                  z   }nU|t          j        |                                |f|j                  z   }n"|                                }d||         z
  ||<   |                     |          }|                     |          }|j        d          t	          j        d||z
             z  S )a|  Compute the pseudo-likelihood of X.

        Parameters
        ----------
        X : {array-like, sparse matrix} of shape (n_samples, n_features)
            Values of the visible layer. Must be all-boolean (not checked).

        Returns
        -------
        pseudo_likelihood : ndarray of shape (n_samples,)
            Value of the pseudo-likelihood (proxy for likelihood).

        Notes
        -----
        This method is not deterministic: it computes a quantity called the
        free energy on X, then on a randomly corrupted version of X, and
        returns the log of the logistic function of the difference.
        r(   F)r)   r*   r   r   )r>   )r   r   r   r   r,   aranger>   randintspissparse
isinstancematrix
csr_matrixAravel	csr_arraycopyrK   rI   )	r#   r0   r8   r?   inddatarP   fefe_s	            r$   score_sampleszBernoulliRBM.score_samplesX  se   & 	$eDDD !233 y$$ckk!QWQZ&L&LM;q>> 	"#;?D$	** J'<AGLLLLtzz||S&9IIIIB"S'kBsGq!!##
{R\!sRx[9999r&   c           	         t          | |dt          j        t          j        f          }|j        d         }t          | j                  }t          j        |                    dd| j	        |j        d         f          d|j
                  | _        | j        j        d         | _        t          j        | j	        |j
                  | _        t          j        |j        d         |j
                  | _        t          j        | j        | j	        f|j
                  | _        t%          t          j        t)          |          | j        z                      }t+          t-          || j        z  ||	                    }| j        }t1          j                    }t3          d| j        dz             D ]}	|D ]}
|                     ||
         |           |ret1          j                    }t9          d
t;          |           j        |	|                     |                                           ||z
  fz             |}| S )a  Fit the model to the data X.

        Parameters
        ----------
        X : {array-like, sparse matrix} of shape (n_samples, n_features)
            Training data.

        y : array-like of shape (n_samples,) or (n_samples, n_outputs), default=None
            Target values (None for unsupervised transformations).

        Returns
        -------
        self : BernoulliRBM
            The fitted model.
        r(   )r)   r+   r   rT   r   rU   )rV   r+   )r+   )	n_samplesz9[%s] Iteration %d, pseudo-likelihood = %.2f, time = %.2fs)!r   r,   r-   r.   r>   r   r   rX   rY   r   r+   r5   rZ   r[   r7   rC   r   rW   intceilrb   listr   r   timeranger   r\   printtype__name__r|   mean)r#   r0   r]   r~   r?   	n_batchesbatch_slicesr   begin	iterationbatch_sliceends               r$   fitzBernoulliRBM.fit  s   " $rz2:>VWWWGAJ	 !233:JJq$!2AGAJ ?@@'
 
 

  $/5a8!#$*;17!K!K!K"$(171:QW"E"E"E(DOT5F#GqwWWWi 0 04? BCCDD	I7iXXX
 
 ,	q$+/22 	 	I+ / /		!K.#.... ikkOT

+!**1--2244e	   r&   c                 |    t                                                      }d|j        _        ddg|j        _        |S )NTr-   r.   )super__sklearn_tags__
input_tagssparsetransformer_tagspreserves_dtype)r#   tags	__class__s     r$   r   zBernoulliRBM.__sklearn_tags__  s7    ww''))!%1:I0F-r&   )r   r"   )r   
__module____qualname____doc__r   r   r   r   dict__annotations__r%   r1   r/   r@   rE   rK   rQ   r
   r_   r\   r|   r   r   __classcell__)r   s   @r$   r   r      s        g gT "(AtFCCCD"(4DCCCDx!T&AAAB8Haf===>;'($ $D    ) ) ) ) ) )"% % %(  "- - -&- - -*  "  * \555') ') ') 65')R1 1 1<': ': ':R \5555 5 5 655n        r&   r   )r   r   numbersr   r   numpyr,   scipy.sparser   ro   scipy.specialr   baser   r   r	   r
   utilsr   r   utils._param_validationr   utils.extmathr   utils.validationr   r   r    r&   r$   <module>r      s4   " "
  " " " " " " " "                            8 7 7 7 7 7 7 7 . . . . . . + + + + + + = = = = = = = =d d d d d24Dm d d d d dr&   