深度学习在材料科学领域的应用

    import torch
    import torch.nn as nn
    import dgl
    import dgl.function as fn
    
    # 定义图卷积网络模型
    class GCN(nn.Module):
    def __init__(self, in_feats, h_feats, num_classes):
        super(GCN, self).__init__()
        self.conv1 = GraphConv(in_feats, h_feats)
        self.conv2 = GraphConv(h_feats, num_classes)
    
    def forward(self, g, in_feat):
        h = self.conv1(g, in_feat)
        h = torch.relu(h)
        h = self.conv2(g, h)
        return h
    
    # 构建分子图数据集
    dataset = DglMoleculeDataset(...)
    train_loader, val_loader, test_loader = ...
    
    # 训练GCN模型
    model = GCN(in_feats=dataset.num_atom_types, h_feats=64, num_classes=1)
    optimizer = torch.optim.Adam(model.parameters())
    for epoch in range(num_epochs):
    for batched_graph, labels in train_loader:
        pred = model(batched_graph, batched_graph.ndata['feat'])
        loss = criterion(pred, labels)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    # 验证集评估
    
    # 利用训练好的模型预测新分子性能
    new_molecule = create_molecule(...)
    new_graph = dgl.from_networkx(new_molecule.to_networkx())
    new_graph.ndata['feat'] = get_atom_features(new_molecule)
    pred = model(new_graph, new_graph.ndata['feat'])
    print(f'Predicted property: {pred.item()}')
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

    import torch.nn as nn
    import torchvision.transforms as transforms
    from PIL import Image
    
    # 定义卷积神经网络模型
    class CeramicsStrengthCNN(nn.Module):
    def __init__(self):
        super(CeramicsStrengthCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, 3, 1, 1)
        self.conv2 = nn.Conv2d(32, 64, 3, 1, 1)
        self.fc1 = nn.Linear(64 * 7 * 7, 128)
        self.fc2 = nn.Linear(128, 1)
    
    def forward(self, x):
        x = self.conv1(x)
        x = nn.ReLU()(x)
        x = nn.MaxPool2d(2)(x)
        x = self.conv2(x)
        x = nn.ReLU()(x)
        x = nn.MaxPool2d(2)(x)
        x = x.view(-1, 64 * 7 * 7)
        x = self.fc1(x)
        x = nn.ReLU()(x)
        x = self.fc2(x)
        return x
    
    # 数据预处理
    transform = transforms.Compose([
    transforms.Grayscale(),
    transforms.Resize((28, 28)),
    transforms.ToTensor()
    ])
    
    # 加载数据集
    train_dataset = CeramicsDataset(root_dir='./data/train', transform=transform)
    test_dataset = CeramicsDataset(root_dir='./data/test', transform=transform)
    train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=32, shuffle=True)
    test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=32, shuffle=False)
    
    # 训练模型
    model = CeramicsStrengthCNN()
    criterion = nn.MSELoss()
    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
    
    for epoch in range(num_epochs):
    for images, labels in train_loader:
        outputs = model(images)
        loss = criterion(outputs, labels)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    
    # 评估模型
    model.eval()
    with torch.no_grad():
    for images, labels in test_loader:
        outputs = model(images)
        mse = criterion(outputs, labels)
        print(f'Test MSE: {mse.item()}')
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读