史蒂夫·賈伯斯（Steve Jobs）曾稱計算機為“心靈的自行車”。 然而，當他談到地球上所有物種的運動效率時，人們對他的隱喻的背景知之甚少。
由 Dall·e 3** 生成，提示“將計算機視為心靈的自行車”。
禿鷲獲勝並位居榜首，超過了所有其他物種。 人類是......在大約三分之一的列表中但是一旦人類騎上自行車，它們就可以遠遠超過禿鷲並登上榜首。 它啟發了我，人類是工具製造者，我們可以製造工具，將這些固有的能力放大到驚人的程度。 對我來說，計算機一直是大腦的自行車，它讓我們遠遠超出了我們的固有能力。 我認為我們只是處於這個工具的早期階段，非常早期的階段。 我們只走了很短的距離，它仍處於形成階段，但我們已經看到了巨大的變化。 在我看來，與未來 100 年將發生的事情相比，這算不了什麼。
史蒂夫·賈伯斯（1990）。
#
謹慎樂觀
LLM 在加速軟體開發中的作用已被廣泛討論。 有人認為，自動生成的**的質量如此之低，以至於使用這些**會產生負面影響。 另一方面，許多人聲稱程式設計時代已經結束。 有許多研究試圖客觀地評估 LLM 在 **質量基準資料集（如 Humaneval 或 MBPP）上的效能。 這些評估對於該領域的發展至關重要，但它們不是本文的重點。
本文的目的是為開發人員提供實用建議，尤其是那些對利用這些模型持保留態度的開發人員。 需要注意的是，我相信，通過正確使用這項技術，乙個人的生產力確實可以實現質的飛躍
需要明確的是，使用 LLM 並不一定意味著您將產生高效能**。 即使是最先進的模型也會犯嚴重的錯誤。 但重要的是要記住，最好的人類工程師也會犯錯誤。 這就是為什麼我們不會在沒有護欄的情況下發布，例如自動化測試和同行評審。 LLM 不會改變最佳實踐的性質，但它們可能會改變它們實施的難易程度。
描述現在交付 ** 的過程（**由 dall·e 3 生成）。
寫高效能**速度真的那麼重要嗎？
如果大多數專業軟體工程師把大部分時間都花在鍵盤上打字，我會感到驚訝。 如果是這樣的話，我們可能會更認真地將“行數”作為效能的衡量標準。 我認為工程師實際上花了更多的時間來決定先寫哪些。 目前，LLM沒有能力進行這種高階抽象思維——OpenAI和許多其他機構正在努力使這些步驟成為可能，但這很可能需要的不僅僅是增加模型的引數或擴充套件訓練資料，而是一種全新的思維方式。 然而，LLM已經能夠在很大程度上加快我們的大部分工作。
#
編寫高效函式
讓我舉個例子，說明我們需要採取哪些步驟來優化 LLM，以便在我們生成乙個小段後使其有用。 測量地球上的一點與另一組坐標之間的距離是地理空間分析中的常見任務。 想象一下這樣的場景。
您看到的第乙個輸出是這樣的：
import mathdef h**ersine(lat1, lon1, lat2, lon2): # radius of the earth in kilometers r = 6371.0 # convert degrees to radians lat1_rad = math.radians(lat1) lon1_rad = math.radians(lon1) lat2_rad = math.radians(lat2) lon2_rad = math.radians(lon2) # differences in coordinates dlat = lat2_rad - lat1_rad dlon = lon2_rad - lon1_rad # h**ersine formula a = math.sin(dlat / 2)**2 + math.cos(lat1_rad) *math.cos(lat2_rad) *math.sin(dlon / 2)**2 c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a)) # distance in kilometers distance = r * c return distancedef find_closest_oil_platform(vessel_lat, vessel_lon, platforms): closest_platform = none min_distance = float('inf') for platform in platforms: distance = h**ersine(vessel_lat, vessel_lon, platform['latitude'], platform['longitude']) if distance < min_distance: min_distance = distance closest_platform = platform return closest_platform, min_distance這一段的質量並不理想。 它有很多問題，最明顯的是它難以閱讀，因為它使用了難以理解和不一致的變數命名，包括大寫和小寫的單字元命名。 此外，它缺乏文件和型別提示，使用不必要且低效的 for 迴圈，並且不處理等距離等特殊情況。
但是修改後：
from typing import tuple, listimport numpy as npdef h**ersine_vectorized(vessel_lat: float, vessel_lon: float, platform_lats: np.ndarray, platform_lons: np.ndarray) -np.ndarray: """ calculate the h**ersine distance between a vessel and multiple platforms in a vectorized manner. parameters: -vessel_lat: latitude of the vessel in decimal degrees. -vessel_lon: longitude of the vessel in decimal degrees. -platform_lats: numpy array of latitudes of oil platforms in decimal degrees. -platform_lons: numpy array of longitudes of oil platforms in decimal degrees. returns: -distances: numpy array of distances from the vessel to each platform in kilometers. """ # convert decimal degrees to radians lat1, lon1, lat2, lon2 = map(np.radians, [vessel_lat, vessel_lon, platform_lats, platform_lons]) # h**ersine formula dlat = lat2 - lat1 dlon = lon2 - lon1 a = np.sin(dlat/2)**2 + np.cos(lat1) *np.cos(lat2) *np.sin(dlon/2)**2 c = 2 * np.arctan2(np.sqrt(a), np.sqrt(1-a)) r = 6371 # radius of earth in kilometers return c * rdef find_closest_platform(vessel_lat: float, vessel_lon: float, platform_lats: np.ndarray, platform_lons: np.ndarray) -tuple[list[int], float]: """ finds the closest oil platform(s) to a vessel given arrays of platform latitudes and longitudes, handling equidistant platforms. parameters: -vessel_lat: latitude of the vessel in decimal degrees. -vessel_lon: longitude of the vessel in decimal degrees. -platform_lats: numpy array of latitudes for oil platforms. -platform_lons: numpy array of longitudes for oil platforms. returns: -a tuple containing a list of indices of the closest platforms and the distance to them in kilometers. """ # calculate distances to all platforms distances = h**ersine_vectorized(vessel_lat, vessel_lon, platform_lats, platform_lons) # find the minimum distance min_distance = np.min(distances) # find all indices with the minimum distance closest_indices = np.where(distances == min_distance)[0].tolist() # return the indices of all closest platforms and the minimum distance return closest_indices, min_distance然而，“好”，更重要的是，它是否符合要求取決於它執行的具體環境。 你知道，你不能只用幾行字有效地評估它的質量，對人類和LLM來說都是如此。
例如，這一段的準確性是否符合使用者的期望？ 它會經常執行嗎？ 是一年一次，還是每微秒一次？ 使用的硬體條件是什麼？ 預期的使用量和規模是否值得進行小規模的優化？ 考慮到你的薪水，這樣做是否划算？
讓我們根據上述因素來評估這一段。
在準確性方面，雖然 h**ersine 公式表現良好，但它並不是最佳選擇，因為它將地球視為乙個完美的球體，而實際上地球更接近乙個扁球體。 當需要在很遠的距離上進行公釐級精度的測量時，這種差異就變得很重要。 如果確實需要這種精確度，可以使用更精確的公式，例如文森特公式，但這需要權衡效能。 由於本部分的使用者不需要公釐級精度（實際上，由於從衛星影象得出的船舶坐標誤差，這種精度無關緊要），因此就精度而言，半正弦函式是合理的選擇。
* 它執行得夠快嗎？ 考慮到只需要計算幾千個海上石油平台，特別是通過向量計算方法，這種計算非常有效。 但是，如果應用程式變成計算到海岸上任何一點的距離（海岸線上有數億個點），那麼“分而治之”的策略可能更合適。 在實踐中，考慮到需要節省計算成本，此函式設計為每天在成本最高的低配置虛擬機器上執行約 1 億次。
基於這些詳細的背景資訊，我們可以認為上面的**實現是合理的。 這也意味著在最終合併之前，應該對其進行測試（我通常不建議僅依賴 LLM）和人類同行評審。
#
加速前進
它不僅通過使用 LLM 像以前一樣自動生成有用的函式來節省您的時間，而且當您開始使用它們來生成整個庫、處理模組之間的依賴關係、編寫文件、視覺化（通過多模態功能）、編寫自述檔案、開發命令列介面等時，它們帶來的價值會呈指數級增長。
讓我們嘗試在 LLM 的幫助下從頭開始建立、訓練、評估和推斷新的計算機視覺模型。 以最近發表的一篇文章為例，“通過深度學習識別 Sentinel-2 影象中船舶尾流元件的臨界點方法”（Del Prete 等人，IEEE GRSL，2023 年），這是推動和激勵我們前進的動力。
*鏈結：
Sentinel-2 衛星影象中顯示的船隻及其尾流。
為什麼我們需要關心衛星影象中船的方向，這項任務的難點是什麼？
對於需要監測水域中人類活動的組織來說，通過靜態影象識別船隻的方向是非常有價值的資訊。 例如，如果一艘船駛向海洋保護區，這可能意味著需要採取警惕或攔截措施。 通常，全球發布的衛星影象的解像度不足以準確確定船舶的方向，尤其是那些只在影象上佔據幾個畫素的小型船隻（例如，Sentinel-2的影象解像度為10公尺畫素）。 然而，即使是小船也會在水中留下相當明顯的漣漪，即使無法直接識別船尾，也能為我們提供船隻前進方向的線索。
這項研究之所以引人注目，是因為它使用了基於EfficientNetB0的模型，該模型足夠小，可以在不花費太多計算資源的情況下大規模應用。 雖然我沒有找到具體的實現，但作者公開了包括標記在內的資料集，這是乙個可觀的步驟。
讓我們開始探索吧！
與任何新的機器學習專案一樣，首先視覺化資料是乙個具有啟發性的步驟。
import osimport jsonfrom pil import image, imagedrawimport matplotlib.pyplot as pltimport seaborn as sns# define the path to your data directorydata_dir = "/path/to/your/data" # adjust this to the path of your data directoryannotations_dir = os.path.join(data_dir, "annotations")images_dir = os.path.join(data_dir, "imgs")# initialize seaborn for better visual aestheticssns.set(style="whitegrid", palette="muted")# create a list to hold file paths for images and their corresponding annotationsimage_files = annotation_files = # loop through the annotations directory to get the list of annotation filesfor annotation_file in os.listdir(annotations_dir): if annotation_file.endswith(".json"): annotation_path = os.path.join(annotations_dir, annotation_file) image_file = annotation_file.replace(".json", ".png") # assuming image file names match annotation file names image_path = os.path.join(images_dir, image_file) # check if the corresponding image file exists if os.path.exists(image_path): annotation_files.append(annotation_path) image_files.append(image_path)# plottingnum_examples = min(len(image_files), 10) # limiting to 10 examples for visualizationfig, axes = plt.subplots(2, 5, figsize=(20, 8))for idx, (image_path, annotation_path) in enumerate(zip(image_files[:num_examples], annotation_files[:num_examples]))# load the image img = image.open(image_path).convert("rgb") # ensure the image is treated as rgb draw = imagedraw.draw(img) # load the corresponding annotations and draw keypoints with open(annotation_path, 'r') as f: annotations = json.load(f) for point in annotations["tooltips"]: x, y = point["x"], point["y"] # draw keypoints in cyan for visibility draw.ellipse([(x-10, y-10), x+10, y+10)],fill='cyan', outline='black') # plot the image with keypoints ax = axes[idx // 5, idx % 5] ax.imshow(img) ax.axis('off') ax.set_title(f"image ")plt.tight_layout()plt.show()
Sentinel-2 衛星影象中的船隻和尾流關鍵點注釋（青色）樣本。
結果顯示，不同**中標記的關鍵點（青點）數量不同; 其次，影象都是灰度的，形狀各異; 第三，雖然樣本量很小，但其內部差異相當大。 考慮到這些基礎，我們將編寫載入資料集、定義神經網路、訓練神經網路並驗證它的基礎。 在請求之前，我們將向 LLM 提供一些背景資訊。
這將導致以下輸出：
import osimport jsonimport torchfrom torch.utils.data import dataset, dataloaderfrom torchvision import transformsfrom torchvision.io import read_imagefrom typing import tuple, listclass wakedataset(dataset): """ custom dataset for loading wake detection imagery and annotations, with preprocessing for efficientnet. images are grayscale and will be converted to three-channel images for model compatibility. """ def __init__(self, annotations_dir: str, images_dir: str, transform=none): """ initializes the dataset with paths to annotations and images directories, and a transform. parameters: -annotations_dir: path to the directory containing annotation json files. -images_dir: path to the directory containing grayscale image files. -transform: a torchvision.transforms transform to be applied on a sample. """ self.annotations_dir = annotations_dir self.images_dir = images_dir self.transform = transform if transform else self.default_transform() self.annotations = self._load_annotations() def default_transform(self): """ defines the default transform to resize images, convert them to three-channel format, and to tensors. returns: -a torchvision.transforms composition for image preprocessing. """ return transforms.compose([ transforms.resize((224, 224)),# resize to the input size for efficientnet transforms.grayscale(num_output_channels=3), # convert grayscale to three-channel transforms.convertimagedtype(torch.float), # ensures image is a float tensor ])def _load_annotations(self) -list[tuple[str, list[int]]]""" loads and filters annotations with at least 2 keypoints. returns: -a list of tuples, where each tuple contains the image filename and its keypoints. """ annotations = for filename in os.listdir(self.annotations_dir): if not filename.endswith('.json'): continue filepath = os.path.join(self.annotations_dir, filename) with open(filepath, 'r') as f: data = json.load(f) if len(data['tooltips']) = 2: # filter annotations with at least 2 keypoints keypoints = [item for sublist in [[kp['x'], kp['y']] for kp in data['tooltips']] for item in sublist] annotations.append((filename.replace('.json', '.png'), keypoints)) return annotations def __len__(self) -int: """ returns the number of items in the dataset. """ return len(self.annotations) def __getitem__(self, idx) -tuple[torch.tensor, torch.tensor]: """ retrieves an item from the dataset at the specified index, with preprocessing for efficientnet. parameters: -idx: index of the item to retrieve. returns: -a tuple containing the preprocessed image tensor and its corresponding keypoints tensor. """ img_name, keypoints = self.annotations[idx] img_path = os.path.join(self.images_dir, img_name) image = read_image(img_path) # load image keypoints = torch.tensor(keypoints + 0] *6 - len(keypoints)),dtype=torch.float) # pad keypoints if self.transform: image = self.transform(image) return image, keypoints
import torchimport torch.nn as nnfrom torchvision import modelsfrom typing import tupleclass efficientnetb0keypointdetector(nn.module): """ a custom efficientnet-b0 model for keypoint detection in grayscale images. the network modifies the input layer to accept single-channel images and adds a custom output layer for predicting a fixed number of keypoints. """ def __init__(self, num_keypoints: int = 3): """ initializes the model. parameters: -num_keypoints: the number of keypoints to predict. default is 3, corresponding to the maximum number of keypoints in the dataset. """ super(efficientnetb0keypointdetector, self)._init__(self.num_keypoints = num_keypoints # load a pre-trained efficientnet-b0 self.efficientnet_b0 = models.efficientnet_b0(pretrained=true) # modify the first convolutional layer to accept single-channel (grayscale) images original_first_conv = self.efficientnet_b0.features[0][0] self.efficientnet_b0.features[0][0] = nn.conv2d( in_channels=1, out_channels=original_first_conv.out_channels, kernel_size=original_first_conv.kernel_size, stride=original_first_conv.stride, padding=original_first_conv.padding, bias=false) # modify the classifier to predict keypoints (num_keypoints * 2 because x, y for each keypoint) self.efficientnet_b0.classifier = nn.linear( in_features=self.efficientnet_b0.classifier[1].in_features, out_features=num_keypoints * 2) def forward(self, x: torch.tensor) -torch.tensor: """ forward pass of the network. parameters: -x: input tensor of shape (batch_size, 1, 224, 224) returns: -a tensor of shape (batch_size, num_keypoints * 2) representing the predicted keypoints. """ return self.efficientnet_b0(x)# example usageif __name__ == "__main__": model = efficientnetb0keypointdetector() print(model) # example input tensor (batch_size, channels, height, width) example_input = torch.randn(1, 1, 224, 224) output = model(example_input) print(output.shape) # expected shape: (1, 6) for 3 keypoints (each with x, y coordinates)
import osimport torchimport torch.nn as nnimport torch.optim as optimfrom torch.utils.data import dataloaderfrom dataset import wakedataset, get_dataloader # assuming dataset.py is in the same directoryfrom net import efficientnetb0keypointdetectorfrom torchvision import transformsimport wandb# initialize weights & biaseswandb.init(project="wake_model_llm_assist", entity="your_wandb_entity", mode="offline")def custom_collate_fn(batch): """ custom collate function to pad keypoints to a fixed size. parameters: -batch: a list of tuples (image, keypoints). returns: -batched images and keypoints with padding as necessary. """ images, keypoints = zip(*batch) images = torch.stack(images, 0) max_keypoints = 3 * 2 # maximum number of keypoints (3) times 2 for (x, y) padded_keypoints = [torch.cat((kp, torch.zeros(max_keypoints - len(kp)))for kp in keypoints] keypoints = torch.stack(padded_keypoints, 0) return images, keypointsdef train_one_epoch(model: nn.module, dataloader: dataloader, optimizer: optim.optimizer, device: torch.device): """ trains the model for one epoch. parameters: -model: the neural network model. -dataloader: dataloader providing the training data. -optimizer: optimizer used for model training. -device: the device to train on. """ model.train() total_loss = 0.0 for images, keypoints in dataloader: images, keypoints = images.to(device), keypoints.to(device) optimizer.zero_grad() outputs = model(images) loss = nn.mseloss()(outputs, keypoints) loss.backward() optimizer.step() total_loss += loss.item() erage_loss = total_loss / len(dataloader) wandb.log()def evaluate(model: nn.module, dataloader: dataloader, device: torch.device): """ evaluates the model on the validation set. parameters: -model: the neural network model. -dataloader: dataloader providing the validation data. -device: the device to evaluate on. """ model.eval() total_loss = 0.0 with torch.no_grad():for images, keypoints in dataloader: images, keypoints = images.to(device), keypoints.to(device) outputs = model(images) loss = nn.mseloss()(outputs, keypoints) total_loss += loss.item() erage_loss = total_loss / len(dataloader) wandb.log()def main():# setup device = torch.device("cuda" if torch.cuda.is_**ailable() else "cpu") model = efficientnetb0keypointdetector().to(device) optimizer = optim.adam(model.parameters(),lr=1e-3) # dataloaders train_dataloader = get_dataloader('path/to/train/annotations', 'path/to/train/images', batch_size=4, transform=transforms.totensor(),collate_fn=custom_collate_fn) val_dataloader = get_dataloader('path/to/val/annotations', 'path/to/val/images', batch_size=4, transform=transforms.totensor(),collate_fn=custom_collate_fn) # training loop for epoch in range(num_epochs): train_one_epoch(model, train_dataloader, optimizer, device) evaluate(model, val_dataloader, device) # log model checkpoints, images, or other metrics as needed wandb.log({}if __name__ == "__main__": main()這樣做有效地解決了任何懸而未決的問題，我開始了培訓......的模型但是訓練速度卻出奇地慢。 就在那時，我意識到我沒有利用 Apple 晶元上的金屬效能著色器 （MPS） 後端。 雖然我通常不會在 PC 上訓練模型，而且 MPS 對我來說還比較新，但我決定新增乙個條件判斷來使用它。
考慮到適度的訓練資料（總共 581 張照片**）以及 EfficientNet 已經在 ImageNet 上進行了預訓練，我決定進行 1000 個週期的訓練。
經過 500 個週期後，列車損耗仍在下降，但驗證損耗似乎已經收斂（至少足以進行快速評估）。 影象是根據權重和偏差複製的。
值得注意的是，雖然有一些基礎模型已經在衛星影象上進行了預訓練（相對於ImageNet），這些模型可能對這項任務更有效，但這些網路比EfficientNet大得多，因此訓練速度較慢（而且太新，無法包含在LLM訓練資料集中）。
現在，讓我們編寫乙個推理指令碼和乙個命令列介面 （CLI） 來測試我們剛剛訓練的模型。
import torchfrom torchvision import transformsfrom pil import imageimport matplotlib.pyplot as pltimport click# assuming net.py contains the efficientnetb0keypointdetector class# and dataset.py contains the transforms used during trainingfrom net import efficientnetb0keypointdetectorfrom dataset import wakedataset # modify as necessary to import transformsdef load_model(model_path): """load the trained model from a file.""" model = efficientnetb0keypointdetector() model.load_state_dict(torch.load(model_path)) model.eval() # set the model to inference mode return modeldef preprocess_image(image_path, transform): """load and preprocess an image.""" image = image.open(image_path).convert("l") # assuming grayscale conversion as in your dataset image = transform(image) # add batch dimension (bxcxhxw) image = image.unsqueeze(0) return imagedef plot_keypoints(image, keypoints): """plot keypoints on the image.""" plt.imshow(image.squeeze(),cmap='gray') # remove batch dimension and show image plt.scatter(keypoints[:,0], keypoints[:,1], s=50, marker='.', c='red') plt.show()@click.command()@click.argument('model_path', type=click.path(exists=true))@click.argument('image_path', type=click.path(exists=true))def run_inference(model_path, image_path): """run inference on an image using a trained model.""" # use the same transforms as during training transform = transforms.compose([ transforms.resize((224, 224)),transforms.totensor(),transforms.grayscale(num_output_channels=3), model = load_model(model_path) image = preprocess_image(image_path, transform) # perform inference with torch.no_grad():keypoints = model(image) keypoints = keypoints.view(-1, 2).cpu().numpy() # reshape and convert to numpy for plotting # load original image for plotting original_image = image.open(image_path).convert("l") plot_keypoints(original_image, keypoints)if __name__ == '__main__': run_inference()它並不完美，但對於第一次通過來說是合理的。
您可以在 GitHub 上找到完整的自述檔案，其中包含所有模組、模型和權重（用於週期 500）和自述檔案。 我花了不到乙個小時的時間就生成了整個庫，這個過程比寫這篇文章花費的時間要少得多。 所有這些工作都是在我的個人開發環境中完成的：MacBook Air M2 + VS Code + Copilot + 儲存時自動格式化（使用 Black、Isort 等）+ 乙個 Python 39.6 的虛擬環境 （..）venv）。
github：
經驗 教訓
為模型提供盡可能多的相關上下文，以幫助其解決任務。 請記住，該模型缺少許多您可能認為理所當然的假設。 生成的 LLM 通常遠非完美，而且失敗的方式具有挑戰性。 因此，在 IDE 中有乙個輔助工具（例如 Copilot）是非常有幫助的。 當你嚴重依賴 LLM 時，請記住，你的寫作速度通常是限制因素。 避免不需要任何更改的重複請求，這不僅會浪費精力，還會減慢您的進度。 LLM 很難“記住”它們輸出的每一行，並且經常需要提醒它們當前狀態（尤其是當存在跨越多個模組的依賴項時）。 對 LLM 生成的 ** 持懷疑態度。 使用測試、視覺化等方式盡可能多地進行驗證。 並將時間投入到重要的事情上。 我花在h**ersine函式上的時間比花在神經部分的時間要多（因為預期的規模需要更多的效能），而對於神經網路，我更關心的是快速發現故障。 #
法學碩士和工程學的未來
只有變化是永恆的。
赫拉克利特。
在LLM引發的繁榮和鉅額現金流的背景下，人們很容易首先期待完美。 然而，有效利用這些工具需要我們進行實驗、學習和適應。
LLM會改變軟體工程團隊的基本結構嗎？ 也許，我們現在只是新世界前的一條小徑。 但法學碩士已經使訪問民主化。 即使是沒有程式設計經驗的人也可以快速輕鬆地構建功能原型。 如果你有嚴格的要求，在你已經熟悉的領域應用LLM可能更明智。 根據我的個人經驗，LLM 可以將高效寫作所需的時間**減少約 90%。 如果你發現他們總是輸出低質量**，那麼也許是時候重新審視你的輸入了。
原文鏈結：