Ë
    ÷Q(hF=  ã                   óÖ   — 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"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)Ú_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                ó¬   — || _         || _        || _        || _        || _        || _        || _        || _        |	| _        |
| _	        || _
        || _        y ©Nr5   )Úselfr&   r'   r(   r)   r*   r+   r,   r-   r.   r0   r/   r1   s                úV/var/www/skyplay_api_hub/venv/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        || jB                  d¬«      | _"        | j                  j:                  jF                  tH        jJ                  k(  r@| jD                  jM                  | j                  j:                  jF                  d¬«      | _"        | jD                  dz  }|dz  }| j(                  jO                  |«      | _(        | jP                  jR                  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   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  € Ø×ÑÐ'¨D¯K©KÐ,CÜð"Ø"&§+¡+ ð /*ð*óð ô &Ø×(Ñ(Ø—;‘;Ø×.Ñ.Ø—;‘;Ø�f‰fØ×,Ñ,Ø—;‘;ô
ˆŒ
ð 	�
‰
�‰�qÔØ"Ÿj™j×7Ñ7ˆÔÜ�4—:‘:Ð2Ô3Ø%)§Z¡Z×%AÑ%AˆDÔ"ä$Ø×*Ñ*Ø Ø×*Ñ*Ø—‘Ø—]‘]Ø—;‘;ô
÷ ‰*˜yˆ*Ó
)ð 	Ôð ×ÑÐ'Ü"Ø—
‘
Ø× Ñ Ø—{‘{Ø—&‘&Ø"×0Ñ0ØØ—{‘{ô‰Cô )Ø—
‘
Ø—{‘{Ø—{‘{Ø—&‘&Ø"×0Ñ0ØØ—{‘{ôˆCô *>¸cÓ)BÑ&Ð Ø! AÒ%Ø�{‰{˜mÒ+´¸´Ü"ðØ1Ð2ð 3;ð;óð ô �M‰MðØ0Ð1ð 2(ð(ð
 õô ,ð Ø—*‘*×#Ñ#ØØ'=Ø!'ØØ—z‘z×3Ñ3ñð —*‘*×5Ñ5ñˆCô *¨#°d×6FÑ6FÐQVÔWˆÔà�:‰:×Ñ×"Ñ"¤b§j¡jÒ0Ø $× 1Ñ 1× 8Ñ 8Ø—
‘
×!Ñ!×'Ñ'¨eð !9ó !ˆDÔð ×Ñ˜qÑ ˆØ	ˆT‰	ˆà×*Ñ*×8Ñ8¸Ó;ˆŒØ#Ÿ™×4Ñ4°QÑ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)``
        rL   r   r   )	r[   r   r`   rT   Úeigenvalues_r]   ÚsqrtÚsumrb   )r8   rf   ÚG_centerÚevalss       r9   Úreconstruction_errorzIsomap.reconstruction_error9  sx   € ð( �4×$Ñ$ aÑ'Ñ'ˆÜ!Ó#×1Ñ1°!Ó4ˆØ× Ñ ×-Ñ-ˆÜ�w‰w”r—v‘v˜h¨™kÓ*¬R¯V©V°E¸1±HÓ-=Ñ=Ó>ÀÇÁÈÁÑ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.
        )rg   ©r8   rE   Úys      r9   rP   z
Isomap.fitR  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.
        )rg   ra   rq   s      r9   r`   zIsomap.fit_transformk  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\   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ƒ  s+  € ô. 	˜ÔØ×ÑÐ'Ø!%§¡×!6Ñ!6°qÈ$Ð!6Ó!OÑˆI‘wà!%§¡×!<Ñ!<¸QÐPTÐ!<Ó!UÑˆI�wð Ÿ
™
×1Ñ1ˆØ—O‘O AÑ&ˆ	ä�1�gÔ 1§7¡7¬b¯j©jÒ#8Ü—J‘J‰Eä—J‘JˆEä�h‰h˜	 =Ð1°5Ó9ˆÜ�yÓ!ò 	VˆAÜ—V‘V˜D×-Ñ-¨g°a©jÑ9¸IÀa¹LÊÈDÈÑ<QÑQÐSTÓUˆC�ŠFð	Vð 	�‰	ˆØˆt‰ˆà×Ñ×)Ñ)¨#Ó.Ð.r;   c                 ól   •— 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__¶  s4   ø€ Ü‰wÑ'Ó)ˆØ1:¸IÐ0Fˆ×ÑÔ-Ø!%ˆ�‰ÔØˆ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      sS  ø… ñIñX ! ¨1¨d¸6ÔBÀDÐIÙ˜D ! T°&Ô9¸4Ð@Ù! (¨A¨t¸FÔCÐDÙ#Ò$?Ó@ÐAÙ˜˜q $¨vÔ6Ð7Ù˜h¨¨4¸Ô?ÀÐFÙ"Ò#6Ó7Ð8Ù *Ò+TÓ UÐVØ˜TÐ"Ù�t˜Q ¨VÔ4Ð5Ù™c .Ó1°]°OÑCÓDÀhÐOØ ˜ñ$Ð˜Dó ð$ ØØØØØØØ"ØØØ
Øô+ò:c8òJLñ2 à&+ôòó	ðñ* à&+ôòó	ðò(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¡      sQ   ðÙ "ó
 ß "ã Ý !ß D÷ó õ &Ý -ß RÑ RÝ *ß :Ý 3Ý .ô^Ð,Ð.>Àõ ^r;   