AI Mass人工智能大模型即服务时代：从智能教育到智能辅导

    class TextCNN(nn.Module):
    def __init__(self, vocab_size, num_classes, **kwargs):
        super().__init__()
        self.embedding = nn.EmbeddingBag(vocab_size, kwargs['embed_dim'], sparse=True)
        self.convs = nn.ModuleList([
            nn.Conv2d(1, kwargs['num_filters'], (fs, kwargs['embed_dim'])) for fs in kwargs['filter_sizes']
        ])
        self.fc = nn.Linear(len(kwargs['filter_sizes']) * kwargs['num_filters'], num_classes)
    
    def forward(self, inputs):
        embed = self.embedding(inputs[0], inputs[1])
        x = embed.unsqueeze(1) # (batch_size, 1, seq_len, embed_dim)
    
        x = [F.relu(conv(x)).squeeze(-1).max(dim=-1)[0] for conv in self.convs]
        x = torch.cat(x, dim=1)
        logit = self.fc(x)
    
        return logit
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

    import os
    from sklearn.datasets import fetch_20newsgroups
    
    if not os.path.exists('./data'):
    os.mkdir('data')
    
    train = fetch_20newsgroups(subset='train', categories=['alt.atheism', 'comp.graphics','sci.med'], data_home='./data/')
    test = fetch_20newsgroups(subset='test', categories=['alt.atheism', 'comp.graphics','sci.med'], data_home='./data/')
    
    labels = {'alt.atheism': 0, 'comp.graphics': 1,'sci.med': 2}
    def convert_to_tensors(X):
    tensorized_text = []
    offsets = []
    curr_offset = 0
    
    for sentence in X:
        indices = list(map(lambda w: train.vocabulary_.get(w, len(train.vocabulary_) - 1), sentence))
        tensorized_text += indices
        offsets += [(curr_offset + i, curr_offset + i + 1) for i in range(len(sentence))]
        curr_offset += len(indices)
    
    text = torch.LongTensor(tensorized_text)
    offset = torch.LongTensor(offsets)
    target = torch.LongTensor([labels[label] for label in train.target])
    
    return (text, offset), target
    
    BATCH_SIZE = 64
    train_loader = DataLoader(list(zip(*convert_to_tensors(train.data))), batch_size=BATCH_SIZE, shuffle=True)
    test_loader = DataLoader(list(zip(*convert_to_tensors(test.data))), batch_size=BATCH_SIZE, shuffle=False)
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

    device = 'cuda' if torch.cuda.is_available() else 'cpu'
    model = TextCNN(len(train.vocabulary_), len(labels), embed_dim=300, filter_sizes=[3, 4, 5], num_filters=100)
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)
    scheduler = StepLR(optimizer, step_size=1, gamma=0.1)
    
    for epoch in range(1, 11):
    model.train()
    total_loss = 0
    
    for text, offset, target in train_loader:
        optimizer.zero_grad()
    
        text, offset, target = map(lambda x: x.to(device), (text, offset, target))
        output = model((text, offset))
    
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()
    
        total_loss += float(loss) * len(target)
    
    scheduler.step()
    avg_loss = total_loss / len(train_loader.dataset)
    print('Epoch:', epoch, '| Loss:', avg_loss)
    
    model.eval()
    correct = 0
    total = 0
    
    with torch.no_grad():
    for text, offset, target in test_loader:
        text, offset, target = map(lambda x: x.to(device), (text, offset, target))
        output = model((text, offset))
    
        _, predicted = torch.max(output.data, 1)
        correct += (predicted == target).sum().item()
        total += target.size(0)
    
    print('Accuracy:', correct / total)
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

    text = ['God is love', 'OpenGL on the GPU is fast and efficient', "Medicine can cure almost any disease"]
    offset = [[0, 7], [0, 16], [0, 15]]
    
    text = torch.LongTensor(text)
    offset = torch.LongTensor(offset)
    
    outputs = model((text, offset)).tolist()
    
    for output in outputs:
    prob = F.softmax(torch.FloatTensor(output), dim=0)
    pred_label = int(prob.argmax())
    print('Label:', list(labels.keys())[list(labels.values()).index(pred_label)],
          '\tProbability:', ['{:.4f}'.format(float(prob[idx])) for idx in sorted(range(len(prob)), key=lambda k: prob[k], reverse=True)])
    
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

    Label: alt.atheism        Probability: ['0.9988', '0.0011', '-1.2448e-05']
    Label: comp.graphics      Probability: ['0.8377', '0.1495', '0.0010']
    Label: sci.med            Probability: ['0.0632', '0.9315', '-0.0056']
    
      
      
    
    代码解读