
    Q3j=                         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! ddl"m#Z#  G d deee      Z$y)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)_ensure_sparse_index_int32)_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   	minkowskir&   r'   r(   r)   r*   r+   r,   r-   r.   r0   r/   r1   c                    || _         || _        || _        || _        || _        || _        || _        || _        |	| _        |
| _	        || _
        || _        y Nr6   )selfr&   r'   r(   r)   r*   r+   r,   r-   r.   r0   r/   r1   s                E/DATA/.local/lib/python3.12/site-packages/sklearn/manifold/_isomap.py__init__zIsomap.__init__   s^      '(( &#6 *    c           
         | j                   %| j                  t        d| j                   d      t        | j                   | j                  | j                  | j
                  | j                  | j                  | j                        | _	        | j                  j                  |       | j                  j                  | _        t        | j                  d      r| j                  j                  | _        t        | j                  d| j                   | j"                  | j$                  | j                        j'                  d      | _        | j                   Ot+        | j                  | j                   | j
                  | j                  | j                  d	| j                  
      }nNt-        | j                  | j                  | j
                  | j                  | j                  d	| j                        }t/        |      \  }}|dkD  r| j
                  dk(  rt1        |      rt3        d| d      t5        j6                  d| dd       t9        d| j                  j:                  |||d	| j                  j<                  d| j                  j>                  }tA        |       tC        || jD                  d      | _#        | j                  j:                  jH                  tJ        jL                  k(  r@| jF                  jO                  | j                  j:                  jH                  d      | _#        | jF                  dz  }|dz  }| j(                  jQ                  |      | _)        | jR                  jT                  d   | _+        y )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   rD   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.r4   )
stacklevel)Xgraphn_connected_componentscomponent_labelsrD   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   r,   dist_matrix_dtypenpfloat32astypefit_transform
embedding_shape_n_features_out)r9   rF   nbgrH   labelsGs         r:   _fit_transformzIsomap._fit_transform   s   'DKK,C""&++ /**  &((;;..;;ff,,;;

 	

q"jj774::23%)ZZ%A%AD"$** **]];;
 *y*
) 	 '"

  {{&&"00{{C )

{{{{&&"00{{C *>c)B&!A%{{m+"12 3;;  MM01 2((
  , **##'=!'zz33 **55C 	#3')#d6F6FQVW::""bjj0 $ 1 1 8 8

!!''e !9 !D q 	T	**88;#44Q7r<   c                 ,   d| j                   dz  z  }t               j                  |      }| 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)``
        rM   r4   r   )	r\   r   ra   rU   eigenvalues_r^   sqrtsumrc   )r9   rg   G_centerevalss       r:   reconstruction_errorzIsomap.reconstruction_error;  sx    ( 4$$a''!#11!4  --wwrvvhk*RVVE1H-==>KKr<   F)prefer_skip_nested_validationc                 (    | j                  |       | 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.
        )rh   r9   rF   ys      r:   rQ   z
Isomap.fitT  s    , 	Ar<   c                 <    | j                  |       | 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.
        )rh   rb   rr   s      r:   ra   zIsomap.fit_transformm  s    * 	Ar<   c                    t        |        | j                  !| j                  j                  |d      \  }}n | j                  j	                  |d      \  }}| j                  j
                  }|j                  d   }t        |d      r.|j                  t        j                  k(  rt        j                  }nt        j                  }t        j                  ||f|      }t        |      D ]8  }t        j                  | j                  ||      ||   dddf   z   d      ||<   : |dz  }|dz  }| j                   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]   r4   rM   )r   r&   rP   
kneighborsradius_neighborsn_samples_fit_rc   rS   r]   r^   r_   float64zerosrangeminr\   rU   rB   )	r9   rF   	distancesindicesn_samples_fit	n_queriesr]   G_Xis	            r:   rB   zIsomap.transform  s$   . 	'!%!6!6q$!6!OIw!%!<!<QPT!<!UIw 

11OOA&	1g177bjj#8JJEJJEhh	=159y!AVVD--gaj9IaLD<QQSTUCF " 		t))#..r<   c                 l    t         |          }ddg|j                  _        d|j                  _        |S )Nrz   r_   T)super__sklearn_tags__transformer_tagspreserves_dtype
input_tagssparse)r9   tags	__class__s     r:   r   zIsomap.__sklearn_tags__  s4    w')1:I0F-!%r<   r8   )__name__
__module____qualname____doc__r   r   r   r   setr   callabledictr2   __annotations__r;   rh   ro   r   rQ   ra   rB   r   __classcell__)r   s   @r:   r   r      sS   IX !1d6BDID!T&94@!(AtFCD#$?@Aq$v67h4?F"#678 *+T UVT"tQV45c.1]OCDhO$D $ "
+:d8LL2 &+	* &+	(1/f r<   r   )%r   rW   numbersr   r   numpyr^   scipy.sparser   scipy.sparse.csgraphr   r   sklearn.baser   r	   r
   r   sklearn.decompositionr   sklearn.metrics.pairwiser   sklearn.neighborsr   r   r   sklearn.preprocessingr   sklearn.utils._param_validationr   r   sklearn.utils.fixesr   sklearn.utils.graphr   sklearn.utils.validationr   r   rN   r<   r:   <module>r      sT    "
  "  ! D  , 3 X X 0 @ : 9 4_,.> _r<   