/
crossover.py
180 lines (134 loc) · 5.5 KB
/
crossover.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
import random
import numpy as np
from rdkit import Chem, rdBase
from rdkit.Chem import AllChem
rdBase.DisableLog('rdApp.error')
def cut(mol):
if not mol.HasSubstructMatch(Chem.MolFromSmarts('[*]-;!@[*]')):
return None
bis = random.choice(mol.GetSubstructMatches(Chem.MolFromSmarts('[*]-;!@[*]'))) # single bond not in ring
bs = [mol.GetBondBetweenAtoms(bis[0], bis[1]).GetIdx()]
fragments_mol = Chem.FragmentOnBonds(mol, bs, addDummies=True, dummyLabels=[(1, 1)])
try:
return Chem.GetMolFrags(fragments_mol, asMols=True, sanitizeFrags=True)
except ValueError:
return None
return None
def cut_ring(mol):
for i in range(10):
if random.random() < 0.5:
if not mol.HasSubstructMatch(Chem.MolFromSmarts('[R]@[R]@[R]@[R]')):
return None
bis = random.choice(mol.GetSubstructMatches(Chem.MolFromSmarts('[R]@[R]@[R]@[R]')))
bis = ((bis[0], bis[1]), (bis[2], bis[3]),)
else:
if not mol.HasSubstructMatch(Chem.MolFromSmarts('[R]@[R;!D2]@[R]')):
return None
bis = random.choice(mol.GetSubstructMatches(Chem.MolFromSmarts('[R]@[R;!D2]@[R]')))
bis = ((bis[0], bis[1]), (bis[1], bis[2]),)
bs = [mol.GetBondBetweenAtoms(x, y).GetIdx() for x, y in bis]
fragments_mol = Chem.FragmentOnBonds(mol, bs, addDummies=True, dummyLabels=[(1, 1), (1, 1)])
try:
fragments = Chem.GetMolFrags(fragments_mol, asMols=True, sanitizeFrags=True)
if len(fragments) == 2:
return fragments
except ValueError:
return None
return None
def ring_OK(mol):
if not mol.HasSubstructMatch(Chem.MolFromSmarts('[R]')):
return True
ring_allene = mol.HasSubstructMatch(Chem.MolFromSmarts('[R]=[R]=[R]'))
cycle_list = mol.GetRingInfo().AtomRings()
max_cycle_length = max([len(j) for j in cycle_list])
macro_cycle = max_cycle_length > 6
double_bond_in_small_ring = mol.HasSubstructMatch(Chem.MolFromSmarts('[r3,r4]=[r3,r4]'))
return not ring_allene and not macro_cycle and not double_bond_in_small_ring
# TODO: set from main? calculate for dataset?
average_size = 39.15
size_stdev = 3.50
def mol_ok(mol):
try:
Chem.SanitizeMol(mol)
target_size = size_stdev * np.random.randn() + average_size # parameters set in GA_mol
if mol.GetNumAtoms() > 5 and mol.GetNumAtoms() < target_size:
return True
else:
return False
except ValueError:
return False
def crossover_ring(parent_A, parent_B):
ring_smarts = Chem.MolFromSmarts('[R]')
if not parent_A.HasSubstructMatch(ring_smarts) and not parent_B.HasSubstructMatch(ring_smarts):
return None
rxn_smarts1 = ['[*:1]~[1*].[1*]~[*:2]>>[*:1]-[*:2]', '[*:1]~[1*].[1*]~[*:2]>>[*:1]=[*:2]']
rxn_smarts2 = ['([*:1]~[1*].[1*]~[*:2])>>[*:1]-[*:2]', '([*:1]~[1*].[1*]~[*:2])>>[*:1]=[*:2]']
for i in range(10):
fragments_A = cut_ring(parent_A)
fragments_B = cut_ring(parent_B)
if fragments_A is None or fragments_B is None:
return None
new_mol_trial = []
for rs in rxn_smarts1:
rxn1 = AllChem.ReactionFromSmarts(rs)
new_mol_trial = []
for fa in fragments_A:
for fb in fragments_B:
new_mol_trial.append(rxn1.RunReactants((fa, fb))[0])
new_mols = []
for rs in rxn_smarts2:
rxn2 = AllChem.ReactionFromSmarts(rs)
for m in new_mol_trial:
m = m[0]
if mol_ok(m):
new_mols += list(rxn2.RunReactants((m,)))
new_mols2 = []
for m in new_mols:
m = m[0]
if mol_ok(m) and ring_OK(m):
new_mols2.append(m)
if len(new_mols2) > 0:
return random.choice(new_mols2)
return None
def crossover_non_ring(parent_A, parent_B):
for i in range(10):
fragments_A = cut(parent_A)
fragments_B = cut(parent_B)
if fragments_A is None or fragments_B is None:
return None
rxn = AllChem.ReactionFromSmarts('[*:1]-[1*].[1*]-[*:2]>>[*:1]-[*:2]')
new_mol_trial = []
for fa in fragments_A:
for fb in fragments_B:
new_mol_trial.append(rxn.RunReactants((fa, fb))[0])
new_mols = []
for mol in new_mol_trial:
mol = mol[0]
if mol_ok(mol):
new_mols.append(mol)
if len(new_mols) > 0:
return random.choice(new_mols)
return None
def crossover(parent_A, parent_B):
parent_smiles = [Chem.MolToSmiles(parent_A), Chem.MolToSmiles(parent_B)]
try:
Chem.Kekulize(parent_A, clearAromaticFlags=True)
Chem.Kekulize(parent_B, clearAromaticFlags=True)
except ValueError:
pass
for i in range(10):
if random.random() <= 0.5:
# print 'non-ring crossover'
new_mol = crossover_non_ring(parent_A, parent_B)
if new_mol is not None:
new_smiles = Chem.MolToSmiles(new_mol)
if new_smiles is not None and new_smiles not in parent_smiles:
return new_mol
else:
# print 'ring crossover'
new_mol = crossover_ring(parent_A, parent_B)
if new_mol is not None:
new_smiles = Chem.MolToSmiles(new_mol)
if new_smiles is not None and new_smiles not in parent_smiles:
return new_mol
return None