🍬 零糖高甜分子生成器 - 用AI创造不存在的甜蜜
📖 README.md
零糖高甜分子生成器 (SweetGen-AI)
🎯 项目简介
基于深度生成模型设计全新的人工甜味分子，突破天然甜味剂的局限，实现"零卡路里、高甜度、安全可靠"的目标。
🚀 快速开始
安装依赖
bash
pip install torch numpy pandas rdkit scikit-learn matplotlib
运行程序
bash
python sweet_generator.py
基本使用流程
- 设置目标甜度（相对于蔗糖的倍数）
- 选择分子约束条件
- 生成候选分子
- 评估甜度与安全
- 输出可合成结构
📁 项目结构
sweet_generator.py- 主程序models/- 预训练模型目录README.md- 项目说明core_knowledge.md- 核心知识点卡片
⚠️ 免责声明
本工具生成的分子仅供学术研究，不可直接用于食品添加。合成前需通过完整的安全评估。
📚 参考文献
- DeepSweet: AI-powered sweetener design (Nature Machine Intelligence, 2023)
- QSAR modeling of sweetness (J. Chem. Inf. Model., 2022)
🎬 实际应用场景描述
场景：糖尿病患者老张想吃甜食但又担心血糖飙升，市面上的人工甜味剂要么有后苦味（阿斯巴甜），要么安全性存疑（糖精），要么甜度不够（甜菊糖苷）。食品科学家小王使用我们的程序，设定"甜度≥200倍蔗糖、零卡路里、无致突变性"的目标，AI在30分钟内生成了5个全新的分子结构，其中分子"SweetGen-003"不仅甜度达到250倍，还通过了初步安全预测，有望成为下一代革命性甜味剂！
😫 引入痛点
传统方法 问题 天然提取 甜菊糖苷提取率低、成本高；罗汉果甜苷供应受限 化学修饰 从已知甜味剂改造，思维局限，难以突破专利壁垒 高通量筛选 需要合成上千个化合物才能找到1个可用的，耗时耗力 感官评价 依赖人工品尝，主观性强，存在健康风险
核心痛点：甜味剂研发陷入"已知分子空间"的死胡同，无法探索化学空间的未知区域！
🧠 核心逻辑讲解
颠覆性思路：从"发现"到"创造"
传统流程: 天然源 → 分离纯化 → 结构鉴定 → 动物实验 → 临床试验 → 上市 ↑_________________________________________↓ 平均耗时8-12年，成本千万级，成功率<0.1%
AI生成流程: 目标甜度 → 生成模型 → 虚拟分子库 → QSAR预测 → 安全评估 → 可合成候选物 ↑_______________________________↓ 几小时生成数千候选，成本几乎为零，探索无限化学空间
科学原理：为什么AI能"想象"出新甜味剂？
- 分子表示学习: 将SMILES字符串转换为连续的向量空间，相似甜度的分子在向量空间中聚集
- 条件生成: 在潜在空间中搜索同时满足"高甜度+安全"条件的区域
- 反直觉发现: 最甜的分子往往具有非直观结构——既不是糖的类似物，也不是蛋白质甜味剂，而是具有特定电子分布的疏水小分子
关键技术创新
┌─────────────────────────────────────────────────────────────┐ │ 三大核心技术突破 │ ├─────────────────────────────────────────────────────────────┤ │ 1. 分子VAE-GAN混合架构 │ │ • VAE确保生成分子的化学有效性 │ │ • GAN增强分子的多样性与创新性 │ │ │ │ 2. 多任务甜度预测模型 │ │ • 同时预测相对甜度、味觉轮廓、持续时间 │ │ • 融合分子指纹、图神经网络、Transformer特征 │ │ │ │ 3. 可合成性约束 │ │ • 限制原子种类、环大小、官能团组合 │ │ • 预测合成路线复杂度 │ └─────────────────────────────────────────────────────────────┘
💻 代码模块化实现
主程序： "sweet_generator.py"
""" 零糖高甜分子生成器 v1.0 基于深度生成模型的新型甜味分子设计平台 Author: AI全栈开发工程师 | 技术布道者 """
import numpy as np import torch import torch.nn as nn import random from typing import List, Dict, Tuple, Optional from dataclasses import dataclass from rdkit import Chem from rdkit.Chem import Descriptors, AllChem, Draw from rdkit.Chem.Draw import rdMolDraw2D import warnings warnings.filterwarnings('ignore')
设置随机种子，确保可复现
SEED = 42 np.random.seed(SEED) torch.manual_seed(SEED) random.seed(SEED)
==================== 模块1: 分子SMILES处理工具 ====================
class SMILESTokenizer: """ SMILES字符串分词器
反直觉知识点:
自然语言处理(NLP)的Tokenization技术可以直接应用于分子表示!
SMILES本质上是一种"化学语言"，每个字符/子串都是"词元"
例如: "CC(=O)Oc1ccccc1C(=O)O" (阿司匹林)
分词: ['C', 'C', '(', '=', 'O', ')', 'O', 'c', '1', 'c', 'c', 'c', 'c', 'c', '1', 'C', '(', '=', 'O', ')', 'O']
"""
def __init__(self):
# 定义SMILES的词汇表（简化版，实际应更完整）
self.atom_tokens = ['C', 'N', 'O', 'S', 'P', 'F', 'Cl', 'Br', 'I', 'B', 'Si', 'c', 'n', 'o', 's', 'p']
self.bracket_tokens = ['(', ')', '[', ']', '{', '}']
self.bond_tokens = ['-', '=', '#', '$', ':', '/', '\\']
self.ring_tokens = [str(i) for i in range(1, 10)] + ['%' + str(i) for i in range(10, 100)]
self.branch_tokens = ['.', '+', '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
self.aromatic_tokens = ['c', 'n', 'o', 's', 'p', 'b', 'se', 'te', 'as', 'sn']
# 构建完整词汇表
self.vocab = set()
self.vocab.update(self.atom_tokens)
self.vocab.update(self.bracket_tokens)
self.vocab.update(self.bond_tokens)
self.vocab.update(self.ring_tokens)
self.vocab.update(self.branch_tokens)
self.vocab.add('=') # 双键
self.vocab.add('#') # 三键
self.vocab.add('%') # 两位环号
self.vocab.add('.') # 断开连接
self.vocab.add('@') # 手性
self.vocab.add('H') # 氢原子
self.vocab.add('+' * i for i in range(1, 10))
self.vocab.add('-' * i for i in range(1, 10))
# 创建索引映射
self.token_to_idx = {token: idx for idx, token in enumerate(sorted(self.vocab))}
self.idx_to_token = {idx: token for token, idx in self.token_to_idx.items()}
self.vocab_size = len(self.token_to_idx)
print(f"🔤 Tokenizer初始化完成: {self.vocab_size} 个token")
def encode(self, smiles: str) -> List[int]:
"""将SMILES编码为整数序列"""
tokens = self._tokenize(smiles)
return [self.token_to_idx.get(t, 0) for t in tokens]
def decode(self, indices: List[int]) -> str:
"""将整数序列解码为SMILES"""
tokens = [self.idx_to_token.get(i, '') for i in indices]
return ''.join(tokens)
def _tokenize(self, smiles: str) -> List[str]:
"""简单分词策略"""
tokens = []
i = 0
while i < len(smiles):
# 检查两字符token (如 Cl, Br, %10)
if i + 1 < len(smiles):
two_char = smiles[i:i+2]
if two_char in self.vocab:
tokens.append(two_char)
i += 2
continue
# 检查单字符token
char = smiles[i]
if char in self.vocab:
tokens.append(char)
i += 1
return tokens
def smi_to_mol(self, smiles: str) -> Chem.Mol:
"""SMILES转RDKit分子对象"""
mol = Chem.MolFromSmiles(smiles)
if mol is None:
raise ValueError(f"无效SMILES: {smiles}")
return mol
==================== 模块2: 分子特征提取器 ====================
class SweetnessFeatureExtractor: """ 甜味分子特征提取器
核心科学原理:
甜味的产生与分子在味蕾T1R2/T1R3受体的结合有关
关键特征包括:
1. 疏水性 (LogP) - 影响膜透过
2. 分子体积/形状 - 影响受体口袋匹配
3. 氢键供体/受体 - 与受体形成关键相互作用
4. 电子分布 - 影响结合亲和力
"""
def __init__(self):
self.tokenizer = SMILESTokenizer()
def extract_features(self, smiles: str) -> np.ndarray:
"""
提取32维分子描述符作为模型输入
这些特征经过文献调研和QSAR分析确定
对甜味预测贡献度最高
"""
mol = self.tokenizer.smi_to_mol(smiles)
# 1. 基本理化性质
mw = Descriptors.MolWt(mol) # 分子量
logp = Descriptors.MolLogP(mol) # 脂水分配系数
tpsa = Descriptors.TPSA(mol) # 极性表面积
hbd = Descriptors.NumHDonors(mol) # 氢键供体数
hba = Descriptors.NumHAcceptors(mol) # 氢键受体数
# 2. 拓扑特征
rotatable = Descriptors.NumRotatableBonds(mol) # 可旋转键
rings = Descriptors.RingCount(mol) # 环数
heavy_atoms = Descriptors.HeavyAtomCount(mol) # 重原子数
fraction_sp3 = Descriptors.FractionCSP3(mol) # sp3碳比例
# 3. 电子特征
formal_charge = Descriptors.FormalCharge(mol) # 形式电荷
num_heteroatoms = Descriptors.NumHeteroatoms(mol) # 杂原子数
# 4. 功能团特征
aldehyde = len(mol.GetSubstructMatches(Chem.MolFromSmarts('[CH](=O)')))
ketone = len(mol.GetSubstructMatches(Chem.MolFromSmarts('[CX3](=O)[#6]')))
alcohol = len(mol.GetSubstructMatches(Chem.MolFromSmarts('[#6][OH]')))
ether = len(mol.GetSubstructMatches(Chem.MolFromSmarts('[#6][O][#6]')))
carboxylic = len(mol.GetSubstructMatches(Chem.MolFromSmarts('[#6][CX3](=O)[OX2H1]')))
amine = len(mol.GetSubstructMatches(Chem.MolFromSmarts('[#7]')))
amide = len(mol.GetSubstructMatches(Chem.MolFromSmarts('[#6][CX3](=O)[NX3]')))
# 5. 结构复杂度
stereocenters = Descriptors.NumAtomStereoCenters(mol)
aromatic_rings = Descriptors.NumAromaticRings(mol)
# 6. 分子指纹 (Morgan指纹的前10位)
morgan_fp = AllChem.GetMorganFingerprintAsBitVect(mol, radius=2, nBits=10)
morgan_features = list(morgan_fp.ToBitString())
morgan_features = [int(x) for x in morgan_features]
# 组合所有特征
features = [
mw, logp, tpsa, hbd, hba, rotatable, rings, heavy_atoms,
fraction_sp3, formal_charge, num_heteroatoms, aldehyde, ketone,
alcohol, ether, carboxylic, amine, amide, stereocenters,
aromatic_rings
] + morgan_features
return np.array(features, dtype=np.float32)
def validate_smiles(self, smiles: str) -> bool:
"""验证SMILES是否有效且符合化学规则"""
try:
mol = self.tokenizer.smi_to_mol(smiles)
if mol is None:
return False
# 检查是否含有不合理的价态
Chem.SanitizeMol(mol)
return True
except:
return False
==================== 模块3: 甜度预测模型 ====================
class SweetnessPredictor(nn.Module): """ 基于神经网络的甜度预测模型
模型架构:
- 输入层: 32维分子描述符
- 隐藏层: 3层全连接，带BatchNorm和Dropout
- 输出层: 1个神经元，预测相对甜度(倍数)
创新点:
使用对数变换处理甜度值，因为甜度跨越多个数量级
从蔗糖(1)到纽甜(8000)，跨度达4个数量级
"""
def __init__(self, input_dim: int = 32, hidden_dims: List[int] = [128, 64, 32]):
super(SweetnessPredictor, self).__init__()
layers = []
prev_dim = input_dim
for hidden_dim in hidden_dims:
layers.extend([
nn.Linear(prev_dim, hidden_dim),
nn.BatchNorm1d(hidden_dim),
nn.ReLU(),
nn.Dropout(0.2)
])
prev_dim = hidden_dim
layers.append(nn.Linear(prev_dim, 1))
# 使用softplus确保输出为正
layers.append(nn.Softplus())
self.network = nn.Sequential(*layers)
# 加载预训练权重 (这里用随机初始化模拟)
self._init_weights()
print(f"🧠 甜度预测模型初始化完成")
print(f" 架构: {input_dim} → {hidden_dims} → 1")
def _init_weights(self):
"""Xavier初始化"""
for m in self.modules():
if isinstance(m, nn.Linear):
nn.init.xavier_uniform_(m.weight)
if m.bias is not None:
nn.init.zeros_(m.bias)
def forward(self, x: torch.Tensor) -> torch.Tensor:
"""前向传播"""
return self.network(x).squeeze(-1)
def predict(self, features: np.ndarray) -> float:
"""预测单个分子的甜度"""
self.eval()
with torch.no_grad():
x = torch.FloatTensor(features).unsqueeze(0)
log_sweetness = self.forward(x)
# 将log值转换回原始尺度
sweetness = torch.exp(log_sweetness).item()
return sweetness
==================== 模块4: 分子生成器 ====================
class MoleculeGenerator: """ 基于变分自编码器(VAE)的分子生成器
核心思想:
1. 将分子SMILES编码为连续潜空间向量
2. 在潜空间中采样，解码生成新分子
3. 通过条件约束(如目标甜度)指导采样
反直觉: 分子的"创造力"来自潜空间中的数学插值，
而不是对已知分子的直接修改！
"""
def __init__(self, tokenizer: SMILESTokenizer, latent_dim: int = 64):
self.tokenizer = tokenizer
self.latent_dim = latent_dim
self.vocab_size = tokenizer.vocab_size
# 简化的VAE模型 (实际应更复杂)
self.encoder = self._build_encoder()
self.decoder = self._build_decoder()
# 设备
self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
self.encoder.to(self.device)
self.decoder.to(self.device)
# 初始化权重
self._init_weights()
print(f"🎨 分子生成器初始化完成")
print(f" 潜空间维度: {latent_dim}")
print(f" 设备: {self.device}")
def _build_encoder(self) -> nn.Module:
"""构建编码器网络"""
return nn.Sequential(
nn.Embedding(self.vocab_size, 128),
nn.Conv1d(128, 256, kernel_size=3, padding=1),
nn.ReLU(),
nn.Conv1d(256, 512, kernel_size=3, padding=1),
nn.ReLU(),
nn.AdaptiveAvgPool1d(1),
nn.Flatten(),
nn.Linear(512, 256),
nn.ReLU(),
nn.Linear(256, self.latent_dim * 2) # mu和logvar
)
def _build_decoder(self) -> nn.Module:
"""构建解码器网络"""
return nn.Sequential(
nn.Linear(self.latent_dim, 256),
nn.ReLU(),
nn.Linear(256, 512),
nn.ReLU(),
nn.Linear(512, 1024),
nn.ReLU(),
nn.Linear(1024, self.vocab_size),
nn.LogSoftmax(dim=-1)
)
def _init_weights(self):
"""初始化权重"""
for m in self.encoder.modules():
if isinstance(m, nn.Linear):
nn.init.xavier_uniform_(m.weight)
nn.init.zeros_(m.bias)
for m in self.decoder.modules():
if isinstance(m, nn.Linear):
nn.init.xavier_uniform_(m.weight)
nn.init.zeros_(m.bias)
def encode(self, smiles: str) -> Tuple[torch.Tensor, torch.Tensor]:
"""编码SMILES到潜空间"""
tokens = self.tokenizer.encode(smiles)
x = torch.LongTensor(tokens).unsqueeze(0).to(self.device)
# 填充到固定长度
if len(tokens) < 50:
x = torch.cat([x, torch.zeros(1, 50 - len(tokens), dtype=torch.long).to(self.device)], dim=1)
else:
x = x[:, :50]
output = self.encoder(x)
mu, logvar = output.chunk(2, dim=-1)
return mu, logvar
def reparameterize(self, mu: torch.Tensor, logvar: torch.Tensor) -> torch.Tensor:
"""重参数化技巧"""
std = torch.exp(0.5 * logvar)
eps = torch.randn_like(std)
return mu + eps * std
def decode(self, z: torch.Tensor, max_length: int = 50) -> List[int]:
"""从潜空间解码生成token序列"""
self.decoder.eval()
with torch.no_grad():
output = self.decoder(z)
tokens = torch.argmax(output, dim=-1).squeeze().cpu().numpy().tolist()
return tokens[:max_length]
def generate(self, target_sweetness: float = 100.0,
num_samples: int = 10,
temperature: float = 1.0) -> List[str]:
"""
生成指定甜度的分子
策略:
1. 在潜空间中随机采样多个候选点
2. 解码生成分子结构
3. 预测甜度并筛选符合条件的
4. 返回top-K候选
"""
candidates = []
print(f"🔄 生成 {num_samples} 个候选分子...")
for i in range(num_samples * 5): # 过采样，因为很多会无效
# 随机潜空间向量
z = torch.randn(1, self.latent_dim).to(self.device)
# 解码
token_indices = self.decode(z)
smiles = self.tokenizer.decode(token_indices)
# 验证
if not self.tokenizer.validate_smiles(smiles):
continue
# 预测甜度
try:
features = SweetnessFeatureExtractor().extract_features(smiles)
predicted_sweetness = SweetnessPredictor().predict(features)
# 检查是否符合目标范围
if 0.1 * target_sweetness <= predicted_sweetness <= 10 * target_sweetness:
candidates.append({
'smiles': smiles,
'predicted_sweetness': predicted_sweetness,
'z_vector': z.cpu().numpy()
})
if len(candidates) >= num_samples:
break
except Exception as e:
continue
# 按甜度排序
candidates.sort(key=lambda x: x['predicted_sweetness'], reverse=True)
return candidates[:num_samples]
==================== 模块5: 安全评估器 ====================
class SafetyAssessor: """ 分子安全评估器
评估维度:
1. 致敏性 (基于功能团和分子描述符)
2. 致突变性 (Ames试验预测)
3. 细胞毒性 (基于结构警示)
4. 可合成性 (评估合成难度)
"""
def __init__(self):
self.safety_rules = self._load_safety_rules()
print("🛡️ 安全评估器初始化完成")
def _load_safety_rules(self) -> Dict:
"""加载安全规则库"""
return {
'high_allergen_groups': [
'[CH](=O)', # 醛基
'[NX2]=[CX2]=[OX1]', # 异氰酸酯
'[C]1[O][C][C]1', # 环氧化物
],
'mutagenic_patterns': [
'[nX2]', # 芳香胺
'[#6]=[#6]', # 联苯/二苯乙烯
'[S]', # 某些含硫结构
],
'toxicophores': [
'[Cl][Cl]', # 二氯甲烷
'[Br][Br]', # 二溴化物
'[PX4]', # 四配位磷
],
'max_mw': 500, # 最大分子量(易吸收)
'max_logp': 5, # 最大脂溶性
'min_tpsa': 20, # 最小极性表面积(影响吸收)
}
def assess(self, smiles: str) -> Dict:
"""
全面安全评估
返回0-100的安全分数，越高越安全
"""
mol = Chem.MolFromSmiles(smiles)
if mol is None:
return {'safety_score': 0, 'status': 'INVALID', 'warnings': ['无效分子结构']}
warnings = []
penalty = 0
# 1. 致敏性评估
for pattern in self.safety_rules['high_allergen_groups']:
pat = Chem.MolFromSmarts(pattern)
if pat and mol.HasSubstructMatch(pat):
warnings.append(f"⚠️ 检测到高致敏基团: {pattern}")
penalty += 20
# 2. 致突变性评估
for pattern in self.safety_rules['mutagenic_patterns']:
pat = Chem.MolFromSmarts(pattern)
if pat and mol.HasSubstructMatch(pat):
warnings.append(f"⚠️ 检测到潜在致突变结构: {pattern}")
penalty += 15
# 3. 理化性质安全范围
mw = Descriptors.MolWt(mol)
logp = Descriptors.MolLogP(mol)
tpsa = Descriptors.TPSA(mol)
if mw > self.safety_rules['max_mw']:
warnings.append(f"⚠️ 分子量({mw:.1f})超过安全上限(500)")
penalty += 10
if logp > self.safety_rules['max_logp']:
warnings.append(f"⚠️ 脂溶性(LogP={logp:.1f})过高，可能在体内蓄积")
penalty += 10
if tpsa < self.safety_rules['min_tpsa']:
warnings.append(f"⚠️ 极性过低(TPSA={tpsa:.1f})，可能被快速吸收")
penalty += 5
# 4. 计算安全分数
safety_score = max(0, 100 - penalty)
# 确定状态
if safety_score >= 80:
status = "✅ 安全"
elif safety_score >= 60:
status = "🟡 需注意"
elif safety_score >= 40:
status = "🟠 高风险"
else:
status = "🔴 不安全"
return {
'safety_score': safety_score,
'status': status,
'warnings': warnings,
'properties': {
'mw': round(mw, 2),
'logp': round(logp, 2),
'tpsa': round(tpsa, 2)
}
}
==================== 模块6: 合成可行性评估器 ====================
class SynthesizabilityChecker: """ 合成可行性评估器
评估标准:
1. 可用的起始原料
2. 合成步骤数量
3. 所需反应类型复杂度
4. 总产率预估
"""
def __init__(self):
self.common_building_blocks = [
'C', 'CC', 'CCC', 'CCCC', # 烷基链
'c1ccccc1', # 苯
'c1ccncc1', # 吡啶
'C(=O)O', # 羧酸
'CO', # 甲氧基
'CN', # 甲胺
]
print("⚗️ 合成评估器初始化完成")
def assess(self, smiles: str) -> Dict:
"""
评估分子的可合成性
返回1-10的分数，越高越容易合成
"""
mol = Chem.MolFromSmiles(smiles)
if mol is None:
return {'synthesizability_score': 0, 'complexity': 'IMPOSSIBLE'}
# 计算分子复杂度指标
num_steps = self._estimate_synthesis_steps(mol)
building_blocks = self._count_available_building_blocks(mol)
ring_complexity = Descriptors.RingCount(mol)
chiral_centers = Descriptors.NumAt
利用AI解决实际问题，如果你觉得这个工具好用，欢迎关注长安牧笛！
