人工智能和云计算带来的技术变革：自动驾驶汽车的发展

    import torch
    from torchvision import transforms as T
    from models import DarkNet
    from utils import get_dataloader, compute_loss, save_checkpoint
    
    device = "cuda" if torch.cuda.is_available() else "cpu"
    
    transform = T.Compose([
    T.ToTensor(),
    # normalize RGB values to [0, 1] range
    T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ])
    
    trainset = VOCDataset("path/to/data", transform=transform)
    valset = VOCDataset("path/to/data", split='val', transform=transform)
    
    batch_size = 32
    num_workers = 4
    
    trainloader = DataLoader(trainset, batch_size=batch_size, shuffle=True, num_workers=num_workers)
    valloader = DataLoader(valset, batch_size=batch_size, shuffle=False, num_workers=num_workers)
    
    model = DarkNet().to(device)
    
    criterion = YoloLoss(anchors).to(device)
    
    optimizer = optim.Adam(model.parameters())
    
    
    for epoch in range(num_epochs):
    
    train_loss = []
    model.train()
    
    for images, targets in trainloader:
        images = images.to(device)
        targets = [ann.to(device) for ann in targets]
    
        optimizer.zero_grad()
    
        predictions = model(images)
        loss = criterion(predictions, targets)
    
        loss.backward()
        optimizer.step()
    
        train_loss.append(loss.item())
    
    val_loss = []
    model.eval()
    
    with torch.no_grad():
    
        for images, targets in valloader:
            images = images.to(device)
            targets = [ann.to(device) for ann in targets]
    
            predictions = model(images)
            loss = criterion(predictions, targets)
    
            val_loss.append(loss.item())
    
    print(f"Epoch {epoch+1}/{num_epochs}, Train Loss: {sum(train_loss)/len(train_loss)}, Val Loss: {sum(val_loss)/len(val_loss)}")
    
    save_checkpoint(state={'epoch': epoch + 1, 'arch': 'darknet','state_dict': model.state_dict()}, 
                filename='/path/to/checkpoint')
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

    import cv2
    import numpy as np
    import torch
    from PIL import Image
    from models import DarkNet
    
    def detect(img_path):
    
    device = "cuda" if torch.cuda.is_available() else "cpu"
    image = Image.open(img_path).convert('RGB')
    img_transforms = Compose([Resize((input_dim, input_dim)), ToTensor()])
    transformed_img = img_transforms(image)
    
    inputs = transformed_img.unsqueeze(0)
    inputs = Variable(inputs.type(FloatTensor))
    
    checkpoint = torch.load('/path/to/checkpoint')['state_dict']
    
    model = DarkNet(cfg['structure'], (depth, width)).to(device)
    model.load_state_dict(checkpoint)
    model.eval()
    
    output = model(inputs)
    pred_boxes = non_max_suppression(output[0][:, :, :].sigmoid(), conf_thres=conf_thresh, nms_thres=nms_thresh)[0]
    
    boxes = []
    
    for i in range(pred_boxes.shape[0]):
        bbox = list(map(int, pred_boxes[i][:4]))
        score = float(pred_boxes[i][4])
        label = int(pred_boxes[i][5])
    
        if score > conf_thresh:
            x1 = max(bbox[0]-margin, 0)
            y1 = max(bbox[1]-margin, 0)
            x2 = min(bbox[2]+margin, orig_w)
            y2 = min(bbox[3]+margin, orig_h)
    
            boxes.append([(x1,y1), (x2,y2)])
    
    return boxes
    
    if __name__ == '__main__':
    
    img_path = '/path/to/test_img'
    
    margin = 10
    
    # Set the confidence threshold for detections
    conf_thresh = 0.8
    
    # set the NMS threshold for removing duplicates during NMS process
    nms_thresh = 0.4
    
    labels = open('/path/to/labels.txt').read().strip().split('\n')
    classes = dict(zip(range(len(labels)), labels))
    
    colors = np.random.uniform(0, 255, size=(len(classes), 3))
    
    assert os.path.exists(args.img_path), f"{os.path.abspath(args.img_path)} does not exist!"
    
    img = cv2.imread(args.img_path)
    orig_h, orig_w, _ = img.shape
    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    
    boxes = detect(img_path)
    
    for bbox in boxes:
        x1, y1 = bbox[0]
        x2, y2 = bbox[1]
    
        class_ind = pred_cls[0]
        color = colors[class_ind]
    
        text = classes[class_ind]
        fontScale = 1
        thickness = 2
        txt_size = cv2.getTextSize(text, cv2.FONT_HERSHEY_PLAIN, fontScale, thickness)[0]
        cv2.rectangle(img, (x1, y1), (x2, y2), color, thickness)
        cv2.putText(img, text, (x1, y1 - txt_size[1]), cv2.FONT_HERSHEY_PLAIN,
                    fontScale, (255,255,255), thickness)
    
    plt.imshow(img[:, :, ::-1]); plt.show()
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读