3 、无监督学习

Repeat {
    # Assign points to cluster centroids
    for i = 1 to m
        c(i) := index (from 1 to K) of cluster centroid closest to x(i)

    # Move cluster centroids
    for k = 1 to K
        mu_k := average (mean) of points assigned to cluster k
}

For i = 1 to 100 {
    Randomly initialize K-means.
    Run K-means. Get c^(1), ..., c^(m), μ_1, μ_2, ..., μ_k
    Compute cost function (distortion) J(c^(1), ..., c^(m), μ_1, μ_2, ..., μ_k)
}
Pick set of clusters that gave lowest cost J

def cofi_cost_func(X, W, b, Y, R, lambda_):
    """
    Returns the cost for the content-based filtering
    Args:
      X (ndarray (num_movies,num_features)): matrix of item features
      W (ndarray (num_users,num_features)) : matrix of user parameters
      b (ndarray (1, num_users)            : vector of user parameters
      Y (ndarray (num_movies,num_users)    : matrix of user ratings of movies
      R (ndarray (num_movies,num_users)    : matrix, where R(i, j) = 1 if the i-th movies was rated by the j-th user
      lambda_ (float): regularization parameter
    Returns:
      J (float) : Cost
    """
    nm, nu = Y.shape
    J = 0
    ### START CODE HERE ###  
    for j in range(nu):
        w = W[j, :]
        b_j = b[0, j]
        for i in range(nm):
            x = X[i, :]
            y = Y[i, j]
            r = R[i, j]
            J += 0.5 * np.square(r * (np.dot(w, x) + b_j - y))
    # Regularization
    J += (lambda_ / 2) * (np.sum(np.square(W)) + np.sum(np.square(X)))
    ### END CODE HERE ### 

    return J

# Initialize an optimizer
optimizer = keras.optimizers.Adam(learning_rate=1e-1)

# Set the number of iterations
iterations = 200

# Define the cost function
def cofiCostFuncV(X, W, b, Ynorm, R, num_users, num_movies, lambda):
    # The implementation of the cost function should be here
    pass

# Gradient descent loop
for iter in range(iterations):
    # Use TensorFlow's GradientTape to record the operations used to compute the cost
    with tf.GradientTape() as tape:
        # Compute the cost
        cost_value = cofiCostFuncV(X, W, b, Ynorm, R, num_users, num_movies, lambda)

    # Use the gradient tape to automatically retrieve the gradients of the trainable variables with respect to the loss
    grads = tape.gradient(cost_value, [X, W, b])

    # Run one step of gradient descent by updating the value of the variables to minimize the loss
    optimizer.apply_gradients(zip(grads, [X, W, b]))

# Create the user neural network
user_NN = tf.keras.models.Sequential([
    tf.keras.layers.Dense(256, activation='relu'),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(32)
])

# Create the item neural network
item_NN = tf.keras.models.Sequential([
    tf.keras.layers.Dense(256, activation='relu'),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(32)
])

# Create the user input and point to the base network
input_user = tf.keras.layers.Input(shape=(num_user_features,))
vu = user_NN(input_user)
vu = tf.linalg.l2_normalize(vu, axis=1)

# Create the item input and point to the base network
input_item = tf.keras.layers.Input(shape=(num_item_features,))
vm = item_NN(input_item)
vm = tf.linalg.l2_normalize(vm, axis=1)

# Measure the similarity of the two vector outputs
output = tf.keras.layers.Dot(axes=1)([vu, vm])

# Specify the inputs and output of the model
model = tf.keras.Model(inputs=[input_user, input_item], outputs=output)

# Specify the cost function
cost_fn = tf.keras.losses.MeanSquaredError()