Showing preview only (9,975K chars total). Download the full file or copy to clipboard to get everything.
Repository: yifanlu0227/MIT-6.5940
Branch: main
Commit: 869de40e7cdf
Files: 6
Total size: 9.5 MB
Directory structure:
gitextract_b8gsmqh4/
├── .gitmodules
├── Lab1.ipynb
├── Lab2.ipynb
├── Lab3.ipynb
├── Lab4.ipynb
└── README.md
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitmodules
================================================
[submodule "Lab5"]
path = Lab5
url = https://github.com/yifanlu0227/LLaMA2-7B-on-laptop.git
================================================
FILE: Lab1.ipynb
================================================
{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "view-in-github",
"colab_type": "text"
},
"source": [
"<a href=\"https://colab.research.google.com/github/yifanlu0227/MIT-6.5940/blob/main/Lab1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "RdC9V9xB10Gt"
},
"source": [
"# **MIT 6.5940 EfficientML.ai Fall 2023: Lab 1 Pruning**"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "3GlPu1PwwmqS"
},
"source": [
"\n",
"This colab notebook provides code and a framework for ***Lab 1 Pruning***. You can work out your solutions here.\n",
"\n"
]
},
{
"cell_type": "markdown",
"source": [
"Please fill out this [feedback form](https://forms.gle/fapEmEUYr3WnXjBU8) when you finished this lab. We would love to hear your thoughts or feedback on how we can improve this lab!"
],
"metadata": {
"id": "6BpLnUHfQ9cP"
}
},
{
"cell_type": "code",
"source": [],
"metadata": {
"id": "ykXj956Jr5wm"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"## Goals\n",
"\n",
"In this assignment, you will practice pruning a classical neural network model to reduce both model size and latency. The goals of this assignment are as follows:\n",
"\n",
"- Understand the basic concept of **pruning**\n",
"- Implement and apply **fine-grained pruning**\n",
"- Implement and apply **channel pruning**\n",
"- Get a basic understanding of performance improvement (such as speedup) from pruning\n",
"- Understand the differences and tradeoffs between these pruning approaches"
],
"metadata": {
"id": "2IqUbyC9YaLZ"
}
},
{
"cell_type": "markdown",
"source": [
"## Contents\n",
"\n",
"There are two main sections in this lab: ***Fine-grained Pruning*** and ***Channel Pruning***.\n",
"\n",
"There are ***9*** questions in total:\n",
"- For *Fine-grained Pruning*, there are ***5*** questions (Question 1-5).\n",
"- For *Channel Pruning*, there are ***3*** questions (Question 6-8).\n",
"- Question 9 compares fine-grained pruning and channel pruning."
],
"metadata": {
"id": "VDkb-exkYai1"
}
},
{
"cell_type": "markdown",
"metadata": {
"id": "2tFjnZZVlIFL"
},
"source": [
"# Setup"
]
},
{
"cell_type": "markdown",
"source": [
"First, install the required packages and download the datasets and pretrained model. Here we use CIFAR10 dataset and VGG network which is the same as what we used in the Lab 0 tutorial."
],
"metadata": {
"id": "W76-32bi_mHm"
}
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "nyngBRTXQG2n",
"colab": {
"base_uri": "https://localhost:8080/"
},
"outputId": "2c34103b-229f-425c-9594-c207b9cd2dc6"
},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Installing torchprofile...\n",
"All required packages have been successfully installed!\n"
]
}
],
"source": [
"print('Installing torchprofile...')\n",
"!pip install torchprofile 1>/dev/null\n",
"print('All required packages have been successfully installed!')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "jQb3_6zlQfib"
},
"outputs": [],
"source": [
"import copy\n",
"import math\n",
"import random\n",
"import time\n",
"from collections import OrderedDict, defaultdict\n",
"from typing import Union, List\n",
"\n",
"import numpy as np\n",
"import torch\n",
"from matplotlib import pyplot as plt\n",
"from torch import nn\n",
"from torch.optim import *\n",
"from torch.optim.lr_scheduler import *\n",
"from torch.utils.data import DataLoader\n",
"from torchprofile import profile_macs\n",
"from torchvision.datasets import *\n",
"from torchvision.transforms import *\n",
"from tqdm.auto import tqdm\n",
"\n",
"from torchprofile import profile_macs\n",
"\n",
"assert torch.cuda.is_available(), \\\n",
"\"The current runtime does not have CUDA support.\" \\\n",
"\"Please go to menu bar (Runtime - Change runtime type) and select GPU\""
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "yCjLyoR10Eib",
"colab": {
"base_uri": "https://localhost:8080/"
},
"outputId": "a8318ddf-e02f-49e8-fe29-f2deb99379e8"
},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"<torch._C.Generator at 0x7b2904390cd0>"
]
},
"metadata": {},
"execution_count": 3
}
],
"source": [
"random.seed(0)\n",
"np.random.seed(0)\n",
"torch.manual_seed(0)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "PYvLYMPC1Hel"
},
"outputs": [],
"source": [
"def download_url(url, model_dir='.', overwrite=False):\n",
" import os, sys, ssl\n",
" from urllib.request import urlretrieve\n",
" ssl._create_default_https_context = ssl._create_unverified_context\n",
" target_dir = url.split('/')[-1]\n",
" model_dir = os.path.expanduser(model_dir)\n",
" try:\n",
" if not os.path.exists(model_dir):\n",
" os.makedirs(model_dir)\n",
" model_dir = os.path.join(model_dir, target_dir)\n",
" cached_file = model_dir\n",
" if not os.path.exists(cached_file) or overwrite:\n",
" sys.stderr.write('Downloading: \"{}\" to {}\\n'.format(url, cached_file))\n",
" urlretrieve(url, cached_file)\n",
" return cached_file\n",
" except Exception as e:\n",
" # remove lock file so download can be executed next time.\n",
" os.remove(os.path.join(model_dir, 'download.lock'))\n",
" sys.stderr.write('Failed to download from url %s' % url + '\\n' + str(e) + '\\n')\n",
" return None"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "54K1dJOx1JYZ"
},
"outputs": [],
"source": [
"class VGG(nn.Module):\n",
" ARCH = [64, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M']\n",
"\n",
" def __init__(self) -> None:\n",
" super().__init__()\n",
"\n",
" layers = []\n",
" counts = defaultdict(int)\n",
"\n",
" def add(name: str, layer: nn.Module) -> None:\n",
" layers.append((f\"{name}{counts[name]}\", layer))\n",
" counts[name] += 1\n",
"\n",
" in_channels = 3\n",
" for x in self.ARCH:\n",
" if x != 'M':\n",
" # conv-bn-relu\n",
" add(\"conv\", nn.Conv2d(in_channels, x, 3, padding=1, bias=False))\n",
" add(\"bn\", nn.BatchNorm2d(x))\n",
" add(\"relu\", nn.ReLU(True))\n",
" in_channels = x\n",
" else:\n",
" # maxpool\n",
" add(\"pool\", nn.MaxPool2d(2))\n",
"\n",
" self.backbone = nn.Sequential(OrderedDict(layers))\n",
" self.classifier = nn.Linear(512, 10)\n",
"\n",
" def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
" # backbone: [N, 3, 32, 32] => [N, 512, 2, 2]\n",
" x = self.backbone(x)\n",
"\n",
" # avgpool: [N, 512, 2, 2] => [N, 512]\n",
" x = x.mean([2, 3])\n",
"\n",
" # classifier: [N, 512] => [N, 10]\n",
" x = self.classifier(x)\n",
" return x"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "FI49lOle1KuL"
},
"outputs": [],
"source": [
"def train(\n",
" model: nn.Module,\n",
" dataloader: DataLoader,\n",
" criterion: nn.Module,\n",
" optimizer: Optimizer,\n",
" scheduler: LambdaLR,\n",
" callbacks = None\n",
") -> None:\n",
" model.train()\n",
"\n",
" for inputs, targets in tqdm(dataloader, desc='train', leave=False):\n",
" # Move the data from CPU to GPU\n",
" inputs = inputs.cuda()\n",
" targets = targets.cuda()\n",
"\n",
" # Reset the gradients (from the last iteration)\n",
" optimizer.zero_grad()\n",
"\n",
" # Forward inference\n",
" outputs = model(inputs)\n",
" loss = criterion(outputs, targets)\n",
"\n",
" # Backward propagation\n",
" loss.backward()\n",
"\n",
" # Update optimizer and LR scheduler\n",
" optimizer.step()\n",
" scheduler.step()\n",
"\n",
" if callbacks is not None:\n",
" for callback in callbacks:\n",
" callback()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "bCSnuQVKidfZ"
},
"outputs": [],
"source": [
"@torch.inference_mode()\n",
"def evaluate(\n",
" model: nn.Module,\n",
" dataloader: DataLoader,\n",
" verbose=True,\n",
") -> float:\n",
" model.eval()\n",
"\n",
" num_samples = 0\n",
" num_correct = 0\n",
"\n",
" for inputs, targets in tqdm(dataloader, desc=\"eval\", leave=False,\n",
" disable=not verbose):\n",
" # Move the data from CPU to GPU\n",
" inputs = inputs.cuda()\n",
" targets = targets.cuda()\n",
"\n",
" # Inference\n",
" outputs = model(inputs)\n",
"\n",
" # Convert logits to class indices\n",
" outputs = outputs.argmax(dim=1)\n",
"\n",
" # Update metrics\n",
" num_samples += targets.size(0)\n",
" num_correct += (outputs == targets).sum()\n",
"\n",
" return (num_correct / num_samples * 100).item()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "QBBKNhKNlAwE"
},
"source": [
"Helper Functions (Flops, Model Size calculation, etc.)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "mRdK_ThzlMxL"
},
"outputs": [],
"source": [
"def get_model_macs(model, inputs) -> int:\n",
" return profile_macs(model, inputs)\n",
"\n",
"\n",
"def get_sparsity(tensor: torch.Tensor) -> float:\n",
" \"\"\"\n",
" calculate the sparsity of the given tensor\n",
" sparsity = #zeros / #elements = 1 - #nonzeros / #elements\n",
" \"\"\"\n",
" return 1 - float(tensor.count_nonzero()) / tensor.numel()\n",
"\n",
"\n",
"def get_model_sparsity(model: nn.Module) -> float:\n",
" \"\"\"\n",
" calculate the sparsity of the given model\n",
" sparsity = #zeros / #elements = 1 - #nonzeros / #elements\n",
" \"\"\"\n",
" num_nonzeros, num_elements = 0, 0\n",
" for param in model.parameters():\n",
" num_nonzeros += param.count_nonzero()\n",
" num_elements += param.numel()\n",
" return 1 - float(num_nonzeros) / num_elements\n",
"\n",
"def get_num_parameters(model: nn.Module, count_nonzero_only=False) -> int:\n",
" \"\"\"\n",
" calculate the total number of parameters of model\n",
" :param count_nonzero_only: only count nonzero weights\n",
" \"\"\"\n",
" num_counted_elements = 0\n",
" for param in model.parameters():\n",
" if count_nonzero_only:\n",
" num_counted_elements += param.count_nonzero()\n",
" else:\n",
" num_counted_elements += param.numel()\n",
" return num_counted_elements\n",
"\n",
"\n",
"def get_model_size(model: nn.Module, data_width=32, count_nonzero_only=False) -> int:\n",
" \"\"\"\n",
" calculate the model size in bits\n",
" :param data_width: #bits per element\n",
" :param count_nonzero_only: only count nonzero weights\n",
" \"\"\"\n",
" return get_num_parameters(model, count_nonzero_only) * data_width\n",
"\n",
"Byte = 8\n",
"KiB = 1024 * Byte\n",
"MiB = 1024 * KiB\n",
"GiB = 1024 * MiB"
]
},
{
"cell_type": "markdown",
"source": [
"*Define* misc functions for verification."
],
"metadata": {
"id": "FtPpHs2blEqt"
}
},
{
"cell_type": "code",
"source": [
"def test_fine_grained_prune(\n",
" test_tensor=torch.tensor([[-0.46, -0.40, 0.39, 0.19, 0.37],\n",
" [0.00, 0.40, 0.17, -0.15, 0.16],\n",
" [-0.20, -0.23, 0.36, 0.25, 0.03],\n",
" [0.24, 0.41, 0.07, 0.13, -0.15],\n",
" [0.48, -0.09, -0.36, 0.12, 0.45]]),\n",
" test_mask=torch.tensor([[True, True, False, False, False],\n",
" [False, True, False, False, False],\n",
" [False, False, False, False, False],\n",
" [False, True, False, False, False],\n",
" [True, False, False, False, True]]),\n",
" target_sparsity=0.75, target_nonzeros=None):\n",
" def plot_matrix(tensor, ax, title):\n",
" ax.imshow(tensor.cpu().numpy() == 0, vmin=0, vmax=1, cmap='tab20c')\n",
" ax.set_title(title)\n",
" ax.set_yticklabels([])\n",
" ax.set_xticklabels([])\n",
" for i in range(tensor.shape[1]):\n",
" for j in range(tensor.shape[0]):\n",
" text = ax.text(j, i, f'{tensor[i, j].item():.2f}',\n",
" ha=\"center\", va=\"center\", color=\"k\")\n",
"\n",
" test_tensor = test_tensor.clone()\n",
" fig, axes = plt.subplots(1,2, figsize=(6, 10))\n",
" ax_left, ax_right = axes.ravel()\n",
" plot_matrix(test_tensor, ax_left, 'dense tensor')\n",
"\n",
" sparsity_before_pruning = get_sparsity(test_tensor)\n",
" mask = fine_grained_prune(test_tensor, target_sparsity)\n",
" sparsity_after_pruning = get_sparsity(test_tensor)\n",
" sparsity_of_mask = get_sparsity(mask)\n",
"\n",
" plot_matrix(test_tensor, ax_right, 'sparse tensor')\n",
" fig.tight_layout()\n",
" plt.show()\n",
"\n",
" print('* Test fine_grained_prune()')\n",
" print(f' target sparsity: {target_sparsity:.2f}')\n",
" print(f' sparsity before pruning: {sparsity_before_pruning:.2f}')\n",
" print(f' sparsity after pruning: {sparsity_after_pruning:.2f}')\n",
" print(f' sparsity of pruning mask: {sparsity_of_mask:.2f}')\n",
"\n",
" if target_nonzeros is None:\n",
" if test_mask.equal(mask):\n",
" print('* Test passed.')\n",
" else:\n",
" print('* Test failed.')\n",
" else:\n",
" if mask.count_nonzero() == target_nonzeros:\n",
" print('* Test passed.')\n",
" else:\n",
" print('* Test failed.')"
],
"metadata": {
"id": "NLYqk61hlEyZ"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "Kx48A6hRhXxB"
},
"source": [
"Load the pretrained model and the CIFAR-10 dataset."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "y-C55wY2nHLT",
"colab": {
"base_uri": "https://localhost:8080/"
},
"outputId": "332385e2-b2db-4741-8399-dc803517d840"
},
"outputs": [
{
"output_type": "stream",
"name": "stderr",
"text": [
"Downloading: \"https://hanlab18.mit.edu/files/course/labs/vgg.cifar.pretrained.pth\" to ./vgg.cifar.pretrained.pth\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"=> loading checkpoint 'https://hanlab18.mit.edu/files/course/labs/vgg.cifar.pretrained.pth'\n"
]
}
],
"source": [
"checkpoint_url = \"https://hanlab18.mit.edu/files/course/labs/vgg.cifar.pretrained.pth\"\n",
"checkpoint = torch.load(download_url(checkpoint_url), map_location=\"cpu\")\n",
"model = VGG().cuda()\n",
"print(f\"=> loading checkpoint '{checkpoint_url}'\")\n",
"model.load_state_dict(checkpoint['state_dict'])\n",
"recover_model = lambda: model.load_state_dict(checkpoint['state_dict'])"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "ZxBWrQIeoSu6",
"colab": {
"base_uri": "https://localhost:8080/"
},
"outputId": "d4a42ac7-eb69-4b0e-9f2e-4189d07d5040"
},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to data/cifar10/cifar-10-python.tar.gz\n"
]
},
{
"output_type": "stream",
"name": "stderr",
"text": [
"100%|██████████| 170498071/170498071 [00:05<00:00, 30751597.43it/s]\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Extracting data/cifar10/cifar-10-python.tar.gz to data/cifar10\n",
"Files already downloaded and verified\n"
]
}
],
"source": [
"image_size = 32\n",
"transforms = {\n",
" \"train\": Compose([\n",
" RandomCrop(image_size, padding=4),\n",
" RandomHorizontalFlip(),\n",
" ToTensor(),\n",
" ]),\n",
" \"test\": ToTensor(),\n",
"}\n",
"dataset = {}\n",
"for split in [\"train\", \"test\"]:\n",
" dataset[split] = CIFAR10(\n",
" root=\"data/cifar10\",\n",
" train=(split == \"train\"),\n",
" download=True,\n",
" transform=transforms[split],\n",
" )\n",
"dataloader = {}\n",
"for split in ['train', 'test']:\n",
" dataloader[split] = DataLoader(\n",
" dataset[split],\n",
" batch_size=512,\n",
" shuffle=(split == 'train'),\n",
" num_workers=0,\n",
" pin_memory=True,\n",
" )"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "rjESsg5nkdBG"
},
"source": [
"# Let's First Evaluate the Accuracy and Model Size of Dense Model"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "mMjz8MHjZRLg"
},
"source": [
"Neural networks have become ubiquitous in many applications. Here we have loaded a pretrained VGG model for classifying images in CIFAR10 dataset.\n",
"\n",
"Let's first evaluate the accuracy and model size of this model."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "DTiA8hxMkkbU",
"colab": {
"base_uri": "https://localhost:8080/",
"height": 52,
"referenced_widgets": [
"10e602da054f4a868f523d8b3b211751",
"157bed79805944cd9a15dd1125ae319d",
"2d38e867fbd24514a70c85ad0babc223",
"d92f58dad548490aa7d4e28ab461b0ab",
"8e73405283084f66b0c56bbbab4564ce",
"dfca63ad3a334383b82e01a93afb8f3b",
"69732ab72e094c5a928f7c81e29f35b1",
"718f9ce911a94b3a8106043daa52169d",
"db3f67e9b27d46b59746ec6f3505cac8",
"8a57e4bfc5924a25b0e0e7ecbfde8925",
"9849a9d4186e481e94238076c319fb84"
]
},
"outputId": "d5950075-ac85-4a1e-e276-fbf472ce73ff"
},
"outputs": [
{
"output_type": "display_data",
"data": {
"text/plain": [
"eval: 0%| | 0/20 [00:00<?, ?it/s]"
],
"application/vnd.jupyter.widget-view+json": {
"version_major": 2,
"version_minor": 0,
"model_id": "10e602da054f4a868f523d8b3b211751"
}
},
"metadata": {}
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"dense model has accuracy=92.95%\n",
"dense model has size=35.20 MiB\n"
]
}
],
"source": [
"dense_model_accuracy = evaluate(model, dataloader['test'])\n",
"dense_model_size = get_model_size(model)\n",
"print(f\"dense model has accuracy={dense_model_accuracy:.2f}%\")\n",
"print(f\"dense model has size={dense_model_size/MiB:.2f} MiB\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "G-Oj8IYkxKst"
},
"source": [
"While large neural networks are very powerful, their size consumes considerable storage, memory bandwidth, and computational resources.\n",
"As we can see from the results above, a model for the task as simple as classifying $32\\times32$ images into 10 classes can be as large as 35 MiB.\n",
"For embedded mobile applications, these resource demands become prohibitive."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "05ebw8KW1wDj"
},
"source": [
"Therefore, neural network pruning is exploited to facilitates storage and transmission of mobile applications incorporating DNNs.\n",
"\n",
"The goal of pruning is to reduce the model size while maintaining the accuracy."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "9EtFfSfCumT6"
},
"source": [
"# Let's see the distribution of weight values"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "0LNx2qCtZFlh"
},
"source": [
"Before we jump into pruning, let's see the distribution of weight values in the dense model."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "qg2rkEo8umkb",
"colab": {
"base_uri": "https://localhost:8080/",
"height": 609
},
"outputId": "487a71c6-7b20-4aa2-d8b8-97dad1424e2f"
},
"outputs": [
{
"output_type": "display_data",
"data": {
"text/plain": [
"<Figure size 1000x600 with 9 Axes>"
],
"image/png": "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\n"
},
"metadata": {}
}
],
"source": [
"def plot_weight_distribution(model, bins=256, count_nonzero_only=False):\n",
" fig, axes = plt.subplots(3,3, figsize=(10, 6))\n",
" axes = axes.ravel()\n",
" plot_index = 0\n",
" for name, param in model.named_parameters():\n",
" if param.dim() > 1:\n",
" ax = axes[plot_index]\n",
" if count_nonzero_only:\n",
" param_cpu = param.detach().view(-1).cpu()\n",
" param_cpu = param_cpu[param_cpu != 0].view(-1)\n",
" ax.hist(param_cpu, bins=bins, density=True,\n",
" color = 'blue', alpha = 0.5)\n",
" else:\n",
" ax.hist(param.detach().view(-1).cpu(), bins=bins, density=True,\n",
" color = 'blue', alpha = 0.5)\n",
" ax.set_xlabel(name)\n",
" ax.set_ylabel('density')\n",
" plot_index += 1\n",
" fig.suptitle('Histogram of Weights')\n",
" fig.tight_layout()\n",
" fig.subplots_adjust(top=0.925)\n",
" plt.show()\n",
"\n",
"plot_weight_distribution(model)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "4gRkueJTY0hL"
},
"source": [
"## Question 1 (10 pts)\n",
"\n",
"Please answer the following questions using the information in the above histograms of weights."
]
},
{
"cell_type": "markdown",
"source": [
"\n",
"### Question 1.1 (5 pts)\n",
"\n",
"What are the common characteristics of the weight distribution in the different layers?"
],
"metadata": {
"id": "LrKtD5x6AGYt"
}
},
{
"cell_type": "markdown",
"metadata": {
"id": "klj92pzBcvaI"
},
"source": [
"**Your Answer:** A lot of 0."
]
},
{
"cell_type": "markdown",
"source": [
"### Question 1.2 (5 pts)\n",
"\n",
"How do these characteristics help pruning?"
],
"metadata": {
"id": "g5eIrHzR__ir"
}
},
{
"cell_type": "markdown",
"source": [
"**Your Answer:** We can remove these 0."
],
"metadata": {
"id": "DD5lzMoAABdO"
}
},
{
"cell_type": "markdown",
"metadata": {
"id": "USisw8QcnPNP"
},
"source": [
"# Fine-grained Pruning"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "hkeZm_NJZ0NM"
},
"source": [
"In this section, we will implement and perform fine-grained pruning.\n",
"\n",
"Fine-grained pruning removes the synapses with lowest importance. The weight tensor $W$ will become sparse after fine-grained pruning, which can be described with **sparsity**:\n",
"\n",
"> $\\mathrm{sparsity} := \\#\\mathrm{Zeros} / \\#W = 1 - \\#\\mathrm{Nonzeros} / \\#W$\n",
"\n",
"where $\\#W$ is the number of elements in $W$.\n",
"\n",
"In practice, given the target sparsity $s$, the weight tensor $W$ is multiplied with a binary mask $M$ to disregard removed weight:\n",
"\n",
"> $v_{\\mathrm{thr}} = \\texttt{kthvalue}(Importance, \\#W \\cdot s)$\n",
">\n",
"> $M = Importance > v_{\\mathrm{thr}}$\n",
">\n",
"> $W = W \\cdot M$\n",
"\n",
"where $Importance$ is importance tensor with the same shape of $W$, $\\texttt{kthvalue}(X, k)$ finds the $k$-th smallest value of tensor $X$, $v_{\\mathrm{thr}}$ is the threshold value."
]
},
{
"cell_type": "markdown",
"source": [
"## Magnitude-based Pruning\n",
"\n",
"For fine-grained pruning, a widely-used importance is the magnitude of weight value, *i.e.*,\n",
"\n",
"$Importance=|W|$\n",
"\n",
"This is known as **Magnitude-based Pruning** (see [Learning both Weights and Connections for Efficient\n",
"Neural Networks](https://arxiv.org/pdf/1506.02626.pdf))."
],
"metadata": {
"id": "Qajrblu0Is3z"
}
},
{
"cell_type": "markdown",
"source": [
"
Download .json
Condensed preview — 6 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (10,082K chars).
[
{
"path": ".gitmodules",
"chars": 94,
"preview": "[submodule \"Lab5\"]\n\tpath = Lab5\n\turl = https://github.com/yifanlu0227/LLaMA2-7B-on-laptop.git\n"
},
{
"path": "Lab1.ipynb",
"chars": 1398386,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"id\": \"view-in-github\",\n \"colab_t"
},
{
"path": "Lab2.ipynb",
"chars": 1031138,
"preview": "{\n \"nbformat\": 4,\n \"nbformat_minor\": 0,\n \"metadata\": {\n \"colab\": {\n \"provenance\": [],\n \"toc_visible\": tr"
},
{
"path": "Lab3.ipynb",
"chars": 4183105,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"id\": \"view-in-github\",\n \"colab_t"
},
{
"path": "Lab4.ipynb",
"chars": 3356217,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {\n \"id\": \"view-in-github\",\n \"colab_t"
},
{
"path": "README.md",
"chars": 3853,
"preview": "# MIT-6.5940\nTinyML and Efficient Deep Learning Computing 6.5940 • Fall • 2023 • https://efficientml.ai\n\n## Introduction"
}
]
About this extraction
This page contains the full source code of the yifanlu0227/MIT-6.5940 GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 6 files (9.5 MB), approximately 2.5M tokens. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.