如何计算成对距离的雅可比矩阵 function (`scipy.spatial.pdist`)

Question

赏金将在 5 天后到期。 此问题的答案有资格获得+300声望赏金。 Paul Brodersen想让更多人关注这个问题：

下面 @adrianop01 的回答推导并实现了约束 function 的 Jacobian。不幸的是，这并没有改善优化的运行时间。 这个赏金是为了引起人们对我问题的第二部分的注意，即为成本 function 推导和实施雅可比行列式。我将把赏金奖励给以当前形式为成本 function 构建雅可比行列式的答案，或者以其他方式大大提高了优化的运行时间。

语境

我是netgraph的作者和维护者，这是一个用于创建网络可视化的 python 库。 我目前正在尝试优化一个例程，该例程为.networks 计算一组N个节点位置，其中每条边都具有定义的长度。 可以在此处找到示例。

问题

该例程的核心是运行scipy.optimize.minimize以计算使节点之间的总距离最大化的位置：

def cost_function(positions):
    return 1. / np.sum((pdist(positions.reshape((-1, 2))))**power)

result = minimize(cost_function, initial_positions.flatten(), method='SLSQP',
                  jac="2-point", constraints=[nonlinear_constraint])

• positions是 (unravelled) numpy (x, y) 元组的数组。
• power是一个较小的数字，它限制了大距离的影响（以鼓励紧凑的节点布局），但出于这个问题的目的，可以假定为 1。
• pdist是 scipy.spatial 中的成对距离scipy.spatial 。

使用以下非线性约束来约束最小化（/最大化）：

lower_bounds = ... # (squareform of an) (N, N) distance matrix of the sum of node sizes (i.e. nodes should not overlap)
upper_bounds = ... # (squareform of an) (N, N) distance matrix constructed from the given edge lengths

def constraint_function(positions):
    positions = np.reshape(positions, (-1, 2))
    return pdist(positions)

nonlinear_constraint = NonlinearConstraint(constraint_function, lb=lower_bounds, ub=upper_bounds, jac='2-point')

对于玩具示例，优化可以正确快速地完成。 然而，即使对于 smallish.networks，运行时间也相当糟糕。 我当前的实现使用有限差分来近似梯度 ( jac='2-point' )。 为了加快计算速度，我想明确地计算雅可比矩阵。

在几个 Math Stackexchange 帖子 ( 1 , 2 ) 之后，我计算了成对距离 function 的雅可比矩阵，如下所示：

    def delta_constraint(positions):
        positions = np.reshape(positions, (-1, 2))
        total_positions = positions.shape[0]
        delta = positions[np.newaxis, :, :] - positions[:, np.newaxis, :]
        distance = np.sqrt(np.sum(delta ** 2, axis=-1))
        jac = delta / distance[:, :, np.newaxis]
        squareform_indices = np.triu_indices(total_positions, 1)
        return jac[squareform_indices]

nonlinear_constraint = NonlinearConstraint(constraint_function, lb=lower_bounds, ub=upper_bounds, jac=delta_constraint)

但是，这会导致ValueError ，因为 output 的形状不正确。 对于三角形示例，预期的 output 形状是 (3, 6)，而上面的 function 返回 (3, 2) 数组（即 3 对距离乘以 2 维）。 对于正方形，预期的 output 是 (6, 8)，而实际是 (6, 2)。 将对jac arguments 的正确可调用项实现为NonlinearConstraint和minimize的任何帮助都将不胜感激。

笔记

我想避免使用 autograd/jax/numdifftools（如在这个问题中），因为我想使我的库的依赖项数量保持较小。

最小的工作示例

#!/usr/bin/env python
"""
Create a node layout with fixed edge lengths but unknown node positions.
"""

import numpy as np

from scipy.optimize import minimize, NonlinearConstraint
from scipy.spatial.distance import pdist, squareform


def get_geometric_node_layout(edges, edge_length, node_size=0., power=0.2, maximum_iterations=200, origin=(0, 0), scale=(1, 1)):
    """Node layout for defined edge lengths but unknown node positions.

    Node positions are determined through non-linear optimisation: the
    total distance between nodes is maximised subject to the constraint
    imposed by the edge lengths, which are used as upper bounds.
    If provided, node sizes are used to set lower bounds.

    Parameters
    ----------
    edges : list
        The edges of the graph, with each edge being represented by a (source node ID, target node ID) tuple.
    edge_lengths : dict
        Mapping of edges to their lengths.
    node_size : scalar or dict, default 0.
        Size (radius) of nodes.
        Providing the correct node size minimises the overlap of nodes in the graph,
        which can otherwise occur if there are many nodes, or if the nodes differ considerably in size.
    power : float, default 0.2.
        The cost being minimised is the inverse of the sum of distances.
        The power parameter is the exponent applied to each distance before summation.
        Large values result in positions that are stretched along one axis.
        Small values decrease the influence of long distances on the cost
        and promote a more compact layout.
    maximum_iterations : int
        Maximum number of iterations of the minimisation.
    origin : tuple, default (0, 0)
        The (float x, float y) coordinates corresponding to the lower left hand corner of the bounding box specifying the extent of the canvas.
    scale : tuple, default (1, 1)
        The (float x, float y) dimensions representing the width and height of the bounding box specifying the extent of the canvas.

    Returns
    -------
    node_positions : dict
        Dictionary mapping each node ID to (float x, float y) tuple, the node position.

    """
    # TODO: assert triangle inequality

    # TODO: assert that the edges fit within the canvas dimensions

    # ensure that graph is bi-directional
    edges = edges + [(target, source) for (source, target) in edges] # forces copy
    edges = list(set(edges))

    # upper bound: pairwise distance matrix with unknown distances set to the maximum possible distance given the canvas dimensions
    lengths = []
    for (source, target) in edges:
        if (source, target) in edge_length:
            lengths.append(edge_length[(source, target)])
        else:
            lengths.append(edge_length[(target, source)])

    sources, targets = zip(*edges)
    nodes = sources + targets
    unique_nodes = set(nodes)
    indices = range(len(unique_nodes))
    node_to_idx = dict(zip(unique_nodes, indices))
    source_indices = [node_to_idx[source] for source in sources]
    target_indices = [node_to_idx[target] for target in targets]

    total_nodes = len(unique_nodes)
    max_distance = np.sqrt(scale[0]**2 + scale[1]**2)
    distance_matrix = np.full((total_nodes, total_nodes), max_distance)
    distance_matrix[source_indices, target_indices] = lengths
    distance_matrix[np.diag_indices(total_nodes)] = 0
    upper_bounds = squareform(distance_matrix)

    # lower bound: sum of node sizes
    if isinstance(node_size, (int, float)):
        sizes = node_size * np.ones((total_nodes))
    elif isinstance(node_size, dict):
        sizes = np.array([node_size[node] if node in node_size else 0. for node in unique_nodes])

    sum_of_node_sizes = sizes[np.newaxis, :] + sizes[:, np.newaxis]
    sum_of_node_sizes -= np.diag(np.diag(sum_of_node_sizes)) # squareform requires zeros on diagonal
    lower_bounds = squareform(sum_of_node_sizes)

    def cost_function(positions):
        return 1. / np.sum((pdist(positions.reshape((-1, 2))))**power)

    def constraint_function(positions):
        positions = np.reshape(positions, (-1, 2))
        return pdist(positions)

    initial_positions = _initialise_geometric_node_layout(edges)
    nonlinear_constraint = NonlinearConstraint(constraint_function, lb=lower_bounds, ub=upper_bounds, jac='2-point')
    result = minimize(cost_function, initial_positions.flatten(), method='SLSQP',
                      jac="2-point", constraints=[nonlinear_constraint], options=dict(maxiter=maximum_iterations))

    if not result.success:
        print("Warning: could not compute valid node positions for the given edge lengths.")
        print(f"scipy.optimize.minimize: {result.message}.")

    node_positions_as_array = result.x.reshape((-1, 2))
    node_positions = dict(zip(unique_nodes, node_positions_as_array))
    return node_positions


def _initialise_geometric_node_layout(edges):
    sources, targets = zip(*edges)
    total_nodes = len(set(sources + targets))
    return np.random.rand(total_nodes, 2)


if __name__ == '__main__':

    import matplotlib.pyplot as plt

    def plot_graph(edges, node_layout):
        # poor man's graph plotting
        fig, ax = plt.subplots()
        for source, target in edges:
            x1, y1 = node_layout[source]
            x2, y2 = node_layout[target]
            ax.plot([x1, x2], [y1, y2], color='darkgray')
        ax.set_aspect('equal')

    ################################################################################
    # triangle with right angle

    edges = [
        (0, 1),
        (1, 2),
        (2, 0)
    ]

    lengths = {
        (0, 1) : 3,
        (1, 2) : 4,
        (2, 0) : 5,
    }

    pos = get_geometric_node_layout(edges, lengths, node_size=0)

    plot_graph(edges, node_layout=pos)

    plt.show()

    ################################################################################
    # square

    edges = [
        (0, 1),
        (1, 2),
        (2, 3),
        (3, 0),
    ]

    lengths = {
        (0, 1) : 0.5,
        (1, 2) : 0.5,
        (2, 3) : 0.5,
        (3, 0) : 0.5,
    }

    pos = get_geometric_node_layout(edges, lengths, node_size=0)

    plot_graph(edges, node_layout=pos)

    plt.show()

编辑：计时的实际用例

下面是一个更真实的用例，我用它来为我的代码计时。 我已将 @adrianop01 的雅可比行列式计算纳入约束。 它还包括一个高级初始化。 它需要额外的依赖networkx和netgraph ，它们都可以通过 pip 安装。

#!/usr/bin/env python
"""
Create a node layout with fixed edge lengths but unknown node positions.
"""

import numpy as np

from itertools import combinations
from scipy.optimize import minimize, NonlinearConstraint
from scipy.spatial.distance import pdist, squareform

from netgraph._node_layout import _rescale_to_frame


def get_geometric_node_layout(edges, edge_length, node_size=0., power=0.2, maximum_iterations=200, origin=(0, 0), scale=(1, 1)):
    """Node layout for defined edge lengths but unknown node positions.

    Node positions are determined through non-linear optimisation: the
    total distance between nodes is maximised subject to the constraint
    imposed by the edge lengths, which are used as upper bounds.
    If provided, node sizes are used to set lower bounds.

    Parameters
    ----------
    edges : list
        The edges of the graph, with each edge being represented by a (source node ID, target node ID) tuple.
    edge_lengths : dict
        Mapping of edges to their lengths.
    node_size : scalar or dict, default 0.
        Size (radius) of nodes.
        Providing the correct node size minimises the overlap of nodes in the graph,
        which can otherwise occur if there are many nodes, or if the nodes differ considerably in size.
    power : float, default 0.2.
        The cost being minimised is the inverse of the sum of distances.
        The power parameter is the exponent applied to each distance before summation.
        Large values result in positions that are stretched along one axis.
        Small values decrease the influence of long distances on the cost
        and promote a more compact layout.
    maximum_iterations : int
        Maximum number of iterations of the minimisation.
    origin : tuple, default (0, 0)
        The (float x, float y) coordinates corresponding to the lower left hand corner of the bounding box specifying the extent of the canvas.
    scale : tuple, default (1, 1)
        The (float x, float y) dimensions representing the width and height of the bounding box specifying the extent of the canvas.

    Returns
    -------
    node_positions : dict
        Dictionary mapping each node ID to (float x, float y) tuple, the node position.

    """
    # TODO: assert triangle inequality

    # TODO: assert that the edges fit within the canvas dimensions

    # ensure that graph is bi-directional
    edges = edges + [(target, source) for (source, target) in edges] # forces copy
    edges = list(set(edges))

    # upper bound: pairwise distance matrix with unknown distances set to the maximum possible distance given the canvas dimensions
    lengths = []
    for (source, target) in edges:
        if (source, target) in edge_length:
            lengths.append(edge_length[(source, target)])
        else:
            lengths.append(edge_length[(target, source)])

    sources, targets = zip(*edges)
    nodes = sources + targets
    unique_nodes = set(nodes)
    indices = range(len(unique_nodes))
    node_to_idx = dict(zip(unique_nodes, indices))
    source_indices = [node_to_idx[source] for source in sources]
    target_indices = [node_to_idx[target] for target in targets]

    total_nodes = len(unique_nodes)
    max_distance = np.sqrt(scale[0]**2 + scale[1]**2)
    distance_matrix = np.full((total_nodes, total_nodes), max_distance)
    distance_matrix[source_indices, target_indices] = lengths
    distance_matrix[np.diag_indices(total_nodes)] = 0
    upper_bounds = squareform(distance_matrix)

    # lower bound: sum of node sizes
    if isinstance(node_size, (int, float)):
        sizes = node_size * np.ones((total_nodes))
    elif isinstance(node_size, dict):
        sizes = np.array([node_size[node] if node in node_size else 0. for node in unique_nodes])

    sum_of_node_sizes = sizes[np.newaxis, :] + sizes[:, np.newaxis]
    sum_of_node_sizes -= np.diag(np.diag(sum_of_node_sizes)) # squareform requires zeros on diagonal
    lower_bounds = squareform(sum_of_node_sizes)
    invalid = lower_bounds > upper_bounds
    lower_bounds[invalid] = upper_bounds[invalid] - 1e-8

    def cost_function(positions):
        # return -np.sum((pdist(positions.reshape((-1, 2))))**power)
        return 1. / np.sum((pdist(positions.reshape((-1, 2))))**power)

    def cost_jacobian(positions):
        # TODO
        pass

    def constraint_function(positions):
        positions = np.reshape(positions, (-1, 2))
        return pdist(positions)

    # adapted from https://stackoverflow.com/a/75154395/2912349
    total_pairs = int((total_nodes - 1) * total_nodes / 2)
    source_indices, target_indices = np.array(list(combinations(range(total_nodes), 2))).T # node order thus (0,1) ... (0,N-1), (1,2),...(1,N-1),...,(N-2,N-1)
    rows = np.repeat(np.arange(total_pairs).reshape(-1, 1), 2, axis=1)
    source_columns = np.vstack((source_indices*2, source_indices*2+1)).T
    target_columns = np.vstack((target_indices*2, target_indices*2+1)).T

    def constraint_jacobian(positions):
        positions = np.reshape(positions, (-1, 2))
        pairwise_distances = constraint_function(positions)
        jac = np.zeros((total_pairs, 2 * total_nodes))
        jac[rows, source_columns] = (positions[source_indices] - positions[target_indices]) / pairwise_distances.reshape((-1, 1))
        jac[rows, target_columns] = -jac[rows, source_columns]
        return jac

    initial_positions = _initialise_geometric_node_layout(edges, edge_length)
    nonlinear_constraint = NonlinearConstraint(constraint_function, lb=lower_bounds, ub=upper_bounds, jac=constraint_jacobian)
    result = minimize(cost_function, initial_positions.flatten(), method='SLSQP',
                      jac='2-point', constraints=[nonlinear_constraint], options=dict(maxiter=maximum_iterations))
    # result = minimize(cost_function, initial_positions.flatten(), method='trust-constr',
    #                   jac=cost_jacobian, constraints=[nonlinear_constraint])

    if not result.success:
        print("Warning: could not compute valid node positions for the given edge lengths.")
        print(f"scipy.optimize.minimize: {result.message}.")

    node_positions_as_array = result.x.reshape((-1, 2))
    node_positions_as_array = _rescale_to_frame(node_positions_as_array, np.array(origin), np.array(scale))
    node_positions = dict(zip(unique_nodes, node_positions_as_array))
    return node_positions


# # slow
# def _initialise_geometric_node_layout(edges, edge_length=None):
#     sources, targets = zip(*edges)
#     total_nodes = len(set(sources + targets))
#     return np.random.rand(total_nodes, 2)

# much faster
def _initialise_geometric_node_layout(edges, edge_length=None):
    """Initialises the node positions using the FR algorithm with weights.
    Shorter edges are given a larger weight such that the nodes experience a strong attractive force."""

    from netgraph import get_fruchterman_reingold_layout
    if edge_length:
        edge_weight = dict()
        for edge, length in edge_length.items():
            edge_weight[edge] = 1 / length
    else:
        edge_weight = None
    node_positions = get_fruchterman_reingold_layout(edges)
    return np.array(list(node_positions.values()))


if __name__ == '__main__':

    from time import time
    import matplotlib.pyplot as plt
    import networkx as nx # pip install networkx

    from netgraph import Graph # pip install netgraph


    fig, (ax1, ax2) = plt.subplots(1, 2)

    g = nx.random_geometric_graph(50, 0.3, seed=2)
    node_positions = nx.get_node_attributes(g, 'pos')
    plot_instance = Graph(g,
                          node_layout=node_positions,
                          node_size=1, # netgraph rescales node sizes by 0.01
                          node_edge_width=0.1,
                          edge_width=0.1,
                          ax=ax1,
    )
    ax1.axis([0, 1, 0, 1])
    ax1.set_title('Original node positions')

    def get_euclidean_distance(p1, p2):
        return np.sqrt(np.sum((np.array(p1)-np.array(p2))**2))

    edge_length = dict()
    for (source, target) in g.edges:
        edge_length[(source, target)] = get_euclidean_distance(node_positions[source], node_positions[target])

    tic = time()
    new_node_positions = get_geometric_node_layout(list(g.edges), edge_length, node_size=0.01)
    toc = time()

    print(f"Time elapsed : {toc-tic}")

    Graph(g,
          node_layout=new_node_positions,
          node_size=1,
          node_edge_width=0.1,
          edge_width=0.1,
          ax=ax2,
    )
    ax2.axis([0, 1, 0, 1])
    ax2.set_title('Reconstructed node positions')

    plt.show()

Answer 1

此实现根据与 OP 的讨论计算所有点对的雅可比矩阵。 np 数组矢量化代码可能并不完美，因此我欢迎进一步评论基于雅可比公式的代码细化。

雅可比矩阵的推导

2d Point 可以定义为一个向量：

雅可比矩阵是（M 行，N 列，M 是独特的 2 点对的数量，N 是独特的点的数量）：

对于雅可比矩阵的每个单独元素，我们有以下三种情况：

1. 具体点坐标x/y为2范数中的点1 x/y。
2. 具体点坐标x/y为2范数中的点2 x/y。
3. 具体点坐标 x/y 与当前 2-norm 无关。

因此，我们希望雅可比矩阵是一个稀疏矩阵，其中有很多零，每行最多有 4 个非零项。

代码

代码是不言自明的。 我们将 Jacobian 矩阵作为 MxN np.zeros矩阵开始，并且仅更新与当前 2 范数函数/点对相关的那些条目（因此，每行 4 次更新）。

from itertools import combinations

n_pt = len(initial_positions) #N
n_ptpair = len(upper_bounds) #total number of pointpairs, M

idx_pts= np.array(list(combinations(range(n_pt),2))) #point id order thus in (0,1) ... (0,N-1), (1,2),...(1,N-1),...,(N-2,N-1)
idx_pt1= np.array(idx_pts[:,0]) 
idx_pt2= np.array(idx_pts[:,1])

row_idx = np.repeat(np.arange(n_ptpair).reshape(-1,1),2,axis=1)
col1_idx = np.vstack((idx_pt1*2,idx_pt1*2+1)).T
col2_idx = np.vstack((idx_pt2*2,idx_pt2*2+1)).T

def delta_constraint(positions):
  positions = np.reshape(positions, (-1, 2))
  pairdist = constraint_function(positions) #pairwise R2 distance between each point pair
  jac = np.zeros((n_ptpair,2*n_pt)) #(M,(x0,y0,x1,y1,...,xc,yc...,xN,yN))
  jac[row_idx,col1_idx] = (positions[idx_pt1]-positions[idx_pt2])/pairdist.reshape((-1,1))
  jac[row_idx,col2_idx] = -jac[row_idx,col1_idx]
  return jac

结果

1.代码中的三角形

2.Square 在你的代码中

3.比较复杂的图

  edges = [
        (0, 1),
        (1, 2),
        (2, 3),
        (3, 0),
        (3, 1),
        (4, 1),
        (5, 1),
        (5, 2),
    ]

    lengths = {
        (0, 1) : 0.5,
        (1, 2) : 0.5,
        (2, 3) : 0.5,
        (3, 0) : 0.5,
        (3, 1) : 0.8,
        (4, 1) : 0.8,
        (5, 1) : 0.2,
        (5, 2) : 1,
    }

Answer 2

我说过在评论中的假设下得到雅可比行列式很容易所以......这是一个解释我的意思的答案。 在我下面的测试代码中，实际上比 2-point 慢了一点。 一方面，我可能是错的或犯了错误。 另一方面，即使梯度是正确的，也不足为奇，因为 2 点计算可能更快，问题是高度受限的，只在局部凸出，并且在大多数情况下会在短距离内下降到局部最小值，所以我们可能不会从更准确的梯度信息中获益太多。 如果真的想加快速度，也许可以考虑降低maxiter和ftol优化设置。

我计算了雅可比行列式...但是，... ValueError ...任何帮助将 jac arguments 的正确可调用项实现为 NonlinearConstraint 和最小化的任何帮助都将不胜感激。

还说：

power 是一个较小的数字，它限制了大距离的影响（以鼓励紧凑的节点布局），但出于这个问题的目的，可以假定为 1。

当幂为 1 或 2 时，获取雅可比行列式更简单 - 如您链接到的 Mathoverflow 帖子之一所示 - 因此我对power = 2的考虑有限。 基本上，向量第二范数的雅可比行列式（Latex： f(x) = ||xc||_2^2 ）只是2x （ \nabla f(x) = \nabla ||xc||_2^2 = 2x ). 您可能可以使用链式规则概括为任何 integer 的power ，只是没有考虑它。

重述问题（希望理解正确..）：我们有一组二维点X 。 我们有一个子图G(V,E) ，其中V是X中点的某个子集。 E中的边(a,b,l,u)表示点a和b之间的距离（此处假定为欧氏距离）介于某些常数值l和u之间。 我们希望在满足G给出的边约束的同时最大化X中各点之间的距离之和（某种幂）。 我还假设X中的所有点都绑定到 [0,1]。 即目标是：

让|X| = N |X| = N 。 f是 function f:R^{2N}->R ，在这种情况下，“Jacobian”只是f的梯度向量（ R^{2N}中的向量）。 如果我们只考虑两个点， X = {a,b}很容易看出梯度平行于这两点之间的边缘：

当power为正时，梯度指向外（如上）。 当它为负时，它指向内部。 大小取决于power 。 当p = 2时，它只是 +/- 边向量乘以a和b的两倍（当p = 1时，它只是 +/- 给定的单位向量）。 扩展到更多点， X中某个a的梯度只是每个其他点的所有这些向量的总和：

代码：

我将假设power = 2如前所述，并使用-1x形式而不是-1/x 。 这两个假设都使梯度更容易推导：

import os
import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import minimize, Bounds
from scipy.spatial import distance_matrix

# Numer of nodes:
n = 4
points = np.random.random((n,2))*.8+0.1
# Random sparse edges between points:
adj_matrix = np.triu(np.random.randint(0, 2, (n,n)), 1)*np.triu(np.random.randint(0, 2, (n,n)), 1)
adj_list = [(i, j) for (i, x) in enumerate(adj_matrix) for (j,y) in enumerate(x) if y == 1]
# Upper/lower bound for points in adj_list is initial distance +/- slack/2:
slack = 5e-3
# Initial distance matrix squared. Used for edge constraints:
point_distances = distance_matrix(points, points)**2


def cost_function(x):
  return -1 * distance_matrix(x.reshape((-1,2)), x.reshape((-1,2))**2).sum()/2.


def deriv_function(x):
  return -2 * (n * x.reshape((-1,2)) - x.reshape((-1,2)).sum(axis=0))


def constraints():
  def zmm(x, keep, axis=0, fn=None):
    ''' Zero mask out rows/cols along axis not in keep index, applying fn(<kept>) if fn is provided.
    I couldn't find this in Numpy.
    '''
    r = np.zeros(x.shape)
    if axis == 0:
      i = x[keep,:]
      r[keep,:] = fn(i).reshape(i.shape) if fn else i
    elif axis == 1:
      i = x[:,keep]
      r[:,keep] = fn(i).reshape(i.shape) if fn else i
    else:
      raise np.AxisError(axis)
    return r
  # NOTE: Added scaling factor due to getting "Positive directional derivative for linesearch".
  # I don't completely understand it but means either scaling issue, or jac is wrong, or SLSQP just sucks.
  # See https://stackoverflow.com/a/11177146/2038383
  k=1e-3
  constraints = []
  for (i,j) in adj_list:
    constraints += [{
      'type': 'ineq',
      'fun': lambda x, i=i, j=j: k * (((x.reshape((-1,2))[j] - x.reshape((-1,2))[i])**2).sum() - point_distances[i,j] + slack),
      'jaq': lambda x, i=i, j=j: 2 * k * (lambda x=x.reshape((-1,2)): zmm(x, i, lambda v: x[j] - x[i]) - zmm(x, j, lambda v: x[j] - x[i]))(x)
    }]
    constraints += [{
      'type': 'ineq',
      'fun': lambda x, i=i, j=j: k * (point_distances[i,j] - ((x.reshape((-1,2))[j] - x.reshape((-1,2))[i])**2).sum()  + slack),
      'jaq': lambda x, i=i, j=j: -2 * k * (lambda x=x.reshape((-1,2)): zmm(x, i, lambda v: x[j] - x[i]) - zmm(x, j, lambda v: x[j] - x[i]))(x)
    }]
  return constraints

solver_options = {
  'ftol': 1e-3,
  'maxiter': 1e2,
  'disp': True
}

result = minimize(
  cost_function,
  points.flatten(),
  method='SLSQP',
  jac=deriv_function,
  bounds=Bounds(0,1),
  constraints=constraints(),
  options=solver_options
)
soln = result.x.reshape((-1,2))
print(result)
print('Improvement:', cost_function(points)- cost_function(soln))

if 'SHOW_PLOTS' in os.environ:

  fig, axes = plt.subplots(nrows=1, ncols=2)
  ax0, ax1 = axes.flatten()
  ax0.scatter(points[:,0], points[:,1])
  for (i,j) in adj_list:
    ax0.plot([points[i][0], points[j][0]], [points[i][1], points[j][1]], 'go-')
  ax1.scatter(soln[:,0], soln[:,1])
  for (i,j) in adj_list:
    ax1.plot([soln[i][0], soln[j][0]], [soln[i][1], soln[j][1]], 'go-')
  ax0.set_xlim(-0.1,1.1)
  ax0.set_ylim(-0.1,1.1)
  ax1.set_xlim(-0.1,1.1)
  ax1.set_ylim(-0.1,1.1)
  ax0.set_xticks(np.linspace(0,1,5))
  ax0.set_yticks(np.linspace(0,1,5))
  ax1.set_xticks(np.linspace(0,1,5))
  ax1.set_yticks(np.linspace(0,1,5))
  ax0.set_aspect('equal', 'box')
  ax1.set_aspect('equal', 'box')
  plt.show()

结果（随机边缘约束；之前/之后）：

n=12:

n=4: