AI Mass人工智能大模型即服务时代：大模型的研究前沿和挑战

    import tensorflow as tf
    
    def build_model():
    # define the model architecture using TensorFlow layers API
    
    inputs =...   # input tensors
    outputs =...  # output tensor(s), usually with softmax activation
    
    return tf.keras.Model(inputs=inputs, outputs=outputs)
    
    
    if __name__ == '__main__':
    model = build_model()
    optimizer = tf.optimizers.Adam(learning_rate=...)    # choose an appropriate optimizer and learning rate scheduler
    loss_fn = tf.losses.CategoricalCrossentropy()        # select a suitable loss function for multi-class classification tasks
    
    @tf.function      # convert the model to TensorFlow graph representation and optimize it for faster execution on GPU or TPU
    def train_step(images, labels):
        with tf.GradientTape() as tape:
            logits = model(images, training=True)         # run forward pass through the model
            loss = loss_fn(labels, logits)                  # calculate loss value based on selected criterion
        
        gradients = tape.gradient(loss, model.trainable_variables)     # compute gradients of the loss w.r.t. all the trainable variables in the model
        optimizer.apply_gradients(zip(gradients, model.trainable_variables))   # apply the computed gradients to update the weights of the model
    
    train_ds =...       # create dataset objects for training data and validation data
    val_ds =...
    epochs = 10          # number of iterations over the entire training set (or subset thereof if necessary)
    
    best_val_loss = float('inf')        # initialize variable to keep track of the best validation loss seen so far
    for epoch in range(epochs):
        print(f"Epoch {epoch+1}/{epochs}")
        
        # Training loop - iterate over each mini-batch of data and perform gradient descent updates
        total_loss = 0.0
        num_batches = 0
        for images, labels in train_ds:
            batch_loss = train_step(images, labels)
            total_loss += batch_loss
            num_batches += 1
            
        avg_loss = total_loss / num_batches
        print(f"\tTraining Loss: {avg_loss:.4f}")
        
        # Validation loop - evaluate the trained model on the validation set to check performance during training
        total_loss = 0.0
        num_batches = 0
        for images, labels in val_ds:
            logits = model(images, training=False)
            val_loss = loss_fn(labels, logits)
            
            total_loss += val_loss
            num_batches += 1
            
        avg_val_loss = total_loss / num_batches
        print(f"\tValidation Loss: {avg_val_loss:.4f}")
    
        # Update the best validation loss seen so far and save the trained model checkpoint if improved
        if avg_val_loss < best_val_loss:
            best_val_loss = avg_val_loss
            model.save_weights("best_checkpoint")
    
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

    import torch
    from torchvision import models
    
    def build_model():
    resnet18 = models.resnet18()
    
    # remove the last fully connected layer from the pre-trained ResNet architecture and replace it with custom layers
    
    new_layers = []
    for i in range(len(resnet18)):
        layer = getattr(resnet18, f'layer{i}')
        new_layers.append(nn.Sequential(*list(layer)[:-1]))
        
    return nn.Sequential(*(new_layers + [nn.Linear(in_features=..., out_features=...)]))
    
    
    if __name__ == '__main__':
    device = 'cuda' if torch.cuda.is_available() else 'cpu'
    
    model = build_model().to(device)
    optimizer = optim.SGD(params=model.parameters(), lr=...)             # choose an appropriate optimizer and learning rate scheduler
    loss_fn = nn.CrossEntropyLoss()                                   # select a suitable loss function for multi-class classification tasks
    
    @torch.no_grad()        # decorate this function with `@torch.no_grad()` to avoid unnecessary computations and memory usage
    def eval_model(data_loader):
        model.eval()
        correct = 0
        total = 0
        
        for images, labels in data_loader:
            images = images.to(device)
            labels = labels.to(device)
    
            outputs = model(images)              # run forward pass through the model
            predicted = torch.argmax(outputs, dim=1)           # get the index of the max log-probability
            
            total += len(predicted)                 # count the number of samples processed
            correct += (predicted == labels).sum().item()   # accumulate the number of correct predictions
        
        acc = correct / total                           # calculate accuracy metric based on the accumulated predictions
        
        return acc
    
    
    def train_model(data_loaders, num_epochs):
        best_acc = 0.0
        
        for epoch in range(num_epochs):
            running_loss = 0.0
            running_correct = 0
            
            # Iterate over each mini-batch of data and perform gradient descent updates
            for phase in ['train', 'val']:
                if phase == 'train':
                    model.train()
                else:
                    model.eval()
                
                for images, labels in data_loaders[phase]:
                    images = images.to(device)
                    labels = labels.to(device)
                    
                    optimizer.zero_grad()                     # zero out the gradients before computing them
                    
                    with torch.set_grad_enabled(phase=='train'):
                        outputs = model(images)               # run forward pass through the model
                        
                        _, preds = torch.max(outputs, 1)        # predict the class indices by taking the argmax of the output tensor
    
                        loss = loss_fn(outputs, labels)         # calculate the cross entropy loss between the predicted and true classes
                        
                        if phase == 'train':
                            loss.backward()                      # backpropagate the error to the model parameters to update their values
                            
                            optimizer.step()                       # update the model parameters using the updated gradients
    
                    running_loss += loss.item() * images.size(0)  # accumulate the loss value across all samples in the current batch
                    running_correct += torch.sum(preds == labels.data)    # accumulate the number of correct predictions across all samples in the current batch
                    
            epoch_loss = running_loss / len(data_loaders['train'].dataset)
            epoch_acc = running_correct.double() / len(data_loaders['train'].dataset)
            
            print(f"{datetime.now()} | Epoch [{epoch+1}/{num_epochs}] | Train Loss: {epoch_loss:.4f} | Train Acc: {epoch_acc:.4f}")
            
            # Save the model weights after every epoch that has a better accuracy than the previous one
            if phase == 'val' and epoch_acc > best_acc:
                best_acc = epoch_acc
                torch.save({'state_dict': model.state_dict()}, os.path.join(..., "best_checkpoint.pth"))
    
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读