编程实现PAM算法对有20%高斯噪声的waveform数据聚类，并对有噪声得图像进行分割。

PAM算法，即Partitioning Around Medoids算法，是一种经典的聚类算法。它的主要思想是将数据集中的点分成若干个簇，并且每个簇都有一个代表点，也就是medoid。在此基础上，PAM算法通过迭代不断更新medoid和聚类簇中的点，直到收敛为止。

下面是使用PAM算法对20%高斯噪声的waveform数据进行聚类的Python实现：

import numpy as np
from sklearn.datasets import make_blobs
from sklearn.metrics.pairwise import pairwise_distances

def PAM(X, n_clusters, max_iter=100):
    n_samples, n_features = X.shape

    # Step 1: Randomly select n_clusters samples as initial medoids
    medoids = np.zeros(n_clusters, dtype=int)
    medoids[:] = np.random.choice(n_samples, n_clusters, replace=False)

    # Step 2: Assign each sample to the nearest medoid
    distances = pairwise_distances(X, X[medoids])
    labels = np.argmin(distances, axis=1)

    for i in range(max_iter):
        # Step 3: For each medoid m and each non-medoid point o, swap m and o, compute the cost of the configuration,
        # and select the configuration with the lowest cost as the new medoid.
        for j in range(n_clusters):
            cluster = X[labels == j]
            distances = pairwise_distances(cluster, cluster)
            medoid = np.argmin(distances.sum(axis=1))
            medoids[j] = np.where(labels == j)[0][medoid]

        # Step 4: Re-assign each sample to the nearest medoid
        distances = pairwise_distances(X, X[medoids])
        new_labels = np.argmin(distances, axis=1)

        # Step 5: Check for convergence
        if np.all(labels == new_labels):
            break

        labels = new_labels

    return medoids, labels

# Generate some sample data with 20% Gaussian noise
X, y = make_blobs(n_samples=500, centers=3, n_features=2, random_state=42)
noise = np.random.normal(size=X.shape) * 0.2
X += noise

# Run PAM algorithm to cluster the data
medoids, labels = PAM(X, n_clusters=3)

# Plot the results
import matplotlib.pyplot as plt
plt.scatter(X[:, 0], X[:, 1], c=labels)
plt.scatter(X[medoids, 0], X[medoids, 1], c='red', marker='x')
plt.show()

接下来是使用PAM算法对有噪声的图像进行分割的Python实现：

import numpy as np
from sklearn.metrics.pairwise import pairwise_distances

def PAM(X, n_clusters, max_iter=100):
    n_samples, n_features = X.shape

    # Step 1: Randomly select n_clusters samples as initial medoids
    medoids = np.zeros(n_clusters, dtype=int)
    medoids[:] = np.random.choice(n_samples, n_clusters, replace=False)

    # Step 2: Assign each sample to the nearest medoid
    distances = pairwise_distances(X, X[medoids])
    labels = np.argmin(distances, axis=1)

    for i in range(max_iter):
        # Step 3: For each medoid m and each non-medoid point o, swap m and o, compute the cost of the configuration,
        # and select the configuration with the lowest cost as the new medoid.
        for j in range(n_clusters):
            cluster = X[labels == j]
            distances = pairwise_distances(cluster, cluster)
            medoid = np.argmin(distances.sum(axis=1))
            medoids[j] = np.where(labels == j)[0][medoid]

        # Step 4: Re-assign each sample to the nearest medoid
        distances = pairwise_distances(X, X[medoids])
        new_labels = np.argmin(distances, axis=1)

        # Step 5: Check for convergence
        if np.all(labels == new_labels):
            break

        labels = new_labels

    return medoids, labels

# Load the image and add some Gaussian noise
from skimage import io, color
from skimage.util import random_noise
image = io.imread('image.jpg', as_gray=True)
image = color.rgb2gray(image)
noisy_image = random_noise(image, mode='gaussian', var=0.2)

# Reshape the image to a 2D array
height, width = noisy_image.shape
X = noisy_image.reshape(-1, 1)

# Run PAM algorithm to segment the image
medoids, labels = PAM(X, n_clusters=2)

# Reshape the labels back to the original image shape
segmented_image = labels.reshape(height, width)

# Plot the results
fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(8, 4))
ax1.imshow(noisy_image, cmap='gray')
ax1.set_title('Noisy Image')
ax2.imshow(segmented_image, cmap='gray')
ax2.set_title('Segmented Image')
plt.show()

需要注意的是，PAM算法对于大规模数据集的计算复杂度较高，因此在实际应用中需要考虑到算法的效率。