Explorer l’art dans la culture et les supports avec l’algorithme voisin le plus rapide, conditionnel, k-nearest

Cet article décrit la recherche de correspondance via l’algorithme k-nearest-neighbors. Vous créez des ressources de code qui permettent aux requêtes impliquant des cultures et des moyens d’art amassés à partir du Metropolitan Museum of Art à NYC et au Rijks museum of Art d’Amsterdam.

Conditions préalables

Un bloc-notes attaché à un lac. Pour plus d’informations, consultez Explorer les données de votre lakehouse avec un bloc-notes .

Vue d’ensemble de BallTree

Le modèle k-NN s’appuie sur la structure de données BallTree . BallTree est une arborescence binaire récursive, où chaque nœud (ou « ball ») contient une partition, ou un sous-ensemble, des points de données que vous souhaitez interroger. Pour créer un BallTree, déterminez le centre « ball » (basé sur une fonctionnalité spécifiée) le plus proche de chaque point de données. Ensuite, affectez chaque point de données à cette « boule » la plus proche correspondante. Ces affectations créent une structure qui permet des traversées de type arbre binaire, et se prête à trouver des voisins k-nearest à une feuille BallTree.

Installation

Importez les bibliothèques Python nécessaires et préparez le jeu de données :

from synapse.ml.core.platform import *

if running_on_binder():
    from IPython import get_ipython

from pyspark.sql.types import BooleanType
from pyspark.sql.types import *
from pyspark.ml.feature import Normalizer
from pyspark.sql.functions import lit, array, array_contains, udf, col, struct
from synapse.ml.nn import ConditionalKNN, ConditionalKNNModel
from PIL import Image
from io import BytesIO

import requests
import numpy as np
import matplotlib.pyplot as plt
from pyspark.sql import SparkSession

# Bootstrap Spark Session
spark = SparkSession.builder.getOrCreate()

Le jeu de données provient d’une table qui contient des informations d’art du Musée Met et du Rijks museum. La table possède ce schéma :

ID : identificateur unique pour chaque pièce d’art spécifique
- Exemple d’ID met : 388395
- Exemple d’ID Rijks : SK-A-2344
Titre : Titre de l’œuvre d’art, tel qu’écrit dans la base de données du musée
Artiste : Artiste artistique, tel qu’écrit dans la base de données du musée
Thumbnail_Url : Emplacement d’une miniature JPEG de l’œuvre d’art
Image_Url Emplacement URL du site web de l’image de l’œuvre d’art, hébergé sur le site Web Met/Rijks
Culture : Catégorie culture de l’œuvre d’art
- Exemples de catégories de culture : Amérique latine, Egyptienne, etc.
Classification : Catégorie moyenne de l’œuvre d’art
- Exemples de catégories moyennes : boiseries, peintures, etc.
Museum_Page : lien URL vers l’œuvre d’art, hébergée sur le site web Met/Rijks
Norm_Features : incorporation de l’image de l’œuvre d’art
Musée : Le musée hébergeant l’œuvre d’art réelle

# loads the dataset and the two trained conditional k-NN models for querying by medium and culture
df = spark.read.parquet(
    "wasbs://publicwasb@mmlspark.blob.core.windows.net/met_and_rijks.parquet"
)
display(df.drop("Norm_Features"))

Pour générer la requête, définissez les catégories

Utilisez deux modèles k-NN : un pour la culture et un pour moyen :

# mediums = ['prints', 'drawings', 'ceramics', 'textiles', 'paintings', "musical instruments","glass", 'accessories', 'photographs',  "metalwork",
#           "sculptures", "weapons", "stone", "precious", "paper", "woodwork", "leatherwork", "uncategorized"]

mediums = ["paintings", "glass", "ceramics"]

# cultures = ['african (general)', 'american', 'ancient american', 'ancient asian', 'ancient european', 'ancient middle-eastern', 'asian (general)',
#            'austrian', 'belgian', 'british', 'chinese', 'czech', 'dutch', 'egyptian']#, 'european (general)', 'french', 'german', 'greek',
#            'iranian', 'italian', 'japanese', 'latin american', 'middle eastern', 'roman', 'russian', 'south asian', 'southeast asian',
#            'spanish', 'swiss', 'various']

cultures = ["japanese", "american", "african (general)"]

# Uncomment the above for more robust and large scale searches!

classes = cultures + mediums

medium_set = set(mediums)
culture_set = set(cultures)
selected_ids = {"AK-RBK-17525-2", "AK-MAK-1204", "AK-RAK-2015-2-9"}

small_df = df.where(
    udf(
        lambda medium, culture, id_val: (medium in medium_set)
        or (culture in culture_set)
        or (id_val in selected_ids),
        BooleanType(),
    )("Classification", "Culture", "id")
)

small_df.count()

Définir et ajuster des modèles k-NN conditionnels

Créez des modèles k-NN conditionnels pour les colonnes moyennes et culturelles. Chaque modèle prend

une colonne de sortie
une colonne de caractéristiques (vecteur de caractéristique)
une colonne de valeurs (valeurs de cellule sous la colonne de sortie)
une colonne d’étiquette (la qualité sur laquelle le k-NN respectif est conditionné)

medium_cknn = (
    ConditionalKNN()
    .setOutputCol("Matches")
    .setFeaturesCol("Norm_Features")
    .setValuesCol("Thumbnail_Url")
    .setLabelCol("Classification")
    .fit(small_df)
)

culture_cknn = (
    ConditionalKNN()
    .setOutputCol("Matches")
    .setFeaturesCol("Norm_Features")
    .setValuesCol("Thumbnail_Url")
    .setLabelCol("Culture")
    .fit(small_df)
)

Définir des méthodes de correspondance et de visualisation

Après la configuration initiale du jeu de données et de la catégorie, préparez les méthodes pour interroger et visualiser les résultats du K-NN conditionnel :

addMatches() crée un dataframe avec quelques correspondances par catégorie :

def add_matches(classes, cknn, df):
    results = df
    for label in classes:
        results = cknn.transform(
            results.withColumn("conditioner", array(lit(label)))
        ).withColumnRenamed("Matches", "Matches_{}".format(label))
    return results

plot_urls() appels plot_img pour visualiser les correspondances principales pour chaque catégorie dans une grille :

def plot_img(axis, url, title):
    try:
        response = requests.get(url)
        img = Image.open(BytesIO(response.content)).convert("RGB")
        axis.imshow(img, aspect="equal")
    except:
        pass
    if title is not None:
        axis.set_title(title, fontsize=4)
    axis.axis("off")


def plot_urls(url_arr, titles, filename):
    nx, ny = url_arr.shape

    plt.figure(figsize=(nx * 5, ny * 5), dpi=1600)
    fig, axes = plt.subplots(ny, nx)

    # reshape required in the case of 1 image query
    if len(axes.shape) == 1:
        axes = axes.reshape(1, -1)

    for i in range(nx):
        for j in range(ny):
            if j == 0:
                plot_img(axes[j, i], url_arr[i, j], titles[i])
            else:
                plot_img(axes[j, i], url_arr[i, j], None)

    plt.savefig(filename, dpi=1600)  # saves the results as a PNG

    display(plt.show())

Rassembler tous les éléments

Pour prendre en compte

données
modèles k-NN conditionnels
valeurs d’ID d’art à interroger sur
chemin d’accès au fichier où la visualisation de sortie est enregistrée

définir une fonction appelée test_all()

Les modèles moyens et culturels ont été formés et chargés précédemment.

# main method to test a particular dataset with two conditional k-NN models and a set of art IDs, saving the result to filename.png

def test_all(data, cknn_medium, cknn_culture, test_ids, root):
    is_nice_obj = udf(lambda obj: obj in test_ids, BooleanType())
    test_df = data.where(is_nice_obj("id"))

    results_df_medium = add_matches(mediums, cknn_medium, test_df)
    results_df_culture = add_matches(cultures, cknn_culture, results_df_medium)

    results = results_df_culture.collect()

    original_urls = [row["Thumbnail_Url"] for row in results]

    culture_urls = [
        [row["Matches_{}".format(label)][0]["value"] for row in results]
        for label in cultures
    ]
    culture_url_arr = np.array([original_urls] + culture_urls)[:, :]
    plot_urls(culture_url_arr, ["Original"] + cultures, root + "matches_by_culture.png")

    medium_urls = [
        [row["Matches_{}".format(label)][0]["value"] for row in results]
        for label in mediums
    ]
    medium_url_arr = np.array([original_urls] + medium_urls)[:, :]
    plot_urls(medium_url_arr, ["Original"] + mediums, root + "matches_by_medium.png")

    return results_df_culture

Manif

La cellule suivante effectue des requêtes par lots, en fonction des ID d’image souhaités et d’un nom de fichier pour enregistrer la visualisation.

# sample query
result_df = test_all(small_df, medium_cknn, culture_cknn, selected_ids, root=".")

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2025-04-05