Implementasikan kueri aproksimasi untuk geometri molekul menggunakan TairVector - Tair (Redis® OSS-Compatible)

Topik ini menjelaskan cara menggunakan TairVector untuk mengimplementasikan kueri aproksimasi geometri molekul.

Informasi latar belakang

Dalam penemuan obat berbasis AI, vektor sering digunakan untuk merepresentasikan senyawa dan farmasi serta menghitung kesamaan antara mereka. Hal ini memungkinkan peneliti memprediksi dan mengoptimalkan reaksi kimia dari senyawa atau farmasi yang berbeda. Skenario ini memerlukan kueri aproksimasi geometri molekul yang cepat dan akurat menggunakan vektor untuk mempercepat R&D obat baru.

Dibandingkan dengan layanan pengambilan vektor konvensional, TairVector menyimpan data di memori dan mendukung pembaruan indeks secara real-time untuk mengurangi latensi baca dan tulis. Selain itu, TairVector menyediakan perintah seperti TVS.KNNSEARCH untuk kueri tetangga terdekat vektor, memungkinkan peneliti dengan cepat mengambil geometri molekul yang paling mirip untuk geometri tertentu. Ini mencegah kesalahan dan kerugian yang disebabkan oleh perhitungan manual.

Solusi

Gambar berikut menunjukkan alur kerja. Tair Vector分子结构检索流程图..jpeg

Unduh dataset geometri molekul dalam format file Simplified Molecular Input Line Entry System (SMILES atau SMI).

Contoh ini menggunakan 11.012 baris data dari dataset sumber terbuka di PubChem sebagai data uji, termasuk kolom rumus molekul dan ID unik.

Catatan

Dalam kasus penggunaan nyata, Anda dapat menulis lebih banyak data ke Tair untuk merasakan kemampuannya mengambil vektor dalam milidetik.

CCC1=CN=C2C(C(=O)N(C)C(=O)N2C)/C1=N/c1ccc(OC)cc1OC,168000001
CC(C)CN1C(=O)C2SCCC2N2C(=S)NNC12,168000002
CC1=C[NH+]=C2C(C(=O)N(C)C(=O)N2C)/C1=N/c1cccc(C(F)(F)F)c1,168000003
CC1=CN=C2C(C(=O)N(C)C(=O)N2C)/C1=N/c1cccc(C(F)(F)F)c1,168000004

Jika Anda mengunduh dataset langsung dari PubChem, Anda akan mendapatkan file dalam format Spatial Data File (SDF). Dalam hal ini, jalankan kode berikut untuk mengonversi file ke format SMI.

Kode Sampel

import sys
from rdkit import Chem

def converter(file_name):
    mols = [mol for mol in Chem.SDMolSupplier(file_name)]
    outname = file_name.split(".sdf")[0] + ".smi"
    out_file = open(outname, "w")
    for mol in mols:
        smi = Chem.MolToSmiles(mol)
        name = mol.GetProp("_Name")
        out_file.write("{},{}\n".format(smi, name))
    out_file.close()

if __name__ == "__main__":
    converter(sys.argv[1])

Hubungkan ke instance Tair Anda. Untuk implementasi kode spesifik, lihat fungsi get_tair dalam kode sampel berikut.
Buat indeks vektor di instance Tair untuk menyimpan geometri molekul. Untuk implementasi kode spesifik, lihat fungsi create_index dalam kode sampel berikut.
Tulis geometri molekul yang ingin Anda kueri untuk geometri serupa. Untuk implementasi kode spesifik, lihat fungsi do_load dalam kode sampel berikut.
RDKit digunakan untuk mengekstrak vektor fitur dari geometri molekul yang ditentukan, dan perintah TVS.HSET dari TairVector dijalankan untuk menulis ID unik, informasi fitur, dan rumus molekul ke instance Tair.
Kueri geometri molekul serupa untuk geometri yang ditentukan. Untuk implementasi kode spesifik, lihat fungsi do_search dalam kode sampel berikut.
RDKit digunakan untuk mengekstrak vektor fitur dari geometri molekul yang ditentukan, dan perintah TVS.KNNSEARCH dari TairVector dijalankan untuk mengkueri geometri molekul yang paling mirip dari indeks tertentu di instance Tair.

Contoh kode

Contoh ini menggunakan Python 3.8, dengan dependensi numpy, rdkit, tair, dan matplotlib diinstal menggunakan perintah pip install.

import os
import sys
from tair import Tair
from tair.tairvector import DistanceMetric
from rdkit.Chem import Draw, AllChem
from rdkit import DataStructs, Chem
from rdkit import RDLogger
from concurrent.futures import ThreadPoolExecutor
RDLogger.DisableLog('rdApp.*')


def get_tair() -> Tair:
    """
    Hubungkan ke instance Tair. 
    * host: titik akhir yang digunakan untuk menghubungkan ke instance Tair. 
    * port: nomor port yang digunakan untuk menghubungkan ke instance Tair. Nilai default: 6379. 
    * password: kata sandi akun database default dari instance Tair. Jika Anda ingin menghubungkan ke instance Tair menggunakan akun database kustom, Anda harus menentukan kata sandi dalam format username:kata sandi. 
    """
    tair: Tair = Tair(
        host="r-bp1mlxv3xzv6kf****pd.redis.rds.aliyuncs.com",
        port=6379,
        db=0,
        password="Da******3",
    )
    return tair


def create_index():
    """
    Buat indeks vektor untuk menyimpan geometri molekul.
    * Dalam contoh ini, indeks diberi nama MOLSEARCH_TEST. 
    * Dimensi vektor adalah 512. 
    * Ukuran jarak Euclidean (L2 norm) digunakan. 
    * Algoritma pengindeksan Hierarchical Navigable Small World (HNSW) digunakan. 
    """
    ret = tair.tvs_get_index(INDEX_NAME)
    if ret is None:
        tair.tvs_create_index(INDEX_NAME, 512, distance_type=DistanceMetric.L2, index_type="HNSW")
    print("buat indeks selesai")


def do_load(file_path):
    """
    Tentukan jalur dataset geometri molekul Anda. Metode ini secara otomatis mengekstrak vektor fitur dari geometri molekul dengan memanggil fungsi smiles_to_vector dan menulis vektor fitur ke TairVector. 
    Metode ini memanggil fungsi seperti parallel_submit_lines, handle_line, smiles_to_vector, dan insert_data. 
    Tulis data tentang geometri molekul ke TairVector dalam format berikut:
    * Nama indeks vektor: MOLSEARCH_TEST. 
    * ID unik: kunci geometri molekul. Contoh: 168000001. 
    * Informasi fitur: Dimensi vektor adalah 512. 
    * smiles: rumus molekul geometri molekul. Contoh: CCC1=CN=C2C(C(=O)N(C)C(=O)N2C)/C1=N/c1ccc(OC)cc1OC. 
    """
    num = 0
    lines = []
    with open(file_path, 'r') as f:
        for line in f:
            if line.find("smiles") >= 0:
                continue
            lines.append(line)
            if len(lines) >= 10:
                parallel_submit_lines(lines)
                num += len(lines)
                lines.clear()
                if num % 10000 == 0:
                    print("muat jumlah", num)
    if len(lines) > 0:
        parallel_submit_lines(lines)
    print("muat selesai")


def parallel_submit_lines(lines):
    """
    Panggil metode ini untuk penulisan bersamaan. 
    """
    with ThreadPoolExecutor(len(lines)) as t:
        for line in lines:
            t.submit(handle_line, line=line)


def handle_line(line):
    """
    Tulis geometri molekul tunggal. 
    """
    if line.find("smiles") >= 0:
        return
    parts = line.strip().split(',')
    try:
        ids = parts[1]
        smiles = parts[0]
        vec = smiles_to_vector(smiles)
        insert_data(ids, smiles, vec)
    except Exception as result:
        print(result)


def smiles_to_vector(smiles):
    """
    Ekstrak vektor fitur dari geometri molekul dan konversikan data yang diekstraksi dari format file SMI ke vektor. 
    """
    mols = Chem.MolFromSmiles(smiles)
    fp = AllChem.GetMorganFingerprintAsBitVect(mols, 2, 512 * 8)
    hex_fp = DataStructs.BitVectToFPSText(fp)
    vec = list(bytearray.fromhex(hex_fp))
    return vec


def insert_data(id, smiles, vector):
    """
    Tulis vektor geometri molekul ke TairVector. 
    """
    attr = {'smiles': smiles}
    tair.tvs_hset(INDEX_NAME, id, vector, **attr)


def do_search(search_smiles,k):
    """
    Tentukan geometri molekul yang ingin Anda lakukan kueri aproksimasi. Metode ini mengkueri dan mengembalikan k geometri molekul yang paling mirip dengan geometri molekul yang ditentukan dari indeks tertentu di instance Tair. 
    Metode ini mengekstrak vektor fitur dari geometri molekul yang ditentukan, menjalankan perintah TVS.KNNSEARCH untuk mengkueri ID k geometri molekul yang paling mirip dengan geometri molekul yang ditentukan, dan kemudian menjalankan perintah TVS.HMGET untuk mengkueri rumus molekul dari geometri molekul tersebut. Dalam contoh ini, k diatur ke 10. 
    """
    vector = smiles_to_vector(search_smiles)
    result = tair.tvs_knnsearch(INDEX_NAME, k, vector)
    print("Geometri molekul berikut yang paling mirip dengan geometri molekul yang ditentukan dikembalikan:")
    for key, value in result:
        similar_smiles = tair.tvs_hmget(INDEX_NAME, key, "smiles")
        print(key, value, similar_smiles)


if __name__ == "__main__":
    # Hubungkan ke instance Tair dan buat indeks vektor bernama MOLSEARCH_TEST. 
    tair = get_tair()
    INDEX_NAME = "MOLSEARCH_TEST"
    create_index()
    # Tulis data sampel. 
    do_load("D:\Test\Compound_168000001_168500000.smi")
    # Kueri 10 geometri molekul yang paling mirip dengan rumus molekul CCOC(=O)N1CCC(NC(=O)CN2CCN(c3cc(C)cc(C)c3)C(=O)C2=O)CC1 dari indeks MOLSEARCH_TEST. 
    do_search("CCOC(=O)N1CCC(NC(=O)CN2CCN(c3cc(C)cc(C)c3)C(=O)C2=O)CC1",10)

Keluaran sukses sampel:

buat indeks selesai
muat jumlah 10000
muat selesai
Geometri molekul berikut yang paling mirip dengan geometri molekul yang ditentukan dikembalikan:
b'168000009' 0.0 ['CCOC(=O)N1CCC(NC(=O)CN2CCN(c3cc(C)cc(C)c3)C(=O)C2=O)CC1']
b'168003114' 29534.0 ['Cc1cc(C)cc(N2CCN(CC(=O)NC3CCCC3)C(=O)C2=O)c1']
b'168000210' 60222.0 ['COc1ccc(N2CCN(CC(=O)Nc3cc(C)cc(C)c3)C(=O)C2=O)cc1OC']
b'168001000' 61123.0 ['COc1ccc(N2CCN(CC(=O)Nc3ccc(C)cc3)C(=O)C2=O)cc1OC']
b'168003038' 64524.0 ['CCN1CCN(c2cc(C)cc(C)c2)C(=O)C1=O']
b'168003095' 67591.0 ['O=C(CN1CCN(c2cccc(Cl)c2)C(=O)C1=O)NC1CCCC1']
b'168000396' 70376.0 ['COc1ccc(N2CCN(Cc3ccc(C)cc3)C(=O)C2=O)cc1OC']
b'168002227' 71121.0 ['CCOC(=O)CN1CCN(C2CC2)C(=O)C1=O']
b'168000441' 73197.0 ['Cc1cc(C)cc(NC(=O)CN2CCN(c3ccc(F)c(F)c3)C(=O)C2=O)c1']
b'168000561' 73269.0 ['Cc1cc(C)cc(N2CCN(CC(=O)Nc3ccc(C)cc3C)C(=O)C2=O)c1']

Hasil

Anda dapat mengonversi representasi SMILES geometri molekul menjadi objek gambar, seperti yang ditunjukkan pada gambar berikut. 相似分子结构检索..jpeg

Kode Sampel

import numpy
from rdkit.Chem import Draw
from rdkit import Chem
import matplotlib.pyplot as plt

def to_images(data):
    imgs = []
    for smiles in data:
        mol = Chem.MolFromSmiles(smiles)
        img=Chem.Draw.MolToImage(mol,size=(500,500))
        imgs.append(img )
        plt.imshow(img)
        plt.show()
    return imgs

if __name__ == "__main__":
    images = to_images(["CCOC(=O)N1CCC(NC(=O)CN2CCN(c3cc(C)cc(C)c3)C(=O)C2=O)CC1"])

Ringkasan

TairVector memungkinkan Anda mengkueri geometri molekul yang paling mirip dalam milidetik. Semakin banyak geometri molekul yang dimiliki instance Tair Anda, semakin akurat hasil kueri aproksimasi. Ini membantu mempercepat R&D obat baru.