moleculenet_eval/showcase.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7678e528-e2d6-4ef4-bd11-8c745bbce7c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from transformers import BertModel, BertConfig, AutoTokenizer\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.manifold import TSNE\n",
    "from sklearn.metrics.pairwise import cosine_similarity\n",
    "from sklearn.cluster import KMeans\n",
    "import umap.umap_ as umap\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "# Set style for better plots\n",
    "plt.style.use('seaborn-v0_8')\n",
    "sns.set_palette(\"husl\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ad8d5a02-6162-41f7-a730-e31e353ed9b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PrecomputedContrastiveSmilesDataset(Dataset):\n",
    "    \"\"\"\n",
    "    A Dataset class that reads pre-augmented SMILES pairs from a Parquet file.\n",
    "    This is significantly faster as it offloads the expensive SMILES randomization\n",
    "    to a one-time preprocessing step.\n",
    "    \"\"\"\n",
    "    def __init__(self, tokenizer, file_path: str, max_length: int = 512):\n",
    "        self.tokenizer = tokenizer\n",
    "        self.max_length = max_length\n",
    "        \n",
    "        # Load the entire dataset from the Parquet file into memory.\n",
    "        # This is fast and efficient for subsequent access.\n",
    "        print(f\"Loading pre-computed data from {file_path}...\")\n",
    "        self.data = pd.read_parquet(file_path)\n",
    "        print(\"Data loaded successfully.\")\n",
    "\n",
    "    def __len__(self):\n",
    "        \"\"\"Returns the total number of pairs in the dataset.\"\"\"\n",
    "        return len(self.data)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        \"\"\"\n",
    "        Retrieves a pre-augmented pair, tokenizes it, and returns it\n",
    "        in the format expected by the DataCollator.\n",
    "        \"\"\"\n",
    "        # Retrieve the pre-augmented pair from the DataFrame\n",
    "        row = self.data.iloc[idx]\n",
    "        smiles_1 = row['smiles_1']\n",
    "        smiles_2 = row['smiles_2']\n",
    "        \n",
    "        # Tokenize the pair. This operation is fast and remains in the data loader.\n",
    "        tokens_1 = self.tokenizer(smiles_1, max_length=self.max_length, truncation=True, padding='max_length')\n",
    "        tokens_2 = self.tokenizer(smiles_2, max_length=self.max_length, truncation=True, padding='max_length')\n",
    "        \n",
    "        return {\n",
    "            'input_ids_1': torch.tensor(tokens_1['input_ids']),\n",
    "            'attention_mask_1': torch.tensor(tokens_1['attention_mask']),\n",
    "            'input_ids_2': torch.tensor(tokens_2['input_ids']),\n",
    "            'attention_mask_2': torch.tensor(tokens_2['attention_mask']),\n",
    "        }\n",
    "\n",
    "def global_ap(x):\n",
    "    return torch.mean(x.view(x.size(0), x.size(1), -1), dim=1)\n",
    "\n",
    "class SimSonEncoder(nn.Module):\n",
    "    def __init__(self, config: BertConfig, max_len: int, dropout: float = 0.1):\n",
    "        super(SimSonEncoder, self).__init__()\n",
    "        self.config = config\n",
    "        self.max_len = max_len\n",
    "        self.bert = BertModel(config, add_pooling_layer=False)\n",
    "        self.linear = nn.Linear(config.hidden_size, max_len)\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "    \n",
    "    def forward(self, input_ids, attention_mask=None):\n",
    "        if attention_mask is None:\n",
    "            attention_mask = input_ids.ne(self.config.pad_token_id)\n",
    "        outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)\n",
    "        hidden_states = self.dropout(outputs.last_hidden_state)\n",
    "        pooled = global_ap(hidden_states)\n",
    "        return self.linear(pooled)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "476226dd-54f3-4d3e-adb4-cc30e922fd96",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OptimizedModule(\n",
       "  (_orig_mod): SimSonEncoder(\n",
       "    (bert): BertModel(\n",
       "      (embeddings): BertEmbeddings(\n",
       "        (word_embeddings): Embedding(591, 768, padding_idx=0)\n",
       "        (position_embeddings): Embedding(512, 768)\n",
       "        (token_type_embeddings): Embedding(2, 768)\n",
       "        (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
       "        (dropout): Dropout(p=0.1, inplace=False)\n",
       "      )\n",
       "      (encoder): BertEncoder(\n",
       "        (layer): ModuleList(\n",
       "          (0-3): 4 x BertLayer(\n",
       "            (attention): BertAttention(\n",
       "              (self): BertSdpaSelfAttention(\n",
       "                (query): Linear(in_features=768, out_features=768, bias=True)\n",
       "                (key): Linear(in_features=768, out_features=768, bias=True)\n",
       "                (value): Linear(in_features=768, out_features=768, bias=True)\n",
       "                (dropout): Dropout(p=0.1, inplace=False)\n",
       "              )\n",
       "              (output): BertSelfOutput(\n",
       "                (dense): Linear(in_features=768, out_features=768, bias=True)\n",
       "                (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
       "                (dropout): Dropout(p=0.1, inplace=False)\n",
       "              )\n",
       "            )\n",
       "            (intermediate): BertIntermediate(\n",
       "              (dense): Linear(in_features=768, out_features=2048, bias=True)\n",
       "              (intermediate_act_fn): GELUActivation()\n",
       "            )\n",
       "            (output): BertOutput(\n",
       "              (dense): Linear(in_features=2048, out_features=768, bias=True)\n",
       "              (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
       "              (dropout): Dropout(p=0.1, inplace=False)\n",
       "            )\n",
       "          )\n",
       "        )\n",
       "      )\n",
       "    )\n",
       "    (linear): Linear(in_features=768, out_features=512, bias=True)\n",
       "    (dropout): Dropout(p=0.1, inplace=False)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tokenizer = AutoTokenizer.from_pretrained('DeepChem/ChemBERTa-77M-MTR')\n",
    "model_config = BertConfig(\n",
    "    vocab_size=tokenizer.vocab_size,\n",
    "    hidden_size=768,\n",
    "    num_hidden_layers=4,\n",
    "    num_attention_heads=12,\n",
    "    intermediate_size=2048,\n",
    "    max_position_embeddings=512\n",
    ")\n",
    "\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "\n",
    "model = SimSonEncoder(config=model_config, max_len=512).to(device)\n",
    "model = torch.compile(model)\n",
    "model.load_state_dict(torch.load('/home/jovyan/simson_training_bolgov/simson_checkpoints_polymer_1M/simson_model_single_gpu.bin'))\n",
    "model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "df28c332-c20b-4804-b4ca-97de9d652445",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test dataset shape: (5000, 2)\n",
      "Columns: ['smiles_1', 'smiles_2']\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>smiles_1</th>\n",
       "      <th>smiles_2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>c1c(ccc(c1)OC(=O)CCCS(CCCc1ccc(C(O*)=O)cc1)(=O...</td>\n",
       "      <td>c1cc(ccc1OC(CCCS(CCCc1ccc(C(=O)O*)cc1)(=O)=O)=...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>C(CC(=O)NCCC[Si](O*)(C)C)CCCCC(OCCCCCOC(Cc1cc(...</td>\n",
       "      <td>CN(*)Cc1cccc(c1)CC(OCCCCCOC(CCCCCCC(=O)NCCC[Si...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>C(SCCNC(OCC*)=O)CSCCCOCCNC(=O)O*</td>\n",
       "      <td>O=C(OCC*)NCCSCCSCCCOCCNC(O*)=O</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>*CCCCOC(=O)CSCCCC[PH](C)(=O)O*</td>\n",
       "      <td>*CCCCOC(=O)CSCCCC[PH](C)(=O)O*</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>C(O*)COCCOCCN(C(=O)OCCC*)C(=O)OC</td>\n",
       "      <td>C(CC*)OC(=O)N(C(=O)OC)CCOCCOCCO*</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                            smiles_1  \\\n",
       "0  c1c(ccc(c1)OC(=O)CCCS(CCCc1ccc(C(O*)=O)cc1)(=O...   \n",
       "1  C(CC(=O)NCCC[Si](O*)(C)C)CCCCC(OCCCCCOC(Cc1cc(...   \n",
       "2                   C(SCCNC(OCC*)=O)CSCCCOCCNC(=O)O*   \n",
       "3                     *CCCCOC(=O)CSCCCC[PH](C)(=O)O*   \n",
       "4                   C(O*)COCCOCCN(C(=O)OCCC*)C(=O)OC   \n",
       "\n",
       "                                            smiles_2  \n",
       "0  c1cc(ccc1OC(CCCS(CCCc1ccc(C(=O)O*)cc1)(=O)=O)=...  \n",
       "1  CN(*)Cc1cccc(c1)CC(OCCCCCOC(CCCCCCC(=O)NCCC[Si...  \n",
       "2                     O=C(OCC*)NCCSCCSCCCOCCNC(O*)=O  \n",
       "3                     *CCCCOC(=O)CSCCCC[PH](C)(=O)O*  \n",
       "4                   C(CC*)OC(=O)N(C(=O)OC)CCOCCOCCO*  "
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_data = pd.read_parquet('/home/jovyan/simson_training_bolgov/data/polymer_splits/test.parquet')\n",
    "print(f\"Test dataset shape: {test_data.shape}\")\n",
    "print(f\"Columns: {test_data.columns.tolist()}\")\n",
    "test_data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a7f2e2bc-12f5-443b-9d80-899542e07370",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating embeddings for original SMILES...\n",
      "Processed 2560 / 5000 SMILES\n",
      "Processed 5000 / 5000 SMILES\n",
      "Generating embeddings for augmented SMILES...\n",
      "Processed 2560 / 5000 SMILES\n",
      "Processed 5000 / 5000 SMILES\n",
      "Original embeddings shape: (5000, 512)\n",
      "Augmented embeddings shape: (5000, 512)\n"
     ]
    }
   ],
   "source": [
    "def generate_embeddings(model, tokenizer, smiles_list, batch_size=256, max_length=512):\n",
    "    \"\"\"Generate embeddings for a list of SMILES strings\"\"\"\n",
    "    model.eval()\n",
    "    embeddings = []\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        for i in range(0, len(smiles_list), batch_size):\n",
    "            batch_smiles = smiles_list[i:i+batch_size]\n",
    "            \n",
    "            # Tokenize batch\n",
    "            tokens = tokenizer(batch_smiles, \n",
    "                             max_length=max_length, \n",
    "                             truncation=True, \n",
    "                             padding='max_length', \n",
    "                             return_tensors='pt')\n",
    "            \n",
    "            # Move to device\n",
    "            input_ids = tokens['input_ids'].to(device)\n",
    "            attention_mask = tokens['attention_mask'].to(device)\n",
    "            \n",
    "            # Generate embeddings\n",
    "            batch_embeddings = model(input_ids, attention_mask)\n",
    "            embeddings.append(batch_embeddings.cpu().numpy())\n",
    "            \n",
    "            if (i // batch_size + 1) % 10 == 0:\n",
    "                print(f\"Processed {i + len(batch_smiles)} / {len(smiles_list)} SMILES\")\n",
    "    \n",
    "    return np.vstack(embeddings)\n",
    "\n",
    "# Generate embeddings for original and augmented SMILES\n",
    "print(\"Generating embeddings for original SMILES...\")\n",
    "original_embeddings = generate_embeddings(model, tokenizer, test_data['smiles_1'].tolist())\n",
    "\n",
    "print(\"Generating embeddings for augmented SMILES...\")\n",
    "augmented_embeddings = generate_embeddings(model, tokenizer, test_data['smiles_2'].tolist())\n",
    "\n",
    "print(f\"Original embeddings shape: {original_embeddings.shape}\")\n",
    "print(f\"Augmented embeddings shape: {augmented_embeddings.shape}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "c770d7f4-fa37-4519-bda2-9b084d2a4b32",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average cosine similarity between original and augmented SMILES: 0.9874\n",
      "Standard deviation: 0.0197\n",
      "Min similarity: 0.7691\n",
      "Max similarity: 1.0000\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def calculate_pairwise_similarities(embeddings1, embeddings2):\n",
    "    \"\"\"Calculate cosine similarities between corresponding pairs\"\"\"\n",
    "    similarities = []\n",
    "    for i in range(len(embeddings1)):\n",
    "        sim = cosine_similarity([embeddings1[i]], [embeddings2[i]])[0][0]\n",
    "        similarities.append(sim)\n",
    "    return np.array(similarities)\n",
    "\n",
    "# Calculate cosine similarities\n",
    "pairwise_similarities = calculate_pairwise_similarities(original_embeddings, augmented_embeddings)\n",
    "\n",
    "print(f\"Average cosine similarity between original and augmented SMILES: {np.mean(pairwise_similarities):.4f}\")\n",
    "print(f\"Standard deviation: {np.std(pairwise_similarities):.4f}\")\n",
    "print(f\"Min similarity: {np.min(pairwise_similarities):.4f}\")\n",
    "print(f\"Max similarity: {np.max(pairwise_similarities):.4f}\")\n",
    "\n",
    "# Plot similarity distribution\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.hist(pairwise_similarities, bins=50, alpha=0.7, edgecolor='black')\n",
    "plt.axvline(np.mean(pairwise_similarities), color='red', linestyle='--', \n",
    "           label=f'Mean: {np.mean(pairwise_similarities):.4f}')\n",
    "plt.xlabel('Cosine Similarity')\n",
    "plt.ylabel('Frequency')\n",
    "plt.title('Distribution of Cosine Similarities Between Original and Augmented SMILES')\n",
    "plt.legend()\n",
    "plt.grid(True, alpha=0.3)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "d7fa6ed4-b546-4544-bb00-4d90a99678da",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=== Embedding Space Analysis ===\n",
      "Embedding dimensionality: 512\n",
      "Average L2 norm (original): 11.9105\n",
      "Average L2 norm (augmented): 11.9072\n",
      "Average intra-class similarity (original): 0.0047\n",
      "Average intra-class similarity (augmented): 0.0048\n",
      "Average inter-class similarity: 0.0049\n",
      "\n",
      "=== Nearest Neighbor Analysis (k=5) ===\n",
      "Augmented SMILES in top-5 neighbors: 5000/5000 (100.0%)\n",
      "Augmented SMILES as top-1 neighbor: 4872/5000 (97.4%)\n"
     ]
    }
   ],
   "source": [
    "# 1. Embedding Space Statistics\n",
    "def analyze_embedding_space(original_emb, augmented_emb):\n",
    "    \"\"\"Analyze the embedding space properties\"\"\"\n",
    "    print(\"=== Embedding Space Analysis ===\")\n",
    "    \n",
    "    # Dimensionality and norms\n",
    "    print(f\"Embedding dimensionality: {original_emb.shape[1]}\")\n",
    "    print(f\"Average L2 norm (original): {np.mean(np.linalg.norm(original_emb, axis=1)):.4f}\")\n",
    "    print(f\"Average L2 norm (augmented): {np.mean(np.linalg.norm(augmented_emb, axis=1)):.4f}\")\n",
    "    \n",
    "    # Intra-class similarities\n",
    "    orig_similarities = cosine_similarity(original_emb)\n",
    "    aug_similarities = cosine_similarity(augmented_emb)\n",
    "    \n",
    "    # Remove diagonal (self-similarity)\n",
    "    orig_similarities_off_diag = orig_similarities[np.triu_indices_from(orig_similarities, k=1)]\n",
    "    aug_similarities_off_diag = aug_similarities[np.triu_indices_from(aug_similarities, k=1)]\n",
    "    \n",
    "    print(f\"Average intra-class similarity (original): {np.mean(orig_similarities_off_diag):.4f}\")\n",
    "    print(f\"Average intra-class similarity (augmented): {np.mean(aug_similarities_off_diag):.4f}\")\n",
    "    \n",
    "    # Inter-class similarities\n",
    "    inter_similarities = cosine_similarity(original_emb, augmented_emb)\n",
    "    print(f\"Average inter-class similarity: {np.mean(inter_similarities):.4f}\")\n",
    "\n",
    "analyze_embedding_space(original_embeddings, augmented_embeddings)\n",
    "\n",
    "# 2. Nearest Neighbor Analysis\n",
    "def nearest_neighbor_analysis(original_emb, augmented_emb, k=5):\n",
    "    \"\"\"Analyze nearest neighbors between original and augmented embeddings\"\"\"\n",
    "    print(f\"\\n=== Nearest Neighbor Analysis (k={k}) ===\")\n",
    "    \n",
    "    # For each original embedding, find its k nearest neighbors in augmented set\n",
    "    similarities = cosine_similarity(original_emb, augmented_emb)\n",
    "    \n",
    "    # Find cases where augmented version is among top-k neighbors\n",
    "    correct_matches = 0\n",
    "    top1_matches = 0\n",
    "    \n",
    "    for i in range(len(original_emb)):\n",
    "        # Get similarity scores for i-th original embedding\n",
    "        sim_scores = similarities[i]\n",
    "        top_k_indices = np.argsort(sim_scores)[-k:][::-1]\n",
    "        \n",
    "        if i in top_k_indices:\n",
    "            correct_matches += 1\n",
    "        if np.argmax(sim_scores) == i:\n",
    "            top1_matches += 1\n",
    "    \n",
    "    print(f\"Augmented SMILES in top-{k} neighbors: {correct_matches}/{len(original_emb)} ({100*correct_matches/len(original_emb):.1f}%)\")\n",
    "    print(f\"Augmented SMILES as top-1 neighbor: {top1_matches}/{len(original_emb)} ({100*top1_matches/len(original_emb):.1f}%)\")\n",
    "\n",
    "nearest_neighbor_analysis(original_embeddings, augmented_embeddings)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f136743a-c742-469b-a9b8-9a4da8eb4c08",
   "metadata": {},
   "source": [
    "Объяснение\n",
    "\n",
    "* Embedding Space Analysis. Показывает, что различные величины (L2 norm - длина вектора, близости) практически идентичны для оригинальных, и для аугментированных молекул (показывая, что они отображаются практически одними и теми же для модели)\n",
    "* Nearest Neighbor Analysis (k=5). Показывает, что топ 5 ближайших векторов к любому из векторов - всегда его аугментация (кроме его самого, естественно). В 97.4 % случаях вектор, соответствующий аугментации, является ближайшим."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "133fb52e-bea8-4159-ab06-386998b71ed0",
   "metadata": {},
   "source": [
    "С разными SMILES - ровно обратная картина, как и должно быть (различные smiles являются очень разными)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "cc48f04e-b8bf-415b-89f0-b51d98f7e6b6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "\n",
    "num_molecules = original_embeddings.shape[0]\n",
    "\n",
    "# Shuffle indices for unrelated molecules\n",
    "unrelated_indices = np.random.permutation(num_molecules)\n",
    "unrelated_embeddings = augmented_embeddings[unrelated_indices]\n",
    "\n",
    "# Compute pairwise cosine similarity between original and unrelated\n",
    "pairwise_unrelated_similarities = np.array([\n",
    "    cosine_similarity([original_embeddings[i]], [unrelated_embeddings[i]])[0][0]\n",
    "    for i in range(num_molecules)\n",
    "])\n",
    "\n",
    "\n",
    "plt.figure(figsize=(10,6))\n",
    "plt.hist(pairwise_unrelated_similarities, bins=50, alpha=0.7, color='skyblue', edgecolor='black')\n",
    "mean_sim = pairwise_unrelated_similarities.mean()\n",
    "plt.axvline(mean_sim, color='red', linestyle='--', label=f'Mean = {mean_sim:.4f}')\n",
    "plt.xlabel('Cosine Similarity')\n",
    "plt.ylabel('Frequency')\n",
    "plt.title('Cosine Similarity Distribution of Different Molecules (Unrelated SMILES)')\n",
    "plt.legend()\n",
    "plt.grid(True, alpha=0.3)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "881eca62-7bf5-4b84-b0df-659942930a73",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean cosine similarity: 0.0048\n",
      "Std deviation: 0.1357\n",
      "Range: -0.4617 to 0.6631\n"
     ]
    }
   ],
   "source": [
    "print(f\"Mean cosine similarity: {pairwise_unrelated_similarities.mean():.4f}\")\n",
    "print(f\"Std deviation: {pairwise_unrelated_similarities.std():.4f}\")\n",
    "print(f\"Range: {pairwise_unrelated_similarities.min():.4f} to {pairwise_unrelated_similarities.max():.4f}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "051f4149-d3eb-472b-b6d0-7060662efb6a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unrelated in top-5 neighbors: 4/5000\n",
      "Unrelated as top-1 neighbor: 0/5000\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics.pairwise import cosine_similarity\n",
    "\n",
    "k = 5\n",
    "similarities = cosine_similarity(original_embeddings, unrelated_embeddings)\n",
    "correct_matches = sum(i in np.argsort(similarities[i])[-k:] for i in range(num_molecules))\n",
    "top1_matches = sum(np.argmax(similarities[i]) == i for i in range(num_molecules))\n",
    "\n",
    "print(f\"Unrelated in top-{k} neighbors: {correct_matches}/{num_molecules}\")\n",
    "print(f\"Unrelated as top-1 neighbor: {top1_matches}/{num_molecules}\")\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:.mlspace-bolgov_simson_training]",
   "language": "python",
   "name": "conda-env-.mlspace-bolgov_simson_training-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}