← Back
Editing: _qap.cpython-311.pyc
� d�c l � � � d dl Zd dlZddlmZmZ ddlmZ d dlm Z d dl Z ddgZ dd�Z d � Z d � Z dd�Zd� Zdd�Z dd�ZdS )� N� )�linear_sum_assignment�OptimizeResult)�_check_unknown_options)�check_random_state�faq�2optc � � |�i }|� � � }t t d�}||vrt d|� d|� d�� � � || | |fi |��}|S )ay Approximates solution to the quadratic assignment problem and the graph matching problem. Quadratic assignment solves problems of the following form: .. math:: \min_P & \ {\ \text{trace}(A^T P B P^T)}\\ \mbox{s.t. } & {P \ \epsilon \ \mathcal{P}}\\ where :math:`\mathcal{P}` is the set of all permutation matrices, and :math:`A` and :math:`B` are square matrices. Graph matching tries to *maximize* the same objective function. This algorithm can be thought of as finding the alignment of the nodes of two graphs that minimizes the number of induced edge disagreements, or, in the case of weighted graphs, the sum of squared edge weight differences. Note that the quadratic assignment problem is NP-hard. The results given here are approximations and are not guaranteed to be optimal. Parameters ---------- A : 2-D array, square The square matrix :math:`A` in the objective function above. B : 2-D array, square The square matrix :math:`B` in the objective function above. method : str in {'faq', '2opt'} (default: 'faq') The algorithm used to solve the problem. :ref:`'faq' <optimize.qap-faq>` (default) and :ref:`'2opt' <optimize.qap-2opt>` are available. options : dict, optional A dictionary of solver options. All solvers support the following: maximize : bool (default: False) Maximizes the objective function if ``True``. partial_match : 2-D array of integers, optional (default: None) Fixes part of the matching. Also known as a "seed" [2]_. Each row of `partial_match` specifies a pair of matched nodes: node ``partial_match[i, 0]`` of `A` is matched to node ``partial_match[i, 1]`` of `B`. The array has shape ``(m, 2)``, where ``m`` is not greater than the number of nodes, :math:`n`. rng : {None, int, `numpy.random.Generator`, `numpy.random.RandomState`}, optional If `seed` is None (or `np.random`), the `numpy.random.RandomState` singleton is used. If `seed` is an int, a new ``RandomState`` instance is used, seeded with `seed`. If `seed` is already a ``Generator`` or ``RandomState`` instance then that instance is used. For method-specific options, see :func:`show_options('quadratic_assignment') <show_options>`. Returns ------- res : OptimizeResult `OptimizeResult` containing the following fields. col_ind : 1-D array Column indices corresponding to the best permutation found of the nodes of `B`. fun : float The objective value of the solution. nit : int The number of iterations performed during optimization. Notes ----- The default method :ref:`'faq' <optimize.qap-faq>` uses the Fast Approximate QAP algorithm [1]_; it typically offers the best combination of speed and accuracy. Method :ref:`'2opt' <optimize.qap-2opt>` can be computationally expensive, but may be a useful alternative, or it can be used to refine the solution returned by another method. References ---------- .. [1] J.T. Vogelstein, J.M. Conroy, V. Lyzinski, L.J. Podrazik, S.G. Kratzer, E.T. Harley, D.E. Fishkind, R.J. Vogelstein, and C.E. Priebe, "Fast approximate quadratic programming for graph matching," PLOS one, vol. 10, no. 4, p. e0121002, 2015, :doi:`10.1371/journal.pone.0121002` .. [2] D. Fishkind, S. Adali, H. Patsolic, L. Meng, D. Singh, V. Lyzinski, C. Priebe, "Seeded graph matching", Pattern Recognit. 87 (2019): 203-215, :doi:`10.1016/j.patcog.2018.09.014` .. [3] "2-opt," Wikipedia. https://en.wikipedia.org/wiki/2-opt Examples -------- >>> import numpy as np >>> from scipy.optimize import quadratic_assignment >>> A = np.array([[0, 80, 150, 170], [80, 0, 130, 100], ... [150, 130, 0, 120], [170, 100, 120, 0]]) >>> B = np.array([[0, 5, 2, 7], [0, 0, 3, 8], ... [0, 0, 0, 3], [0, 0, 0, 0]]) >>> res = quadratic_assignment(A, B) >>> print(res) fun: 3260 col_ind: [0 3 2 1] nit: 9 The see the relationship between the returned ``col_ind`` and ``fun``, use ``col_ind`` to form the best permutation matrix found, then evaluate the objective function :math:`f(P) = trace(A^T P B P^T )`. >>> perm = res['col_ind'] >>> P = np.eye(len(A), dtype=int)[perm] >>> fun = np.trace(A.T @ P @ B @ P.T) >>> print(fun) 3260 Alternatively, to avoid constructing the permutation matrix explicitly, directly permute the rows and columns of the distance matrix. >>> fun = np.trace(A.T @ B[perm][:, perm]) >>> print(fun) 3260 Although not guaranteed in general, ``quadratic_assignment`` happens to have found the globally optimal solution. >>> from itertools import permutations >>> perm_opt, fun_opt = None, np.inf >>> for perm in permutations([0, 1, 2, 3]): ... perm = np.array(perm) ... fun = np.trace(A.T @ B[perm][:, perm]) ... if fun < fun_opt: ... fun_opt, perm_opt = fun, perm >>> print(np.array_equal(perm_opt, res['col_ind'])) True Here is an example for which the default method, :ref:`'faq' <optimize.qap-faq>`, does not find the global optimum. >>> A = np.array([[0, 5, 8, 6], [5, 0, 5, 1], ... [8, 5, 0, 2], [6, 1, 2, 0]]) >>> B = np.array([[0, 1, 8, 4], [1, 0, 5, 2], ... [8, 5, 0, 5], [4, 2, 5, 0]]) >>> res = quadratic_assignment(A, B) >>> print(res) fun: 178 col_ind: [1 0 3 2] nit: 13 If accuracy is important, consider using :ref:`'2opt' <optimize.qap-2opt>` to refine the solution. >>> guess = np.array([np.arange(len(A)), res.col_ind]).T >>> res = quadratic_assignment(A, B, method="2opt", ... options = {'partial_guess': guess}) >>> print(res) fun: 176 col_ind: [1 2 3 0] nit: 17 N)r r zmethod z must be in �.)�lower�_quadratic_assignment_faq�_quadratic_assignment_2opt� ValueError)�A�B�method�options�methods�ress �5/usr/lib/python3/dist-packages/scipy/optimize/_qap.py�quadratic_assignmentr s} � �X ���� �\�\�^�^�F�/�1�3� 3�G� �W� � ��A�6�A�A�w�A�A�A�B�B�B� �'�&�/�!�Q� *� *�'� *� *�C� �J� c �P � t j | || d d �|f z � � S �N)�np�sum)r r �perms r � _calc_scorer � s( � � �6�!�a��g�a�a�a��g�&�&� '� '�'r c � � t j | � � } t j |� � }|�t j g g g� � j }t j |� � � t � � }d }| j d | j d k rd}�nV|j d |j d k rd}�n6| j dk s |j dk rd}�n | j |j k rd}�n|j d | j d k rd}n�|j d dk rd }n�|j dk rd }n�|dk � � � rd }n�|t | � � k � � � rd }n�t t |d d �df � � � � t |d d �df � � k rAt t |d d �df � � � � t |d d �df � � k sd }|�t |� � �| ||fS )Nr r z`A` must be squarez`B` must be square� z,`A` and `B` must have exactly two dimensionsz*`A` and `B` matrices must be of equal sizez>`partial_match` can have only as many seeds as there are nodesz%`partial_match` must have two columnsz0`partial_match` must have exactly two dimensionsz2`partial_match` must contain only positive indicesz9`partial_match` entries must be less than number of nodesz-`partial_match` column entries must be unique) r � atleast_2d�array�T�astype�int�shape�ndim�any�len�setr )r r � partial_match�msgs r �_common_input_validationr- � s� � � � �a���A� � �a���A�� ���"�b��*�*�,� ��M�-�0�0�7�7��<�<�M� �C��w�q�z�Q�W�Q�Z� � �"��� ����q�w�q�z� !� !�"��� ��1�����!� � �<��� ��A�G� � �:��� � �Q� �!�'�!�*� ,� ,�N��� � �Q� �1� $� $�5��� � �q� � �@��� �!� � � � "� "� >�B��� �3�q�6�6� !� &� &� (� (� >�I����#�m�A�A�A�q�D�)�*�*�+�+�s�=����A��3F�/G�/G�G�G��#�m�A�A�A�q�D�)�*�*�+�+�s�=����A��3F�/G�/G�G�G�=�� ����o�o� � �a� � � r F� barycenter� � ��Q��?c �� � t | � � t j |� � }t | ||� � \ } }}d} t |t � � r|dvrd} n|dk rd} n|dk rd} | �t | � � �t |� � }t | � � } t |� � } | | z } t |t � � s�t j |� � }|j | | fk rd} nl|dk � � � sRt j t j |d�� � d � � r)t j t j |d �� � d � � sd } | �t | � � �nl|d k rt j | | f� � | z }nL|d k rFt j | | f� � | z }t! |� | | f� � � � � }||z dz }| dk s| | k r:t% | ||dd�d f � � }|dd�d f |dd�}t' |� � S d }|rd}t j t+ | � � |dd�d f � � }|r|� |� � }t j t+ | � � |dd�df � � }t j |dd�df |g� � }t j |dd�d f |g� � }t1 | | dd�|f | � � \ }}}}t1 || dd�|f | � � \ }} } } || j z |j | z z } |} t+ d |d z � � D �]�}!| || z | j z z |j | z | z z }"t5 |"|�� � \ }#}$t j | � � |$ }%| |%z }&|&j |z | z � � � }'|&j |j z | j z � � � }(|j |&z })| |&j z }*|)| j |$ z � � � }+||*|$ z � � � },|)j |*z � � � }-|'|(z |+z |,z }.|-|z dk r!d|. d|-z z cxk rd k r n n |. d|-z z }/n t j d|.|-z |z g� � }/|/| z d |/z |%z z }0t j � | |0z � � t j | � � z |k r|0} n|0} ���t5 | d�� � \ }#}1t j t j | � � |1| z f� � }2t j! | tD �� � }3||2 |3|< t% | ||3� � }|3||!d�}t' |� � S )a� Solve the quadratic assignment problem (approximately). This function solves the Quadratic Assignment Problem (QAP) and the Graph Matching Problem (GMP) using the Fast Approximate QAP Algorithm (FAQ) [1]_. Quadratic assignment solves problems of the following form: .. math:: \min_P & \ {\ \text{trace}(A^T P B P^T)}\\ \mbox{s.t. } & {P \ \epsilon \ \mathcal{P}}\\ where :math:`\mathcal{P}` is the set of all permutation matrices, and :math:`A` and :math:`B` are square matrices. Graph matching tries to *maximize* the same objective function. This algorithm can be thought of as finding the alignment of the nodes of two graphs that minimizes the number of induced edge disagreements, or, in the case of weighted graphs, the sum of squared edge weight differences. Note that the quadratic assignment problem is NP-hard. The results given here are approximations and are not guaranteed to be optimal. Parameters ---------- A : 2-D array, square The square matrix :math:`A` in the objective function above. B : 2-D array, square The square matrix :math:`B` in the objective function above. method : str in {'faq', '2opt'} (default: 'faq') The algorithm used to solve the problem. This is the method-specific documentation for 'faq'. :ref:`'2opt' <optimize.qap-2opt>` is also available. Options ------- maximize : bool (default: False) Maximizes the objective function if ``True``. partial_match : 2-D array of integers, optional (default: None) Fixes part of the matching. Also known as a "seed" [2]_. Each row of `partial_match` specifies a pair of matched nodes: node ``partial_match[i, 0]`` of `A` is matched to node ``partial_match[i, 1]`` of `B`. The array has shape ``(m, 2)``, where ``m`` is not greater than the number of nodes, :math:`n`. rng : {None, int, `numpy.random.Generator`, `numpy.random.RandomState`}, optional If `seed` is None (or `np.random`), the `numpy.random.RandomState` singleton is used. If `seed` is an int, a new ``RandomState`` instance is used, seeded with `seed`. If `seed` is already a ``Generator`` or ``RandomState`` instance then that instance is used. P0 : 2-D array, "barycenter", or "randomized" (default: "barycenter") Initial position. Must be a doubly-stochastic matrix [3]_. If the initial position is an array, it must be a doubly stochastic matrix of size :math:`m' \times m'` where :math:`m' = n - m`. If ``"barycenter"`` (default), the initial position is the barycenter of the Birkhoff polytope (the space of doubly stochastic matrices). This is a :math:`m' \times m'` matrix with all entries equal to :math:`1 / m'`. If ``"randomized"`` the initial search position is :math:`P_0 = (J + K) / 2`, where :math:`J` is the barycenter and :math:`K` is a random doubly stochastic matrix. shuffle_input : bool (default: False) Set to `True` to resolve degenerate gradients randomly. For non-degenerate gradients this option has no effect. maxiter : int, positive (default: 30) Integer specifying the max number of Frank-Wolfe iterations performed. tol : float (default: 0.03) Tolerance for termination. Frank-Wolfe iteration terminates when :math:`\frac{||P_{i}-P_{i+1}||_F}{\sqrt{m')}} \leq tol`, where :math:`i` is the iteration number. Returns ------- res : OptimizeResult `OptimizeResult` containing the following fields. col_ind : 1-D array Column indices corresponding to the best permutation found of the nodes of `B`. fun : float The objective value of the solution. nit : int The number of Frank-Wolfe iterations performed. Notes ----- The algorithm may be sensitive to the initial permutation matrix (or search "position") due to the possibility of several local minima within the feasible region. A barycenter initialization is more likely to result in a better solution than a single random initialization. However, calling ``quadratic_assignment`` several times with different random initializations may result in a better optimum at the cost of longer total execution time. Examples -------- As mentioned above, a barycenter initialization often results in a better solution than a single random initialization. >>> from numpy.random import default_rng >>> rng = default_rng() >>> n = 15 >>> A = rng.random((n, n)) >>> B = rng.random((n, n)) >>> res = quadratic_assignment(A, B) # FAQ is default method >>> print(res.fun) 46.871483385480545 # may vary >>> options = {"P0": "randomized"} # use randomized initialization >>> res = quadratic_assignment(A, B, options=options) >>> print(res.fun) 47.224831071310625 # may vary However, consider running from several randomized initializations and keeping the best result. >>> res = min([quadratic_assignment(A, B, options=options) ... for i in range(30)], key=lambda x: x.fun) >>> print(res.fun) 46.671852533681516 # may vary The '2-opt' method can be used to further refine the results. >>> options = {"partial_guess": np.array([np.arange(n), res.col_ind]).T} >>> res = quadratic_assignment(A, B, method="2opt", options=options) >>> print(res.fun) 46.47160735721583 # may vary References ---------- .. [1] J.T. Vogelstein, J.M. Conroy, V. Lyzinski, L.J. Podrazik, S.G. Kratzer, E.T. Harley, D.E. Fishkind, R.J. Vogelstein, and C.E. Priebe, "Fast approximate quadratic programming for graph matching," PLOS one, vol. 10, no. 4, p. e0121002, 2015, :doi:`10.1371/journal.pone.0121002` .. [2] D. Fishkind, S. Adali, H. Patsolic, L. Meng, D. Singh, V. Lyzinski, C. Priebe, "Seeded graph matching", Pattern Recognit. 87 (2019): 203-215, :doi:`10.1016/j.patcog.2018.09.014` .. [3] "Doubly stochastic Matrix," Wikipedia. https://en.wikipedia.org/wiki/Doubly_stochastic_matrix N> r. � randomizedz Invalid 'P0' parameter stringr z$'maxiter' must be a positive integerz 'tol' must be a positive floatz1`P0` matrix must have shape m' x m', where m'=n-m��axisr z%`P0` matrix must be doubly stochasticr. r2 )�sizer ��col_ind�fun�nit���)�maximizeT��dtype)#r �operator�indexr- � isinstance�strr r r) r r! r& r( �allcloser �ones�_doubly_stochastic�uniformr r � setdiff1d�range� permutation� concatenate� _split_matrixr# r �eye�argmin�linalg�norm�sqrt�arange�zerosr% )4r r r; r+ �rng�P0� shuffle_input�maxiter�tol�unknown_optionsr, �n�n_seeds�n_unseed�J�K�scorer �obj_func_scalar� nonseed_B� nonseed_A�perm_A�perm_B�A11�A12�A21�A22�B11�B12�B21�B22� const_sum�P�n_iter�grad_fp�_�cols�Q�R�b21�b12�AR22�BR22�b22a�b22b�a�b�alpha�P_i1�colr �unshuffled_perms4 r r r � s� � �~ �?�+�+�+��n�W�%�%�G� 3�1�a� �G�G��A�q�-� �C��"�c��� /�r�)E� E� E�-��� �A� � �4��� ����.�� ����o�o� � �S� !� !�C� �A���A��-� � �G��7�{�H� �b�#� � � � �]�2� � �� �8��(�+� +� +�E�C�C��A�v�l�l�n�n� :�B�K���r��0B�0B�0B�A�$F�$F� :��[�����!3�!3�!3�Q�7�7� :�9�C� �?� �S�/�/� !� � �|� � � �W�h��)� *� *�X� 5��� �|� � � �G�X�x�(� )� )�H� 4�� �s�{�{��8�0D�{� E� E� F� F���!�e�q�[�� �A�v�v��A� � ��A�q�-����1��"5�6�6��'����1��-�e�A�F�F�� �c�"�"�"��O�� � ��� �U�1�X�X�}�Q�Q�Q��T�':�;�;�I�� /��O�O�I�.�.� �� �U�1�X�X�}�Q�Q�Q��T�':�;�;�I� �^�]�1�1�1�a�4� 0�)� <� =� =�F� �^�]�1�1�1�a�4� 0�)� <� =� =�F� '�q��y����F��';�W�E�E��C��c�3�&�q��y����F��';�W�E�E��C��c�3��c�e� �c�e�c�k�)�I� �A���7�1�9�%�%� "� "�� �s�Q�w����.�����S� �@��'��(�C�C�C���4� �F�8� � �T� "�� ��E����c� �S� �%�%�'�'����c�e� �s�u�$�)�)�+�+���u�q�y���Q�S�y���s�u�T�{�"�'�'�)�)���d�4�j� �%�%�'�'�� �V�d�]� � � !� !�� �#�I�� �t� #�� �_� �q� � �Q�1�"�a��c�(�%7�%7�%7�%7�a�%7�%7�%7�%7�%7��B��!��H�E�E��I�q�1�q�5�/�"9� :�;�;�E� �q�y�A��I��?�*�� �9�>�>�!�d�(� #� #�b�g�h�&7�&7� 7�#� =� =��A� �E� ��� #�1�t� 4� 4� 4�F�A�s� �>�2�9�W�-�-�s�W�}�=� >� >�D��h�q��,�,�,�O� $�T�l�O�F�� ��1�o� .� .�E�%�e�F� C� C�C� �#� � � r c � � | d |� | |d � }}|d d �d |�f |d d �|d �f |d d �d |�f |d d �|d �f fS r � )�XrX �upperr s r rJ rJ sj � ��R�a�R�5�!�A�B�B�%�5�E� ����B�Q�B��<��q�q�q�!�"�"�u� �u�Q�Q�Q����U�|�U�1�1�1�a�b�b�5�\� A�Ar ���MbP?c � � d}d| � d�� � z }d| |z z }| }t |� � D ]�}t j |� d�� � dz � � |k � � � rCt j |� d�� � dz � � |k � � � r n#d|| z z }d| |z z }|d d �d f | z |z }��|S )Ni� r r r3 )r rG r �abs�all)rl rV �max_iter�c�r�P_eps�its r rD rD s� � � �H� �A�E�E�q�E�M�M��A� �Q��U� �A� �E��H�o�o� #� #�� �V�E�I�I�1�I�%�%��)� *� *�S� 0� 5� 5� 7� 7� ���� � �q� �)�)�A�-�.�.��4�9�9�;�;� � �E� ��Q��K�� ��Q��K���!�!�!�T�'� �Q���"��� �Lr c � � t |� � t |� � }t | ||� � \ } }}t | � � }|dk s|j d |k r:t | ||dd�df � � }|dd�df |dd�} t | � � S |�t j g g g� � j }t j |� � � t � � }d} |j d | j d k rd} n�|j d dk rd} n�|j dk rd} n�|dk � � � rd } n�|t | � � k � � � rd } n�t t |dd�df � � � � t |dd�df � � k rAt t |dd�df � � � � t |dd�df � � k sd } | �t! | � � �d} |j s|j r�t j |t& � � � } t j |t& � � � } t j |t& � � � } t j |t& � � � }t j |t � � � }|j \ }}d | |< d | |< ||| < |j \ }}d | |< d ||< ||| < | | z }| | z }|� t j |� � | � � ||< n'|� t j |� � � � }t | ||� � }t j |� � }| � || }|r t, j n t, j }d}d}|sst3 j |d� � D ]Y\ }} |dz }|| || c||< || < t | ||� � } |||� � r|} n|| || c||< || < �Zd }|�s|||d�} t | � � S )a� Solve the quadratic assignment problem (approximately). This function solves the Quadratic Assignment Problem (QAP) and the Graph Matching Problem (GMP) using the 2-opt algorithm [1]_. Quadratic assignment solves problems of the following form: .. math:: \min_P & \ {\ \text{trace}(A^T P B P^T)}\\ \mbox{s.t. } & {P \ \epsilon \ \mathcal{P}}\\ where :math:`\mathcal{P}` is the set of all permutation matrices, and :math:`A` and :math:`B` are square matrices. Graph matching tries to *maximize* the same objective function. This algorithm can be thought of as finding the alignment of the nodes of two graphs that minimizes the number of induced edge disagreements, or, in the case of weighted graphs, the sum of squared edge weight differences. Note that the quadratic assignment problem is NP-hard. The results given here are approximations and are not guaranteed to be optimal. Parameters ---------- A : 2-D array, square The square matrix :math:`A` in the objective function above. B : 2-D array, square The square matrix :math:`B` in the objective function above. method : str in {'faq', '2opt'} (default: 'faq') The algorithm used to solve the problem. This is the method-specific documentation for '2opt'. :ref:`'faq' <optimize.qap-faq>` is also available. Options ------- maximize : bool (default: False) Maximizes the objective function if ``True``. rng : {None, int, `numpy.random.Generator`, `numpy.random.RandomState`}, optional If `seed` is None (or `np.random`), the `numpy.random.RandomState` singleton is used. If `seed` is an int, a new ``RandomState`` instance is used, seeded with `seed`. If `seed` is already a ``Generator`` or ``RandomState`` instance then that instance is used. partial_match : 2-D array of integers, optional (default: None) Fixes part of the matching. Also known as a "seed" [2]_. Each row of `partial_match` specifies a pair of matched nodes: node ``partial_match[i, 0]`` of `A` is matched to node ``partial_match[i, 1]`` of `B`. The array has shape ``(m, 2)``, where ``m`` is not greater than the number of nodes, :math:`n`. partial_guess : 2-D array of integers, optional (default: None) A guess for the matching between the two matrices. Unlike `partial_match`, `partial_guess` does not fix the indices; they are still free to be optimized. Each row of `partial_guess` specifies a pair of matched nodes: node ``partial_guess[i, 0]`` of `A` is matched to node ``partial_guess[i, 1]`` of `B`. The array has shape ``(m, 2)``, where ``m`` is not greater than the number of nodes, :math:`n`. Returns ------- res : OptimizeResult `OptimizeResult` containing the following fields. col_ind : 1-D array Column indices corresponding to the best permutation found of the nodes of `B`. fun : float The objective value of the solution. nit : int The number of iterations performed during optimization. Notes ----- This is a greedy algorithm that works similarly to bubble sort: beginning with an initial permutation, it iteratively swaps pairs of indices to improve the objective function until no such improvements are possible. References ---------- .. [1] "2-opt," Wikipedia. https://en.wikipedia.org/wiki/2-opt .. [2] D. Fishkind, S. Adali, H. Patsolic, L. Meng, D. Singh, V. Lyzinski, C. Priebe, "Seeded graph matching", Pattern Recognit. 87 (2019): 203-215, https://doi.org/10.1016/j.patcog.2018.09.014 r Nr r6 z@`partial_guess` can have only as many entries as there are nodesr z%`partial_guess` must have two columnsz0`partial_guess` must have exactly two dimensionsz2`partial_guess` must contain only positive indicesz9`partial_guess` entries must be less than number of nodesz-`partial_guess` column entries must be uniquer< TF)r r r- r) r& r r r r" r# r! r$ r% r' r( r* r r5 rQ �boolrH rP r> �gt�lt� itertools� combinations_with_replacement) r r r; rR r+ � partial_guessrW �Nr] r r, � fixed_rows� guess_rows� guess_cols� fixed_colsr �rg�cg�rf�cf� random_rows� random_cols� best_score�i_free�betterrm �done�i�js r r r sJ � �D �?�+�+�+� �S� !� !�C�2�1�a� �G�G��A�q�-� �A���A��A�v�v� �$�Q�'�1�,�,��A�q�-����1��"5�6�6��'����1��-�e�A�F�F�� �c�"�"�"�� ���"�b��*�*�,� ��M�-�0�0�7�7��<�<�M� �C���1� ���� �*�*�1��� � �Q� �1� $� $�5��� � �q� � �@��� �!� � � � "� "� >�B��� �3�q�6�6� !� &� &� (� (� >�I����#�m�A�A�A�q�D�)�*�*�+�+�s�=����A��3F�/G�/G�G�G��#�m�A�A�A�q�D�)�*�*�+�+�s�=����A��3F�/G�/G�G�G�=�� ����o�o� ��J��� -�]� /� -� �X�a�t�,�,�,� ��X�a�t�,�,�,� ��X�a�t�,�,�,� ��X�a�t�,�,�,� ��x���%�%�%�� � ���B� � �2�� � �2�� ��Z�� � ���B� � �2�� � �2�� ��Z��!�k�Z�K�/� �!�k�Z�K�/� � �O�O�B�I�a�L�L��,E� F� F��[������r�y��|�|�,�,�� �Q��4�(�(�J� �Y�q�\�\�F�� ��� �$�� $� 5�X�[�[�(�+�F� �F� �D�� � �;�F�A�F�F� � �D�A�q� �a�K�F� #�A�w��Q�� �D��G�T�!�W� ��1�d�+�+�E��v�e�Z�(�(� � "� ��� #�A�w��Q�� �D��G�T�!�W�W��D� � � �:�f� =� =�C� �#� � � r )r N)FNNr. Fr/ r0 )r� )FNNN)�numpyr r> � r r � _optimizer �scipy._lib._utilr r� � QUADRATIC_ASSIGNMENT_METHODSr r r- r rJ rD r r� r r �<module>r� s �� � � � � ���� 5� 5� 5� 5� 5� 5� 5� 5� -� -� -� -� -� -� /� /� /� /� /� /� � � � � %�v�� �u� u� u� u�p(� (� (� " � " � " �L GK�LN�"&�P � P � P � P �fB� B� B� � � � �0 :>�-1�-1�v � v � v � v � v � v r
Save File
Cancel