matchms-spectral-matching

Matchms — スペクトルマッチングと代謝物の同定

概要

Matchmsは、スペクトル類似度の計算と化合物の同定に重点を置いた、質量分析データ処理用のPythonライブラリです。複数形式の入出力、メタデータの調整とピーク処理に使える50種類以上のスペクトルフィルター、8種類の類似度スコアリング関数、再現性の高い分析ワークフローを実現するパイプラインフレームワークを提供します。

使用する場面

• MS/MSスペクトルを参照ライブラリと照合して未知の代謝物を同定する場合
• スペクトル類似度スコア（コサイン、修正コサイン、フィンガープリントベース）を計算する場合
• 複数形式（mzML、MGF、MSP、JSON）の質量スペクトルデータを処理して標準化する場合
• 品質管理のために再現性の高いスペクトル処理パイプラインを構築する場合
• スペクトルデータベース間でメタデータ（化合物名、SMILES、InChI、付加イオン）を調整する場合
• 大規模なスペクトルライブラリの比較や重複検出を行う場合
• LC-MS/MSプロテオミクスのワークフロー全般（特徴量検出、タンパク質同定）には、代わりにpyopenmsを使用してください
• 質量スペクトルを使わずに化学構造の類似性を調べるには、rdkitのフィンガープリント比較を使用してください

前提条件

uv pip install matchms numpy pandas
# For chemical structure processing (SMILES, InChI, fingerprints):
uv pip install matchms[chemistry]

• Python 3.8以上。ピーク配列の操作にはNumPyが必要です
• 入力：MGF、MSP、mzML、mzXML、JSON、またはpickle形式のスペクトルデータ
• 照合用の参照ライブラリ（サポートされている形式であれば使用可能）

事前確認

分析コードを書く前に、以下の内容をユーザーと確認してください。

decisions:
  - id: D1
    param: referenceLibrary
    kind: required
    source: user
    ask: "Which spectral library should queries be matched against?"
    default: null

  - id: D2
    param: similarityMeasure
    kind: required
    source: user
    ask: "Should matching require the same precursor mass, or allow a mass shift so modified analogues still match?"
    default: "cosine on matched peaks, precursor mass fixed"

  - id: D3
    param: peakMatchTolerance
    kind: required
    source: data
    ask: "How close must two peaks be in m/z to count as the same fragment?"
    default: "0.1 Da - tighten toward 0.005 for high-resolution data"

  - id: D4
    param: spectrumPreprocessing
    kind: required
    source: user
    ask: "Which peaks should be discarded before scoring - low-intensity noise, peaks near the precursor, or spectra with too few peaks to be informative?"
    default: "drop peaks under 1% relative intensity, require at least 10 peaks"

  - id: D5
    param: scoreCutoff
    kind: required
    source: user
    ask: "What similarity score, and how many matched peaks, should a hit need before it is reported as an identification?"
    default: null

  - id: D6
    param: peakWeighting
    kind: optional
    source: user
    ask: "Should the score weight fragment m/z as well as intensity, favouring informative high-mass fragments?"
    default: "intensity only"

  - id: D7
    param: fingerprintSettings
    kind: optional_conditional
    source: user
    ask: "Which molecular fingerprint should structural similarity use, when comparing hits to known structures?"
    default: "not computed"

D3とD5には、安全な共通のデフォルト値はありません。この2つは直接的にトレードオフの関係にあるためです。許容誤差を緩くし、スコアのしきい値を低くすると、もっともらしく見える同定結果がすべてのクエリスペクトルに返されます。許容誤差は装置の実際の精度に基づいて設定し、しきい値はライブラリが対応できる範囲に基づいて設定してください。

クイックスタート

from matchms.importing import load_from_mgf
from matchms.filtering import default_filters, normalize_intensities
from matchms.filtering import select_by_relative_intensity, require_minimum_number_of_peaks
from matchms import calculate_scores
from matchms.similarity import CosineGreedy

# Load and process query spectra
queries = list(load_from_mgf("queries.mgf"))
queries = [default_filters(s) for s in queries]
queries = [normalize_intensities(s) for s in queries if s is not None]
queries = [require_minimum_number_of_peaks(s, n_required=5) for s in queries if s is not None]

# Load reference library
refs = list(load_from_mgf("library.mgf"))
refs = [default_filters(s) for s in refs]
refs = [normalize_intensities(s) for s in refs if s is not None]

# Calculate similarity scores
scores = calculate_scores(references=refs, queries=queries,
                          similarity_function=CosineGreedy(tolerance=0.1))
# Get best matches for first query
best = scores.scores_by_query(queries[0], sort=True)[:5]
for match, score_tuple in best:
    print(f"Score: {score_tuple['score']:.3f}, Matches: {score_tuple['matches']}")

コアAPI

モジュール1：スペクトルの入出力

複数のファイル形式からスペクトルを読み込み、処理済みデータを書き出します。

from matchms.importing import (load_from_mgf, load_from_mzml, load_from_msp,
                                load_from_json, load_from_mzxml, load_from_pickle,
                                load_from_usi)
from matchms.exporting import save_as_mgf, save_as_msp, save_as_json, save_as_pickle

# Import from various formats (returns generators)
spectra_mgf = list(load_from_mgf("library.mgf"))
spectra_mzml = list(load_from_mzml("data.mzML"))
spectra_msp = list(load_from_msp("nist_library.msp"))
spectra_json = list(load_from_json("gnps_spectra.json"))
print(f"Loaded: MGF={len(spectra_mgf)}, mzML={len(spectra_mzml)}")

# Export processed spectra
save_as_mgf(spectra_mgf, "processed.mgf")
save_as_json(spectra_mgf, "processed.json")
save_as_pickle(spectra_mgf, "spectra.pickle")  # Fast for intermediate results

# Pickle for large datasets (fastest I/O)
from matchms.importing import load_from_pickle
spectra = list(load_from_pickle("spectra.pickle"))

from matchms import Spectrum
import numpy as np

# Create spectrum manually
mz = np.array([100.0, 150.0, 200.0, 250.0, 300.0])
intensities = np.array([0.1, 0.5, 0.9, 0.3, 0.7])
metadata = {
    "precursor_mz": 325.5,
    "ionmode": "positive",
    "compound_name": "Caffeine",
    "smiles": "CN1C=NC2=C1C(=O)N(C(=O)N2C)C"
}
spectrum = Spectrum(mz=mz, intensities=intensities, metadata=metadata)

# Access spectrum data
print(f"Peaks: {spectrum.peaks.mz}")
print(f"Precursor: {spectrum.get('precursor_mz')}")
print(f"Name: {spectrum.get('compound_name')}")

# Visualize
spectrum.plot()

モジュール2：スペクトルのフィルタリングと処理

メタデータの調整とピーク処理のフィルターを適用します。Matchmsは50種類以上のフィルターを提供します。

from matchms.filtering import (
    default_filters, normalize_intensities,
    select_by_relative_intensity, select_by_mz,
    require_minimum_number_of_peaks, reduce_to_number_of_peaks,
    remove_peaks_around_precursor_mz, add_losses
)

# default_filters applies: metadata cleanup, charge correction, adduct parsing
spectrum = default_filters(spectrum)

# Peak normalization (max intensity → 1.0)
spectrum = normalize_intensities(spectrum)

# Filter peaks by relative intensity (remove noise below 1%)
spectrum = select_by_relative_intensity(spectrum, intensity_from=0.01, intensity_to=1.0)

# Filter peaks by m/z range
spectrum = select_by_mz(spectrum, mz_from=50.0, mz_to=500.0)

# Keep top N peaks only
spectrum = reduce_to_number_of_peaks(spectrum, n_max=50)

# Remove peaks near precursor (common contaminants)
spectrum = remove_peaks_around_precursor_mz(spectrum, mz_tolerance=17.0)

# Require minimum peaks for matching
spectrum = require_minimum_number_of_peaks(spectrum, n_required=5)

# Add neutral losses (useful for NeutralLossesCosine)
spectrum = add_losses(spectrum)

if spectrum is not None:
    print(f"After filtering: {len(spectrum.peaks.mz)} peaks")

# Chemical annotation filters (require matchms[chemistry])
from matchms.filtering import (
    derive_inchi_from_smiles, derive_inchikey_from_inchi,
    derive_smiles_from_inchi, add_fingerprint,
    repair_inchi_inchikey_smiles, require_valid_annotation
)

# Derive chemical identifiers from SMILES
spectrum = derive_inchi_from_smiles(spectrum)
spectrum = derive_inchikey_from_inchi(spectrum)

# Add molecular fingerprint for structural similarity
spectrum = add_fingerprint(spectrum, fingerprint_type="morgan", nbits=2048)

# Validate annotations
spectrum = require_valid_annotation(spectrum)
if spectrum is not None:
    print(f"InChIKey: {spectrum.get('inchikey')}")

モジュール3：類似度スコアリング

複数の類似度指標を使ってスペクトルを比較します。

from matchms import calculate_scores
from matchms.similarity import (
    CosineGreedy, CosineHungarian, ModifiedCosine,
    NeutralLossesCosine, FingerprintSimilarity,
    MetadataMatch, PrecursorMzMatch
)

# CosineGreedy — fast peak matching (greedy algorithm)
scores = calculate_scores(references=library, queries=unknowns,
                          similarity_function=CosineGreedy(tolerance=0.1))

# ModifiedCosine — accounts for precursor mass differences (best for analog search)
scores = calculate_scores(references=library, queries=unknowns,
                          similarity_function=ModifiedCosine(tolerance=0.1))

# CosineHungarian — optimal peak matching (slower but more accurate)
scores = calculate_scores(references=library, queries=unknowns,
                          similarity_function=CosineHungarian(tolerance=0.1))

# NeutralLossesCosine — similarity based on neutral loss patterns
scores = calculate_scores(references=library, queries=unknowns,
                          similarity_function=NeutralLossesCosine(tolerance=0.1))

# Access results
for i, query in enumerate(unknowns[:3]):
    best_matches = scores.scores_by_query(query, sort=True)[:3]
    print(f"\nQuery {i}: precursor_mz={query.get('precursor_mz')}")
    for ref, score_tuple in best_matches:
        print(f"  {ref.get('compound_name', 'Unknown')}: "
              f"score={score_tuple['score']:.3f}, matches={score_tuple['matches']}")

# FingerprintSimilarity — structural similarity (requires fingerprints)
from matchms.similarity import FingerprintSimilarity
scores = calculate_scores(references=library, queries=unknowns,
                          similarity_function=FingerprintSimilarity(
                              similarity_measure="jaccard"))

# PrecursorMzMatch — fast mass-based pre-filtering
from matchms.similarity import PrecursorMzMatch
scores = calculate_scores(references=library, queries=unknowns,
                          similarity_function=PrecursorMzMatch(tolerance=0.1))

# Multi-metric scoring: combine peak + structural similarity
cosine_scores = calculate_scores(references=library, queries=unknowns,
                                  similarity_function=CosineGreedy(tolerance=0.1))
fp_scores = calculate_scores(references=library, queries=unknowns,
                              similarity_function=FingerprintSimilarity())

モジュール4：処理パイプライン

再利用可能で再現性の高い、複数段階の処理ワークフローを構築します。

from matchms import SpectrumProcessor
from matchms.filtering import (
    default_filters, normalize_intensities,
    select_by_relative_intensity, require_minimum_number_of_peaks,
    remove_peaks_around_precursor_mz, add_losses
)

# Define reusable pipeline
pipeline = SpectrumProcessor([
    default_filters,
    normalize_intensities,
    lambda s: select_by_relative_intensity(s, intensity_from=0.01),
    lambda s: remove_peaks_around_precursor_mz(s, mz_tolerance=17.0),
    lambda s: require_minimum_number_of_peaks(s, n_required=5),
    add_losses
])

# Apply to all spectra (filters returning None remove the spectrum)
processed = [pipeline(s) for s in raw_spectra]
processed = [s for s in processed if s is not None]
print(f"Processed: {len(processed)}/{len(raw_spectra)} spectra retained")

主な概念

類似度関数の比較

関数	速度	精度	最適な用途
CosineGreedy	高速	良好	一般的なライブラリ照合
CosineHungarian	低速	最良	小規模な比較、検証
ModifiedCosine	高速	良好	類縁体検索（プリカーサーが異なる場合）
NeutralLossesCosine	中程度	良好	構造クラスの同定
FingerprintSimilarity	高速	中程度	構造ベースの事前フィルタリング
PrecursorMzMatch	最速	該当なし	質量ベースの事前フィルタリング

フィルターのカテゴリー

カテゴリー	例	目的
メタデータの整理	default_filters, clean_compound_name, clean_adduct	メタデータ項目を標準化する
化学的な情報の導出	derive_inchi_from_smiles, add_fingerprint	化学識別子を計算する
質量／電荷	add_precursor_mz, correct_charge, add_parent_mass	質量情報を修正して検証する
ピークの正規化	normalize_intensities, select_by_relative_intensity	ピークをスケーリングしてフィルタリングする
ピークの削減	reduce_to_number_of_peaks, remove_peaks_around_precursor_mz	ノイズやアーティファクトを除去する
品質管理	require_minimum_number_of_peaks, require_precursor_mz	最低品質基準を適用する
中性損失	add_losses	プリカーサーとフラグメントの損失を計算する

スコアタプルの構成

すべての類似度関数は(score, matches)を返します：

• score：float 0.0～1.0（コサイン類似度の値）
• matches：int（クエリと参照スペクトル間で一致したピーク数）

スコアが高く、一致したピーク数が多いほど、より良い一致を示します。確度の高い同定における一般的なしきい値は、score > 0.7かつmatches > 6です。

一般的なワークフロー

ワークフロー 1：代謝物同定のためのライブラリマッチング

from matchms.importing import load_from_mgf
from matchms.filtering import default_filters, normalize_intensities
from matchms.filtering import select_by_relative_intensity, require_minimum_number_of_peaks
from matchms import calculate_scores
from matchms.similarity import ModifiedCosine
import pandas as pd

# Load and process both queries and library identically
def process_spectra(spectra):
    processed = []
    for s in spectra:
        s = default_filters(s)
        if s is None: continue
        s = normalize_intensities(s)
        s = select_by_relative_intensity(s, intensity_from=0.01)
        s = require_minimum_number_of_peaks(s, n_required=5)
        if s is not None:
            processed.append(s)
    return processed

queries = process_spectra(load_from_mgf("unknowns.mgf"))
library = process_spectra(load_from_mgf("reference_library.mgf"))
print(f"Queries: {len(queries)}, Library: {len(library)}")

# Score all query-reference pairs
scores = calculate_scores(references=library, queries=queries,
                          similarity_function=ModifiedCosine(tolerance=0.1))

# Extract best matches
results = []
for query in queries:
    best = scores.scores_by_query(query, sort=True)[:1]
    if best:
        ref, score_tuple = best[0]
        results.append({
            "query_precursor_mz": query.get("precursor_mz"),
            "match_name": ref.get("compound_name", "Unknown"),
            "match_smiles": ref.get("smiles", ""),
            "score": score_tuple["score"],
            "matched_peaks": score_tuple["matches"]
        })

df = pd.DataFrame(results)
confident = df[df["score"] > 0.7]
print(f"Confident matches (score>0.7): {len(confident)}/{len(df)}")
df.to_csv("identification_results.csv", index=False)

ワークフロー 2：品質管理とデータクリーニング

from matchms.importing import load_from_msp
from matchms.exporting import save_as_mgf
from matchms import SpectrumProcessor
from matchms.filtering import (
    default_filters, normalize_intensities,
    select_by_relative_intensity, require_minimum_number_of_peaks,
    require_precursor_mz, add_parent_mass
)

# Define QC pipeline
qc_pipeline = SpectrumProcessor([
    default_filters,
    require_precursor_mz,
    add_parent_mass,
    normalize_intensities,
    lambda s: select_by_relative_intensity(s, intensity_from=0.001),
    lambda s: require_minimum_number_of_peaks(s, n_required=3)
])

# Process and filter
raw = list(load_from_msp("raw_library.msp"))
cleaned = [qc_pipeline(s) for s in raw]
cleaned = [s for s in cleaned if s is not None]

print(f"Input: {len(raw)}, Output: {len(cleaned)} ({len(cleaned)/len(raw)*100:.1f}% retained)")
save_as_mgf(cleaned, "cleaned_library.mgf")

ワークフロー 3：フォーマット変換

1. ソース形式からスペクトルを読み込みます（Core API Module 1 — load_from_mzml）
2. メタデータを調和させるために default_filters を適用します（Core API Module 2）
3. ターゲット形式にエクスポートします（Core API Module 1 — save_as_mgf）

主なパラメーター

パラメーター	関数／モジュール	デフォルト	範囲／オプション	効果
tolerance	CosineGreedy/ModifiedCosine	0.1	0.005–0.5 Da	ピークマッチングの m/z 許容誤差
mz_power	CosineGreedy	0.0	0.0–2.0	スコアリングにおける m/z の重み（0＝無視）
intensity_power	CosineGreedy	1.0	0.0–2.0	スコアリングにおける強度の重み
intensity_from	select_by_relative_intensity	0.0	0.0–1.0	保持する相対強度の最小値
n_required	require_minimum_number_of_peaks	10	1–100	スペクトルに保持するピークの最小数
n_max	reduce_to_number_of_peaks	100	10–500	保持するピークの最大数
mz_tolerance	remove_peaks_around_precursor_mz	17.0	0.5–50 Da	除去するプリカーサー周辺の範囲
fingerprint_type	add_fingerprint	"daylight"	"daylight"/"morgan"/"maccs"	分子フィンガープリントの種類
nbits	add_fingerprint	2048	256–4096	フィンガープリントのビットベクトル長

ベストプラクティス

1. クエリと参照データには必ず同じ処理を適用します — 類似度スコアの系統的な偏りを避けるため、両方のデータセットに同じフィルタリングパイプラインを適用します
2. 中間結果は pickle 形式で保存します — 再読み込みには pickle 形式が最速です。他のツールとの共有には MGF/MSP を使用します
3. プリカーサー質量で事前にフィルタリングします — 大規模なライブラリでは、まず PrecursorMzMatch を使用して比較対象を絞り込み、その後 CosineGreedy でスコアを計算します
4. 複数の指標を組み合わせます — より確実な同定のために、CosineGreedy（ピークマッチング）と FingerprintSimilarity（構造）の両方を使用します
5. フィルタリング後に None でないことを確認します — スペクトルが品質要件を満たさない場合、フィルターは None を返します。必ず次のようにフィルタリングします：[s for s in processed if s is not None]
6. 類縁体検索には ModifiedCosine を使用します — クエリ対象の化合物がライブラリに完全一致で登録されていない可能性がある場合、ModifiedCosine はプリカーサー質量の差を処理できます

よく使うレシピ

レシピ 1：プリカーサーで絞り込むライブラリ検索（効率的）

from matchms import calculate_scores
from matchms.similarity import PrecursorMzMatch, CosineGreedy

# Step 1: Fast mass filter
mass_scores = calculate_scores(references=library, queries=unknowns,
                                similarity_function=PrecursorMzMatch(tolerance=0.5))

# Step 2: Detailed scoring only for mass-matched pairs
cosine = CosineGreedy(tolerance=0.1)
for query in unknowns:
    candidates = mass_scores.scores_by_query(query, sort=True)
    mass_matched = [ref for ref, score in candidates if score["score"] > 0]
    if mass_matched:
        detailed = calculate_scores(references=mass_matched, queries=[query],
                                     similarity_function=cosine)
        best = detailed.scores_by_query(query, sort=True)[:3]
        for ref, s in best:
            print(f"{ref.get('compound_name')}: {s['score']:.3f}")

レシピ 2：イオンモード別の処理

from matchms.importing import load_from_mgf
from matchms.filtering import default_filters, normalize_intensities

spectra = list(load_from_mgf("mixed_library.mgf"))
spectra = [default_filters(s) for s in spectra]
spectra = [s for s in spectra if s is not None]

# Separate by ion mode
positive = [s for s in spectra if s.get("ionmode") == "positive"]
negative = [s for s in spectra if s.get("ionmode") == "negative"]
print(f"Positive: {len(positive)}, Negative: {len(negative)}")

# Process each mode with mode-specific filtering
positive = [normalize_intensities(s) for s in positive]
negative = [normalize_intensities(s) for s in negative]

レシピ 3：メタデータ拡充レポート

import pandas as pd
from matchms.importing import load_from_mgf
from matchms.filtering import default_filters

spectra = [default_filters(s) for s in load_from_mgf("library.mgf")]
spectra = [s for s in spectra if s is not None]

# Extract metadata summary
rows = []
for s in spectra:
    rows.append({
        "compound_name": s.get("compound_name", ""),
        "precursor_mz": s.get("precursor_mz"),
        "ionmode": s.get("ionmode", ""),
        "smiles": s.get("smiles", ""),
        "inchikey": s.get("inchikey", ""),
        "num_peaks": len(s.peaks.mz)
    })

df = pd.DataFrame(rows)
print(f"Library: {len(df)} spectra")
print(f"Named: {(df.compound_name != '').sum()}")
print(f"With SMILES: {(df.smiles != '').sum()}")
print(f"Ion modes: {df.ionmode.value_counts().to_dict()}")

トラブルシューティング

問題	原因	解決策
すべてのスコアが 0.0 になる	許容誤差内に一致するピークがない	tolerance を大きくします（0.2～0.5 Da を試してください）。両方のスペクトルにピークがあることを確認します
同じ化合物なのにスコアが低い	フラグメンテーション条件が異なる	CosineGreedy の代わりに ModifiedCosine を使用し、イオンモードの整合性を確認します
多くのスペクトルが None にフィルタリングされる	品質フィルターが厳しすぎる	require_minimum_number_of_peaks の n_required を下げ、強度のしきい値を緩和します
メタデータフィールドで KeyError が発生する	フィールド名が調和されていない	まず default_filters を適用してメタデータキーを調和させます
大規模なライブラリでメモリエラーが発生する	全件対全件の比較	詳細なスコアリングの前に、プリカーサー質量で事前にフィルタリングします（PrecursorMzMatch）
add_fingerprint が失敗する	RDKit がインストールされていない	化学関連の追加機能をインストールします：pip install matchms[chemistry]
インポート結果が空のリストになる	ファイル形式またはパスが誤っている	形式がローダーと一致していることを確認します（.mgf には MGF、.msp には MSP）。ファイルが空でないことも確認します
実行ごとにスコアが一致しない	処理パイプラインが異なる	SpectrumProcessor を使用して、クエリと参照データに同一の処理を適用します

バンドルされたリソース

• references/filtering_catalog.md — カテゴリー別に整理された、matchms の 50 以上のフィルター関数の完全なカタログ（メタデータ処理、化学構造、質量／電荷、ピーク処理、品質管理）。

  • 内容：すべてのフィルター関数のシグネチャ、パラメーター、簡単な説明、一般的なフィルターの組み合わせ
  • 本文に移動：主なフィルター（default_filters、normalize_intensities、select_by_relative_intensity、reduce_to_number_of_peaks、remove_peaks_around_precursor_mz、add_fingerprint）は Core API Module 2 に、フィルターカテゴリーの概要は Key Concepts に移動
  • 省略：Core API のパターンと重複する個々のフィルターの例

• references/workflows_similarity.md — 2 つの元のリファレンスを統合した、拡張ワークフローと類似度関数の詳細なドキュメント。

  • 内容：8 つすべての類似度関数とパラメーターテーブル、大規模比較の戦略、複数メトリックによるスコアリングのパターン、7 つの拡張ワークフロー（ライブラリ照合、QC、複数メトリック、形式変換、メタデータ拡充、大規模比較、自動識別レポート）、パフォーマンスに関する考慮事項
  • 本文に移動：CosineGreedy／ModifiedCosine／CosineHungarian／FingerprintSimilarity の使い方は Core API Module 3 に、類似度比較表は Key Concepts に、ライブラリ照合と QC のワークフローは Common Workflows に移動
  • 省略：ネットワークベースのスペクトルクラスタリングのワークフロー — 外部ツール（spec2vec）が必要です。スペクトル可視化のチュートリアル — Core API Module 1 の spectrum.plot() で説明しています

元のリファレンスファイルの扱い：

• importing_exporting.md（417 行）→ Core API Module 1 に完全に統合（I/O 関数、形式の一覧、Spectrum の作成、pickle の使い方）。保持した内容：インポート関数 7 個、エクスポート関数 4 個、Spectrum クラスの作成、形式の選択方法。省略した内容：USI の詳細な例 — ニッチなユースケース
• filtering.md（289 行）→ references/filtering_catalog.md に移行し、主なフィルターは Core API Module 2 に移動
• similarity.md（381 行）→ references/workflows_similarity.md に統合し、主要な関数は Core API Module 3 に配置
• workflows.md（648 行）→ references/workflows_similarity.md に統合し、主なワークフローは Common Workflows に配置

関連スキル

• pyopenms-mass-spectrometry — LC-MS/MS を使用したプロテオミクスとメタボロミクスの完全なパイプライン（特徴検出、タンパク質 ID）
• rdkit-cheminformatics — 分子フィンガープリントの生成と化学構造の類似度評価

参考資料

• matchms のドキュメント：https://matchms.readthedocs.io
• Huber et al. (2020) matchms — 質量分析データの処理と類似度スコアリング。Journal of Open Source Software、DOI: 10.21105/joss.02411
• GitHub：https://github.com/matchms/matchms