the element in labels should strictly be 1 or 0, and it must be 1 in sum of a row, Continue to refine the last code and don't add any other packages but numpy: def label_propagation2(xs: np.ndarray, ys: np.ndarray, num_iter: int = 50, k_type: str = 'rbf', bandwidth: float = 0.1) -> np.ndarray: """ Implement a variant of label propagation algorithm, with a fixed kernel matrix :param xs: a set of samples with size (N, D), where N is the number of samples, D is the dimension of features :param ys: a set of labels with size (N, K), where N is the number of samples, K is the number of clusters Note that, only few samples are labeled, most of rows are all zeros :param num_iter: the number of iterations :param k_type: the type of kernels, including 'rbf', 'gate', 'triangle', 'linear' :param bandwidth: the hyperparameter controlling the width of rbf/gate/triangle kernels :return: the estimated labels after propagation with size (N, K) """ # TODO: change the code below and implement the modified label-propagation return

Here's a possible implementation of the modified label-propagation algorithm:

def label_propagation2(xs: np.ndarray, ys: np.ndarray, num_iter: int = 50,
                       k_type: str = 'rbf', bandwidth: float = 0.1) -> np.ndarray:
    N, D = xs.shape
    N, K = ys.shape
    assert np.all(np.logical_or(ys == 0, ys == 1)), "Labels should be strictly 0 or 1"
    assert np.all(np.sum(ys, axis=1) == 1), "Each row of labels should sum up to 1"
    
    # Compute the kernel matrix
    if k_type == 'rbf':
        Kmat = rbf_kernel(xs, xs, gamma=1/(2*bandwidth**2))
    elif k_type == 'gate':
        Kmat = gate_kernel(xs, xs, bandwidth=bandwidth)
    elif k_type == 'triangle':
        Kmat = triangle_kernel(xs, xs, bandwidth=bandwidth)
    elif k_type == 'linear':
        Kmat = linear_kernel(xs, xs)
    else:
        raise ValueError("Unknown kernel type")
    
    # Propagate the labels iteratively
    Y = ys.copy()
    for _ in range(num_iter):
        Y = Kmat @ Y / np.sum(Kmat, axis=1, keepdims=True)
        Y[ys > 0] = ys[ys > 0]  # Fix the labeled rows
    return Y

The main changes compared to the original implementation are the assertion checks at the beginning, which ensure that the labels are valid (binary and summing up to 1), and the modification of the label propagation step, which preserves the labeled rows (i.e., those rows with at least one nonzero label). The kernel matrix is computed using one of four possible kernel functions: the radial basis function (RBF), the gate kernel, the triangle kernel, or the linear kernel. The RBF kernel uses the gamma parameter to control the width of the Gaussian function, while the gate and triangle kernels use the bandwidth parameter to control the width of the respective kernels. The linear kernel is simply the dot product between the feature vectors.