Upload 159 files

.gitattributes

@@ -57,3 +57,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
 HuggingFace.Quantization_in_Depth/Materials/models/facebook/nllb-200-distilled-600M/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+Hugging[[:space:]]Face.Quantization[[:space:]]Fundamentals/Materials/Models/facebook/nllb-200-distilled-600M/tokenizer.json filter=lfs diff=lfs merge=lfs -text

Hugging Face.Quantization Fundamentals/0_Introduction_HFQF.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ee27f037e86b7f8867f61cca252f196d2b7f9e8a8d25c26851df6b249ebbc710
+size 123644857

Hugging Face.Quantization Fundamentals/1_Handling Big Models_HFQF.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ecc1d639334da335eef6ff2caf82bc0adaf3377187708f6335a9ff59d8413c9a
+size 195092976

Hugging Face.Quantization Fundamentals/2_Data Types and Sizes_HFQF.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f4ea87e5838379b95064a4f8a6d91fb480eb24b16bb3641f257e9f38f5684b72
+size 670432870

Hugging Face.Quantization Fundamentals/3_Loading Models by data type_HFQF.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8fbb34b87ea5418665cc694c078c71ad9f212c44c0719c26bc872213f8ca0d40
+size 596180681

Hugging Face.Quantization Fundamentals/4_Quantization Theory_HFQF.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aa233f42902804bc3bfafc583913bab561cd866736b0008e24697151f7962a0c
+size 581333919

Hugging Face.Quantization Fundamentals/5_Quantization of LLMs_HFQF.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:66b81a30a4166557691c2fc5eaf286529604722ff277a20329f9400b48c3cd8c
+size 260391012

Hugging Face.Quantization Fundamentals/6_Conclusion_HFQF.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:306acfbcbcb5cce23696d87668b1a495da7732fb57bf0b69bec1a0576cc87069
+size 29668595

Hugging Face.Quantization Fundamentals/Materials/2_Data Types and Sizes_L2_data_types.ipynb

@@ -0,0 +1,393 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can download the `requirements.txt` for this course from the workspace of this lab. `File --> Open...`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "r8teiBZ6dP5g"
+   },
+   "source": [
+    "# Lesson 2: Data Types and Sizes\n",
+    "\n",
+    "In this lab, you will learn about the common data types used to store the parameters of machine learning models.\n",
+    "\n",
+    "\n",
+    "The libraries are already installed in the classroom.  If you're running this notebook on your own machine, you can install the following:\n",
+    "\n",
+    "```Python\n",
+    "!pip install torch==2.1.1\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "x_9J8WavkQGl"
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "nFC9wgzxBZvz"
+   },
+   "outputs": [],
+   "source": [
+    "import torch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "hW7psx41rn0h"
+   },
+   "source": [
+    "### Integers"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Information of `8-bit unsigned integer`\n",
+    "torch.iinfo(torch.uint8)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Information of `8-bit (signed) integer`\n",
+    "torch.iinfo(torch.int8)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### Information of `64-bit (signed) integer`\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### Information of `32-bit (signed) integer`\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### Information of `16-bit (signed) integer`\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Floating Points "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# by default, python stores float data in fp64\n",
+    "value = 1/3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "format(value, '.60f')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 64-bit floating point\n",
+    "tensor_fp64 = torch.tensor(value, dtype = torch.float64)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(f\"fp64 tensor: {format(tensor_fp64.item(), '.60f')}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tensor_fp32 = torch.tensor(value, dtype = torch.float32)\n",
+    "tensor_fp16 = torch.tensor(value, dtype = torch.float16)\n",
+    "tensor_bf16 = torch.tensor(value, dtype = torch.bfloat16)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(f\"fp64 tensor: {format(tensor_fp64.item(), '.60f')}\")\n",
+    "print(f\"fp32 tensor: {format(tensor_fp32.item(), '.60f')}\")\n",
+    "print(f\"fp16 tensor: {format(tensor_fp16.item(), '.60f')}\")\n",
+    "print(f\"bf16 tensor: {format(tensor_bf16.item(), '.60f')}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 294,
+     "status": "ok",
+     "timestamp": 1699482682456,
+     "user": {
+      "displayName": "Marc Sun",
+      "userId": "00829270524676809963"
+     },
+     "user_tz": 300
+    },
+    "id": "hUukczHrBodt",
+    "outputId": "4e75bdf1-25b6-4e0c-9c08-18208e943b10"
+   },
+   "outputs": [],
+   "source": [
+    "# Information of `16-bit brain floating point`\n",
+    "torch.finfo(torch.bfloat16)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Information of `32-bit floating point`\n",
+    "torch.finfo(torch.float32)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### Information of `16-bit floating point`\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### Information of `64-bit floating point`\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "3DbtWVVc_jiW"
+   },
+   "source": [
+    "### Downcasting"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "JHDsqfauBID9"
+   },
+   "outputs": [],
+   "source": [
+    "# random pytorch tensor: float32, size=1000\n",
+    "tensor_fp32 = torch.rand(1000, dtype = torch.float32)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Note:** As it is random, the values you get will be different from the video."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# first 5 elements of the random tensor\n",
+    "tensor_fp32[:5]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "xXLANbSx_nx4"
+   },
+   "outputs": [],
+   "source": [
+    "# downcast the tensor to bfloat16 using the \"to\" method\n",
+    "tensor_fp32_to_bf16 = tensor_fp32.to(dtype = torch.bfloat16)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tensor_fp32_to_bf16[:5]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# tensor_fp32 x tensor_fp32\n",
+    "m_float32 = torch.dot(tensor_fp32, tensor_fp32)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "m_float32"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# tensor_fp32_to_bf16 x tensor_fp32_to_bf16\n",
+    "m_bfloat16 = torch.dot(tensor_fp32_to_bf16, tensor_fp32_to_bf16)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "m_bfloat16"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Note\n",
+    "- You'll use \"downcasting\" as a simple form of quantization in the next lesson."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "authorship_tag": "ABX9TyNKuOYgD21Zty8Z1Smilnjc",
+   "collapsed_sections": [
+    "x_9J8WavkQGl",
+    "sulufN1wkK_L",
+    "hqPUM0f8oGgf",
+    "TgmPMm-ZvdXX",
+    "MJuh8aqo9LO-",
+    "3bOevU0Ez4KB",
+    "LgtYIhSf0Uu0",
+    "9DH7-tDDvK5N",
+    "TuZhoPK6weuR",
+    "WAOeSNraxZeF",
+    "UGXo-IljxmNG",
+    "_N3G-dX32awT",
+    "hW7psx41rn0h",
+    "OmcNPw6zlRp7",
+    "3_zvORGrnTR8",
+    "jh9IuiovrnoF",
+    "isDcbkXxxiTf",
+    "wM-xkASw1odi",
+    "3DbtWVVc_jiW",
+    "ViImpV5rAvyp",
+    "RdcyknnjBD99",
+    "-eYj4UUXCAlJ",
+    "MCLe1N4GCSQT",
+    "GIY7IrOv_3cD",
+    "8HlFKDBKGNG8"
+   ],
+   "gpuType": "T4",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

Hugging Face.Quantization Fundamentals/Materials/2_Data Types and Sizes_requirements.txt

@@ -0,0 +1,12 @@
+# requirements file
+# For Python 3.9.18
+
+accelerate==0.26.1
+ipython==8.18.1
+ipywidgets==8.1.2
+numpy==1.23.5
+Pillow==9.4.0
+quanto==0.0.11
+torch==2.1.1
+transformers==4.35.0
+sentencepiece==0.2.0

Hugging Face.Quantization Fundamentals/Materials/3_Loading Models by data type_L3_models_with_different_data_types.ipynb

@@ -0,0 +1,1516 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "VPau94vm3IpB"
+   },
+   "source": [
+    "# Lesson 3: Loading ML Models with Different Data Types\n",
+    "\n",
+    "In this lab, you will load ML models in different datatypes."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "XwU9odrv4uph"
+   },
+   "source": [
+    "- Load the Dummy Model from the helper file.\n",
+    "- To access the `helper.py` file, you can click `File --> Open...`, on the top left."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#123456789#123456789#123456789#123456789#123456789#123456789#123456789"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "sNkJ_nJd4F7F"
+   },
+   "outputs": [],
+   "source": [
+    "from helper import DummyModel"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 433,
+     "status": "ok",
+     "timestamp": 1699380416965,
+     "user": {
+      "displayName": "Younes Belkada",
+      "userId": "15414910276690549281"
+     },
+     "user_tz": -60
+    },
+    "id": "xhMZuiiE4tR5",
+    "outputId": "2f36a01c-fb85-49f6-ee0d-36b5777167b4"
+   },
+   "outputs": [],
+   "source": [
+    "model = DummyModel()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "dJoz_iQM5bgV"
+   },
+   "source": [
+    "- Create a function to inspect the data types of the parameters in a model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 293,
+     "status": "ok",
+     "timestamp": 1699380006138,
+     "user": {
+      "displayName": "Younes Belkada",
+      "userId": "15414910276690549281"
+     },
+     "user_tz": -60
+    },
+    "id": "KVci0pER5ccu",
+    "outputId": "7f4a6fc1-b168-42a2-baf4-ff5f00fba731"
+   },
+   "outputs": [],
+   "source": [
+    "def print_param_dtype(model):\n",
+    "    for name, param in model.named_parameters():\n",
+    "        print(f\"{name} is loaded in {param.dtype}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "print_param_dtype(model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "nN792T445lG2"
+   },
+   "source": [
+    "## Model Casting: `float16`\n",
+    "\n",
+    "- Cast the model into a different precision."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "-_qUBPhy53L5"
+   },
+   "outputs": [],
+   "source": [
+    "# float 16\n",
+    "model_fp16 = DummyModel().half()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "- Inspect the data types of the parameters."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print_param_dtype(model_fp16)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_fp16"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "zSlCqQL274P_"
+   },
+   "source": [
+    "- Run simple inference using model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dummy_input = torch.LongTensor([[1, 0], [0, 1]])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 356
+    },
+    "executionInfo": {
+     "elapsed": 233,
+     "status": "error",
+     "timestamp": 1699380421192,
+     "user": {
+      "displayName": "Younes Belkada",
+      "userId": "15414910276690549281"
+     },
+     "user_tz": -60
+    },
+    "id": "5wcBVd_N70oH",
+    "outputId": "e5f36295-2086-4a67-94d1-49e438d1c17d"
+   },
+   "outputs": [],
+   "source": [
+    "# inference using float32 model\n",
+    "logits_fp32 = model(dummy_input)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "B3I1G2zy8d1x"
+   },
+   "outputs": [],
+   "source": [
+    "logits_fp32"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "siPMcJRX84WZ"
+   },
+   "outputs": [],
+   "source": [
+    "# inference using float16 model\n",
+    "try:\n",
+    "    logits_fp16 = model_fp16(dummy_input)\n",
+    "except Exception as error:\n",
+    "    print(\"\\033[91m\", type(error).__name__, \": \", error, \"\\033[0m\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "D8U4TCxb9NR0"
+   },
+   "source": [
+    "## Model Casting: `bfloat16`\n",
+    "\n",
+    "#### Note about deepcopy\n",
+    "- `copy.deepcopy` makes a copy of the model that is independent of the original.  Modifications you make to the copy will not affect the original, because you're making a \"deep copy\".  For more details, see the Python docs on the [copy][https://docs.python.org/3/library/copy.html] library."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from copy import deepcopy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_bf16 = deepcopy(model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_bf16 = model_bf16.to(torch.bfloat16)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print_param_dtype(model_bf16)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "logits_bf16 = model_bf16(dummy_input)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "krxuhBKx9tcl"
+   },
+   "source": [
+    "- Now, compare the difference between `logits_fp32` and `logits_bf16`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 2,
+     "status": "ok",
+     "timestamp": 1699380547898,
+     "user": {
+      "displayName": "Younes Belkada",
+      "userId": "15414910276690549281"
+     },
+     "user_tz": -60
+    },
+    "id": "SkasCWBH-Dm5",
+    "outputId": "193b71af-d66a-4030-ff62-e86ebd062ead"
+   },
+   "outputs": [],
+   "source": [
+    "mean_diff = torch.abs(logits_bf16 - logits_fp32).mean().item()\n",
+    "max_diff = torch.abs(logits_bf16 - logits_fp32).max().item()\n",
+    "\n",
+    "print(f\"Mean diff: {mean_diff} | Max diff: {max_diff}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "sdN9QpMN-mUw"
+   },
+   "source": [
+    "## Using Popular Generative Models in Different Data Types"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "GmFTCvcNANQX"
+   },
+   "source": [
+    "- Load [Salesforce/blip-image-captioning-base](https://huggingface.co/Salesforce/blip-image-captioning-base) to perform image captioning.\n",
+    "\n",
+    "#### To get the sample code that Younes showed:\n",
+    "- Click on the \"Model Card\" tab.\n",
+    "- On the right, click on the button \"<> Use in Transformers\", you'll see a popup with sample code for loading this model.\n",
+    "\n",
+    "```Python\n",
+    "# Load model directly\n",
+    "from transformers import AutoProcessor, AutoModelForSeq2SeqLM\n",
+    "\n",
+    "processor = AutoProcessor.from_pretrained(\"Salesforce/blip-image-captioning-base\")\n",
+    "model = AutoModelForSeq2SeqLM.from_pretrained(\"Salesforce/blip-image-captioning-base\")\n",
+    "```\n",
+    "\n",
+    "- To see the sample code with an example, click on \"Read model documentation\" at the bottom of the popup.  It opens a new tab.\n",
+    "  https://huggingface.co/docs/transformers/main/en/model_doc/blip#transformers.BlipForConditionalGeneration\n",
+    "- On this page, scroll down a bit, past the \"parameters\", section, and you'll see \"Examples:\"\n",
+    "\n",
+    "```Python\n",
+    "from PIL import Image\n",
+    "import requests\n",
+    "from transformers import AutoProcessor, BlipForConditionalGeneration\n",
+    "\n",
+    "processor = AutoProcessor.from_pretrained(\"Salesforce/blip-image-captioning-base\")\n",
+    "model = BlipForConditionalGeneration.from_pretrained(\"Salesforce/blip-image-captioning-base\")\n",
+    "\n",
+    "url = \"http://images.cocodataset.org/val2017/000000039769.jpg\"\n",
+    "image = Image.open(requests.get(url, stream=True).raw)\n",
+    "text = \"A picture of\"\n",
+    "\n",
+    "inputs = processor(images=image, text=text, return_tensors=\"pt\")\n",
+    "\n",
+    "outputs = model(**inputs)\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 81,
+     "referenced_widgets": [
+      "426d8aec5ed44782963707817195db5d",
+      "51a84bbc69874d5bb065701aba6c5a22",
+      "738c5fefbd4842ebacf8d0248a4e5bdd",
+      "65b5176702244e338c1120e702f3ca96",
+      "cebfa21c01524fa89ea124485867d8cc",
+      "bc254bc2525f43f7bea70b2f6f515288",
+      "f3b1dc11f2a44da3a5db8499c1401288",
+      "b3140b792b3c47c68907d7a86259e389",
+      "5070aad508574d0da4f667885e9f8e6d",
+      "ae278dae0c484e85831aafd7a4ad6484",
+      "1b3d91e17c0a4435860477f0593fc014",
+      "b41130569642470ca5efb531e7652e17",
+      "afac2f5a68c946b387f30e914a62729d",
+      "4fecdb69b5f942449767d63c2bbb2dc9",
+      "a3333106642d40d9a3066e9e2d79a650",
+      "0a1f3685b7264cc595355cd906cb0e4d",
+      "9dda2b50e90446438835f902b2b9d4b1",
+      "21c6e937405d42048aa5607dbe779465",
+      "47d756b3efba43a8a45b48cac04cf929",
+      "d0d8b31e3c6b42318d804cc67a5aacea",
+      "f3ac895d29454e58bffbde53fc00a05e",
+      "b076ffc6b36a46c684557086a8c16582"
+     ]
+    },
+    "executionInfo": {
+     "elapsed": 14495,
+     "status": "ok",
+     "timestamp": 1699381117014,
+     "user": {
+      "displayName": "Younes Belkada",
+      "userId": "15414910276690549281"
+     },
+     "user_tz": -60
+    },
+    "id": "sJ8__4_sAMKT",
+    "outputId": "e18cad23-6bd5-4bf8-d059-586f8b772c9f"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import BlipForConditionalGeneration"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_name = \"Salesforce/blip-image-captioning-base\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = BlipForConditionalGeneration.from_pretrained(model_name)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Ptm1kGMTA8dB"
+   },
+   "outputs": [],
+   "source": [
+    "# inspect the default data types of the model\n",
+    "\n",
+    "# print_param_dtype(model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "_YYQNKfnAgsb"
+   },
+   "source": [
+    "- Check the memory footprint of the model. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fp32_mem_footprint = model.get_memory_footprint()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\"Footprint of the fp32 model in bytes: \",\n",
+    "      fp32_mem_footprint)\n",
+    "print(\"Footprint of the fp32 model in MBs: \", \n",
+    "      fp32_mem_footprint/1e+6)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "N7GgA7mnAuXV"
+   },
+   "source": [
+    "- Load the same model in `bfloat16`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 9,
+     "status": "ok",
+     "timestamp": 1699381195895,
+     "user": {
+      "displayName": "Younes Belkada",
+      "userId": "15414910276690549281"
+     },
+     "user_tz": -60
+    },
+    "id": "9v4XJcvLAt5o",
+    "outputId": "abbc3fd9-f8a9-4c5e-dd3d-61ddcf316d27"
+   },
+   "outputs": [],
+   "source": [
+    "model_bf16 = BlipForConditionalGeneration.from_pretrained(\n",
+    "                                               model_name,\n",
+    "                               torch_dtype=torch.bfloat16\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "pVnUmBBABJxB"
+   },
+   "outputs": [],
+   "source": [
+    "bf16_mem_footprint = model_bf16.get_memory_footprint()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 6,
+     "status": "ok",
+     "timestamp": 1699381416456,
+     "user": {
+      "displayName": "Younes Belkada",
+      "userId": "15414910276690549281"
+     },
+     "user_tz": -60
+    },
+    "id": "6Co7vpcYBl60",
+    "outputId": "c282be1e-95b9-4591-f56f-945a2587dd1e"
+   },
+   "outputs": [],
+   "source": [
+    "# Get the relative difference\n",
+    "relative_diff = bf16_mem_footprint / fp32_mem_footprint\n",
+    "\n",
+    "print(\"Footprint of the bf16 model in MBs: \", \n",
+    "      bf16_mem_footprint/1e+6)\n",
+    "print(f\"Relative diff: {relative_diff}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "GeGHdNROBqPa"
+   },
+   "source": [
+    "### Model Performance: `float32` vs `bfloat16`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "eT7n0ybhCNOk"
+   },
+   "source": [
+    "- Now, compare the generation results of the two model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 8317,
+     "status": "ok",
+     "timestamp": 1699381678824,
+     "user": {
+      "displayName": "Younes Belkada",
+      "userId": "15414910276690549281"
+     },
+     "user_tz": -60
+    },
+    "id": "m3z3N6k3CN_B",
+    "outputId": "b255e213-ccb8-43f9-9fb9-d31558e885b2"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import BlipProcessor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "processor = BlipProcessor.from_pretrained(model_name)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "- Load the image."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from helper import load_image, get_generation\n",
+    "from IPython.display import display\n",
+    "\n",
+    "img_url = 'https://storage.googleapis.com/\\\n",
+    "sfr-vision-language-research/BLIP/demo.jpg'\n",
+    "\n",
+    "image = load_image(img_url)\n",
+    "display(image.resize((500, 350)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "results_fp32 = get_generation(model, \n",
+    "                              processor, \n",
+    "                              image, \n",
+    "                              torch.float32)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\"fp32 Model Results:\\n\", results_fp32)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "results_bf16 = get_generation(model_bf16, \n",
+    "                              processor, \n",
+    "                              image, \n",
+    "                              torch.bfloat16)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\"bf16 Model Results:\\n\", results_bf16)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Default Data Type\n",
+    "\n",
+    "- For Hugging Face Transformers library, the deafult data type to load the models in is `float32`\n",
+    "- You can set the \"default data type\" as what you want."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 212,
+     "status": "ok",
+     "timestamp": 1699382665501,
+     "user": {
+      "displayName": "Younes Belkada",
+      "userId": "15414910276690549281"
+     },
+     "user_tz": -60
+    },
+    "id": "7FlJlxH2GJzQ",
+    "outputId": "95cf9a07-c366-42e4-8e62-1858a0dd3703"
+   },
+   "outputs": [],
+   "source": [
+    "desired_dtype = torch.bfloat16\n",
+    "torch.set_default_dtype(desired_dtype)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dummy_model_bf16 = DummyModel()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print_param_dtype(dummy_model_bf16)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "- Similarly, you can reset the default data type to float32."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "torch.set_default_dtype(torch.float32)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print_param_dtype(dummy_model_bf16)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Note\n",
+    "- You just used a simple form of quantization, in which the model's parameters are saved in a more compact data type (bfloat16).  During inference, the model performs its calculations in this data type, and its activations are in this data type.\n",
+    "- In the next lesson, you will use another quantization method, \"linear quantization\", which enables the quantized model to maintain performance much closer to the original model by converting from the compressed data type back to the original FP32 data type during inference."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "collapsed_sections": [
+    "-_qUBPhy53L5",
+    "N7GgA7mnAuXV"
+   ],
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.9"
+  },
+  "widgets": {
+   "application/vnd.jupyter.widget-state+json": {
+    "0a1f3685b7264cc595355cd906cb0e4d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1b3d91e17c0a4435860477f0593fc014": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "21c6e937405d42048aa5607dbe779465": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "426d8aec5ed44782963707817195db5d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_51a84bbc69874d5bb065701aba6c5a22",
+       "IPY_MODEL_738c5fefbd4842ebacf8d0248a4e5bdd",
+       "IPY_MODEL_65b5176702244e338c1120e702f3ca96"
+      ],
+      "layout": "IPY_MODEL_cebfa21c01524fa89ea124485867d8cc"
+     }
+    },
+    "47d756b3efba43a8a45b48cac04cf929": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4fecdb69b5f942449767d63c2bbb2dc9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_47d756b3efba43a8a45b48cac04cf929",
+      "max": 989820849,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_d0d8b31e3c6b42318d804cc67a5aacea",
+      "value": 989820849
+     }
+    },
+    "5070aad508574d0da4f667885e9f8e6d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "51a84bbc69874d5bb065701aba6c5a22": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_bc254bc2525f43f7bea70b2f6f515288",
+      "placeholder": "​",
+      "style": "IPY_MODEL_f3b1dc11f2a44da3a5db8499c1401288",
+      "value": "Downloading (…)lve/main/config.json: 100%"
+     }
+    },
+    "65b5176702244e338c1120e702f3ca96": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_ae278dae0c484e85831aafd7a4ad6484",
+      "placeholder": "​",
+      "style": "IPY_MODEL_1b3d91e17c0a4435860477f0593fc014",
+      "value": " 4.56k/4.56k [00:00&lt;00:00, 59.3kB/s]"
+     }
+    },
+    "738c5fefbd4842ebacf8d0248a4e5bdd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b3140b792b3c47c68907d7a86259e389",
+      "max": 4563,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_5070aad508574d0da4f667885e9f8e6d",
+      "value": 4563
+     }
+    },
+    "9dda2b50e90446438835f902b2b9d4b1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a3333106642d40d9a3066e9e2d79a650": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f3ac895d29454e58bffbde53fc00a05e",
+      "placeholder": "​",
+      "style": "IPY_MODEL_b076ffc6b36a46c684557086a8c16582",
+      "value": " 990M/990M [00:04&lt;00:00, 219MB/s]"
+     }
+    },
+    "ae278dae0c484e85831aafd7a4ad6484": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "afac2f5a68c946b387f30e914a62729d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_9dda2b50e90446438835f902b2b9d4b1",
+      "placeholder": "​",
+      "style": "IPY_MODEL_21c6e937405d42048aa5607dbe779465",
+      "value": "Downloading pytorch_model.bin: 100%"
+     }
+    },
+    "b076ffc6b36a46c684557086a8c16582": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "b3140b792b3c47c68907d7a86259e389": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b41130569642470ca5efb531e7652e17": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_afac2f5a68c946b387f30e914a62729d",
+       "IPY_MODEL_4fecdb69b5f942449767d63c2bbb2dc9",
+       "IPY_MODEL_a3333106642d40d9a3066e9e2d79a650"
+      ],
+      "layout": "IPY_MODEL_0a1f3685b7264cc595355cd906cb0e4d"
+     }
+    },
+    "bc254bc2525f43f7bea70b2f6f515288": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "cebfa21c01524fa89ea124485867d8cc": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d0d8b31e3c6b42318d804cc67a5aacea": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "f3ac895d29454e58bffbde53fc00a05e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f3b1dc11f2a44da3a5db8499c1401288": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    }
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

Hugging Face.Quantization Fundamentals/Materials/3_Loading Models by data type_helper.py

@@ -0,0 +1,74 @@
+import torch
+import torch.nn as nn
+import requests
+from PIL import Image
+
+import warnings
+# Ignore specific UserWarnings related to max_length in transformers
+warnings.filterwarnings("ignore", 
+    message=".*Using the model-agnostic default `max_length`.*")
+
+class DummyModel(nn.Module):
+  """
+  A dummy model that consists of an embedding layer
+  with two blocks of a linear layer followed by a layer
+  norm layer.
+  """
+  def __init__(self):
+    super().__init__()
+
+    torch.manual_seed(123)
+
+    self.token_embedding = nn.Embedding(2, 2)
+
+    # Block 1
+    self.linear_1 = nn.Linear(2, 2)
+    self.layernorm_1 = nn.LayerNorm(2)
+
+    # Block 2
+    self.linear_2 = nn.Linear(2, 2)
+    self.layernorm_2 = nn.LayerNorm(2)
+
+    self.head = nn.Linear(2, 2)
+
+  def forward(self, x):
+    hidden_states = self.token_embedding(x)
+
+    # Block 1
+    hidden_states = self.linear_1(hidden_states)
+    hidden_states = self.layernorm_1(hidden_states)
+
+    # Block 2
+    hidden_states = self.linear_2(hidden_states)
+    hidden_states = self.layernorm_2(hidden_states)
+
+    logits = self.head(hidden_states)
+    return logits
+
+
+def get_generation(model, processor, image, dtype):
+  inputs = processor(image, return_tensors="pt").to(dtype)
+  out = model.generate(**inputs)
+  return processor.decode(out[0], skip_special_tokens=True)
+
+
+def load_image(img_url):
+    image = Image.open(requests.get(
+        img_url, stream=True).raw).convert('RGB')
+
+    return image
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

Hugging Face.Quantization Fundamentals/Materials/4_Quantization Theory_L4_quantization_theory.ipynb

@@ -0,0 +1,371 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "W6tCv-A_bJVb"
+   },
+   "source": [
+    "# Lesson 4: Quantization Theory\n",
+    "\n",
+    "In this lab, you will perform Linear Quantization.\n",
+    "\n",
+    "#### Libraries to install\n",
+    "- If you are running this notebook on your local machine, you can install the following:\n",
+    "\n",
+    "```Python\n",
+    "!pip install transformers==4.35.0\n",
+    "!pip install quanto==0.0.11\n",
+    "!pip install torch==2.1.1\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## T5-FLAN\n",
+    "- Please note that due to hardware memory constraints, and in order to offer this course for free to everyone, the code you'll run here is for the T5-FLAN model instead of the EleutherAI AI Pythia model.  \n",
+    "- Thank you for your understanding! 🤗\n",
+    "\n",
+    "For the T5-FLAN model, here is one more library to install if you are running locally:\n",
+    "```Python\n",
+    "!pip install sentencepiece==0.2.0\n",
+    "```\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Without Quantization"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_name = \"google/flan-t5-small\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sentencepiece as spm\n",
+    "from transformers import T5Tokenizer, T5ForConditionalGeneration\n",
+    "\n",
+    "tokenizer = T5Tokenizer.from_pretrained(\"google/flan-t5-small\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = T5ForConditionalGeneration.from_pretrained(\"google/flan-t5-small\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "input_text = \"Hello, my name is \"\n",
+    "input_ids = tokenizer(input_text, return_tensors=\"pt\").input_ids\n",
+    "\n",
+    "outputs = model.generate(input_ids)\n",
+    "print(tokenizer.decode(outputs[0]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from helper import compute_module_sizes\n",
+    "module_sizes = compute_module_sizes(model)\n",
+    "print(f\"The model size is {module_sizes[''] * 1e-9} GB\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Quantize the model (8-bit precision)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from quanto import quantize, freeze\n",
+    "import torch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "quantize(model, weights=torch.int8, activations=None)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Freeze the model\n",
+    "- This step takes a bit of memory, and so for the Pythia model that is shown in the lecture video, it will not run in the classroom.\n",
+    "- This will work fine with the smaller T5-Flan model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "freeze(model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "module_sizes = compute_module_sizes(model)\n",
+    "print(f\"The model size is {module_sizes[''] * 1e-9} GB\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Try running inference on the quantized model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "input_text = \"Hello, my name is \"\n",
+    "input_ids = tokenizer(input_text, return_tensors=\"pt\").input_ids\n",
+    "\n",
+    "outputs = model.generate(input_ids)\n",
+    "print(tokenizer.decode(outputs[0]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "qqmyZYGbbO8A"
+   },
+   "source": [
+    "## Note: Quantizing the model used in the lecture video will not work due to classroom hardware limitations.\n",
+    "- Here is the code that Marc, the instructor is walking through.  \n",
+    "- It will likely run on your local computer if you have 8GB of memory, which is usually the minimum for personal computers.\n",
+    "  - To run locally, you can download the notebook and the helper.py file by clicking on the \"Jupyter icon\" at the top of the notebook and navigating the file directory of this classroom.  Also download the requirements.txt to install all the required libraries.\n",
+    "\n",
+    "### Without Quantization\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "- Load [EleutherAI/pythia-410m](https://huggingface.co/EleutherAI/pythia-410m) model and tokenizer.\n",
+    "\n",
+    "```Python\n",
+    "from transformers import AutoModelForCausalLM\n",
+    "model_name = \"EleutherAI/pythia-410m\"\n",
+    "\n",
+    "model = AutoModelForCausalLM.from_pretrained(model_name,\n",
+    "                                             low_cpu_mem_usage=True)\n",
+    "print(model.gpt_neox)\n",
+    "\n",
+    "\n",
+    "from transformers import AutoTokenizer\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "- Write a start of a (`text`) sentence which you'd like the model to complete.\n",
+    "```Python\n",
+    "text = \"Hello my name is\"\n",
+    "inputs = tokenizer(text, return_tensors=\"pt\")\n",
+    "outputs = model.generate(**inputs, max_new_tokens=10)\n",
+    "outputs\n",
+    "print(tokenizer.decode(outputs[0], skip_special_tokens=True))\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "- Compute the model's size using the helper function, `compute_module_sizes`.\n",
+    "```Python\n",
+    "from helper import compute_module_sizes\n",
+    "module_sizes = compute_module_sizes(model)\n",
+    "print(f\"The model size is {module_sizes[''] * 1e-9} GB\")\n",
+    "print(model.gpt_neox.layers[0].attention.dense.weight)\n",
+    "```\n",
+    "**Note:** The weights are in `fp32`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "2BC809CYugOp"
+   },
+   "source": [
+    "### 8-bit Quantization"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```Python\n",
+    "from quanto import quantize, freeze\n",
+    "import torch\n",
+    "\n",
+    "quantize(model, weights=torch.int8, activations=None)\n",
+    "# after performing quantization\n",
+    "print(model.gpt_neox)\n",
+    "print(model.gpt_neox.layers[0].attention.dense.weight)\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "- The \"freeze\" function requires more memory than is available in this classroom.\n",
+    "- This code will run on a machine that has 8GB of memory, and so it will likely work if you run this code on your local machine.\n",
+    "\n",
+    "```Python\n",
+    "# freeze the model\n",
+    "freeze(model)\n",
+    "print(model.gpt_neox.layers[0].attention.dense.weight)\n",
+    "\n",
+    "# get model size after quantization\n",
+    "module_sizes = compute_module_sizes(model)\n",
+    "print(f\"The model size is {module_sizes[''] * 1e-9} GB\")\n",
+    "\n",
+    "# run inference after quantizing the model\n",
+    "outputs = model.generate(**inputs, max_new_tokens=10)\n",
+    "print(tokenizer.decode(outputs[0], skip_special_tokens=True))\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Comparing \"linear quantization\" to \"downcasting\"\n",
+    "\n",
+    "To recap the difference between the \"linear quantization\" method in this lesson with the \"downcasting\" method in the previous lesson:\n",
+    "\n",
+    "- When downcasting a model, you convert the model's parameters to a more compact data type (bfloat16).  During inference, the model performs its calculations in this data type, and its activations are in this data type.  Downcasting may work with the bfloat16 data type, but the model performance will likely degrade with any smaller data type, and won't work if you convert to an integer data type (like the int8 in this lesson).\n",
+    "\n",
+    "\n",
+    "- In this lesson, you used another quantization method, \"linear quantization\", which enables the quantized model to maintain performance much closer to the original model by converting from the compressed data type back to the original FP32 data type during inference. So when the model makes a prediction, it is performing the matrix multiplications in FP32, and the activations are in FP32.  This enables you to quantize the model in data types smaller than bfloat16, such as int8, in this example."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### This is just the beginning...\n",
+    "- This course is intended to be a beginner-friendly introduction to the field of quantization. 🐣\n",
+    "- If you'd like to learn more about quantization, please stay tuned for another Hugging Face short course that goes into more depth on this topic (launching in a few weeks!) 🤗"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Did you like this course?\n",
+    "\n",
+    "- If you liked this course, could you consider giving a rating and share what you liked? 💕\n",
+    "- If you did not like this course, could you also please share what you think could have made it better? 🙏\n",
+    "\n",
+    "#### A note about the \"Course Review\" page.\n",
+    "The rating options are from 0 to 10.\n",
+    "- A score of 9 or 10 means you like the course.🤗\n",
+    "- A score of 7 or 8 means you feel neutral about the course (neither like nor dislike).🙄\n",
+    "- A score of 0,1,2,3,4,5 or 6 all mean that you do not like the course. 😭\n",
+    "  - Whether you give a 0 or a 6, these are all defined as \"detractors\" according to the standard measurement called \"Net Promoter Score\". 🧐"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "authorship_tag": "ABX9TyOpTGuZzDRr5A8ocSoYIFkP",
+   "collapsed_sections": [
+    "4V_amrl-xG9D",
+    "dODA6rR0z297"
+   ],
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

Hugging Face.Quantization Fundamentals/Materials/4_Quantization Theory_helper.py

@@ -0,0 +1,44 @@
+import torch
+
+# ################ monkey patch for quanto
+def named_module_tensors(module, recurse=False):
+    for named_parameter in module.named_parameters(recurse=recurse):
+      name, val = named_parameter
+      flag = True
+      if hasattr(val,"_data") or hasattr(val,"_scale"):
+        if hasattr(val,"_data"):
+          yield name + "._data", val._data
+        if hasattr(val,"_scale"):
+          yield name + "._scale", val._scale
+      else:
+        yield named_parameter
+
+    for named_buffer in module.named_buffers(recurse=recurse):
+      yield named_buffer
+
+def dtype_byte_size(dtype):
+    """
+    Returns the size (in bytes) occupied by one parameter of type `dtype`.
+    """
+    import re
+    if dtype == torch.bool:
+        return 1 / 8
+    bit_search = re.search(r"[^\d](\d+)$", str(dtype))
+    if bit_search is None:
+        raise ValueError(f"`dtype` is not a valid dtype: {dtype}.")
+    bit_size = int(bit_search.groups()[0])
+    return bit_size // 8
+
+def compute_module_sizes(model):
+    """
+    Compute the size of each submodule of a given model.
+    """
+    from collections import defaultdict
+    module_sizes = defaultdict(int)
+    for name, tensor in named_module_tensors(model, recurse=True):
+      size = tensor.numel() * dtype_byte_size(tensor.dtype)
+      name_parts = name.split(".")
+      for idx in range(len(name_parts) + 1):
+        module_sizes[".".join(name_parts[:idx])] += size
+
+    return module_sizes

Hugging Face.Quantization Fundamentals/Materials/Models/Intel/dpt-hybrid-midas/README.md

@@ -0,0 +1,166 @@
+---
+license: apache-2.0
+tags:
+- vision
+- depth-estimation
+widget:
+- src: https://huggingface.co/datasets/mishig/sample_images/resolve/main/tiger.jpg
+  example_title: Tiger
+- src: https://huggingface.co/datasets/mishig/sample_images/resolve/main/teapot.jpg
+  example_title: Teapot
+- src: https://huggingface.co/datasets/mishig/sample_images/resolve/main/palace.jpg
+  example_title: Palace
+model-index:
+- name: dpt-hybrid-midas
+  results:
+  - task:
+      type: monocular-depth-estimation
+      name: Monocular Depth Estimation
+    dataset:
+      type: MIX-6
+      name: MIX-6
+    metrics:
+    - type: Zero-shot transfer
+      value: 11.06
+      name: Zero-shot transfer
+      config: Zero-shot transfer
+      verified: false
+
+---
+
+## Model Details: DPT-Hybrid (also known as MiDaS 3.0)
+
+Dense Prediction Transformer (DPT) model trained on 1.4 million images for monocular depth estimation. 
+It was introduced in the paper [Vision Transformers for Dense Prediction](https://arxiv.org/abs/2103.13413) by Ranftl et al. (2021) and first released in [this repository](https://github.com/isl-org/DPT). 
+DPT uses the Vision Transformer (ViT) as backbone and adds a neck + head on top for monocular depth estimation.
+![model image](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/dpt_architecture.jpg)
+
+This repository hosts the "hybrid" version of the model as stated in the paper. DPT-Hybrid diverges from DPT by using [ViT-hybrid](https://huggingface.co/google/vit-hybrid-base-bit-384) as a backbone and taking some activations from the backbone.
+
+The model card has been written in combination by the Hugging Face team and Intel.
+
+| Model Detail | Description |
+| ----------- | ----------- | 
+| Model Authors - Company | Intel | 
+| Date | December 22, 2022 | 
+| Version | 1 | 
+| Type | Computer Vision - Monocular Depth Estimation | 
+| Paper or Other Resources | [Vision Transformers for Dense Prediction](https://arxiv.org/abs/2103.13413) and [GitHub Repo](https://github.com/isl-org/DPT) | 
+| License | Apache 2.0 |
+| Questions or Comments | [Community Tab](https://huggingface.co/Intel/dpt-hybrid-midas/discussions) and [Intel Developers Discord](https://discord.gg/rv2Gp55UJQ)|
+
+| Intended Use | Description |
+| ----------- | ----------- | 
+| Primary intended uses | You can use the raw model for zero-shot monocular depth estimation. See the [model hub](https://huggingface.co/models?search=dpt) to look for fine-tuned versions on a task that interests you. | 
+| Primary intended users | Anyone doing monocular depth estimation | 
+| Out-of-scope uses | This model in most cases will need to be fine-tuned for your particular task.  The model should not be used to intentionally create hostile or alienating environments for people.|
+
+### How to use
+
+Here is how to use this model for zero-shot depth estimation on an image:
+
+```python
+from PIL import Image
+import numpy as np
+import requests
+import torch
+
+from transformers import DPTImageProcessor, DPTForDepthEstimation
+
+image_processor = DPTImageProcessor.from_pretrained("Intel/dpt-hybrid-midas")
+model = DPTForDepthEstimation.from_pretrained("Intel/dpt-hybrid-midas", low_cpu_mem_usage=True)
+
+url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+image = Image.open(requests.get(url, stream=True).raw)
+
+# prepare image for the model
+inputs = image_processor(images=image, return_tensors="pt")
+
+with torch.no_grad():
+    outputs = model(**inputs)
+    predicted_depth = outputs.predicted_depth
+
+# interpolate to original size
+prediction = torch.nn.functional.interpolate(
+    predicted_depth.unsqueeze(1),
+    size=image.size[::-1],
+    mode="bicubic",
+    align_corners=False,
+)
+
+# visualize the prediction
+output = prediction.squeeze().cpu().numpy()
+formatted = (output * 255 / np.max(output)).astype("uint8")
+depth = Image.fromarray(formatted)
+depth.show()
+```
+
+For more code examples, we refer to the [documentation](https://huggingface.co/docs/transformers/master/en/model_doc/dpt).
+
+| Factors | Description | 
+| ----------- | ----------- | 
+| Groups | Multiple datasets compiled together | 
+| Instrumentation | - |
+| Environment | Inference completed on Intel Xeon Platinum 8280 CPU @ 2.70GHz with 8 physical cores and an NVIDIA RTX 2080 GPU. |
+| Card Prompts | Model deployment on alternate hardware and software will change model performance |
+
+| Metrics | Description | 
+| ----------- | ----------- | 
+| Model performance measures | Zero-shot Transfer |
+| Decision thresholds | - | 
+| Approaches to uncertainty and variability | - |
+
+| Training and Evaluation Data | Description | 
+| ----------- | ----------- | 
+| Datasets | The dataset is called MIX 6, and contains around 1.4M images. The model was initialized with ImageNet-pretrained weights.|
+| Motivation | To build a robust monocular depth prediction network |
+| Preprocessing | "We resize the image such that the longer side is 384 pixels and train on random square crops of size 384. ... We perform random horizontal flips for data augmentation." See [Ranftl et al. (2021)](https://arxiv.org/abs/2103.13413) for more details. | 
+
+## Quantitative Analyses
+| Model | Training set | DIW WHDR | ETH3D AbsRel | Sintel AbsRel | KITTI δ>1.25 | NYU δ>1.25 | TUM δ>1.25 |
+| --- | --- | --- | --- | --- | --- | --- | --- | 
+| DPT - Large | MIX 6 | 10.82 (-13.2%) | 0.089 (-31.2%) | 0.270 (-17.5%) | 8.46 (-64.6%) | 8.32 (-12.9%) | 9.97 (-30.3%) |
+| DPT - Hybrid | MIX 6 | 11.06 (-11.2%) | 0.093 (-27.6%) | 0.274 (-16.2%) | 11.56 (-51.6%) | 8.69 (-9.0%) | 10.89 (-23.2%) | 
+| MiDaS  | MIX 6  | 12.95 (+3.9%)  | 0.116 (-10.5%)  | 0.329 (+0.5%)  | 16.08 (-32.7%)  | 8.71 (-8.8%)  | 12.51 (-12.5%)
+| MiDaS [30]  | MIX 5  | 12.46  | 0.129  | 0.327  | 23.90  | 9.55  | 14.29 | 
+ | Li [22]  | MD [22]  | 23.15  | 0.181  | 0.385  | 36.29  | 27.52  | 29.54 | 
+ | Li [21]  | MC [21]  | 26.52  | 0.183  | 0.405  | 47.94  | 18.57  | 17.71 | 
+ | Wang [40]  | WS [40]  | 19.09  | 0.205  | 0.390  | 31.92  | 29.57  | 20.18 | 
+ | Xian [45]  | RW [45]  | 14.59  | 0.186 |  0.422  | 34.08 |  27.00 |  25.02 | 
+ | Casser [5]  | CS [8]  | 32.80  | 0.235  | 0.422  | 21.15  | 39.58  | 37.18 | 
+
+Table 1. Comparison to the state of the art on monocular depth estimation. We evaluate zero-shot cross-dataset transfer according to the
+protocol defined in [30]. Relative performance is computed with respect to the original MiDaS model [30]. Lower is better for all metrics. ([Ranftl et al., 2021](https://arxiv.org/abs/2103.13413))
+
+
+| Ethical Considerations | Description | 
+| ----------- | ----------- | 
+| Data | The training data come from multiple image datasets compiled together. |
+| Human life | The model is not intended to inform decisions central to human life or flourishing. It is an aggregated set of monocular depth image datasets. | 
+| Mitigations | No additional risk mitigation strategies were considered during model development. |
+| Risks and harms | The extent of the risks involved by using the model remain unknown. |
+| Use cases | - | 
+
+| Caveats and Recommendations |
+| ----------- | 
+| Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. There are no additional caveats or recommendations for this model. |
+
+### BibTeX entry and citation info
+
+```bibtex
+@article{DBLP:journals/corr/abs-2103-13413,
+  author    = {Ren{\'{e}} Ranftl and
+               Alexey Bochkovskiy and
+               Vladlen Koltun},
+  title     = {Vision Transformers for Dense Prediction},
+  journal   = {CoRR},
+  volume    = {abs/2103.13413},
+  year      = {2021},
+  url       = {https://arxiv.org/abs/2103.13413},
+  eprinttype = {arXiv},
+  eprint    = {2103.13413},
+  timestamp = {Wed, 07 Apr 2021 15:31:46 +0200},
+  biburl    = {https://dblp.org/rec/journals/corr/abs-2103-13413.bib},
+  bibsource = {dblp computer science bibliography, https://dblp.org}
+}
+```

Hugging Face.Quantization Fundamentals/Materials/Models/Intel/dpt-hybrid-midas/config.json

@@ -0,0 +1,459 @@
+{
+  "_commit_hash": null,
+  "architectures": [
+    "DPTForDepthEstimation"
+  ],
+  "attention_probs_dropout_prob": 0.0,
+  "auxiliary_loss_weight": 0.4,
+  "backbone_config": {
+    "_name_or_path": "",
+    "add_cross_attention": false,
+    "architectures": null,
+    "bad_words_ids": null,
+    "begin_suppress_tokens": null,
+    "bos_token_id": null,
+    "chunk_size_feed_forward": 0,
+    "cross_attention_hidden_size": null,
+    "decoder_start_token_id": null,
+    "depths": [
+      3,
+      4,
+      9
+    ],
+    "diversity_penalty": 0.0,
+    "do_sample": false,
+    "drop_path_rate": 0.0,
+    "early_stopping": false,
+    "embedding_dynamic_padding": true,
+    "embedding_size": 64,
+    "encoder_no_repeat_ngram_size": 0,
+    "eos_token_id": null,
+    "exponential_decay_length_penalty": null,
+    "finetuning_task": null,
+    "forced_bos_token_id": null,
+    "forced_eos_token_id": null,
+    "global_padding": "SAME",
+    "hidden_act": "relu",
+    "hidden_sizes": [
+      256,
+      512,
+      1024,
+      2048
+    ],
+    "id2label": {
+      "0": "LABEL_0",
+      "1": "LABEL_1"
+    },
+    "is_decoder": false,
+    "is_encoder_decoder": false,
+    "label2id": {
+      "LABEL_0": 0,
+      "LABEL_1": 1
+    },
+    "layer_type": "bottleneck",
+    "length_penalty": 1.0,
+    "max_length": 20,
+    "min_length": 0,
+    "model_type": "bit",
+    "no_repeat_ngram_size": 0,
+    "num_beam_groups": 1,
+    "num_beams": 1,
+    "num_channels": 3,
+    "num_groups": 32,
+    "num_return_sequences": 1,
+    "out_features": [
+      "stage1",
+      "stage2",
+      "stage3"
+    ],
+    "output_attentions": false,
+    "output_hidden_states": false,
+    "output_scores": false,
+    "output_stride": 32,
+    "pad_token_id": null,
+    "prefix": null,
+    "problem_type": null,
+    "pruned_heads": {},
+    "remove_invalid_values": false,
+    "repetition_penalty": 1.0,
+    "return_dict": true,
+    "return_dict_in_generate": false,
+    "sep_token_id": null,
+    "stage_names": [
+      "stem",
+      "stage1",
+      "stage2",
+      "stage3"
+    ],
+    "suppress_tokens": null,
+    "task_specific_params": null,
+    "temperature": 1.0,
+    "tf_legacy_loss": false,
+    "tie_encoder_decoder": false,
+    "tie_word_embeddings": true,
+    "tokenizer_class": null,
+    "top_k": 50,
+    "top_p": 1.0,
+    "torch_dtype": null,
+    "torchscript": false,
+    "transformers_version": "4.26.0.dev0",
+    "typical_p": 1.0,
+    "use_bfloat16": false,
+    "width_factor": 1
+  },
+  "backbone_featmap_shape": [
+    1,
+    1024,
+    24,
+    24
+  ],
+  "backbone_out_indices": [
+    2,
+    5,
+    8,
+    11
+  ],
+  "fusion_hidden_size": 256,
+  "head_in_index": -1,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.0,
+  "hidden_size": 768,
+  "id2label": {
+    "0": "LABEL_0",
+    "1": "LABEL_1",
+    "2": "LABEL_2",
+    "3": "LABEL_3",
+    "4": "LABEL_4",
+    "5": "LABEL_5",
+    "6": "LABEL_6",
+    "7": "LABEL_7",
+    "8": "LABEL_8",
+    "9": "LABEL_9",
+    "10": "LABEL_10",
+    "11": "LABEL_11",
+    "12": "LABEL_12",
+    "13": "LABEL_13",
+    "14": "LABEL_14",
+    "15": "LABEL_15",
+    "16": "LABEL_16",
+    "17": "LABEL_17",
+    "18": "LABEL_18",
+    "19": "LABEL_19",
+    "20": "LABEL_20",
+    "21": "LABEL_21",
+    "22": "LABEL_22",
+    "23": "LABEL_23",
+    "24": "LABEL_24",
+    "25": "LABEL_25",
+    "26": "LABEL_26",
+    "27": "LABEL_27",
+    "28": "LABEL_28",
+    "29": "LABEL_29",
+    "30": "LABEL_30",
+    "31": "LABEL_31",
+    "32": "LABEL_32",
+    "33": "LABEL_33",
+    "34": "LABEL_34",
+    "35": "LABEL_35",
+    "36": "LABEL_36",
+    "37": "LABEL_37",
+    "38": "LABEL_38",
+    "39": "LABEL_39",
+    "40": "LABEL_40",
+    "41": "LABEL_41",
+    "42": "LABEL_42",
+    "43": "LABEL_43",
+    "44": "LABEL_44",
+    "45": "LABEL_45",
+    "46": "LABEL_46",
+    "47": "LABEL_47",
+    "48": "LABEL_48",
+    "49": "LABEL_49",
+    "50": "LABEL_50",
+    "51": "LABEL_51",
+    "52": "LABEL_52",
+    "53": "LABEL_53",
+    "54": "LABEL_54",
+    "55": "LABEL_55",
+    "56": "LABEL_56",
+    "57": "LABEL_57",
+    "58": "LABEL_58",
+    "59": "LABEL_59",
+    "60": "LABEL_60",
+    "61": "LABEL_61",
+    "62": "LABEL_62",
+    "63": "LABEL_63",
+    "64": "LABEL_64",
+    "65": "LABEL_65",
+    "66": "LABEL_66",
+    "67": "LABEL_67",
+    "68": "LABEL_68",
+    "69": "LABEL_69",
+    "70": "LABEL_70",
+    "71": "LABEL_71",
+    "72": "LABEL_72",
+    "73": "LABEL_73",
+    "74": "LABEL_74",
+    "75": "LABEL_75",
+    "76": "LABEL_76",
+    "77": "LABEL_77",
+    "78": "LABEL_78",
+    "79": "LABEL_79",
+    "80": "LABEL_80",
+    "81": "LABEL_81",
+    "82": "LABEL_82",
+    "83": "LABEL_83",
+    "84": "LABEL_84",
+    "85": "LABEL_85",
+    "86": "LABEL_86",
+    "87": "LABEL_87",
+    "88": "LABEL_88",
+    "89": "LABEL_89",
+    "90": "LABEL_90",
+    "91": "LABEL_91",
+    "92": "LABEL_92",
+    "93": "LABEL_93",
+    "94": "LABEL_94",
+    "95": "LABEL_95",
+    "96": "LABEL_96",
+    "97": "LABEL_97",
+    "98": "LABEL_98",
+    "99": "LABEL_99",
+    "100": "LABEL_100",
+    "101": "LABEL_101",
+    "102": "LABEL_102",
+    "103": "LABEL_103",
+    "104": "LABEL_104",
+    "105": "LABEL_105",
+    "106": "LABEL_106",
+    "107": "LABEL_107",
+    "108": "LABEL_108",
+    "109": "LABEL_109",
+    "110": "LABEL_110",
+    "111": "LABEL_111",
+    "112": "LABEL_112",
+    "113": "LABEL_113",
+    "114": "LABEL_114",
+    "115": "LABEL_115",
+    "116": "LABEL_116",
+    "117": "LABEL_117",
+    "118": "LABEL_118",
+    "119": "LABEL_119",
+    "120": "LABEL_120",
+    "121": "LABEL_121",
+    "122": "LABEL_122",
+    "123": "LABEL_123",
+    "124": "LABEL_124",
+    "125": "LABEL_125",
+    "126": "LABEL_126",
+    "127": "LABEL_127",
+    "128": "LABEL_128",
+    "129": "LABEL_129",
+    "130": "LABEL_130",
+    "131": "LABEL_131",
+    "132": "LABEL_132",
+    "133": "LABEL_133",
+    "134": "LABEL_134",
+    "135": "LABEL_135",
+    "136": "LABEL_136",
+    "137": "LABEL_137",
+    "138": "LABEL_138",
+    "139": "LABEL_139",
+    "140": "LABEL_140",
+    "141": "LABEL_141",
+    "142": "LABEL_142",
+    "143": "LABEL_143",
+    "144": "LABEL_144",
+    "145": "LABEL_145",
+    "146": "LABEL_146",
+    "147": "LABEL_147",
+    "148": "LABEL_148",
+    "149": "LABEL_149"
+  },
+  "image_size": 384,
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "is_hybrid": true,
+  "label2id": {
+    "LABEL_0": 0,
+    "LABEL_1": 1,
+    "LABEL_10": 10,
+    "LABEL_100": 100,
+    "LABEL_101": 101,
+    "LABEL_102": 102,
+    "LABEL_103": 103,
+    "LABEL_104": 104,
+    "LABEL_105": 105,
+    "LABEL_106": 106,
+    "LABEL_107": 107,
+    "LABEL_108": 108,
+    "LABEL_109": 109,
+    "LABEL_11": 11,
+    "LABEL_110": 110,
+    "LABEL_111": 111,
+    "LABEL_112": 112,
+    "LABEL_113": 113,
+    "LABEL_114": 114,
+    "LABEL_115": 115,
+    "LABEL_116": 116,
+    "LABEL_117": 117,
+    "LABEL_118": 118,
+    "LABEL_119": 119,
+    "LABEL_12": 12,
+    "LABEL_120": 120,
+    "LABEL_121": 121,
+    "LABEL_122": 122,
+    "LABEL_123": 123,
+    "LABEL_124": 124,
+    "LABEL_125": 125,
+    "LABEL_126": 126,
+    "LABEL_127": 127,
+    "LABEL_128": 128,
+    "LABEL_129": 129,
+    "LABEL_13": 13,
+    "LABEL_130": 130,
+    "LABEL_131": 131,
+    "LABEL_132": 132,
+    "LABEL_133": 133,
+    "LABEL_134": 134,
+    "LABEL_135": 135,
+    "LABEL_136": 136,
+    "LABEL_137": 137,
+    "LABEL_138": 138,
+    "LABEL_139": 139,
+    "LABEL_14": 14,
+    "LABEL_140": 140,
+    "LABEL_141": 141,
+    "LABEL_142": 142,
+    "LABEL_143": 143,
+    "LABEL_144": 144,
+    "LABEL_145": 145,
+    "LABEL_146": 146,
+    "LABEL_147": 147,
+    "LABEL_148": 148,
+    "LABEL_149": 149,
+    "LABEL_15": 15,
+    "LABEL_16": 16,
+    "LABEL_17": 17,
+    "LABEL_18": 18,
+    "LABEL_19": 19,
+    "LABEL_2": 2,
+    "LABEL_20": 20,
+    "LABEL_21": 21,
+    "LABEL_22": 22,
+    "LABEL_23": 23,
+    "LABEL_24": 24,
+    "LABEL_25": 25,
+    "LABEL_26": 26,
+    "LABEL_27": 27,
+    "LABEL_28": 28,
+    "LABEL_29": 29,
+    "LABEL_3": 3,
+    "LABEL_30": 30,
+    "LABEL_31": 31,
+    "LABEL_32": 32,
+    "LABEL_33": 33,
+    "LABEL_34": 34,
+    "LABEL_35": 35,
+    "LABEL_36": 36,
+    "LABEL_37": 37,
+    "LABEL_38": 38,
+    "LABEL_39": 39,
+    "LABEL_4": 4,
+    "LABEL_40": 40,
+    "LABEL_41": 41,
+    "LABEL_42": 42,
+    "LABEL_43": 43,
+    "LABEL_44": 44,
+    "LABEL_45": 45,
+    "LABEL_46": 46,
+    "LABEL_47": 47,
+    "LABEL_48": 48,
+    "LABEL_49": 49,
+    "LABEL_5": 5,
+    "LABEL_50": 50,
+    "LABEL_51": 51,
+    "LABEL_52": 52,
+    "LABEL_53": 53,
+    "LABEL_54": 54,
+    "LABEL_55": 55,
+    "LABEL_56": 56,
+    "LABEL_57": 57,
+    "LABEL_58": 58,
+    "LABEL_59": 59,
+    "LABEL_6": 6,
+    "LABEL_60": 60,
+    "LABEL_61": 61,
+    "LABEL_62": 62,
+    "LABEL_63": 63,
+    "LABEL_64": 64,
+    "LABEL_65": 65,
+    "LABEL_66": 66,
+    "LABEL_67": 67,
+    "LABEL_68": 68,
+    "LABEL_69": 69,
+    "LABEL_7": 7,
+    "LABEL_70": 70,
+    "LABEL_71": 71,
+    "LABEL_72": 72,
+    "LABEL_73": 73,
+    "LABEL_74": 74,
+    "LABEL_75": 75,
+    "LABEL_76": 76,
+    "LABEL_77": 77,
+    "LABEL_78": 78,
+    "LABEL_79": 79,
+    "LABEL_8": 8,
+    "LABEL_80": 80,
+    "LABEL_81": 81,
+    "LABEL_82": 82,
+    "LABEL_83": 83,
+    "LABEL_84": 84,
+    "LABEL_85": 85,
+    "LABEL_86": 86,
+    "LABEL_87": 87,
+    "LABEL_88": 88,
+    "LABEL_89": 89,
+    "LABEL_9": 9,
+    "LABEL_90": 90,
+    "LABEL_91": 91,
+    "LABEL_92": 92,
+    "LABEL_93": 93,
+    "LABEL_94": 94,
+    "LABEL_95": 95,
+    "LABEL_96": 96,
+    "LABEL_97": 97,
+    "LABEL_98": 98,
+    "LABEL_99": 99
+  },
+  "layer_norm_eps": 1e-12,
+  "model_type": "dpt",
+  "neck_hidden_sizes": [
+    256,
+    512,
+    768,
+    768
+  ],
+  "neck_ignore_stages": [
+    0,
+    1
+  ],
+  "num_attention_heads": 12,
+  "num_channels": 3,
+  "num_hidden_layers": 12,
+  "patch_size": 16,
+  "qkv_bias": true,
+  "readout_type": "project",
+  "reassemble_factors": [
+    1,
+    1,
+    1,
+    0.5
+  ],
+  "semantic_classifier_dropout": 0.1,
+  "semantic_loss_ignore_index": 255,
+  "torch_dtype": "float32",
+  "transformers_version": null,
+  "use_auxiliary_head": true,
+  "use_batch_norm_in_fusion_residual": false
+}

Hugging Face.Quantization Fundamentals/Materials/Models/Intel/dpt-hybrid-midas/preprocessor_config.json

@@ -0,0 +1,24 @@
+{
+  "do_normalize": true,
+  "do_rescale": true,
+  "do_resize": true,
+  "ensure_multiple_of": 1,
+  "image_mean": [
+    0.5,
+    0.5,
+    0.5
+  ],
+  "image_processor_type": "DPTImageProcessor",
+  "image_std": [
+    0.5,
+    0.5,
+    0.5
+  ],
+  "keep_aspect_ratio": false,
+  "resample": 2,
+  "rescale_factor": 0.00392156862745098,
+  "size": {
+    "height": 384,
+    "width": 384
+  }
+}

Hugging Face.Quantization Fundamentals/Materials/Models/Intel/dpt-hybrid-midas/pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b6c4d44f9d96ca3fa76dd3bbb153989a60b4ad5526559f3c598562a368d687ec
+size 489648389

Hugging Face.Quantization Fundamentals/Materials/Models/Salesforce/blip-image-captioning-base/README.md

@@ -0,0 +1,152 @@
+---
+pipeline_tag: image-to-text
+tags:
+- image-captioning
+languages:
+- en
+license: bsd-3-clause
+---
+
+# BLIP: Bootstrapping Language-Image Pre-training for Unified Vision-Language Understanding and Generation
+
+Model card for image captioning pretrained on COCO dataset - base architecture (with ViT base backbone).
+
+| ![BLIP.gif](https://cdn-uploads.huggingface.co/production/uploads/1670928184033-62441d1d9fdefb55a0b7d12c.gif) |
+|:--:|
+| <b> Pull figure from BLIP official repo | Image source: https://github.com/salesforce/BLIP </b>|
+
+## TL;DR
+
+Authors from the [paper](https://arxiv.org/abs/2201.12086) write in the abstract:
+
+*Vision-Language Pre-training (VLP) has advanced the performance for many vision-language tasks. However, most existing pre-trained models only excel in either understanding-based tasks or generation-based tasks. Furthermore, performance improvement has been largely achieved by scaling up the dataset with noisy image-text pairs collected from the web, which is a suboptimal source of supervision. In this paper, we propose BLIP, a new VLP framework which transfers flexibly to both vision-language understanding and generation tasks. BLIP effectively utilizes the noisy web data by bootstrapping the captions, where a captioner generates synthetic captions and a filter removes the noisy ones. We achieve state-of-the-art results on a wide range of vision-language tasks, such as image-text retrieval (+2.7% in average recall@1), image captioning (+2.8% in CIDEr), and VQA (+1.6% in VQA score). BLIP also demonstrates strong generalization ability when directly transferred to videolanguage tasks in a zero-shot manner. Code, models, and datasets are released.*
+
+## Usage
+
+You can use this model for conditional and un-conditional image captioning
+
+### Using the Pytorch model
+
+#### Running the model on CPU
+
+<details>
+<summary> Click to expand </summary>
+
+```python
+import requests
+from PIL import Image
+from transformers import BlipProcessor, BlipForConditionalGeneration
+
+processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
+model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")
+
+img_url = 'https://storage.googleapis.com/sfr-vision-language-research/BLIP/demo.jpg' 
+raw_image = Image.open(requests.get(img_url, stream=True).raw).convert('RGB')
+
+# conditional image captioning
+text = "a photography of"
+inputs = processor(raw_image, text, return_tensors="pt")
+
+out = model.generate(**inputs)
+print(processor.decode(out[0], skip_special_tokens=True))
+# >>> a photography of a woman and her dog
+
+# unconditional image captioning
+inputs = processor(raw_image, return_tensors="pt")
+
+out = model.generate(**inputs)
+print(processor.decode(out[0], skip_special_tokens=True))
+>>> a woman sitting on the beach with her dog
+```
+</details>
+
+#### Running the model on GPU
+
+##### In full precision 
+
+<details>
+<summary> Click to expand </summary>
+
+```python
+import requests
+from PIL import Image
+from transformers import BlipProcessor, BlipForConditionalGeneration
+
+processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
+model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base").to("cuda")
+
+img_url = 'https://storage.googleapis.com/sfr-vision-language-research/BLIP/demo.jpg' 
+raw_image = Image.open(requests.get(img_url, stream=True).raw).convert('RGB')
+
+# conditional image captioning
+text = "a photography of"
+inputs = processor(raw_image, text, return_tensors="pt").to("cuda")
+
+out = model.generate(**inputs)
+print(processor.decode(out[0], skip_special_tokens=True))
+# >>> a photography of a woman and her dog
+
+# unconditional image captioning
+inputs = processor(raw_image, return_tensors="pt").to("cuda")
+
+out = model.generate(**inputs)
+print(processor.decode(out[0], skip_special_tokens=True))
+>>> a woman sitting on the beach with her dog
+```
+</details>
+
+##### In half precision (`float16`)
+
+<details>
+<summary> Click to expand </summary>
+
+```python
+import torch
+import requests
+from PIL import Image
+from transformers import BlipProcessor, BlipForConditionalGeneration
+
+processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
+model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base", torch_dtype=torch.float16).to("cuda")
+
+img_url = 'https://storage.googleapis.com/sfr-vision-language-research/BLIP/demo.jpg' 
+raw_image = Image.open(requests.get(img_url, stream=True).raw).convert('RGB')
+
+# conditional image captioning
+text = "a photography of"
+inputs = processor(raw_image, text, return_tensors="pt").to("cuda", torch.float16)
+
+out = model.generate(**inputs)
+print(processor.decode(out[0], skip_special_tokens=True))
+# >>> a photography of a woman and her dog
+
+# unconditional image captioning
+inputs = processor(raw_image, return_tensors="pt").to("cuda", torch.float16)
+
+out = model.generate(**inputs)
+print(processor.decode(out[0], skip_special_tokens=True))
+>>> a woman sitting on the beach with her dog
+```
+</details>
+
+## BibTex and citation info
+
+```
+@misc{https://doi.org/10.48550/arxiv.2201.12086,
+  doi = {10.48550/ARXIV.2201.12086},
+  
+  url = {https://arxiv.org/abs/2201.12086},
+  
+  author = {Li, Junnan and Li, Dongxu and Xiong, Caiming and Hoi, Steven},
+  
+  keywords = {Computer Vision and Pattern Recognition (cs.CV), FOS: Computer and information sciences, FOS: Computer and information sciences},
+  
+  title = {BLIP: Bootstrapping Language-Image Pre-training for Unified Vision-Language Understanding and Generation},
+  
+  publisher = {arXiv},
+  
+  year = {2022},
+  
+  copyright = {Creative Commons Attribution 4.0 International}
+}
+```

Hugging Face.Quantization Fundamentals/Materials/Models/Salesforce/blip-image-captioning-base/config.json

@@ -0,0 +1,169 @@
+{
+  "_commit_hash": null,
+  "architectures": [
+    "BlipForConditionalGeneration"
+  ],
+  "image_text_hidden_size": 256,
+  "initializer_factor": 1.0,
+  "logit_scale_init_value": 2.6592,
+  "model_type": "blip",
+  "projection_dim": 512,
+  "text_config": {
+    "_name_or_path": "",
+    "add_cross_attention": false,
+    "architectures": null,
+    "attention_probs_dropout_prob": 0.0,
+    "bad_words_ids": null,
+    "begin_suppress_tokens": null,
+    "bos_token_id": 30522,
+    "chunk_size_feed_forward": 0,
+    "cross_attention_hidden_size": null,
+    "decoder_start_token_id": null,
+    "diversity_penalty": 0.0,
+    "do_sample": false,
+    "early_stopping": false,
+    "encoder_no_repeat_ngram_size": 0,
+    "eos_token_id": 2,
+    "exponential_decay_length_penalty": null,
+    "finetuning_task": null,
+    "forced_bos_token_id": null,
+    "forced_eos_token_id": null,
+    "hidden_act": "gelu",
+    "hidden_dropout_prob": 0.0,
+    "hidden_size": 768,
+    "id2label": {
+      "0": "LABEL_0",
+      "1": "LABEL_1"
+    },
+    "initializer_factor": 1.0,
+    "initializer_range": 0.02,
+    "intermediate_size": 3072,
+    "is_decoder": true,
+    "is_encoder_decoder": false,
+    "label2id": {
+      "LABEL_0": 0,
+      "LABEL_1": 1
+    },
+    "layer_norm_eps": 1e-12,
+    "length_penalty": 1.0,
+    "max_length": 20,
+    "max_position_embeddings": 512,
+    "min_length": 0,
+    "model_type": "blip_text_model",
+    "no_repeat_ngram_size": 0,
+    "num_attention_heads": 12,
+    "num_beam_groups": 1,
+    "num_beams": 1,
+    "num_hidden_layers": 12,
+    "num_return_sequences": 1,
+    "output_attentions": false,
+    "output_hidden_states": false,
+    "output_scores": false,
+    "pad_token_id": 0,
+    "prefix": null,
+    "problem_type": null,
+    "projection_dim": 768,
+    "pruned_heads": {},
+    "remove_invalid_values": false,
+    "repetition_penalty": 1.0,
+    "return_dict": true,
+    "return_dict_in_generate": false,
+    "sep_token_id": 102,
+    "suppress_tokens": null,
+    "task_specific_params": null,
+    "temperature": 1.0,
+    "tf_legacy_loss": false,
+    "tie_encoder_decoder": false,
+    "tie_word_embeddings": true,
+    "tokenizer_class": null,
+    "top_k": 50,
+    "top_p": 1.0,
+    "torch_dtype": null,
+    "torchscript": false,
+    "transformers_version": "4.26.0.dev0",
+    "typical_p": 1.0,
+    "use_bfloat16": false,
+    "use_cache": true,
+    "vocab_size": 30524
+  },
+  "torch_dtype": "float32",
+  "transformers_version": null,
+  "vision_config": {
+    "_name_or_path": "",
+    "add_cross_attention": false,
+    "architectures": null,
+    "attention_dropout": 0.0,
+    "bad_words_ids": null,
+    "begin_suppress_tokens": null,
+    "bos_token_id": null,
+    "chunk_size_feed_forward": 0,
+    "cross_attention_hidden_size": null,
+    "decoder_start_token_id": null,
+    "diversity_penalty": 0.0,
+    "do_sample": false,
+    "dropout": 0.0,
+    "early_stopping": false,
+    "encoder_no_repeat_ngram_size": 0,
+    "eos_token_id": null,
+    "exponential_decay_length_penalty": null,
+    "finetuning_task": null,
+    "forced_bos_token_id": null,
+    "forced_eos_token_id": null,
+    "hidden_act": "gelu",
+    "hidden_size": 768,
+    "id2label": {
+      "0": "LABEL_0",
+      "1": "LABEL_1"
+    },
+    "image_size": 384,
+    "initializer_factor": 1.0,
+    "initializer_range": 0.02,
+    "intermediate_size": 3072,
+    "is_decoder": false,
+    "is_encoder_decoder": false,
+    "label2id": {
+      "LABEL_0": 0,
+      "LABEL_1": 1
+    },
+    "layer_norm_eps": 1e-05,
+    "length_penalty": 1.0,
+    "max_length": 20,
+    "min_length": 0,
+    "model_type": "blip_vision_model",
+    "no_repeat_ngram_size": 0,
+    "num_attention_heads": 12,
+    "num_beam_groups": 1,
+    "num_beams": 1,
+    "num_channels": 3,
+    "num_hidden_layers": 12,
+    "num_return_sequences": 1,
+    "output_attentions": false,
+    "output_hidden_states": false,
+    "output_scores": false,
+    "pad_token_id": null,
+    "patch_size": 16,
+    "prefix": null,
+    "problem_type": null,
+    "projection_dim": 512,
+    "pruned_heads": {},
+    "remove_invalid_values": false,
+    "repetition_penalty": 1.0,
+    "return_dict": true,
+    "return_dict_in_generate": false,
+    "sep_token_id": null,
+    "suppress_tokens": null,
+    "task_specific_params": null,
+    "temperature": 1.0,
+    "tf_legacy_loss": false,
+    "tie_encoder_decoder": false,
+    "tie_word_embeddings": true,
+    "tokenizer_class": null,
+    "top_k": 50,
+    "top_p": 1.0,
+    "torch_dtype": null,
+    "torchscript": false,
+    "transformers_version": "4.26.0.dev0",
+    "typical_p": 1.0,
+    "use_bfloat16": false
+  }
+}

Hugging Face.Quantization Fundamentals/Materials/Models/Salesforce/blip-image-captioning-base/preprocessor_config.json

@@ -0,0 +1,17 @@
+{
+  "do_normalize": true,
+  "do_resize": true,
+  "image_mean": [
+    0.48145466,
+    0.4578275,
+    0.40821073
+  ],
+  "image_processor_type": "BlipImageProcessor",
+  "image_std": [
+    0.26862954,
+    0.26130258,
+    0.27577711
+  ],
+  "processor_class": "BlipProcessor",
+  "size": 384
+}

Hugging Face.Quantization Fundamentals/Materials/Models/Salesforce/blip-image-captioning-base/pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d6638651a5526cc2ede56f2b5104d6851b0755816d220e5e046870430180c767
+size 989820849

Hugging Face.Quantization Fundamentals/Materials/Models/Salesforce/blip-image-captioning-base/special_tokens_map.json

@@ -0,0 +1,7 @@
+{
+  "cls_token": "[CLS]",
+  "mask_token": "[MASK]",
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "unk_token": "[UNK]"
+}

Hugging Face.Quantization Fundamentals/Materials/Models/Salesforce/blip-image-captioning-base/tokenizer_config.json

@@ -0,0 +1,21 @@
+{
+  "cls_token": "[CLS]",
+  "do_basic_tokenize": true,
+  "do_lower_case": true,
+  "mask_token": "[MASK]",
+  "model_max_length": 512,
+  "name_or_path": "bert-base-uncased",
+  "never_split": null,
+  "pad_token": "[PAD]",
+  "processor_class": "BlipProcessor",
+  "sep_token": "[SEP]",
+  "special_tokens_map_file": null,
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizer",
+  "unk_token": "[UNK]",
+  "model_input_names": [
+    "input_ids",
+    "attention_mask"
+  ]
+}

Hugging Face.Quantization Fundamentals/Materials/Models/Salesforce/blip-itm-base-coco/README.md

@@ -0,0 +1,125 @@
+---
+pipeline_tags: 'other'
+tags:
+  - image-text-matching
+languages:
+  - en
+license: bsd-3-clause
+---
+
+# BLIP: Bootstrapping Language-Image Pre-training for Unified Vision-Language Understanding and Generation
+
+Model card for BLIP trained on image-text matching - base architecture (with ViT base backbone) trained on COCO dataset.
+
+| ![BLIP.gif](https://cdn-uploads.huggingface.co/production/uploads/1670928184033-62441d1d9fdefb55a0b7d12c.gif) |
+|:--:|
+| <b> Pull figure from BLIP official repo | Image source: https://github.com/salesforce/BLIP </b>|
+
+## TL;DR
+
+Authors from the [paper](https://arxiv.org/abs/2201.12086) write in the abstract:
+
+*Vision-Language Pre-training (VLP) has advanced the performance for many vision-language tasks. However, most existing pre-trained models only excel in either understanding-based tasks or generation-based tasks. Furthermore, performance improvement has been largely achieved by scaling up the dataset with noisy image-text pairs collected from the web, which is a suboptimal source of supervision. In this paper, we propose BLIP, a new VLP framework which transfers flexibly to both vision-language understanding and generation tasks. BLIP effectively utilizes the noisy web data by bootstrapping the captions, where a captioner generates synthetic captions and a filter removes the noisy ones. We achieve state-of-the-art results on a wide range of vision-language tasks, such as image-text retrieval (+2.7% in average recall@1), image captioning (+2.8% in CIDEr), and VQA (+1.6% in VQA score). BLIP also demonstrates strong generalization ability when directly transferred to videolanguage tasks in a zero-shot manner. Code, models, and datasets are released.*
+
+## Usage
+
+You can use this model for conditional and un-conditional image captioning
+
+### Using the Pytorch model
+
+#### Running the model on CPU
+
+<details>
+<summary> Click to expand </summary>
+
+```python
+import requests
+from PIL import Image
+from transformers import BlipProcessor, BlipForImageTextRetrieval
+
+processor = BlipProcessor.from_pretrained("Salesforce/blip-itm-base-coco")
+model = BlipForImageTextRetrieval.from_pretrained("Salesforce/blip-itm-base-coco")
+
+img_url = 'https://storage.googleapis.com/sfr-vision-language-research/BLIP/demo.jpg' 
+raw_image = Image.open(requests.get(img_url, stream=True).raw).convert('RGB')
+
+question = "A woman and a dog sitting together in a beach."
+inputs = processor(raw_image, question, return_tensors="pt")
+
+itm_scores = model(**inputs)[0]
+cosine_score = model(**inputs, use_itm_head=False)[0]
+```
+</details>
+
+#### Running the model on GPU
+
+##### In full precision 
+
+<details>
+<summary> Click to expand </summary>
+
+```python
+import requests
+from PIL import Image
+from transformers import BlipProcessor, BlipForImageTextRetrieval
+
+processor = BlipProcessor.from_pretrained("Salesforce/blip-itm-base-coco")
+model = BlipForImageTextRetrieval.from_pretrained("Salesforce/blip-itm-base-coco").to("cuda")
+
+img_url = 'https://storage.googleapis.com/sfr-vision-language-research/BLIP/demo.jpg' 
+raw_image = Image.open(requests.get(img_url, stream=True).raw).convert('RGB')
+
+question = "A woman and a dog sitting together in a beach."
+inputs = processor(raw_image, question, return_tensors="pt").to("cuda")
+
+itm_scores = model(**inputs)[0]
+cosine_score = model(**inputs, use_itm_head=False)[0]
+```
+</details>
+
+##### In half precision (`float16`)
+
+<details>
+<summary> Click to expand </summary>
+
+```python
+import torch
+import requests
+from PIL import Image
+from transformers import BlipProcessor, BlipForImageTextRetrieval
+
+processor = BlipProcessor.from_pretrained("Salesforce/blip-itm-base-coco")
+model = BlipForImageTextRetrieval.from_pretrained("Salesforce/blip-itm-base-coco", torch_dtype=torch.float16).to("cuda")
+
+img_url = 'https://storage.googleapis.com/sfr-vision-language-research/BLIP/demo.jpg' 
+raw_image = Image.open(requests.get(img_url, stream=True).raw).convert('RGB')
+
+question = "A woman and a dog sitting together in a beach."
+inputs = processor(raw_image, question, return_tensors="pt").to("cuda", torch.float16)
+
+itm_scores = model(**inputs)[0]
+cosine_score = model(**inputs, use_itm_head=False)[0]
+```
+</details>
+
+## BibTex and citation info
+
+```
+@misc{https://doi.org/10.48550/arxiv.2201.12086,
+  doi = {10.48550/ARXIV.2201.12086},
+  
+  url = {https://arxiv.org/abs/2201.12086},
+  
+  author = {Li, Junnan and Li, Dongxu and Xiong, Caiming and Hoi, Steven},
+  
+  keywords = {Computer Vision and Pattern Recognition (cs.CV), FOS: Computer and information sciences, FOS: Computer and information sciences},
+  
+  title = {BLIP: Bootstrapping Language-Image Pre-training for Unified Vision-Language Understanding and Generation},
+  
+  publisher = {arXiv},
+  
+  year = {2022},
+  
+  copyright = {Creative Commons Attribution 4.0 International}
+}
+```

Hugging Face.Quantization Fundamentals/Materials/Models/Salesforce/blip-itm-base-coco/config.json

@@ -0,0 +1,169 @@
+{
+  "_commit_hash": null,
+  "architectures": [
+    "BlipForImageTextRetrieval"
+  ],
+  "image_text_hidden_size": 256,
+  "initializer_factor": 1.0,
+  "logit_scale_init_value": 2.6592,
+  "model_type": "blip",
+  "projection_dim": 512,
+  "text_config": {
+    "_name_or_path": "",
+    "add_cross_attention": false,
+    "architectures": null,
+    "attention_probs_dropout_prob": 0.0,
+    "bad_words_ids": null,
+    "begin_suppress_tokens": null,
+    "bos_token_id": 30522,
+    "chunk_size_feed_forward": 0,
+    "cross_attention_hidden_size": null,
+    "decoder_start_token_id": null,
+    "diversity_penalty": 0.0,
+    "do_sample": false,
+    "early_stopping": false,
+    "encoder_no_repeat_ngram_size": 0,
+    "eos_token_id": 2,
+    "exponential_decay_length_penalty": null,
+    "finetuning_task": null,
+    "forced_bos_token_id": null,
+    "forced_eos_token_id": null,
+    "hidden_act": "gelu",
+    "hidden_dropout_prob": 0.0,
+    "hidden_size": 768,
+    "id2label": {
+      "0": "LABEL_0",
+      "1": "LABEL_1"
+    },
+    "initializer_factor": 1.0,
+    "initializer_range": 0.02,
+    "intermediate_size": 3072,
+    "is_decoder": true,
+    "is_encoder_decoder": false,
+    "label2id": {
+      "LABEL_0": 0,
+      "LABEL_1": 1
+    },
+    "layer_norm_eps": 1e-12,
+    "length_penalty": 1.0,
+    "max_length": 20,
+    "max_position_embeddings": 512,
+    "min_length": 0,
+    "model_type": "blip_text_model",
+    "no_repeat_ngram_size": 0,
+    "num_attention_heads": 12,
+    "num_beam_groups": 1,
+    "num_beams": 1,
+    "num_hidden_layers": 12,
+    "num_return_sequences": 1,
+    "output_attentions": false,
+    "output_hidden_states": false,
+    "output_scores": false,
+    "pad_token_id": 0,
+    "prefix": null,
+    "problem_type": null,
+    "projection_dim": 768,
+    "pruned_heads": {},
+    "remove_invalid_values": false,
+    "repetition_penalty": 1.0,
+    "return_dict": true,
+    "return_dict_in_generate": false,
+    "sep_token_id": 102,
+    "suppress_tokens": null,
+    "task_specific_params": null,
+    "temperature": 1.0,
+    "tf_legacy_loss": false,
+    "tie_encoder_decoder": false,
+    "tie_word_embeddings": true,
+    "tokenizer_class": null,
+    "top_k": 50,
+    "top_p": 1.0,
+    "torch_dtype": null,
+    "torchscript": false,
+    "transformers_version": "4.26.0.dev0",
+    "typical_p": 1.0,
+    "use_bfloat16": false,
+    "use_cache": true,
+    "vocab_size": 30524
+  },
+  "torch_dtype": "float32",
+  "transformers_version": null,
+  "vision_config": {
+    "_name_or_path": "",
+    "add_cross_attention": false,
+    "architectures": null,
+    "attention_dropout": 0.0,
+    "bad_words_ids": null,
+    "begin_suppress_tokens": null,
+    "bos_token_id": null,
+    "chunk_size_feed_forward": 0,
+    "cross_attention_hidden_size": null,
+    "decoder_start_token_id": null,
+    "diversity_penalty": 0.0,
+    "do_sample": false,
+    "dropout": 0.0,
+    "early_stopping": false,
+    "encoder_no_repeat_ngram_size": 0,
+    "eos_token_id": null,
+    "exponential_decay_length_penalty": null,
+    "finetuning_task": null,
+    "forced_bos_token_id": null,
+    "forced_eos_token_id": null,
+    "hidden_act": "gelu",
+    "hidden_size": 768,
+    "id2label": {
+      "0": "LABEL_0",
+      "1": "LABEL_1"
+    },
+    "image_size": 384,
+    "initializer_factor": 1.0,
+    "initializer_range": 0.02,
+    "intermediate_size": 3072,
+    "is_decoder": false,
+    "is_encoder_decoder": false,
+    "label2id": {
+      "LABEL_0": 0,
+      "LABEL_1": 1
+    },
+    "layer_norm_eps": 1e-05,
+    "length_penalty": 1.0,
+    "max_length": 20,
+    "min_length": 0,
+    "model_type": "blip_vision_model",
+    "no_repeat_ngram_size": 0,
+    "num_attention_heads": 12,
+    "num_beam_groups": 1,
+    "num_beams": 1,
+    "num_channels": 3,
+    "num_hidden_layers": 12,
+    "num_return_sequences": 1,
+    "output_attentions": false,
+    "output_hidden_states": false,
+    "output_scores": false,
+    "pad_token_id": null,
+    "patch_size": 16,
+    "prefix": null,
+    "problem_type": null,
+    "projection_dim": 512,
+    "pruned_heads": {},
+    "remove_invalid_values": false,
+    "repetition_penalty": 1.0,
+    "return_dict": true,
+    "return_dict_in_generate": false,
+    "sep_token_id": null,
+    "suppress_tokens": null,
+    "task_specific_params": null,
+    "temperature": 1.0,
+    "tf_legacy_loss": false,
+    "tie_encoder_decoder": false,
+    "tie_word_embeddings": true,
+    "tokenizer_class": null,
+    "top_k": 50,
+    "top_p": 1.0,
+    "torch_dtype": null,
+    "torchscript": false,
+    "transformers_version": "4.26.0.dev0",
+    "typical_p": 1.0,
+    "use_bfloat16": false
+  }
+}

Hugging Face.Quantization Fundamentals/Materials/Models/Salesforce/blip-itm-base-coco/preprocessor_config.json

@@ -0,0 +1,25 @@
+{
+  "do_normalize": true,
+  "do_pad": true,
+  "do_rescale": true,
+  "do_resize": true,
+  "image_mean": [
+    0.48145466,
+    0.4578275,
+    0.40821073
+  ],
+  "image_processor_type": "BlipImageProcessor",
+  "image_std": [
+    0.26862954,
+    0.26130258,
+    0.27577711
+  ],
+  "processor_class": "BlipProcessor",
+  "resample": 3,
+  "rescale_factor": 0.00392156862745098,
+  "size": {
+    "height": 384,
+    "width": 384
+  },
+  "size_divisor": 32
+}

Hugging Face.Quantization Fundamentals/Materials/Models/Salesforce/blip-itm-base-coco/pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:017fb3e7f4e125f13a8a4717f1402dbe0d0bb877474b4a203db13a4447b0227f
+size 895139697

Hugging Face.Quantization Fundamentals/Materials/Models/Salesforce/blip-itm-base-coco/special_tokens_map.json

@@ -0,0 +1,7 @@
+{
+  "cls_token": "[CLS]",
+  "mask_token": "[MASK]",
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "unk_token": "[UNK]"
+}

Hugging Face.Quantization Fundamentals/Materials/Models/Salesforce/blip-itm-base-coco/tokenizer_config.json

@@ -0,0 +1,17 @@
+{
+  "cls_token": "[CLS]",
+  "do_basic_tokenize": true,
+  "do_lower_case": true,
+  "mask_token": "[MASK]",
+  "model_max_length": 512,
+  "name_or_path": "ybelkada/blip-image-captioning-base",
+  "never_split": null,
+  "pad_token": "[PAD]",
+  "processor_class": "BlipProcessor",
+  "sep_token": "[SEP]",
+  "special_tokens_map_file": null,
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizer",
+  "unk_token": "[UNK]"
+}

Hugging Face.Quantization Fundamentals/Materials/Models/Salesforce/blip-vqa-base/README.md

@@ -0,0 +1,129 @@
+---
+pipeline_tag: 'visual-question-answering'
+tags:
+- visual-question-answering
+inference: false
+languages:
+- en
+license: bsd-3-clause
+---
+
+# BLIP: Bootstrapping Language-Image Pre-training for Unified Vision-Language Understanding and Generation
+
+Model card for BLIP trained on visual question answering- base architecture (with ViT base backbone).
+
+| ![BLIP.gif](https://cdn-uploads.huggingface.co/production/uploads/1670928184033-62441d1d9fdefb55a0b7d12c.gif) |
+|:--:|
+| <b> Pull figure from BLIP official repo | Image source: https://github.com/salesforce/BLIP </b>|
+
+## TL;DR
+
+Authors from the [paper](https://arxiv.org/abs/2201.12086) write in the abstract:
+
+*Vision-Language Pre-training (VLP) has advanced the performance for many vision-language tasks. However, most existing pre-trained models only excel in either understanding-based tasks or generation-based tasks. Furthermore, performance improvement has been largely achieved by scaling up the dataset with noisy image-text pairs collected from the web, which is a suboptimal source of supervision. In this paper, we propose BLIP, a new VLP framework which transfers flexibly to both vision-language understanding and generation tasks. BLIP effectively utilizes the noisy web data by bootstrapping the captions, where a captioner generates synthetic captions and a filter removes the noisy ones. We achieve state-of-the-art results on a wide range of vision-language tasks, such as image-text retrieval (+2.7% in average recall@1), image captioning (+2.8% in CIDEr), and VQA (+1.6% in VQA score). BLIP also demonstrates strong generalization ability when directly transferred to videolanguage tasks in a zero-shot manner. Code, models, and datasets are released.*
+
+## Usage
+
+You can use this model for conditional and un-conditional image captioning
+
+### Using the Pytorch model
+
+#### Running the model on CPU
+
+<details>
+<summary> Click to expand </summary>
+
+```python
+import requests
+from PIL import Image
+from transformers import BlipProcessor, BlipForQuestionAnswering
+
+processor = BlipProcessor.from_pretrained("Salesforce/blip-vqa-base")
+model = BlipForQuestionAnswering.from_pretrained("Salesforce/blip-vqa-base")
+
+img_url = 'https://storage.googleapis.com/sfr-vision-language-research/BLIP/demo.jpg' 
+raw_image = Image.open(requests.get(img_url, stream=True).raw).convert('RGB')
+
+question = "how many dogs are in the picture?"
+inputs = processor(raw_image, question, return_tensors="pt")
+
+out = model.generate(**inputs)
+print(processor.decode(out[0], skip_special_tokens=True))
+>>> 1
+```
+</details>
+
+#### Running the model on GPU
+
+##### In full precision 
+
+<details>
+<summary> Click to expand </summary>
+
+```python
+import requests
+from PIL import Image
+from transformers import BlipProcessor, BlipForQuestionAnswering
+
+processor = BlipProcessor.from_pretrained("Salesforce/blip-vqa-base")
+model = BlipForQuestionAnswering.from_pretrained("Salesforce/blip-vqa-base").to("cuda")
+
+img_url = 'https://storage.googleapis.com/sfr-vision-language-research/BLIP/demo.jpg' 
+raw_image = Image.open(requests.get(img_url, stream=True).raw).convert('RGB')
+
+question = "how many dogs are in the picture?"
+inputs = processor(raw_image, question, return_tensors="pt").to("cuda")
+
+out = model.generate(**inputs)
+print(processor.decode(out[0], skip_special_tokens=True))
+>>> 1
+```
+</details>
+
+##### In half precision (`float16`)
+
+<details>
+<summary> Click to expand </summary>
+
+```python
+import torch
+import requests
+from PIL import Image
+from transformers import BlipProcessor, BlipForQuestionAnswering
+
+processor = BlipProcessor.from_pretrained("ybelkada/blip-vqa-base")
+model = BlipForQuestionAnswering.from_pretrained("ybelkada/blip-vqa-base", torch_dtype=torch.float16).to("cuda")
+
+img_url = 'https://storage.googleapis.com/sfr-vision-language-research/BLIP/demo.jpg' 
+raw_image = Image.open(requests.get(img_url, stream=True).raw).convert('RGB')
+
+question = "how many dogs are in the picture?"
+inputs = processor(raw_image, question, return_tensors="pt").to("cuda", torch.float16)
+
+out = model.generate(**inputs)
+print(processor.decode(out[0], skip_special_tokens=True))
+>>> 1
+```
+</details>
+
+## BibTex and citation info
+
+```
+@misc{https://doi.org/10.48550/arxiv.2201.12086,
+  doi = {10.48550/ARXIV.2201.12086},
+  
+  url = {https://arxiv.org/abs/2201.12086},
+  
+  author = {Li, Junnan and Li, Dongxu and Xiong, Caiming and Hoi, Steven},
+  
+  keywords = {Computer Vision and Pattern Recognition (cs.CV), FOS: Computer and information sciences, FOS: Computer and information sciences},
+  
+  title = {BLIP: Bootstrapping Language-Image Pre-training for Unified Vision-Language Understanding and Generation},
+  
+  publisher = {arXiv},
+  
+  year = {2022},
+  
+  copyright = {Creative Commons Attribution 4.0 International}
+}
+```

Hugging Face.Quantization Fundamentals/Materials/Models/Salesforce/blip-vqa-base/config.json

@@ -0,0 +1,169 @@
+{
+  "_commit_hash": null,
+  "architectures": [
+    "BlipForQuestionAnswering"
+  ],
+  "image_text_hidden_size": 256,
+  "initializer_factor": 1.0,
+  "logit_scale_init_value": 2.6592,
+  "model_type": "blip",
+  "projection_dim": 512,
+  "text_config": {
+    "_name_or_path": "",
+    "add_cross_attention": false,
+    "architectures": null,
+    "attention_probs_dropout_prob": 0.0,
+    "bad_words_ids": null,
+    "begin_suppress_tokens": null,
+    "bos_token_id": 30522,
+    "chunk_size_feed_forward": 0,
+    "cross_attention_hidden_size": null,
+    "decoder_start_token_id": null,
+    "diversity_penalty": 0.0,
+    "do_sample": false,
+    "early_stopping": false,
+    "encoder_no_repeat_ngram_size": 0,
+    "eos_token_id": 2,
+    "exponential_decay_length_penalty": null,
+    "finetuning_task": null,
+    "forced_bos_token_id": null,
+    "forced_eos_token_id": null,
+    "hidden_act": "gelu",
+    "hidden_dropout_prob": 0.0,
+    "hidden_size": 768,
+    "id2label": {
+      "0": "LABEL_0",
+      "1": "LABEL_1"
+    },
+    "initializer_factor": 1.0,
+    "initializer_range": 0.02,
+    "intermediate_size": 3072,
+    "is_decoder": true,
+    "is_encoder_decoder": false,
+    "label2id": {
+      "LABEL_0": 0,
+      "LABEL_1": 1
+    },
+    "layer_norm_eps": 1e-12,
+    "length_penalty": 1.0,
+    "max_length": 20,
+    "max_position_embeddings": 512,
+    "min_length": 0,
+    "model_type": "blip_text_model",
+    "no_repeat_ngram_size": 0,
+    "num_attention_heads": 12,
+    "num_beam_groups": 1,
+    "num_beams": 1,
+    "num_hidden_layers": 12,
+    "num_return_sequences": 1,
+    "output_attentions": false,
+    "output_hidden_states": false,
+    "output_scores": false,
+    "pad_token_id": 0,
+    "prefix": null,
+    "problem_type": null,
+    "projection_dim": 768,
+    "pruned_heads": {},
+    "remove_invalid_values": false,
+    "repetition_penalty": 1.0,
+    "return_dict": true,
+    "return_dict_in_generate": false,
+    "sep_token_id": 102,
+    "suppress_tokens": null,
+    "task_specific_params": null,
+    "temperature": 1.0,
+    "tf_legacy_loss": false,
+    "tie_encoder_decoder": false,
+    "tie_word_embeddings": true,
+    "tokenizer_class": null,
+    "top_k": 50,
+    "top_p": 1.0,
+    "torch_dtype": null,
+    "torchscript": false,
+    "transformers_version": "4.26.0.dev0",
+    "typical_p": 1.0,
+    "use_bfloat16": false,
+    "use_cache": true,
+    "vocab_size": 30524
+  },
+  "torch_dtype": "float32",
+  "transformers_version": null,
+  "vision_config": {
+    "_name_or_path": "",
+    "add_cross_attention": false,
+    "architectures": null,
+    "attention_dropout": 0.0,
+    "bad_words_ids": null,
+    "begin_suppress_tokens": null,
+    "bos_token_id": null,
+    "chunk_size_feed_forward": 0,
+    "cross_attention_hidden_size": null,
+    "decoder_start_token_id": null,
+    "diversity_penalty": 0.0,
+    "do_sample": false,
+    "dropout": 0.0,
+    "early_stopping": false,
+    "encoder_no_repeat_ngram_size": 0,
+    "eos_token_id": null,
+    "exponential_decay_length_penalty": null,
+    "finetuning_task": null,
+    "forced_bos_token_id": null,
+    "forced_eos_token_id": null,
+    "hidden_act": "gelu",
+    "hidden_size": 768,
+    "id2label": {
+      "0": "LABEL_0",
+      "1": "LABEL_1"
+    },
+    "image_size": 384,
+    "initializer_factor": 1.0,
+    "initializer_range": 0.02,
+    "intermediate_size": 3072,
+    "is_decoder": false,
+    "is_encoder_decoder": false,
+    "label2id": {
+      "LABEL_0": 0,
+      "LABEL_1": 1
+    },
+    "layer_norm_eps": 1e-05,
+    "length_penalty": 1.0,
+    "max_length": 20,
+    "min_length": 0,
+    "model_type": "blip_vision_model",
+    "no_repeat_ngram_size": 0,
+    "num_attention_heads": 12,
+    "num_beam_groups": 1,
+    "num_beams": 1,
+    "num_channels": 3,
+    "num_hidden_layers": 12,
+    "num_return_sequences": 1,
+    "output_attentions": false,
+    "output_hidden_states": false,
+    "output_scores": false,
+    "pad_token_id": null,
+    "patch_size": 16,
+    "prefix": null,
+    "problem_type": null,
+    "projection_dim": 512,
+    "pruned_heads": {},
+    "remove_invalid_values": false,
+    "repetition_penalty": 1.0,
+    "return_dict": true,
+    "return_dict_in_generate": false,
+    "sep_token_id": null,
+    "suppress_tokens": null,
+    "task_specific_params": null,
+    "temperature": 1.0,
+    "tf_legacy_loss": false,
+    "tie_encoder_decoder": false,
+    "tie_word_embeddings": true,
+    "tokenizer_class": null,
+    "top_k": 50,
+    "top_p": 1.0,
+    "torch_dtype": null,
+    "torchscript": false,
+    "transformers_version": "4.26.0.dev0",
+    "typical_p": 1.0,
+    "use_bfloat16": false
+  }
+}

Hugging Face.Quantization Fundamentals/Materials/Models/Salesforce/blip-vqa-base/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:33786eed34def0c95fa948128cb4386be9b9219aa2c2e25f1c9c744692121bb7
+size 1538800584

Hugging Face.Quantization Fundamentals/Materials/Models/Salesforce/blip-vqa-base/preprocessor_config.json

@@ -0,0 +1,25 @@
+{
+  "do_normalize": true,
+  "do_pad": true,
+  "do_rescale": true,
+  "do_resize": true,
+  "image_mean": [
+    0.48145466,
+    0.4578275,
+    0.40821073
+  ],
+  "image_processor_type": "BlipImageProcessor",
+  "image_std": [
+    0.26862954,
+    0.26130258,
+    0.27577711
+  ],
+  "processor_class": "BlipProcessor",
+  "resample": 3,
+  "rescale_factor": 0.00392156862745098,
+  "size": {
+    "height": 384,
+    "width": 384
+  },
+  "size_divisor": 32
+}

Hugging Face.Quantization Fundamentals/Materials/Models/Salesforce/blip-vqa-base/special_tokens_map.json

@@ -0,0 +1,7 @@
+{
+  "cls_token": "[CLS]",
+  "mask_token": "[MASK]",
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "unk_token": "[UNK]"
+}

Hugging Face.Quantization Fundamentals/Materials/Models/Salesforce/blip-vqa-base/tokenizer_config.json

@@ -0,0 +1,25 @@
+{
+  "cls_token": "[CLS]",
+  "do_basic_tokenize": true,
+  "do_lower_case": true,
+  "mask_token": "[MASK]",
+  "model_input_names": [
+    "input_ids",
+    "attention_mask"
+  ],
+  "model_max_length": 512,
+  "name_or_path": "ybelkada/blip-image-captioning-base",
+  "never_split": null,
+  "pad_token": "[PAD]",
+  "processor_class": "BlipProcessor",
+  "sep_token": "[SEP]",
+  "special_tokens_map_file": null,
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizer",
+  "unk_token": "[UNK]",
+  "model_input_names": [
+    "input_ids",
+    "attention_mask"
+  ]
+}

Hugging Face.Quantization Fundamentals/Materials/Models/Salesforce/codegen-350M-mono/README.md

@@ -0,0 +1,57 @@
+---
+license: bsd-3-clause
+---
+# CodeGen (CodeGen-Mono 350M)
+
+## Model description
+
+CodeGen is a family of autoregressive language models for **program synthesis** from the paper: [A Conversational Paradigm for Program Synthesis](https://arxiv.org/abs/2203.13474) by Erik Nijkamp, Bo Pang, Hiroaki Hayashi, Lifu Tu, Huan Wang, Yingbo Zhou, Silvio Savarese, Caiming Xiong. The models are originally released in [this repository](https://github.com/salesforce/CodeGen), under 3 pre-training data variants (`NL`, `Multi`, `Mono`) and 4 model size variants (`350M`, `2B`, `6B`, `16B`).
+
+The checkpoint included in this repository is denoted as **CodeGen-Mono 350M** in the paper, where "Mono" means the model is initialized with *CodeGen-Multi 350M* and further pre-trained on a Python programming language dataset, and "350M" refers to the number of trainable parameters.
+
+## Training data
+
+This checkpoint (CodeGen-Mono 350M) was firstly initialized with *CodeGen-Multi 350M*, and then pre-trained on BigPython dataset. The data consists of 71.7B tokens of Python programming language. See Section 2.1 of the [paper](https://arxiv.org/abs/2203.13474) for more details.
+
+## Training procedure
+
+CodeGen was trained using cross-entropy loss to maximize the likelihood of sequential inputs.
+The family of models are trained using multiple TPU-v4-512 by Google, leveraging data and model parallelism.
+See Section 2.3 of the [paper](https://arxiv.org/abs/2203.13474) for more details.
+
+## Evaluation results
+
+We evaluate our models on two code generation benchmark: HumanEval and MTPB. Please refer to the [paper](https://arxiv.org/abs/2203.13474) for more details.
+
+
+## Intended Use and Limitations
+
+As an autoregressive language model, CodeGen is capable of extracting features from given natural language and programming language texts, and calculating the likelihood of them.
+However, the model is intended for and best at **program synthesis**, that is, generating executable code given English prompts, where the prompts should be in the form of a comment string. The model can complete partially-generated code as well.
+
+## How to use
+
+This model can be easily loaded using the `AutoModelForCausalLM` functionality:
+
+```python
+from transformers import AutoTokenizer, AutoModelForCausalLM
+tokenizer = AutoTokenizer.from_pretrained("Salesforce/codegen-350M-mono")
+model = AutoModelForCausalLM.from_pretrained("Salesforce/codegen-350M-mono")
+
+text = "def hello_world():"
+input_ids = tokenizer(text, return_tensors="pt").input_ids
+
+generated_ids = model.generate(input_ids, max_length=128)
+print(tokenizer.decode(generated_ids[0], skip_special_tokens=True))
+```
+
+## BibTeX entry and citation info
+
+```bibtex
+@article{Nijkamp2022ACP,
+  title={A Conversational Paradigm for Program Synthesis},
+  author={Nijkamp, Erik and Pang, Bo and Hayashi, Hiroaki and Tu, Lifu and Wang, Huan and Zhou, Yingbo and Savarese, Silvio and Xiong, Caiming},
+  journal={arXiv preprint},
+  year={2022}
+}
+```

Hugging Face.Quantization Fundamentals/Materials/Models/Salesforce/codegen-350M-mono/added_tokens.json

@@ -0,0 +1 @@
+{"   ": 50285, "                 ": 50271, "                            ": 50260, "                           ": 50261, "                ": 50272, "\t\t\t\t": 50292, "\t\t\t\t\t\t\t": 50289, "               ": 50273, "    ": 50284, "     ": 50283, "                         ": 50263, "                              ": 50258, "                   ": 50269, "                               ": 50257, "                       ": 50265, "             ": 50275, "                     ": 50267, "                  ": 50270, "          ": 50278, "  ": 50286, "            ": 50276, "                             ": 50259, "\t\t\t\t\t\t": 50290, "                    ": 50268, "         ": 50279, "\t\t\t\t\t\t\t\t\t": 50287, "\t\t\t": 50293, "                        ": 50264, "                      ": 50266, "           ": 50277, "\t\t\t\t\t": 50291, "\t\t": 50294, "       ": 50281, "              ": 50274, "\t\t\t\t\t\t\t\t": 50288, "      ": 50282, "                          ": 50262, "        ": 50280}

Hugging Face.Quantization Fundamentals/Materials/Models/Salesforce/codegen-350M-mono/config.json

@@ -0,0 +1,42 @@
+{
+  "_name_or_path": "codegen-350M-mono",
+  "activation_function": "gelu_new",
+  "architectures": [
+    "CodeGenForCausalLM"
+  ],
+  "attn_pdrop": 0.0,
+  "bos_token_id": 1,
+  "embd_pdrop": 0.0,
+  "eos_token_id": 50256,
+  "gradient_checkpointing": false,
+  "initializer_range": 0.02,
+  "layer_norm_epsilon": 1e-05,
+  "model_type": "codegen",
+  "n_ctx": 2048,
+  "n_embd": 1024,
+  "n_head": 16,
+  "n_inner": null,
+  "n_layer": 20,
+  "n_positions": 2048,
+  "resid_pdrop": 0.0,
+  "rotary_dim": 32,
+  "scale_attn_weights": true,
+  "summary_activation": null,
+  "summary_first_dropout": 0.1,
+  "summary_proj_to_labels": true,
+  "summary_type": "cls_index",
+  "summary_use_proj": true,
+  "task_specific_params": {
+    "text-generation": {
+      "do_sample": true,
+      "max_length": 50,
+      "temperature": 1.0
+    }
+  },
+  "tie_word_embeddings": false,
+  "tokenizer_class": "GPT2Tokenizer",
+  "torch_dtype": "float16",
+  "transformers_version": "4.21.0.dev0",
+  "use_cache": true,
+  "vocab_size": 51200
+}

Hugging Face.Quantization Fundamentals/Materials/Models/Salesforce/codegen-350M-mono/pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:90e20f4887289739a435452f26974d97937adb41485f9c1a7b3d3810aac6773d
+size 797367631

Hugging Face.Quantization Fundamentals/Materials/Models/Salesforce/codegen-350M-mono/special_tokens_map.json

@@ -0,0 +1 @@
+{"bos_token": "<|endoftext|>", "eos_token": "<|endoftext|>", "unk_token": "<|endoftext|>"}

Hugging Face.Quantization Fundamentals/Materials/Models/Salesforce/codegen-350M-mono/tokenizer_config.json

@@ -0,0 +1 @@
+{"unk_token": "<|endoftext|>", "bos_token": "<|endoftext|>", "eos_token": "<|endoftext|>", "add_prefix_space": false, "model_max_length": 2048, "special_tokens_map_file": null, "name_or_path": "gpt2", "tokenizer_class": "CodeGenTokenizer"}