🕸️ Lab 12: Graph-Structured Data

🕸️ Lab 12: Graph-Structured Data#

BINF 4002 – Machine Learning for Health

Learning Objectives#

  1. Understand how data can be represented as graphs (nodes, edges, features, adjacency matrices)

  2. Load and explore real molecular graph datasets used in drug discovery

  3. Build a baseline by extracting hand-crafted graph features and applying classical ML (“tabularization”)

  4. Understand the message-passing framework that underpins Graph Neural Networks (GNNs)

  5. Implement and train a GNN (Graph Convolutional Network & Graph Isomorphism Network) using PyTorch Geometric

  6. Compare tabularization baselines with GNN approaches on a molecular property prediction task

Why Graphs in Healthcare?#

Graph-structured data is ubiquitous in biomedicine:

  • Molecules are graphs of atoms (nodes) connected by bonds (edges) → drug discovery, toxicity prediction

  • Protein structures are residue contact graphs → protein function prediction

  • Knowledge graphs encode relationships between diseases, genes, and drugs → drug repurposing

  • Patient networks connect patients by shared conditions or encounters → epidemiology

In this lab, we focus on molecular property prediction — given the graph structure of a molecule, predict whether it has a particular biological property. This is a core task in computational drug discovery and pharmacology.

Dataset: BBBP (Blood-Brain Barrier Penetration)#

We use the BBBP dataset from MoleculeNet, which contains ~2,000 molecules labeled by whether they can penetrate the blood-brain barrier — a critical property for neurological drug design. Each molecule is represented as a graph where atoms are nodes and bonds are edges.

Set-up#

Install Dependencies#

This lab requires PyTorch and PyTorch Geometric (PyG), the leading library for deep learning on graphs. Run the cell below to install everything needed. (This may take 1–2 minutes on Colab.)

# ── Install PyTorch Geometric and dependencies ──────────────────────────────
# This cell handles installation for Google Colab.
# If running locally, see: https://pytorch-geometric.readthedocs.io/en/latest/install/installation.html

import subprocess, sys

def install(pkg):
    subprocess.check_call([sys.executable, "-m", "pip", "install", "-q", pkg])

try:
    import torch
    print(f"✅ PyTorch {torch.__version__} already installed")
except ImportError:
    install("torch")
    import torch
    print(f"✅ PyTorch {torch.__version__} installed")

try:
    import torch_geometric
    print(f"✅ PyTorch Geometric {torch_geometric.__version__} already installed")
except ImportError:
    install("torch_geometric")
    install("pyg_lib")
    install("torch_scatter")
    install("torch_sparse")
    install("torch_cluster")
    install("torch_spline_conv")
    import torch_geometric
    print(f"✅ PyTorch Geometric {torch_geometric.__version__} installed")

try:
    import rdkit
    print(f"✅ RDKit {rdkit.__version__} already installed")
except ImportError:
    install("rdkit")
    import rdkit
    print(f"✅ RDKit installed")

try:
    import sklearn
    print(f"✅ scikit-learn {sklearn.__version__} already installed")
except ImportError:
    install("scikit-learn")

✅ PyTorch 2.11.0+cu130 already installed

✅ PyTorch Geometric 2.7.0 already installed
✅ RDKit 2026.03.1 already installed

✅ scikit-learn 1.8.0 already installed

Imports#

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')

plt.rcParams['figure.dpi'] = 120
plt.rcParams['axes.spines.top'] = False
plt.rcParams['axes.spines.right'] = False

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch_geometric.datasets import MoleculeNet
from torch_geometric.loader import DataLoader
from torch_geometric.utils import to_dense_adj, degree
from torch_geometric.nn import GCNConv, GINConv, global_mean_pool, global_add_pool

from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.metrics import roc_auc_score, roc_curve, classification_report
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

print("✅ All imports successful")
print(f"   PyTorch: {torch.__version__}")
print(f"   CUDA available: {torch.cuda.is_available()}")

✅ All imports successful
   PyTorch: 2.11.0+cu130
   CUDA available: False

Part 1 — What Is Graph-Structured Data?#

A graph \(G = (V, E)\) consists of:

  • Nodes (vertices) \(V = \{v_1, v_2, \ldots, v_n\}\) — the entities

  • Edges \(E \subseteq V \times V\) — the relationships between entities

Graphs can carry additional information:

  • Node features \(\mathbf{X} \in \mathbb{R}^{n \times d}\): a \(d\)-dimensional feature vector per node

  • Edge features \(\mathbf{E}_{ij}\): attributes on each edge (e.g., bond type)

  • Graph-level labels \(y\): a label for the entire graph (our prediction target)

Molecules as Graphs#

In a molecular graph:

  • Nodes = atoms (carbon, oxygen, nitrogen, …)

  • Edges = chemical bonds (single, double, aromatic, …)

  • Node features = atom properties (atomic number, degree, charge, aromaticity, …)

  • Edge features = bond properties (bond type, stereochemistry, …)

  • Graph label = molecular property (e.g., does it cross the blood-brain barrier?)

We start by building a small graph by hand to understand the representation.

# ── Build a toy molecular graph: ethanol (C₂H₅OH) ──────────────────────────
# We'll represent this manually, then visualize it.
# Ethanol heavy-atom graph (ignoring hydrogens): C-C-O

import networkx as nx

G_toy = nx.Graph()
G_toy.add_node(0, element='C', color='#404040')
G_toy.add_node(1, element='C', color='#404040')
G_toy.add_node(2, element='O', color='#e74c3c')

G_toy.add_edge(0, 1, bond='single')
G_toy.add_edge(1, 2, bond='single')

# Adjacency matrix
A = nx.adjacency_matrix(G_toy).toarray()
print("Adjacency matrix A:")
print(A)
print(f"\nNumber of nodes: {G_toy.number_of_nodes()}")
print(f"Number of edges: {G_toy.number_of_edges()}")
print(f"Node degrees: {dict(G_toy.degree())}")

# Visualize
fig, axes = plt.subplots(1, 2, figsize=(10, 4))

pos = {0: (0, 0), 1: (1, 0), 2: (2, 0)}
colors = [G_toy.nodes[n]['color'] for n in G_toy.nodes()]
labels = {n: G_toy.nodes[n]['element'] for n in G_toy.nodes()}
nx.draw(G_toy, pos, ax=axes[0], with_labels=True, labels=labels,
        node_color=colors, node_size=800, font_size=16, font_color='white',
        edge_color='#888', width=3, font_weight='bold')
axes[0].set_title("Ethanol (heavy atoms)", fontsize=13)

im = axes[1].imshow(A, cmap='Blues', vmin=0, vmax=1)
axes[1].set_xticks(range(3)); axes[1].set_yticks(range(3))
axes[1].set_xticklabels(['C₀', 'C₁', 'O₂']); axes[1].set_yticklabels(['C₀', 'C₁', 'O₂'])
axes[1].set_title("Adjacency Matrix", fontsize=13)
for i in range(3):
    for j in range(3):
        axes[1].text(j, i, str(A[i, j]), ha='center', va='center', fontsize=14,
                     color='white' if A[i, j] else 'black')

plt.tight_layout()
plt.show()

Adjacency matrix A:
[[0 1 0]
 [1 0 1]
 [0 1 0]]

Number of nodes: 3
Number of edges: 2
Node degrees: {0: 1, 1: 2, 2: 1}
../_images/59fb73e2af759b3d8080ded20f5822477ced38a4e38a9ff273bdf740139241b5.png

🤔 Reflection 1.1 — Graphs vs. Tabular Data#

  1. In tabular data, every sample has the same number of features in a fixed order. Why can’t we directly represent a graph in a fixed-length feature vector? (Hint: think about molecules of different sizes.)

  2. The adjacency matrix \(A\) is symmetric for undirected graphs. What would it mean biologically if the molecular graph were directed?

  3. If we have a molecule with \(n\) atoms and \(m\) bonds, what is the shape of the adjacency matrix? How does this compare to the number of features in tabular data? What challenges does this create for batching multiple molecules together?

  4. Two molecules can have the same set of atoms but different structures (isomers). How does graph representation capture this distinction, while a simple atom-count feature vector would not?

# ══ SOLUTION — Reflection 1.1 ═══════════════════════════════════════════════
# 1. Graphs have variable numbers of nodes and edges — a drug molecule might have 20
#    atoms while a protein fragment has 200. Tabular formats require a fixed number of
#    columns. We cannot simply stack adjacency matrices of different sizes into a matrix.
#    Moreover, graphs have no canonical node ordering, so the same graph can have many
#    different adjacency matrices (one per node permutation).
#
# 2. Directed edges would imply an asymmetric relationship between atoms — e.g.,
#    electron donation in a coordinate bond, or flow in a metabolic pathway. In most
#    molecular graphs, bonds are undirected (symmetric), but directed graphs are used
#    in reaction networks and regulatory pathways.
#
# 3. The adjacency matrix is n × n. For a 50-atom molecule, that's 2,500 entries (though
#    sparse — most atoms aren't bonded to most others). In tabular data, we might have
#    d features per sample. The challenge for batching is that different molecules have
#    different n, so we can't simply stack adjacency matrices. PyG handles this by
#    storing graphs in edge-index (COO) format and batching via block-diagonal adjacency.
#
# 4. Isomers like butane vs. isobutane have the same atom counts (C4H10) but different
#    connectivity. A graph captures which atom is bonded to which, while a simple atom
#    count vector {C:4, H:10} is identical for both. Graph isomorphism is precisely what
#    GNNs try to distinguish (the Weisfeiler-Leman test).
print("See comments above for solution.")

See comments above for solution.

Part 2 — Loading and Exploring Molecular Graph Data#

We now load the BBBP (Blood-Brain Barrier Penetration) dataset from MoleculeNet. PyTorch Geometric provides this dataset with molecules pre-converted to graph objects, where each graph has:

  • x: node feature matrix (atom features), shape [num_atoms, num_atom_features]

  • edge_index: edge list in COO format, shape [2, num_edges]

  • edge_attr: edge features (bond type, etc.)

  • y: graph label (1 = penetrates BBB, 0 = does not)

  • smiles: the SMILES string representation of the molecule

# ── Load the BBBP dataset ─────────────────────────────────────────────────
dataset = MoleculeNet(root='/tmp/BBBP', name='BBBP')

print(f"Dataset: {dataset}")
print(f"Number of molecules: {len(dataset)}")
print(f"Number of node features: {dataset.num_node_features}")
print(f"Number of edge features: {dataset.num_edge_features}")
print(f"Number of classes: {dataset.num_classes}")

# Look at a single molecule
mol = dataset[0]
print(f"\n── First molecule ──")
print(f"  SMILES: {mol.smiles}")
print(f"  Number of atoms (nodes): {mol.x.shape[0]}")
print(f"  Node feature dim: {mol.x.shape[1]}")
print(f"  Number of bonds (edges): {mol.edge_index.shape[1] // 2}  (stored as {mol.edge_index.shape[1]} directed)")
print(f"  Label (BBB penetration): {mol.y.item()}")
print(f"  Node features (first 3 atoms):\n{mol.x[:3]}")
print(f"  Edge index (first 6 columns):\n{mol.edge_index[:, :6]}")

Dataset: BBBP(2039)
Number of molecules: 2039
Number of node features: 9
Number of edge features: 3
Number of classes: 2

── First molecule ──
  SMILES: [Cl].CC(C)NCC(O)COc1cccc2ccccc12
  Number of atoms (nodes): 20
  Node feature dim: 9
  Number of bonds (edges): 20  (stored as 40 directed)
  Label (BBB penetration): 1.0
  Node features (first 3 atoms):
tensor([[17,  0,  0,  5,  0,  1,  4,  0,  0],
        [ 6,  0,  4,  5,  3,  0,  4,  0,  0],
        [ 6,  0,  4,  5,  1,  0,  4,  0,  0]])
  Edge index (first 6 columns):
tensor([[1, 2, 2, 2, 3, 4],
        [2, 1, 3, 4, 2, 2]])

# ── Dataset statistics ────────────────────────────────────────────────────
num_atoms_list = []
num_edges_list = []
labels = []

for data in dataset:
    num_atoms_list.append(data.x.shape[0])
    num_edges_list.append(data.edge_index.shape[1] // 2)
    if data.y.dim() > 0:
        labels.append(data.y.squeeze().item())
    else:
        labels.append(data.y.item())

num_atoms_arr = np.array(num_atoms_list)
num_edges_arr = np.array(num_edges_list)
labels_arr = np.array(labels)

# Remove NaN labels if any
valid_mask = ~np.isnan(labels_arr)
print(f"Valid labels: {valid_mask.sum()} / {len(labels_arr)}")
labels_arr_clean = labels_arr[valid_mask]

fig, axes = plt.subplots(1, 3, figsize=(15, 4))

axes[0].hist(num_atoms_arr, bins=30, color='#3498db', edgecolor='white', alpha=0.8)
axes[0].set_xlabel('Number of Atoms')
axes[0].set_ylabel('Count')
axes[0].set_title('Molecule Size Distribution')
axes[0].axvline(np.median(num_atoms_arr), color='#e74c3c', linestyle='--',
                label=f'Median: {np.median(num_atoms_arr):.0f}')
axes[0].legend()

axes[1].hist(num_edges_arr, bins=30, color='#2ecc71', edgecolor='white', alpha=0.8)
axes[1].set_xlabel('Number of Bonds')
axes[1].set_ylabel('Count')
axes[1].set_title('Bond Count Distribution')

counts = pd.Series(labels_arr_clean).value_counts().sort_index()
axes[2].bar(['Non-penetrating (0)', 'Penetrating (1)'], counts.values,
           color=['#e74c3c', '#3498db'], edgecolor='white')
axes[2].set_ylabel('Count')
axes[2].set_title('BBB Penetration Label Distribution')
for i, v in enumerate(counts.values):
    axes[2].text(i, v + 10, str(v), ha='center', fontsize=11)

plt.tight_layout()
plt.show()

print(f"\nAtoms per molecule: mean={num_atoms_arr.mean():.1f}, "
      f"min={num_atoms_arr.min()}, max={num_atoms_arr.max()}")
print(f"Positive rate: {labels_arr_clean.mean():.3f}")

Valid labels: 2039 / 2039
../_images/f506dba64b83628316d90ede4421bc9050b9754abafaa39e5df80e61d08ea42a.png 
Atoms per molecule: mean=24.1, min=2, max=132
Positive rate: 0.765

# ── Visualize a few molecules using RDKit ─────────────────────────────────
from rdkit import Chem
from rdkit.Chem import Draw

smiles_list = [dataset[i].smiles for i in range(len(dataset)) if dataset[i].smiles]
labels_list = [dataset[i].y.squeeze().item() for i in range(len(dataset))]

# Select 4 positive and 4 negative examples
pos_idx = [i for i, l in enumerate(labels_list) if l == 1 and not np.isnan(l)][:4]
neg_idx = [i for i, l in enumerate(labels_list) if l == 0 and not np.isnan(l)][:4]

mols = []
legends = []
for i in pos_idx:
    m = Chem.MolFromSmiles(smiles_list[i])
    if m:
        mols.append(m)
        legends.append(f"BBB+ ({num_atoms_list[i]} atoms)")
for i in neg_idx:
    m = Chem.MolFromSmiles(smiles_list[i])
    if m:
        mols.append(m)
        legends.append(f"BBB- ({num_atoms_list[i]} atoms)")

img = Draw.MolsToGridImage(mols, molsPerRow=4, subImgSize=(300, 250), legends=legends)
img
../_images/6d82a9ff2b52043ab065d08e5bbdf3b93c285a62d859128fa27dea4d221bcd37.png

🤔 Reflection 2.1 — Understanding Molecular Graph Representations#

  1. Each node has a 9-dimensional feature vector. These typically encode: atomic number, degree, formal charge, number of Hs, hybridization, aromaticity, etc. Why might encoding these as categorical one-hot features (rather than raw integers) be important for learning?

  2. The edge_index has shape [2, 2*num_bonds] — each bond appears twice (once per direction). Why does PyG store undirected edges this way? How does this relate to the message-passing paradigm we’ll see in Part 4?

  3. The dataset is imbalanced (~75% positive). How does this affect our choice of evaluation metric? Why might accuracy be misleading?

  4. The molecules vary in size from ~5 to ~130 atoms. What challenges does this create for both classical ML approaches and for neural networks?

# ══ SOLUTION — Reflection 2.1 ═══════════════════════════════════════════════
# 1. Raw integers (e.g., atomic_number=6 for carbon) impose an arbitrary ordering
#    (the model might learn that oxygen at 8 is "greater" than carbon at 6). One-hot
#    encoding treats each element as a distinct category without ordinal assumptions.
#    This matters because chemical properties are NOT monotonic in atomic number.
#
# 2. In message passing, each node aggregates information from its neighbors.
#    Storing edges as (u->v) AND (v->u) means that when we "send messages along edges,"
#    both endpoints receive messages from the other. This is the standard sparse
#    representation in PyG — it avoids materializing the full n*n adjacency matrix.
#
# 3. With 75% positive, a trivial classifier predicting all-positive gets 75% accuracy.
#    We should use AUROC (threshold-free, handles imbalance) or AUPRC (especially
#    meaningful when we care about the minority class). We'll use AUROC as our primary
#    metric, consistent with the MoleculeNet benchmark.
#
# 4. For classical ML: we need to extract fixed-length features regardless of molecule
#    size, which loses structural information. For neural networks: we can't simply
#    stack variable-size tensors into a batch. GNNs handle this via graph-level pooling
#    (aggregating all node embeddings into a fixed-size graph embedding).
print("See comments above for solution.")

See comments above for solution.

Part 3 — Baseline: Graph Tabularization#

Before building a GNN, we establish a baseline by converting each graph into a fixed-length feature vector — this is the “tabularization” approach. If a simple feature extraction + logistic regression works well, a GNN may not be needed.

Two Approaches to Tabularize Molecular Graphs#

Approach A — Hand-crafted graph statistics: Extract structural features like number of atoms, number of edges, degree statistics, clustering coefficient, etc. This loses most chemical information but captures basic topology.

Approach B — Molecular fingerprints: Use domain-specific tools (RDKit) to compute Morgan/ECFP fingerprints — fixed-length binary vectors that encode the presence of molecular substructures. This is the standard baseline in cheminformatics.

# This is an exercise cell with TODOs (??? placeholders) for student work.
# It is skipped in the book build to keep downstream cells runnable.
# Open the notebook in Colab to complete the exercise:
# Exercise cell skipped in book build
print("[exercise cell skipped — open in Colab to complete the TODOs]")

[exercise cell skipped — open in Colab to complete the TODOs]

# ══ SOLUTION — extract_graph_features ════════════════════════════════════════
def extract_graph_features(data):
    x = data.x.numpy()
    edge_index = data.edge_index

    num_atoms = x.shape[0]
    num_bonds = edge_index.shape[1] // 2
    degrees = degree(edge_index[0], num_nodes=num_atoms).numpy()
    mean_degree = degrees.mean()
    max_degree = degrees.max()
    if num_atoms > 1:
        density = 2 * num_bonds / (num_atoms * (num_atoms - 1))
    else:
        density = 0.0

    mean_node_feat = x.mean(axis=0)
    std_node_feat = x.std(axis=0)

    features = np.concatenate([
        [num_atoms, num_bonds, mean_degree, max_degree, density],
        mean_node_feat,
        std_node_feat
    ])
    return features

test_feat = extract_graph_features(dataset[0])
print(f"Feature vector shape: {test_feat.shape}")
print(f"Features: {test_feat.round(3)}")

Feature vector shape: (23,)
Features: [20.    20.     2.     3.     0.105  6.8    0.     3.05   5.     1.05
  0.05   3.45   0.5    0.5    2.421  0.     0.921  0.     0.865  0.218
  0.497  0.5    0.5  ]

# ── Build tabular dataset from ALL molecules ──────────────────────────────
print("Extracting graph features for all molecules...")
all_features = []
all_labels = []
valid_indices = []

for i, data in enumerate(dataset):
    label = data.y.squeeze().item()
    if np.isnan(label):
        continue
    all_features.append(extract_graph_features(data))
    all_labels.append(int(label))
    valid_indices.append(i)

X_tab = np.array(all_features)
y_tab = np.array(all_labels)
print(f"Tabular dataset: {X_tab.shape[0]} molecules x {X_tab.shape[1]} features")
print(f"Positive rate: {y_tab.mean():.3f}")

# Train/val/test split (80/10/10)
X_train, X_temp, y_train, y_temp, idx_train, idx_temp = train_test_split(
    X_tab, y_tab, valid_indices, test_size=0.2, random_state=42, stratify=y_tab)
X_val, X_test, y_val, y_test, idx_val, idx_test = train_test_split(
    X_temp, y_temp, idx_temp, test_size=0.5, random_state=42, stratify=y_temp)

print(f"\nSplit sizes: train={len(y_train)}, val={len(y_val)}, test={len(y_test)}")
print(f"Train positive rate: {y_train.mean():.3f}")

scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_val_s = scaler.transform(X_val)
X_test_s = scaler.transform(X_test)

Extracting graph features for all molecules...
Tabular dataset: 2039 molecules x 23 features
Positive rate: 0.765

Split sizes: train=1631, val=204, test=204
Train positive rate: 0.765

# ── Approach A: Classical ML on hand-crafted features ─────────────────────
baseline_models = {
    'Logistic Regression': LogisticRegression(max_iter=1000, random_state=42),
    'Random Forest': RandomForestClassifier(n_estimators=200, max_depth=10, random_state=42),
    'Gradient Boosting': GradientBoostingClassifier(n_estimators=200, max_depth=5, random_state=42),
}

baseline_results = {}
for name, model in baseline_models.items():
    model.fit(X_train_s, y_train)
    val_proba = model.predict_proba(X_val_s)[:, 1]
    val_auc = roc_auc_score(y_val, val_proba)
    baseline_results[name] = {'model': model, 'val_auc': val_auc, 'val_proba': val_proba}
    print(f"{name:25s}  Val AUROC = {val_auc:.4f}")

print("\n(These are baselines using simple graph statistics — no structural info!)")

Logistic Regression        Val AUROC = 0.8168

Random Forest              Val AUROC = 0.8586

Gradient Boosting          Val AUROC = 0.8204

(These are baselines using simple graph statistics — no structural info!)

# ── Approach B: Molecular fingerprints (Morgan/ECFP) ──────────────────────
from rdkit import Chem
from rdkit.Chem import AllChem

def smiles_to_fingerprint(smiles, radius=2, nbits=1024):
    mol = Chem.MolFromSmiles(smiles)
    if mol is None:
        return None
    fp = AllChem.GetMorganFingerprintAsBitVect(mol, radius, nBits=nbits)
    return np.array(fp)

print("Computing Morgan fingerprints...")

def build_fp_matrix(indices):
    fps, valid = [], []
    for i in indices:
        smiles = dataset[i].smiles
        fp = smiles_to_fingerprint(smiles)
        if fp is not None:
            fps.append(fp)
            valid.append(True)
        else:
            valid.append(False)
    return np.array(fps), np.array(valid)

X_train_fp, mask_train = build_fp_matrix(idx_train)
X_val_fp, mask_val = build_fp_matrix(idx_val)
X_test_fp, mask_test = build_fp_matrix(idx_test)

y_train_fp = y_train[mask_train]
y_val_fp = y_val[mask_val]
y_test_fp = y_test[mask_test]

print(f"Fingerprint dimension: {X_train_fp.shape[1]}")
print(f"Train: {len(y_train_fp)}, Val: {len(y_val_fp)}, Test: {len(y_test_fp)}")

fp_models = {
    'LR + Fingerprints': LogisticRegression(max_iter=1000, random_state=42),
    'RF + Fingerprints': RandomForestClassifier(n_estimators=200, max_depth=15, random_state=42),
    'GBT + Fingerprints': GradientBoostingClassifier(n_estimators=200, max_depth=5, random_state=42),
}

fp_results = {}
for name, model in fp_models.items():
    model.fit(X_train_fp, y_train_fp)
    val_proba = model.predict_proba(X_val_fp)[:, 1]
    val_auc = roc_auc_score(y_val_fp, val_proba)
    fp_results[name] = {'model': model, 'val_auc': val_auc, 'val_proba': val_proba}
    print(f"{name:25s}  Val AUROC = {val_auc:.4f}")

Computing Morgan fingerprints...

[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator

[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator

[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] WARNING: not removing hydrogen atom without neighbors
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator
[00:33:49] DEPRECATION WARNING: please use MorganGenerator

Fingerprint dimension: 1024
Train: 1631, Val: 204, Test: 204

LR + Fingerprints          Val AUROC = 0.8289

RF + Fingerprints          Val AUROC = 0.8814

GBT + Fingerprints         Val AUROC = 0.8502

🤔 Reflection 3.1 — Tabularization Trade-offs#

  1. Compare the AUROC of hand-crafted graph features vs. Morgan fingerprints. Why do fingerprints perform better? What chemical information do they capture that raw graph statistics miss?

  2. Morgan fingerprints (ECFP) encode circular substructures of radius \(r\) around each atom. This is conceptually similar to what operation in GNNs? (We’ll see this in Part 4.)

  3. What information is lost when we tabularize a graph? Give a specific example of two molecules that would have identical hand-crafted features but different properties.

  4. In a clinical drug-screening pipeline, what are the advantages of the fingerprint baseline? When might its simplicity be preferred over a complex GNN?

# ══ SOLUTION — Reflection 3.1 ═══════════════════════════════════════════════
# 1. Fingerprints dramatically outperform hand-crafted features because they encode
#    LOCAL chemical substructure patterns (e.g., "a nitrogen bonded to two carbons
#    with an aromatic ring nearby"). Graph statistics like mean degree and density
#    only capture global topology — they can't distinguish between chemically
#    very different molecules that happen to have similar sizes.
#
# 2. Morgan fingerprints of radius r enumerate all substructures within r bonds of
#    each atom, then hash them into a fixed-length vector. This is essentially the
#    same operation as r rounds of message passing in a GNN! The key difference is
#    that GNNs learn WHAT to extract, while fingerprints use a fixed hashing scheme.
#    This is why GNNs are sometimes called "learnable fingerprints."
#
# 3. Two molecules with the same number of atoms, bonds, and degree distribution
#    but different connectivity (graph isomers) would have identical hand-crafted
#    features. Example: 1,2-dimethylbenzene vs 1,4-dimethylbenzene (ortho- vs para-
#    xylene) — same atom counts and degree stats, different biological properties.
#
# 4. Advantages: (a) Very fast to compute and train — seconds vs. minutes/hours for
#    GNNs. (b) Highly interpretable — you can identify which substructures drive
#    predictions. (c) Robust baselines that are hard to beat on small datasets.
#    (d) No GPU needed. Preferred when: dataset is small (<5K), interpretability is
#    critical, or as a rapid screening step before expensive GNN-based analysis.
print("See comments above for solution.")

See comments above for solution.

Part 4 — Understanding Message Passing#

The core idea behind GNNs is message passing: each node updates its representation by aggregating information from its neighbors. After \(K\) rounds of message passing, each node’s embedding encodes information about its \(K\)-hop neighborhood.

The Message Passing Framework#

At each layer \(k\), node \(v\) updates its embedding \(\mathbf{h}_v^{(k)}\) via:

\[\mathbf{h}_v^{(k)} = \text{UPDATE}\left(\mathbf{h}_v^{(k-1)},\; \text{AGGREGATE}\left(\left\{\mathbf{h}_u^{(k-1)} : u \in \mathcal{N}(v)\right\}\right)\right)\]

where \(\mathcal{N}(v)\) is the set of neighbors of node \(v\).

Different GNN architectures differ in their choice of AGGREGATE and UPDATE:

Architecture

AGGREGATE

UPDATE

GCN

Normalized mean of neighbors

Linear + activation

GraphSAGE

Mean, max, or LSTM over neighbors

Concatenate + linear

GIN

Sum of neighbors

MLP

GAT

Attention-weighted sum

Linear + activation

We’ll implement the simplest version — a Graph Convolutional Network (GCN) layer — by hand.

# This is an exercise cell with TODOs (??? placeholders) for student work.
# It is skipped in the book build to keep downstream cells runnable.
# Open the notebook in Colab to complete the exercise:
# Exercise cell skipped in book build
print("[exercise cell skipped — open in Colab to complete the TODOs]")

[exercise cell skipped — open in Colab to complete the TODOs]

# ══ SOLUTION — gcn_layer_manual ══════════════════════════════════════════════
def gcn_layer_manual(A, H, W):
    n = A.shape[0]
    # Step 1: Add self-loops
    A_tilde = A + np.eye(n)
    # Step 2: Aggregate neighbor features
    agg = A_tilde @ H
    # Step 3: Linear transform
    out = agg @ W
    # Step 4: ReLU
    H_new = np.maximum(0, out)
    return H_new

mol = dataset[0]
A = to_dense_adj(mol.edge_index, max_num_nodes=mol.x.shape[0]).squeeze(0).numpy()
H = mol.x.numpy()
np.random.seed(42)
W = np.random.randn(9, 16) * 0.1
H_new = gcn_layer_manual(A, H, W)
print(f"Input features shape:  {H.shape}")
print(f"Output features shape: {H_new.shape}")
print(f"Output (first 3 nodes, first 5 dims):\n{H_new[:3, :5].round(4)}")

Input features shape:  (20, 9)
Output features shape: (20, 16)
Output (first 3 nodes, first 5 dims):
[[1.1127 0.     1.4129 2.2509 0.    ]
 [1.4908 0.     1.7346 0.6796 0.    ]
 [3.0326 0.     3.4518 1.6336 0.    ]]

# ── Visualize message passing: before and after ──────────────────────────
fig, axes = plt.subplots(1, 3, figsize=(16, 5))

from sklearn.decomposition import PCA
pca = PCA(n_components=2)
H_2d = pca.fit_transform(H)
H_new_2d = pca.fit_transform(H_new)

# Build networkx graph for layout
G_mol = nx.Graph()
edge_list = mol.edge_index.numpy().T
for e in edge_list:
    G_mol.add_edge(int(e[0]), int(e[1]))
pos = nx.spring_layout(G_mol, seed=42)

nx.draw(G_mol, pos, ax=axes[0], node_color='#3498db', node_size=300,
        edge_color='#bbb', width=1.5, with_labels=True, font_size=8, font_color='white')
axes[0].set_title("Graph Structure", fontsize=12)

node_colors_before = H_2d[:, 0]
nx.draw(G_mol, pos, ax=axes[1], node_color=node_colors_before, node_size=300,
        cmap='coolwarm', edge_color='#bbb', width=1.5, with_labels=True, font_size=8,
        font_color='white')
axes[1].set_title("Node Features: Before MP", fontsize=12)

node_colors_after = H_new_2d[:, 0]
nx.draw(G_mol, pos, ax=axes[2], node_color=node_colors_after, node_size=300,
        cmap='coolwarm', edge_color='#bbb', width=1.5, with_labels=True, font_size=8,
        font_color='white')
axes[2].set_title("Node Features: After 1 MP Layer", fontsize=12)

plt.suptitle("Message Passing Smooths Features Across Neighbors", fontsize=13, y=1.02)
plt.tight_layout()
plt.show()

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
File ~/.cache/uv/archive-v0/musG2kJAQFp4AHJmq0Jk3/lib/python3.11/site-packages/matplotlib/axes/_axes.py:4761, in Axes._parse_scatter_color_args(c, edgecolors, kwargs, xsize, get_next_color_func)
   4760 try:  # Is 'c' acceptable as PathCollection facecolors?
-> 4761     colors = mcolors.to_rgba_array(c)
   4762 except (TypeError, ValueError) as err:

File ~/.cache/uv/archive-v0/musG2kJAQFp4AHJmq0Jk3/lib/python3.11/site-packages/matplotlib/colors.py:515, in to_rgba_array(c, alpha)
    514 else:
--> 515     rgba = np.array([to_rgba(cc) for cc in c])
    517 if alpha is not None:

File ~/.cache/uv/archive-v0/musG2kJAQFp4AHJmq0Jk3/lib/python3.11/site-packages/matplotlib/colors.py:515, in <listcomp>(.0)
    514 else:
--> 515     rgba = np.array([to_rgba(cc) for cc in c])
    517 if alpha is not None:

File ~/.cache/uv/archive-v0/musG2kJAQFp4AHJmq0Jk3/lib/python3.11/site-packages/matplotlib/colors.py:317, in to_rgba(c, alpha)
    316 if rgba is None:  # Suppress exception chaining of cache lookup failure.
--> 317     rgba = _to_rgba_no_colorcycle(c, alpha)
    318     try:

File ~/.cache/uv/archive-v0/musG2kJAQFp4AHJmq0Jk3/lib/python3.11/site-packages/matplotlib/colors.py:401, in _to_rgba_no_colorcycle(c, alpha)
    400 if not np.iterable(c):
--> 401     raise ValueError(f"Invalid RGBA argument: {orig_c!r}")
    402 if len(c) not in [3, 4]:

ValueError: Invalid RGBA argument: np.float64(10.763884655428999)

The above exception was the direct cause of the following exception:

ValueError                                Traceback (most recent call last)
Cell In[17], line 21
     17         edge_color='#bbb', width=1.5, with_labels=True, font_size=8, font_color='white')
     18 axes[0].set_title("Graph Structure", fontsize=12)
     19 
     20 node_colors_before = H_2d[:, 0]
---> 21 nx.draw(G_mol, pos, ax=axes[1], node_color=node_colors_before, node_size=300,
     22         cmap='coolwarm', edge_color='#bbb', width=1.5, with_labels=True, font_size=8,
     23         font_color='white')
     24 axes[1].set_title("Node Features: Before MP", fontsize=12)

File ~/.cache/uv/archive-v0/musG2kJAQFp4AHJmq0Jk3/lib/python3.11/site-packages/networkx/drawing/nx_pylab.py:1164, in draw(G, pos, ax, **kwds)
   1161 if "with_labels" not in kwds:
   1162     kwds["with_labels"] = "labels" in kwds
-> 1164 draw_networkx(G, pos=pos, ax=ax, **kwds)
   1165 ax.set_axis_off()
   1166 plt.draw_if_interactive()

File ~/.cache/uv/archive-v0/musG2kJAQFp4AHJmq0Jk3/lib/python3.11/site-packages/networkx/drawing/nx_pylab.py:1352, in draw_networkx(G, pos, arrows, with_labels, **kwds)
   1349 if pos is None:
   1350     pos = nx.drawing.spring_layout(G)  # default to spring layout
-> 1352 draw_networkx_nodes(G, pos, **node_kwds)
   1353 draw_networkx_edges(G, pos, arrows=arrows, **edge_kwds)
   1354 if with_labels:

File ~/.cache/uv/archive-v0/musG2kJAQFp4AHJmq0Jk3/lib/python3.11/site-packages/networkx/drawing/nx_pylab.py:1497, in draw_networkx_nodes(G, pos, nodelist, node_size, node_color, node_shape, alpha, cmap, vmin, vmax, ax, linewidths, edgecolors, label, margins, hide_ticks)
   1494     node_shape = np.asarray(node_shape)
   1496 for shape in np.unique(node_shape):
-> 1497     node_collection = ax.scatter(
   1498         xy[node_shape == shape, 0],
   1499         xy[node_shape == shape, 1],
   1500         s=node_size,
   1501         c=node_color,
   1502         marker=shape,
   1503         cmap=cmap,
   1504         vmin=vmin,
   1505         vmax=vmax,
   1506         alpha=alpha,
   1507         linewidths=linewidths,
   1508         edgecolors=edgecolors,
   1509         label=label,
   1510     )
   1511 if hide_ticks:
   1512     ax.tick_params(
   1513         axis="both",
   1514         which="both",
   (...)   1518         labelleft=False,
   1519     )

File ~/.cache/uv/archive-v0/musG2kJAQFp4AHJmq0Jk3/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:453, in make_keyword_only.<locals>.wrapper(*args, **kwargs)
    447 if len(args) > name_idx:
    448     warn_deprecated(
    449         since, message="Passing the %(name)s %(obj_type)s "
    450         "positionally is deprecated since Matplotlib %(since)s; the "
    451         "parameter will become keyword-only in %(removal)s.",
    452         name=name, obj_type=f"parameter of {func.__name__}()")
--> 453 return func(*args, **kwargs)

File ~/.cache/uv/archive-v0/musG2kJAQFp4AHJmq0Jk3/lib/python3.11/site-packages/matplotlib/__init__.py:1524, in _preprocess_data.<locals>.inner(ax, data, *args, **kwargs)
   1521 @functools.wraps(func)
   1522 def inner(ax, *args, data=None, **kwargs):
   1523     if data is None:
-> 1524         return func(
   1525             ax,
   1526             *map(cbook.sanitize_sequence, args),
   1527             **{k: cbook.sanitize_sequence(v) for k, v in kwargs.items()})
   1529     bound = new_sig.bind(ax, *args, **kwargs)
   1530     auto_label = (bound.arguments.get(label_namer)
   1531                   or bound.kwargs.get(label_namer))

File ~/.cache/uv/archive-v0/musG2kJAQFp4AHJmq0Jk3/lib/python3.11/site-packages/matplotlib/axes/_axes.py:4954, in Axes.scatter(self, x, y, s, c, marker, cmap, norm, vmin, vmax, alpha, linewidths, edgecolors, colorizer, plotnonfinite, **kwargs)
   4951 if edgecolors is None:
   4952     orig_edgecolor = kwargs.get('edgecolor', None)
   4953 c, colors, edgecolors = \
-> 4954     self._parse_scatter_color_args(
   4955         c, edgecolors, kwargs, x.size,
   4956         get_next_color_func=self._get_patches_for_fill.get_next_color)
   4958 if plotnonfinite and colors is None:
   4959     c = np.ma.masked_invalid(c)

File ~/.cache/uv/archive-v0/musG2kJAQFp4AHJmq0Jk3/lib/python3.11/site-packages/matplotlib/axes/_axes.py:4767, in Axes._parse_scatter_color_args(c, edgecolors, kwargs, xsize, get_next_color_func)
   4765 else:
   4766     if not valid_shape:
-> 4767         raise invalid_shape_exception(c.size, xsize) from err
   4768     # Both the mapping *and* the RGBA conversion failed: pretty
   4769     # severe failure => one may appreciate a verbose feedback.
   4770     raise ValueError(
   4771         f"'c' argument must be a color, a sequence of colors, "
   4772         f"or a sequence of numbers, not {c!r}") from err

ValueError: 'c' argument has 20 elements, which is inconsistent with 'x' and 'y' with size 19.
../_images/04544dc02fe8d78ed77f6490b271298f45d824b275380ff5b3bc2a6f1de31e1a.png

🤔 Reflection 4.1 — Message Passing Mechanics#

  1. After one round of message passing, each node’s embedding contains information about itself and its 1-hop neighbors. After \(K\) rounds, each node “sees” its \(K\)-hop neighborhood. How does this relate to the receptive field concept in CNNs?

  2. In the GCN update \(\tilde{A} H W\), the multiplication \(\tilde{A} H\) is essentially averaging each node’s features with its neighbors’ features. What happens if we stack many GCN layers — what problem might arise? (Hint: think about what happens when you repeatedly average signals.)

  3. We added self-loops (\(\tilde{A} = A + I\)) before message passing. What would happen without self-loops? Why is this important?

  4. The GIN (Graph Isomorphism Network) uses sum aggregation instead of mean. Mathematically, why is sum aggregation strictly more expressive than mean? (Hint: consider two nodes where one has 2 neighbors with feature [1] and another has 4 neighbors with feature [1]. What does mean vs. sum tell you?)

# ══ SOLUTION — Reflection 4.1 ═══════════════════════════════════════════════
# 1. This is exactly analogous to the receptive field in CNNs. In a CNN, a neuron
#    in layer K "sees" a spatial region of the input determined by K convolutions.
#    In a GNN, K message-passing layers give each node a "receptive field" of K-hop
#    neighborhoods. Just as deeper CNNs have larger receptive fields, deeper GNNs
#    aggregate information from more distant nodes.
#
# 2. This is the "over-smoothing" problem. After many layers of averaging, all node
#    embeddings converge to the same value (the graph's mean feature). This is why
#    GNNs typically use only 2-5 layers, unlike CNNs which can be very deep.
#    Techniques like residual connections and jumping knowledge help mitigate this.
#
# 3. Without self-loops, each node's new embedding is the aggregate of ONLY its
#    neighbors' features — the node's own current features are lost! Self-loops
#    ensure the node's own representation is included in the aggregation, similar
#    to a residual connection.
#
# 4. Mean aggregation maps {1, 1} and {1, 1, 1, 1} to the same output (mean = 1),
#    making these neighborhoods indistinguishable. Sum aggregation gives 2 vs 4,
#    preserving the multiset structure. The WL isomorphism test (which GIN is based
#    on) requires injective aggregation, and sum over multisets is injective while
#    mean is not. This is why GIN is provably more expressive than GCN.
print("See comments above for solution.")

See comments above for solution.

Part 5 — Training a Graph Neural Network#

Now we train a full GNN using PyTorch Geometric. We’ll implement two architectures:

  1. GCN (Graph Convolutional Network) — the simplest GNN

  2. GIN (Graph Isomorphism Network) — provably more expressive

Both follow the same pipeline:

  1. Multiple message-passing layers produce node embeddings

  2. A readout (pooling) function aggregates node embeddings into a single graph embedding

  3. A classification head maps the graph embedding to a prediction

Graph-Level Readout#

Since we need one prediction per graph (not per node), we need to aggregate all node embeddings into a fixed-size graph representation:

  • Mean pooling: \(\mathbf{h}_G = \frac{1}{|V|} \sum_{v \in V} \mathbf{h}_v\)

  • Sum pooling: \(\mathbf{h}_G = \sum_{v \in V} \mathbf{h}_v\)

  • Max pooling: \(\mathbf{h}_G = \max_{v \in V} \mathbf{h}_v\) (element-wise)

# This is an exercise cell with TODOs (??? placeholders) for student work.
# It is skipped in the book build to keep downstream cells runnable.
# Open the notebook in Colab to complete the exercise:
# Exercise cell skipped in book build
print("[exercise cell skipped — open in Colab to complete the TODOs]")

[exercise cell skipped — open in Colab to complete the TODOs]

# ══ SOLUTION — GCN ═══════════════════════════════════════════════════════════
class GCN(nn.Module):
    def __init__(self, input_dim, hidden_dim=64, dropout=0.3):
        super().__init__()
        self.conv1 = GCNConv(input_dim, hidden_dim)
        self.conv2 = GCNConv(hidden_dim, hidden_dim)
        self.classifier = nn.Linear(hidden_dim, 1)
        self.dropout = dropout

    def forward(self, x, edge_index, batch):
        h = self.conv1(x, edge_index)
        h = F.relu(h)
        h = F.dropout(h, p=self.dropout, training=self.training)

        h = self.conv2(h, edge_index)
        h = F.relu(h)
        h = F.dropout(h, p=self.dropout, training=self.training)

        h_graph = global_mean_pool(h, batch)

        out = torch.sigmoid(self.classifier(h_graph)).squeeze(-1)
        return out

model_gcn = GCN(input_dim=dataset.num_node_features, hidden_dim=64)
print(model_gcn)
print(f"\nTotal parameters: {sum(p.numel() for p in model_gcn.parameters()):,}")

GCN(
  (conv1): GCNConv(9, 64)
  (conv2): GCNConv(64, 64)
  (classifier): Linear(in_features=64, out_features=1, bias=True)
)

Total parameters: 4,865

# ── GIN: A more expressive GNN (provided) ─────────────────────────────────
# The GIN uses an MLP instead of a linear layer after aggregation,
# and uses SUM pooling instead of MEAN for both message passing and readout.

class GIN(nn.Module):
    def __init__(self, input_dim, hidden_dim=64, dropout=0.3):
        super().__init__()
        mlp1 = nn.Sequential(nn.Linear(input_dim, hidden_dim), nn.ReLU(),
                             nn.Linear(hidden_dim, hidden_dim))
        mlp2 = nn.Sequential(nn.Linear(hidden_dim, hidden_dim), nn.ReLU(),
                             nn.Linear(hidden_dim, hidden_dim))
        self.conv1 = GINConv(mlp1)
        self.conv2 = GINConv(mlp2)
        self.classifier = nn.Linear(hidden_dim, 1)
        self.dropout = dropout

    def forward(self, x, edge_index, batch):
        h = F.relu(self.conv1(x, edge_index))
        h = F.dropout(h, p=self.dropout, training=self.training)
        h = F.relu(self.conv2(h, edge_index))
        h = F.dropout(h, p=self.dropout, training=self.training)
        h_graph = global_add_pool(h, batch)  # SUM pooling
        out = torch.sigmoid(self.classifier(h_graph)).squeeze(-1)
        return out

model_gin = GIN(input_dim=dataset.num_node_features, hidden_dim=64)
print(model_gin)
print(f"\nGIN parameters: {sum(p.numel() for p in model_gin.parameters()):,}")

GIN(
  (conv1): GINConv(nn=Sequential(
    (0): Linear(in_features=9, out_features=64, bias=True)
    (1): ReLU()
    (2): Linear(in_features=64, out_features=64, bias=True)
  ))
  (conv2): GINConv(nn=Sequential(
    (0): Linear(in_features=64, out_features=64, bias=True)
    (1): ReLU()
    (2): Linear(in_features=64, out_features=64, bias=True)
  ))
  (classifier): Linear(in_features=64, out_features=1, bias=True)
)

GIN parameters: 13,185

# ── Prepare PyG DataLoaders ────────────────────────────────────────────────
# We use the same train/val/test split indices from Part 3

valid_dataset = [dataset[i] for i in valid_indices]

idx_map = {orig: new for new, orig in enumerate(valid_indices)}
train_data = [valid_dataset[idx_map[i]] for i in idx_train]
val_data = [valid_dataset[idx_map[i]] for i in idx_val]
test_data = [valid_dataset[idx_map[i]] for i in idx_test]

train_loader = DataLoader(train_data, batch_size=64, shuffle=True)
val_loader = DataLoader(val_data, batch_size=64, shuffle=False)
test_loader = DataLoader(test_data, batch_size=64, shuffle=False)

print(f"Train batches: {len(train_loader)}, Val batches: {len(val_loader)}, "
      f"Test batches: {len(test_loader)}")

batch = next(iter(train_loader))
print(f"\nBatch object: {batch}")
print(f"  Batch node features shape: {batch.x.shape}")
print(f"  Batch edge_index shape: {batch.edge_index.shape}")
print(f"  Batch vector shape: {batch.batch.shape}")
print(f"  Batch labels shape: {batch.y.shape}")
print(f"  Number of graphs in batch: {batch.num_graphs}")

Train batches: 26, Val batches: 4, Test batches: 4

Batch object: DataBatch(x=[1435, 9], edge_index=[2, 3112], edge_attr=[3112, 3], smiles=[64], y=[64, 1], batch=[1435], ptr=[65])
  Batch node features shape: torch.Size([1435, 9])
  Batch edge_index shape: torch.Size([2, 3112])
  Batch vector shape: torch.Size([1435])
  Batch labels shape: torch.Size([64, 1])
  Number of graphs in batch: 64

# ── Training and evaluation functions ─────────────────────────────────────
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f"Using device: {device}")

def train_epoch(model, loader, optimizer, criterion):
    model.train()
    total_loss = 0
    for batch in loader:
        batch = batch.to(device)
        optimizer.zero_grad()
        out = model(batch.x.float(), batch.edge_index, batch.batch)
        labels = batch.y.squeeze().float()
        loss = criterion(out, labels)
        loss.backward()
        optimizer.step()
        total_loss += loss.item() * batch.num_graphs
    return total_loss / len(loader.dataset)

@torch.no_grad()
def evaluate(model, loader):
    model.eval()
    all_preds, all_labels = [], []
    total_loss = 0
    criterion = nn.BCELoss()
    for batch in loader:
        batch = batch.to(device)
        out = model(batch.x.float(), batch.edge_index, batch.batch)
        labels = batch.y.squeeze().float()
        total_loss += criterion(out, labels).item() * batch.num_graphs
        all_preds.append(out.cpu().numpy())
        all_labels.append(labels.cpu().numpy())
    preds = np.concatenate(all_preds)
    labels = np.concatenate(all_labels)
    auc = roc_auc_score(labels, preds)
    loss = total_loss / len(loader.dataset)
    return auc, loss, preds, labels

def train_gnn(model, train_loader, val_loader, lr=1e-3, epochs=80, patience=15):
    model = model.to(device)
    optimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=1e-5)
    criterion = nn.BCELoss()

    history = {'train_loss': [], 'val_loss': [], 'train_auc': [], 'val_auc': []}
    best_val_auc = 0
    best_state = None
    wait = 0

    for epoch in range(1, epochs + 1):
        train_loss = train_epoch(model, train_loader, optimizer, criterion)
        train_auc, _, _, _ = evaluate(model, train_loader)
        val_auc, val_loss, _, _ = evaluate(model, val_loader)

        history['train_loss'].append(train_loss)
        history['val_loss'].append(val_loss)
        history['train_auc'].append(train_auc)
        history['val_auc'].append(val_auc)

        if val_auc > best_val_auc:
            best_val_auc = val_auc
            best_state = {k: v.clone() for k, v in model.state_dict().items()}
            wait = 0
        else:
            wait += 1

        if epoch % 10 == 0 or epoch == 1:
            print(f"Epoch {epoch:3d} | Train Loss: {train_loss:.4f} | "
                  f"Val AUC: {val_auc:.4f} | Best: {best_val_auc:.4f}")

        if wait >= patience:
            print(f"Early stopping at epoch {epoch}")
            break

    model.load_state_dict(best_state)
    return model, history

Using device: cpu

# ── Train GCN ─────────────────────────────────────────────────────────────
print("=" * 60)
print("Training GCN")
print("=" * 60)
gcn_model = GCN(input_dim=dataset.num_node_features, hidden_dim=64, dropout=0.3)
gcn_model, gcn_history = train_gnn(gcn_model, train_loader, val_loader, lr=1e-3, epochs=80)

print("\n" + "=" * 60)
print("Training GIN")
print("=" * 60)
gin_model = GIN(input_dim=dataset.num_node_features, hidden_dim=64, dropout=0.3)
gin_model, gin_history = train_gnn(gin_model, train_loader, val_loader, lr=1e-3, epochs=80)

============================================================
Training GCN
============================================================

Epoch   1 | Train Loss: 0.5463 | Val AUC: 0.6080 | Best: 0.6080

Epoch  10 | Train Loss: 0.5017 | Val AUC: 0.6844 | Best: 0.6844

Epoch  20 | Train Loss: 0.4709 | Val AUC: 0.7200 | Best: 0.7254

Epoch  30 | Train Loss: 0.4682 | Val AUC: 0.7408 | Best: 0.7416

Epoch  40 | Train Loss: 0.4733 | Val AUC: 0.7481 | Best: 0.7487

Epoch  50 | Train Loss: 0.4571 | Val AUC: 0.7511 | Best: 0.7515

Epoch  60 | Train Loss: 0.4540 | Val AUC: 0.7579 | Best: 0.7579

Epoch  70 | Train Loss: 0.4510 | Val AUC: 0.7584 | Best: 0.7601

Epoch  80 | Train Loss: 0.4513 | Val AUC: 0.7646 | Best: 0.7651

============================================================
Training GIN
============================================================

Epoch   1 | Train Loss: 8.3299 | Val AUC: 0.6066 | Best: 0.6066

Epoch  10 | Train Loss: 0.5545 | Val AUC: 0.6209 | Best: 0.6593

Epoch  20 | Train Loss: 0.5105 | Val AUC: 0.6161 | Best: 0.6593
Early stopping at epoch 20

# ── Training curves ───────────────────────────────────────────────────────
fig, axes = plt.subplots(2, 2, figsize=(13, 9))

for idx, (name, hist) in enumerate([('GCN', gcn_history), ('GIN', gin_history)]):
    axes[0, idx].plot(hist['train_loss'], label='Train', color='#3498db')
    axes[0, idx].plot(hist['val_loss'], label='Val', color='#e74c3c')
    axes[0, idx].set_xlabel('Epoch'); axes[0, idx].set_ylabel('BCE Loss')
    axes[0, idx].set_title(f'{name} — Loss Curves'); axes[0, idx].legend()

    axes[1, idx].plot(hist['train_auc'], label='Train', color='#3498db')
    axes[1, idx].plot(hist['val_auc'], label='Val', color='#e74c3c')
    axes[1, idx].set_xlabel('Epoch'); axes[1, idx].set_ylabel('AUROC')
    axes[1, idx].set_title(f'{name} — AUROC Curves'); axes[1, idx].legend()

plt.tight_layout()
plt.show()
../_images/7ff3b9eec7375b8db3938ae906dbb69d5ab07e591fe3a36ffba7a439d643bc20.png

🤔 Reflection 5.1 — GNN Architecture and Training#

  1. Compare the parameter counts of GCN vs. GIN. Why does GIN have more parameters? What is the purpose of the MLP inside each GIN layer?

  2. Look at the training curves. Do you see signs of overfitting? How does the gap between train and validation AUROC compare between GCN and GIN?

  3. We used global_mean_pool for GCN and global_add_pool for GIN. For a molecule with 10 atoms vs. one with 50 atoms, how do these pooling strategies differ? Which preserves information about molecule size?

  4. Our GNN has only 2 layers. For a molecule with 20 atoms in a chain, what is the maximum path length between two atoms whose information can interact? When might we want more layers, and what is the trade-off?

# ══ SOLUTION — Reflection 5.1 ═══════════════════════════════════════════════
# 1. GIN uses a 2-layer MLP (linear -> ReLU -> linear) as the UPDATE function in
#    each message-passing layer, while GCN uses a single linear transform. This
#    extra nonlinearity allows GIN to learn more complex node-level transformations.
#    The MLP acts as a universal function approximator within each layer, making
#    the aggregation injective (provably as powerful as the WL test).
#
# 2. Both models likely show some overfitting (train AUC > val AUC), but GIN may
#    overfit more due to its higher capacity. The dataset is small (~2K molecules),
#    making overfitting a persistent challenge. Dropout and early stopping help but
#    can't fully compensate for limited data.
#
# 3. Mean pooling divides by |V|, so a 50-atom molecule's graph embedding has the
#    same scale as a 10-atom molecule's. Sum pooling does NOT normalize, so larger
#    molecules tend to have larger embedding norms. Sum pooling preserves size info,
#    which can be important (larger molecules often have different properties). This
#    is why GIN recommends sum pooling — it's more expressive.
#
# 4. With 2 layers, each node's embedding captures its 2-hop neighborhood. In a
#    20-atom chain, atoms at positions 1 and 20 are 19 hops apart — they cannot
#    directly influence each other. We'd need ~10 layers for full coverage, but
#    over-smoothing would degrade representations long before that. Solutions include
#    virtual nodes (connected to all atoms), jumping knowledge (concatenating all
#    layer outputs), or positional encodings.
print("See comments above for solution.")

See comments above for solution.

Part 6 — Model Comparison and Final Test Evaluation#

We now compare all approaches — tabularization baselines and GNNs — on the held-out test set. As in the earlier labs, this is the first time we touch the test set. All model selection and hyperparameter tuning was done using the validation set.

# ── Collect validation results for model selection ────────────────────────
print("=== Validation Set Results (for model selection) ===\n")

all_results = {}

for name, res in baseline_results.items():
    all_results[name] = res['val_auc']
    print(f"  {name:30s}  Val AUROC = {res['val_auc']:.4f}")

for name, res in fp_results.items():
    all_results[name] = res['val_auc']
    print(f"  {name:30s}  Val AUROC = {res['val_auc']:.4f}")

gcn_val_auc, _, _, _ = evaluate(gcn_model, val_loader)
gin_val_auc, _, _, _ = evaluate(gin_model, val_loader)
all_results['GCN'] = gcn_val_auc
all_results['GIN'] = gin_val_auc
print(f"  {'GCN':30s}  Val AUROC = {gcn_val_auc:.4f}")
print(f"  {'GIN':30s}  Val AUROC = {gin_val_auc:.4f}")

fig, ax = plt.subplots(figsize=(12, 5))
names = list(all_results.keys())
aucs = list(all_results.values())
colors = ['#bdc3c7']*3 + ['#95a5a6']*3 + ['#3498db', '#e74c3c']
bars = ax.barh(names, aucs, color=colors, edgecolor='white')
ax.set_xlabel('Validation AUROC')
ax.set_title('Model Comparison — Validation AUROC')
ax.set_xlim(0.5, 1.0)
for bar, v in zip(bars, aucs):
    ax.text(v + 0.005, bar.get_y() + bar.get_height()/2, f'{v:.4f}',
            va='center', fontsize=10)
plt.tight_layout()
plt.show()

=== Validation Set Results (for model selection) ===

  Logistic Regression             Val AUROC = 0.8168
  Random Forest                   Val AUROC = 0.8586
  Gradient Boosting               Val AUROC = 0.8204
  LR + Fingerprints               Val AUROC = 0.8289
  RF + Fingerprints               Val AUROC = 0.8814
  GBT + Fingerprints              Val AUROC = 0.8502
  GCN                             Val AUROC = 0.7651
  GIN                             Val AUROC = 0.6593
../_images/80df1803958d4d6fde607de3d8f5f00fd5f7e17246e9592a4344eef7da0077a8.png 
# ── Final test evaluation ─────────────────────────────────────────────────
print("=== FINAL TEST SET RESULTS ===")
print("(All models selected on validation set; test set never seen before)\n")

best_fp_name = max(fp_results, key=lambda k: fp_results[k]['val_auc'])
best_fp_model = fp_results[best_fp_name]['model']
fp_test_proba = best_fp_model.predict_proba(X_test_fp)[:, 1]
fp_test_auc = roc_auc_score(y_test_fp, fp_test_proba)

best_bl_name = max(baseline_results, key=lambda k: baseline_results[k]['val_auc'])
best_bl_model = baseline_results[best_bl_name]['model']
bl_test_proba = best_bl_model.predict_proba(X_test_s)[:, 1]
bl_test_auc = roc_auc_score(y_test, bl_test_proba)

gcn_test_auc, _, gcn_test_preds, gcn_test_labels = evaluate(gcn_model, test_loader)
gin_test_auc, _, gin_test_preds, gin_test_labels = evaluate(gin_model, test_loader)

test_summary = {
    f'Best Graph Stats ({best_bl_name})': bl_test_auc,
    f'Best Fingerprints ({best_fp_name})': fp_test_auc,
    'GCN': gcn_test_auc,
    'GIN': gin_test_auc,
}

for name, auc_val in test_summary.items():
    print(f"  {name:45s}  Test AUROC = {auc_val:.4f}")

# ROC curves
fig, ax = plt.subplots(figsize=(8, 6))

fpr, tpr, _ = roc_curve(y_test_fp, fp_test_proba)
ax.plot(fpr, tpr, label=f'Best Fingerprints (AUC={fp_test_auc:.3f})', color='#95a5a6', lw=2)

fpr, tpr, _ = roc_curve(y_test, bl_test_proba)
ax.plot(fpr, tpr, label=f'Best Graph Stats (AUC={bl_test_auc:.3f})', color='#bdc3c7', lw=2)

fpr, tpr, _ = roc_curve(gcn_test_labels, gcn_test_preds)
ax.plot(fpr, tpr, label=f'GCN (AUC={gcn_test_auc:.3f})', color='#3498db', lw=2)

fpr, tpr, _ = roc_curve(gin_test_labels, gin_test_preds)
ax.plot(fpr, tpr, label=f'GIN (AUC={gin_test_auc:.3f})', color='#e74c3c', lw=2)

ax.plot([0, 1], [0, 1], 'k--', lw=1, alpha=0.5)
ax.set_xlabel('False Positive Rate')
ax.set_ylabel('True Positive Rate')
ax.set_title('ROC Curves — Test Set')
ax.legend(loc='lower right')
plt.tight_layout()
plt.show()

=== FINAL TEST SET RESULTS ===
(All models selected on validation set; test set never seen before)

  Best Graph Stats (Random Forest)               Test AUROC = 0.9455
  Best Fingerprints (RF + Fingerprints)          Test AUROC = 0.9722
  GCN                                            Test AUROC = 0.8487
  GIN                                            Test AUROC = 0.7754
../_images/60bb969bf975e950f5c04e98e7164ec590d3d40337316c3b82fb9be688ca408a.png

🤔 Reflection 6.1 — Comparing Approaches#

  1. How do the GNNs compare to the fingerprint baselines? Is the improvement (if any) large enough to justify the additional complexity and compute cost?

  2. The gap between hand-crafted graph statistics and fingerprints is typically larger than the gap between fingerprints and GNNs. Why? What does this tell us about where the “information bottleneck” lies in molecular prediction?

  3. If you were building a drug screening pipeline and needed to classify 10 million molecules, which approach would you use first? How would you combine the approaches?

  4. In what scenarios might GNNs provide a larger advantage over fingerprints? (Hint: think about 3D structure, larger molecules, or tasks beyond classification.)

# ══ SOLUTION — Reflection 6.1 ═══════════════════════════════════════════════
# 1. On BBBP, GNNs and fingerprints tend to perform comparably. The improvement
#    from GNNs (if any) is often small (1-3% AUROC) — not always enough to justify
#    the compute overhead for a production screening pipeline. This is a well-known
#    finding: molecular fingerprints are extremely strong baselines.
#
# 2. The biggest information loss happens when going from structural representation
#    to flat statistics (losing all chemical substructure). Fingerprints preserve
#    local chemical neighborhoods via hashing, which captures most of the predictive
#    signal. GNNs learn the same kind of patterns but with learned (instead of fixed)
#    aggregation functions. The marginal gain from learning vs. hashing is small when
#    the fingerprint space is already well-designed by decades of cheminformatics.
#
# 3. For 10M molecules: (a) use fingerprints for rapid initial screening (seconds
#    per molecule on CPU), (b) apply GNN to the top ~100K candidates for refined
#    ranking, (c) run expensive physics simulations on the top ~1K. This cascade
#    architecture is standard in virtual screening pipelines.
#
# 4. GNNs provide larger advantages for: (a) 3D structure-aware tasks (using 3D
#    coordinates as features), (b) tasks requiring global molecular properties that
#    go beyond local substructure patterns, (c) multi-task learning where shared
#    representations across tasks are valuable, (d) learning on novel chemical
#    spaces where standard fingerprints may not have relevant patterns.
print("See comments above for solution.")

See comments above for solution.

Part 7 — Extensions: What Can You Do From Here?#

If you have extra time or want to explore further, try any of these extensions. They are optional.

# ── Extension 1: Vary GNN depth and observe over-smoothing ────────────────
# Train GCNs with 1, 2, 3, 4, 6 layers and plot val AUROC vs depth.

depths = [1, 2, 3, 4, 6]
depth_results = {}

class GCN_Variable(nn.Module):
    def __init__(self, input_dim, hidden_dim=64, num_layers=2, dropout=0.3):
        super().__init__()
        self.convs = nn.ModuleList()
        self.convs.append(GCNConv(input_dim, hidden_dim))
        for _ in range(num_layers - 1):
            self.convs.append(GCNConv(hidden_dim, hidden_dim))
        self.classifier = nn.Linear(hidden_dim, 1)
        self.dropout = dropout

    def forward(self, x, edge_index, batch):
        h = x
        for conv in self.convs:
            h = F.relu(conv(h, edge_index))
            h = F.dropout(h, p=self.dropout, training=self.training)
        h_graph = global_mean_pool(h, batch)
        return torch.sigmoid(self.classifier(h_graph)).squeeze(-1)

for d in depths:
    print(f"\n--- Depth {d} ---")
    m = GCN_Variable(dataset.num_node_features, hidden_dim=64, num_layers=d)
    m, hist = train_gnn(m, train_loader, val_loader, lr=1e-3, epochs=60, patience=10)
    val_auc, _, _, _ = evaluate(m, val_loader)
    depth_results[d] = val_auc
    print(f"  Val AUROC: {val_auc:.4f}")

plt.figure(figsize=(8, 4))
plt.plot(list(depth_results.keys()), list(depth_results.values()),
         'o-', color='#3498db', lw=2)
plt.xlabel('Number of GCN Layers')
plt.ylabel('Validation AUROC')
plt.title('Over-smoothing: GNN Performance vs Depth')
plt.xticks(depths)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

--- Depth 1 ---

Epoch   1 | Train Loss: 0.6086 | Val AUC: 0.6092 | Best: 0.6092

Epoch  10 | Train Loss: 0.5255 | Val AUC: 0.6860 | Best: 0.7013

Early stopping at epoch 14
  Val AUROC: 0.7013

--- Depth 2 ---

Epoch   1 | Train Loss: 0.5986 | Val AUC: 0.5654 | Best: 0.5654

Epoch  10 | Train Loss: 0.5250 | Val AUC: 0.6733 | Best: 0.6733

Epoch  20 | Train Loss: 0.4868 | Val AUC: 0.7106 | Best: 0.7106

Epoch  30 | Train Loss: 0.4784 | Val AUC: 0.7334 | Best: 0.7346

Epoch  40 | Train Loss: 0.4698 | Val AUC: 0.7463 | Best: 0.7463

Epoch  50 | Train Loss: 0.4608 | Val AUC: 0.7551 | Best: 0.7557

Epoch  60 | Train Loss: 0.4509 | Val AUC: 0.7576 | Best: 0.7606
  Val AUROC: 0.7606

--- Depth 3 ---

Epoch   1 | Train Loss: 0.5684 | Val AUC: 0.5891 | Best: 0.5891

Epoch  10 | Train Loss: 0.5098 | Val AUC: 0.6810 | Best: 0.6834

Epoch  20 | Train Loss: 0.4768 | Val AUC: 0.7222 | Best: 0.7236

Epoch  30 | Train Loss: 0.4639 | Val AUC: 0.7385 | Best: 0.7385

Epoch  40 | Train Loss: 0.4656 | Val AUC: 0.7419 | Best: 0.7465

Epoch  50 | Train Loss: 0.4512 | Val AUC: 0.7579 | Best: 0.7579

Epoch  60 | Train Loss: 0.4394 | Val AUC: 0.7643 | Best: 0.7666
  Val AUROC: 0.7666

--- Depth 4 ---

Epoch   1 | Train Loss: 0.5684 | Val AUC: 0.6127 | Best: 0.6127

Epoch  10 | Train Loss: 0.4971 | Val AUC: 0.6924 | Best: 0.7167

Epoch  20 | Train Loss: 0.4663 | Val AUC: 0.7471 | Best: 0.7471

Epoch  30 | Train Loss: 0.4534 | Val AUC: 0.7638 | Best: 0.7638

Epoch  40 | Train Loss: 0.4378 | Val AUC: 0.7704 | Best: 0.7771

Epoch  50 | Train Loss: 0.4314 | Val AUC: 0.7919 | Best: 0.7919

Epoch  60 | Train Loss: 0.4269 | Val AUC: 0.8082 | Best: 0.8082
  Val AUROC: 0.8082

--- Depth 6 ---

Epoch   1 | Train Loss: 0.5796 | Val AUC: 0.5482 | Best: 0.5482

Epoch  10 | Train Loss: 0.5119 | Val AUC: 0.6653 | Best: 0.6997

Early stopping at epoch 14
  Val AUROC: 0.6997
../_images/5367a4e25776f5860162deb679c13d120a283f88f5c063e60b8ddf9b66f574d0.png

🧠 Final Reflection — Graph Data in the ML Landscape#

Now that you’ve worked through graph-structured data alongside the tabular data from earlier labs, answer these synthesis questions:

  1. Representation matters: We saw that hand-crafted graph statistics \(\ll\) fingerprints \(\approx\) GNNs. What is the general lesson here about the importance of how you represent data vs. which model you use? How does this relate to the “feature engineering vs. feature learning” debate?

  2. Inductive bias: GNNs build in the assumption that graph structure matters — neighbors influence each other. CNNs assume spatial locality. Transformers assume everything can attend to everything. How does the inductive bias of each architecture match or mismatch with different data types in healthcare?

  3. When is graph structure essential? For the BBBP task, fingerprints (which hash the graph) performed nearly as well as GNNs (which learn from it). Can you think of a biomedical problem where the graph structure would be much more important — where you truly need a GNN? (Hint: think protein-protein interactions, drug-drug interactions, or patient similarity networks.)

  4. Scalability and deployment: In the earlier labs, all models could be trained in seconds on a laptop. The GNN required PyTorch, GPUs, and specialized batching. How should the added complexity of graph methods influence your decision to use them in a clinical tool?

  5. Looking ahead: This lab used 2D molecular graphs (connectivity only). Modern molecular ML increasingly uses 3D coordinates (positions of atoms in space). What additional information does 3D structure provide, and why is it especially important for drug-receptor binding prediction?

# ══ SOLUTION — Final Reflection ══════════════════════════════════════════════
# 1. Representation dominates model choice for most problems. The jump from simple
#    statistics to fingerprints (preserving local structure) was much larger than
#    from fingerprints to GNNs. This echoes the broader ML lesson: good features
#    (whether handcrafted or learned) matter more than algorithmic sophistication.
#    Feature engineering = human designs representations; feature learning = model
#    discovers them. GNNs are "learnable fingerprints" — but the fixed fingerprints
#    were already very well designed by decades of cheminformatics research.
#
# 2. GNNs: molecular graphs, protein structures, knowledge graphs — any data with
#    explicit relational structure. CNNs: medical images (X-rays, pathology), where
#    spatial locality matters. Transformers: clinical text (EHR notes, radiology
#    reports), where long-range dependencies matter. The best architecture matches
#    the data's natural structure. Using the wrong inductive bias (e.g., treating
#    graphs as flat feature vectors) wastes information.
#
# 3. Drug-drug interaction prediction: you must know WHICH atoms in drug A interact
#    with WHICH atoms in drug B — this requires graph-level reasoning about molecular
#    substructures that can't be captured by global fingerprints. Protein function
#    prediction from contact maps also requires understanding spatial relationships
#    between residues. Patient similarity networks where the network topology itself
#    (e.g., shared rare diseases) is the signal.
#
# 4. Added complexity increases development time, debugging difficulty, and
#    deployment costs. For clinical deployment, simpler models are preferable unless
#    graph methods provide a clinically meaningful improvement. The decision should
#    be: does the extra 2% AUROC translate to better patient outcomes? If not, use
#    the simpler model. Also consider: reproducibility, interpretability, regulatory
#    approval — all harder with complex deep learning pipelines.
#
# 5. 3D structure provides information about molecular shape, which determines how
#    a drug molecule fits into a protein's binding pocket (like a key in a lock).
#    Two molecules with identical 2D graphs can have different 3D conformations
#    (spatial arrangements) that dramatically affect binding affinity. For drug-
#    receptor binding prediction, 3D-aware models (e.g., SchNet, DimeNet, Equiformer)
#    can capture these interactions, while 2D methods cannot.
print("See comments above for solution.")

See comments above for solution.