
    0PhF=                         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
mZ ddlmZmZmZmZ ddlmZ dd	lmZ dd
lmZmZmZ ddlmZ ddlmZmZ ddlmZ ddl m!Z!  G d deee          Z"dS )zIsomap for manifold learning    N)IntegralReal)issparse)connected_componentsshortest_path   )BaseEstimatorClassNamePrefixFeaturesOutMixinTransformerMixin_fit_context)	KernelPCA)_VALID_METRICS)NearestNeighborskneighbors_graphradius_neighbors_graph)KernelCenterer)Interval
StrOptions)_fix_connected_components)check_is_fittedc                       e Zd ZU dZ eeddd          dg eeddd          dg eeddd          g eh d          g eeddd          g eeddd          dg eh d	          g eh d
          gedg eeddd          g e ee	          dhz            e
gedgdZeed<   ddddddddddddddZd Zd Z ed          dd            Z ed          dd            Zd Z fdZ xZS )Isomapa  Isomap Embedding.

    Non-linear dimensionality reduction through Isometric Mapping

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

    Parameters
    ----------
    n_neighbors : int or None, default=5
        Number of neighbors to consider for each point. If `n_neighbors` is an int,
        then `radius` must be `None`.

    radius : float or None, default=None
        Limiting distance of neighbors to return. If `radius` is a float,
        then `n_neighbors` must be set to `None`.

        .. versionadded:: 1.1

    n_components : int, default=2
        Number of coordinates for the manifold.

    eigen_solver : {'auto', 'arpack', 'dense'}, default='auto'
        'auto' : Attempt to choose the most efficient solver
        for the given problem.

        'arpack' : Use Arnoldi decomposition to find the eigenvalues
        and eigenvectors.

        'dense' : Use a direct solver (i.e. LAPACK)
        for the eigenvalue decomposition.

    tol : float, default=0
        Convergence tolerance passed to arpack or lobpcg.
        not used if eigen_solver == 'dense'.

    max_iter : int, default=None
        Maximum number of iterations for the arpack solver.
        not used if eigen_solver == 'dense'.

    path_method : {'auto', 'FW', 'D'}, default='auto'
        Method to use in finding shortest path.

        'auto' : attempt to choose the best algorithm automatically.

        'FW' : Floyd-Warshall algorithm.

        'D' : Dijkstra's algorithm.

    neighbors_algorithm : {'auto', 'brute', 'kd_tree', 'ball_tree'},                           default='auto'
        Algorithm to use for nearest neighbors search,
        passed to neighbors.NearestNeighbors instance.

    n_jobs : int or None, default=None
        The number of parallel jobs to run.
        ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
        ``-1`` means using all processors. See :term:`Glossary <n_jobs>`
        for more details.

    metric : str, or callable, default="minkowski"
        The metric to use when calculating distance between instances in a
        feature array. If metric is a string or callable, it must be one of
        the options allowed by :func:`sklearn.metrics.pairwise_distances` for
        its metric parameter.
        If metric is "precomputed", X is assumed to be a distance matrix and
        must be square. X may be a :term:`Glossary <sparse graph>`.

        .. versionadded:: 0.22

    p : float, default=2
        Parameter for the Minkowski metric from
        sklearn.metrics.pairwise.pairwise_distances. When p = 1, this is
        equivalent to using manhattan_distance (l1), and euclidean_distance
        (l2) for p = 2. For arbitrary p, minkowski_distance (l_p) is used.

        .. versionadded:: 0.22

    metric_params : dict, default=None
        Additional keyword arguments for the metric function.

        .. versionadded:: 0.22

    Attributes
    ----------
    embedding_ : array-like, shape (n_samples, n_components)
        Stores the embedding vectors.

    kernel_pca_ : object
        :class:`~sklearn.decomposition.KernelPCA` object used to implement the
        embedding.

    nbrs_ : sklearn.neighbors.NearestNeighbors instance
        Stores nearest neighbors instance, including BallTree or KDtree
        if applicable.

    dist_matrix_ : array-like, shape (n_samples, n_samples)
        Stores the geodesic distance matrix of training data.

    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.decomposition.PCA : Principal component analysis that is a linear
        dimensionality reduction method.
    sklearn.decomposition.KernelPCA : Non-linear dimensionality reduction using
        kernels and PCA.
    MDS : Manifold learning using multidimensional scaling.
    TSNE : T-distributed Stochastic Neighbor Embedding.
    LocallyLinearEmbedding : Manifold learning using Locally Linear Embedding.
    SpectralEmbedding : Spectral embedding for non-linear dimensionality.

    References
    ----------

    .. [1] Tenenbaum, J.B.; De Silva, V.; & Langford, J.C. A global geometric
           framework for nonlinear dimensionality reduction. Science 290 (5500)

    Examples
    --------
    >>> from sklearn.datasets import load_digits
    >>> from sklearn.manifold import Isomap
    >>> X, _ = load_digits(return_X_y=True)
    >>> X.shape
    (1797, 64)
    >>> embedding = Isomap(n_components=2)
    >>> X_transformed = embedding.fit_transform(X[:100])
    >>> X_transformed.shape
    (100, 2)
       Nleft)closedr   both>   autodensearpack>   DFWr   >   r   brutekd_tree	ball_treeprecomputed)n_neighborsradiusn_componentseigen_solvertolmax_iterpath_methodneighbors_algorithmn_jobspmetricmetric_params_parameter_constraints   r   r   	minkowskir&   r'   r(   r)   r*   r+   r,   r-   r.   r0   r/   r1   c                    || _         || _        || _        || _        || _        || _        || _        || _        |	| _        |
| _	        || _
        || _        d S Nr5   )selfr&   r'   r(   r)   r*   r+   r,   r-   r.   r0   r/   r1   s                X/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/sklearn/manifold/_isomap.py__init__zIsomap.__init__   sd      '(( &#6 *    c           
      ^   | j         | j        t          d| j         d          t          | j         | j        | j        | j        | j        | j        | j                  | _	        | j	        
                    |           | j	        j        | _        t          | j	        d          r| j	        j        | _        t          | j        d| j        | j        | j        | j                                      d          | _        | j         5t+          | j	        | j         | j        | j        | j        d	| j        
          }n4t-          | j	        | j        | j        | j        | j        d	| j                  }t/          |          \  }}|dk    rx| j        dk    r"t1          |          rt3          d| d          t5          j        d| dd           t9          d| j	        j        |||d	| j	        j        d| j	        j        }tA          || j!        d          | _"        | j	        j        j#        tH          j%        k    r0| j"        &                    | j	        j        j#        d          | _"        | j"        dz  }|dz  }| j        '                    |          | _(        | j(        j)        d         | _*        d S )Nz<Both n_neighbors and radius are provided. Use Isomap(radius=z=, n_neighbors=None) if intended to use radius-based neighbors)r&   r'   	algorithmr0   r/   r1   r.   feature_names_in_r%   )r(   kernelr)   r*   r+   r.   default)	transformdistance)r0   r/   r1   moder.   )r'   r0   r/   r1   rC   r.   r   z=The number of connected components of the neighbors graph is z > 1. The graph cannot be completed with metric='precomputed', and Isomap cannot befitted. Increase the number of neighbors to avoid this issue, or precompute the full distance matrix instead of passing a sparse neighbors graph.zm > 1. Completing the graph to fit Isomap might be slow. Increase the number of neighbors to avoid this issue.r   )
stacklevel)Xgraphn_connected_componentscomponent_labelsrC   r0   F)methoddirected)copy      ࿩ )+r&   r'   
ValueErrorr   r-   r0   r/   r1   r.   nbrs_fitn_features_in_hasattrr>   r   r(   r)   r*   r+   
set_outputkernel_pca_r   r   r   r   RuntimeErrorwarningswarnr   _fit_Xeffective_metric_effective_metric_params_r   r,   dist_matrix_dtypenpfloat32astypefit_transform
embedding_shape_n_features_out)r8   rE   nbgrG   labelsGs         r9   _fit_transformzIsomap._fit_transform   s   'DK,C*"&+* * *   &(;.;f,;
 
 

 	
q"j74:233 	B%)Z%AD"$* *];
 
 
 *y*
)
) 	 '"
 {&"0{  CC )
{{&"0{  C *>c)B)B&!A%%{m+++";1; ; ;   M(0( ( (
     , *#'=!'z3  *5 C *#d6FQVWWW:"bj00 $ 1 8 8
!'e !9 ! !D q 	T	*88;;#4Q7r;   c                    d| j         dz  z  }t                                          |          }| j        j        }t          j        t          j        |dz            t          j        |dz            z
            |j        d         z  S )a(  Compute the reconstruction error for the embedding.

        Returns
        -------
        reconstruction_error : float
            Reconstruction error.

        Notes
        -----
        The cost function of an isomap embedding is

        ``E = frobenius_norm[K(D) - K(D_fit)] / n_samples``

        Where D is the matrix of distances for the input data X,
        D_fit is the matrix of distances for the output embedding X_fit,
        and K is the isomap kernel:

        ``K(D) = -0.5 * (I - 1/n_samples) * D^2 * (I - 1/n_samples)``
        rL   r   r   )	r[   r   r`   rT   eigenvalues_r]   sqrtsumrb   )r8   rf   G_centerevalss       r9   reconstruction_errorzIsomap.reconstruction_error9  sv    ( 4$a''!##11!44 -wrvhk**RVE1H-=-==>>KKr;   F)prefer_skip_nested_validationc                 0    |                      |           | S )a  Compute the embedding vectors for data X.

        Parameters
        ----------
        X : {array-like, sparse matrix, BallTree, KDTree, NearestNeighbors}
            Sample data, shape = (n_samples, n_features), in the form of a
            numpy array, sparse matrix, precomputed tree, or NearestNeighbors
            object.

        y : Ignored
            Not used, present for API consistency by convention.

        Returns
        -------
        self : object
            Returns a fitted instance of self.
        )rg   r8   rE   ys      r9   rP   z
Isomap.fitR  s    , 	Ar;   c                 :    |                      |           | j        S )a  Fit the model from data in X and transform X.

        Parameters
        ----------
        X : {array-like, sparse matrix, BallTree, KDTree}
            Training vector, where `n_samples` is the number of samples
            and `n_features` is the number of features.

        y : Ignored
            Not used, present for API consistency by convention.

        Returns
        -------
        X_new : array-like, shape (n_samples, n_components)
            X transformed in the new space.
        )rg   ra   rq   s      r9   r`   zIsomap.fit_transformk  s     * 	Ar;   c                 l   t          |            | j         | j                            |d          \  }}n| j                            |d          \  }}| j        j        }|j        d         }t          |d          r"|j        t          j
        k    rt          j
        }nt          j        }t          j        ||f|          }t          |          D ]>}t          j        | j        ||                  ||         dddf         z   d          ||<   ?|dz  }|dz  }| j                            |          S )a  Transform X.

        This is implemented by linking the points X into the graph of geodesic
        distances of the training data. First the `n_neighbors` nearest
        neighbors of X are found in the training data, and from these the
        shortest geodesic distances from each point in X to each point in
        the training data are computed in order to construct the kernel.
        The embedding of X is the projection of this kernel onto the
        embedding vectors of the training set.

        Parameters
        ----------
        X : {array-like, sparse matrix}, shape (n_queries, n_features)
            If neighbors_algorithm='precomputed', X is assumed to be a
            distance matrix or a sparse graph of shape
            (n_queries, n_samples_fit).

        Returns
        -------
        X_new : array-like, shape (n_queries, n_components)
            X transformed in the new space.
        NT)return_distancer   r\   r   rL   )r   r&   rO   
kneighborsradius_neighborsn_samples_fit_rb   rR   r\   r]   r^   float64zerosrangeminr[   rT   rA   )	r8   rE   	distancesindicesn_samples_fit	n_queriesr\   G_Xis	            r9   rA   zIsomap.transform  s6   . 	'!%!6!6q$!6!O!OIww!%!<!<QPT!<!U!UIw 
1OA&	1g 	17bj#8#8JEEJEh	=1599y!! 	V 	VAVD-gaj9IaLD<QQSTUUCFF	t))#...r;   c                 |    t                                                      }ddg|j        _        d|j        _        |S )Nry   r^   T)super__sklearn_tags__transformer_tagspreserves_dtype
input_tagssparse)r8   tags	__class__s     r9   r   zIsomap.__sklearn_tags__  s7    ww''))1:I0F-!%r;   r7   )__name__
__module____qualname____doc__r   r   r   r   setr   callabledictr2   __annotations__r:   rg   rn   r   rP   r`   rA   r   __classcell__)r   s   @r9   r   r      s\        I IX !1d6BBBDI8D!T&9994@!(AtFCCCD#$?$?$?@@Aq$v6667Xh4???F"
#6#6#6778 *
+T+T+T U UVT"htQV4445:cc.11]OCDDhO$ $D   $ "
+ + + + +:c8 c8 c8JL L L2 \&+    	 * \&+    	 (1/ 1/ 1/f        r;   r   )#r   rV   numbersr   r   numpyr]   scipy.sparser   scipy.sparse.csgraphr   r   baser	   r
   r   r   decompositionr   metrics.pairwiser   	neighborsr   r   r   preprocessingr   utils._param_validationr   r   utils.graphr   utils.validationr   r   rM   r;   r9   <module>r      sv   " "
  " " " " " " " "     ! ! ! ! ! ! D D D D D D D D            & % % % % % - - - - - - R R R R R R R R R R * * * * * * : : : : : : : : 3 3 3 3 3 3 . . . . . .^ ^ ^ ^ ^,.> ^ ^ ^ ^ ^r;   