From 09e02c531a7db399f615e094c2ee084e35d4db25 Mon Sep 17 00:00:00 2001 From: ouwx <69306954+ouwx@users.noreply.github.com> Date: Mon, 18 Mar 2024 23:01:12 +0800 Subject: [PATCH] =?UTF-8?q?=E4=BD=BF=E7=94=A8=20Colaboratory=20=E5=BB=BA?= =?UTF-8?q?=E7=AB=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Colaboratory.ipynb | 1127 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1127 insertions(+) create mode 100644 Colaboratory.ipynb diff --git a/Colaboratory.ipynb b/Colaboratory.ipynb new file mode 100644 index 000000000..824622fe3 --- /dev/null +++ b/Colaboratory.ipynb @@ -0,0 +1,1127 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Wf5KrEb6vrkR" + }, + "source": [ + "
\n", + "

歡迎使用 Colab!

\n", + "
\n", + "\n", + "\n", + "
\n", + "

(新功能) 使用 Gemini API

\n", + " \n", + "
\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Nma_JWh-W-IF" + }, + "source": [ + "如果你已經熟悉 Colab,請觀看這部影片瞭解互動式表格、執行過的程式碼歷史記錄檢視畫面,以及指令區塊面板。\n", + "\n", + "
\n", + " \n", + " 顯示 3 項 Google Colab 酷炫功能的影片縮圖\n", + " \n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "zwFnJsE6vjf8" + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5fCEDCU_qrC0" + }, + "source": [ + "
\n", + "

Colab 是什麼?

\n", + "
\n", + "\n", + "Colab (全名為「Colaboratory」) 可讓你在瀏覽器中編寫及執行 Python 程式碼,並具有以下優點:\n", + "- 不必進行任何設定\n", + "- 免付費使用 GPU\n", + "- 輕鬆共用\n", + "\n", + "無論你是學生數據資料學家或是 AI 研究人員,Colab 都能讓你的工作事半功倍。請觀看 Colab 的簡介影片瞭解詳情,或是直接瀏覽以下的新手入門說明!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GJBs_flRovLc" + }, + "source": [ + "
\n", + "\n", + "## 開始使用\n", + "
\n", + "\n", + "你正在閱讀的文件並非靜態網頁,而是名為 Colab 筆記本的互動式環境,可讓你撰寫和執行程式碼。\n", + "\n", + "舉例來說,以下是包含簡短 Python 指令碼的程式碼儲存格,可進行運算、將值儲存至變數中並列印運算結果:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "id": "gJr_9dXGpJ05", + "outputId": "9f556d03-ec67-4950-a485-cfdba9ddd14d" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "86400" + ] + }, + "execution_count": 0, + "metadata": { + "tags": [] + }, + "output_type": "execute_result" + } + ], + "source": [ + "seconds_in_a_day = 24 * 60 * 60\n", + "seconds_in_a_day" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2fhs6GZ4qFMx" + }, + "source": [ + "如要執行上方儲存格中的程式碼,請按一下進行選取,再按一下程式碼左側的播放鍵,或是使用鍵盤快速鍵「Command/Ctrl + Enter 鍵」。按一下儲存格即可開始編輯程式碼。\n", + "\n", + "在一個儲存格中定義的變數之後可用於其他儲存格:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "id": "-gE-Ez1qtyIA", + "outputId": "94cb2224-0edf-457b-90b5-0ac3488d8a97" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "604800" + ] + }, + "execution_count": 0, + "metadata": { + "tags": [] + }, + "output_type": "execute_result" + } + ], + "source": [ + "seconds_in_a_week = 7 * seconds_in_a_day\n", + "seconds_in_a_week" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lSrWNr3MuFUS" + }, + "source": [ + "Colab 筆記本可讓你在單一文件中結合可執行的程式碼RTF 格式,並附帶圖片HTMLLaTeX 等其他格式的內容。你建立的 Colab 筆記本會儲存到你的 Google 雲端硬碟帳戶中。你可以輕鬆將 Colab 筆記本與同事或朋友共用,讓他們在筆記本上加上註解,或甚至進行編輯。詳情請參閱 Colab 總覽。如要建立新的 Colab 筆記本,你可以使用上方的「檔案」選單或以下連結:建立新的 Colab 筆記本。\n", + "\n", + "Colab 筆記本是由 Colab 代管的 Jupyter 筆記本。如要進一步瞭解 Jupyter 專案,請參閱 jupyter.org。" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UdRyKR44dcNI" + }, + "source": [ + "
\n", + "\n", + "## 數據資料學\n", + "
\n", + "\n", + "Colab 可讓你充分利用熱門 Python 程式庫的強大功能,對資料進行分析並以視覺化方式呈現。下方的程式碼儲存格使用 numpy 來產生一些隨機性資料,並透過 matplotlib 將這些資料視覺化。按一下儲存格即可開始編輯程式碼。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 333 + }, + "id": "C4HZx7Gndbrh", + "outputId": "b113e0f6-8852-4d53-e054-84689232a454" + }, + "outputs": [ + { + "data": { + "text/markdown": [ + "![Sample Visualization](data:image/png;base64,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)" + ], + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import IPython.display as display\n", + "from matplotlib import pyplot as plt\n", + "import io\n", + "import base64\n", + "\n", + "ys = 200 + np.random.randn(100)\n", + "x = [x for x in range(len(ys))]\n", + "\n", + "fig = plt.figure(figsize=(4, 3), facecolor='w')\n", + "plt.plot(x, ys, '-')\n", + "plt.fill_between(x, ys, 195, where=(ys > 195), facecolor='g', alpha=0.6)\n", + "plt.title(\"Sample Visualization\", fontsize=10)\n", + "\n", + "data = io.BytesIO()\n", + "plt.savefig(data)\n", + "image = F\"data:image/png;base64,{base64.b64encode(data.getvalue()).decode()}\"\n", + "alt = \"Sample Visualization\"\n", + "display.display(display.Markdown(F\"\"\"![{alt}]({image})\"\"\"))\n", + "plt.close(fig)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4_kCnsPUqS6o" + }, + "source": [ + "你可從自己的 Google 雲端硬碟帳戶 (包括試算表)、GitHub 和許多其他來源,將資料匯入 Colab 筆記本中。如要進一步瞭解如何匯入資料以及將 Colab 用於數據資料學,請參閱下方「處理資料」底下的連結。" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OwuxHmxllTwN" + }, + "source": [ + "
\n", + "\n", + "## 機器學習\n", + "
\n", + "\n", + "你只需要寫幾行程式碼,即可透過 Colab 匯入圖片資料集、根據圖片資料集訓練圖片分類工具並評估模型。Colab 筆記本可在 Google 的雲端伺服器上執行程式碼,也就是說,您可以充分運用 Google 硬體的強大效能 (包括 GPU 和 TPU),而不必在意自己的電腦性能如何,因為你只要使用瀏覽器就可以了。" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ufxBm1yRnruN" + }, + "source": [ + "Colab 廣泛運用於機器學習社群,相關應用包括:\n", + "- 開始使用 TensorFlow\n", + "- 開發及訓練類神經網路\n", + "- 使用 TPU 進行實驗\n", + "- 推廣 AI 研究\n", + "- 建立教學課程\n", + "\n", + "如要查看示範機器學習應用程式的範例 Colab 筆記本,請參閱下方的機器學習範例。" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-Rh3-Vt9Nev9" + }, + "source": [ + "
\n", + "\n", + "## 其他資源\n", + "\n", + "### 在 Colab 中使用筆記本\n", + "\n", + "
\n", + "\n", + "- [Colaboratory 總覽](/notebooks/basic_features_overview.ipynb)\n", + "- [Markdown 指南](/notebooks/markdown_guide.ipynb)\n", + "- [匯入程式庫及安裝依附元件](/notebooks/snippets/importing_libraries.ipynb)\n", + "- [儲存和載入 GitHub 中的筆記本](https://colab.research.google.com/github/googlecolab/colabtools/blob/main/notebooks/colab-github-demo.ipynb)\n", + "- [互動式表單](/notebooks/forms.ipynb)\n", + "- [互動式小工具](/notebooks/widgets.ipynb)\n", + "\n", + "
\n", + "\n", + "\n", + "### 處理資料\n", + "
\n", + "\n", + "- [載入資料:雲端硬碟、試算表及 Google Cloud Storage](/notebooks/io.ipynb)\n", + "- [圖表:將資料視覺化](/notebooks/charts.ipynb)\n", + "- [開始使用 BigQuery](/notebooks/bigquery.ipynb)\n", + "\n", + "
\n", + "\n", + "### 機器學習密集課程\n", + "\n", + "
\n", + "\n", + "以下是一些 Google 線上機器學習課程的筆記本。詳情請參閱完整的課程網站。\n", + "- [Pandas DataFrame 簡介](https://colab.research.google.com/github/google/eng-edu/blob/main/ml/cc/exercises/pandas_dataframe_ultraquick_tutorial.ipynb)\n", + "- [以 tf.keras 使用合成資料進行線性迴歸](https://colab.research.google.com/github/google/eng-edu/blob/main/ml/cc/exercises/linear_regression_with_synthetic_data.ipynb)\n", + "\n", + "
\n", + "\n", + "\n", + "### 使用加速硬體\n", + "
\n", + "\n", + "- [搭配 GPU 使用 TensorFlow](/notebooks/gpu.ipynb)\n", + "- [使用 TPU 的 TensorFlow](/notebooks/tpu.ipynb)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "P-H6Lw1vyNNd" + }, + "source": [ + "
\n", + "\n", + "\n", + "\n", + "### 主要範例\n", + "\n", + "
\n", + "\n", + "- NeMo Voice Swap:使用 Nvidia 的 NeMo 對話式 AI 工具組將音訊片段中的語音換成電腦產生的語音。\n", + "\n", + "- 重新訓練圖片分類工具:以預先訓練的圖片分類工具為基礎,建立一個分辨花朵的 Keras 模型。\n", + "- 文字分類:將 IMDB 電影評論分類為正面負面。\n", + "- 風格轉換:運用深度學習轉換圖片的風格。\n", + "- 支援多種語言的 Universal Sentence Encoder 問與答:使用機器學習模型來回答 SQuAD 資料集的問題。\n", + "- 影片畫面內插:預測影片在第一個與最後一個畫面之間的內容。\n" + ] + }, + { + "cell_type": "code", + "source": [ + "!pip install https://github.com/Isotr0py/SakuraLLM-Notebooks/releases/download/wheels/llama_cpp_python-0.2.39-cp310-cp310-manylinux_2_17_x86_64.whl" + ], + "metadata": { + "id": "GxVzvQ-03kXF", + "outputId": "28977c48-3ef2-4d16-fa8e-52674c821f09", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting llama-cpp-python==0.2.39\n", + " Downloading https://github.com/Isotr0py/SakuraLLM-Notebooks/releases/download/wheels/llama_cpp_python-0.2.39-cp310-cp310-manylinux_2_17_x86_64.whl (15.1 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m15.1/15.1 MB\u001b[0m \u001b[31m28.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: typing-extensions>=4.5.0 in /usr/local/lib/python3.10/dist-packages (from llama-cpp-python==0.2.39) (4.10.0)\n", + "Requirement already satisfied: numpy>=1.20.0 in /usr/local/lib/python3.10/dist-packages (from llama-cpp-python==0.2.39) (1.25.2)\n", + "Collecting diskcache>=5.6.1 (from llama-cpp-python==0.2.39)\n", + " Downloading diskcache-5.6.3-py3-none-any.whl (45 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m45.5/45.5 kB\u001b[0m \u001b[31m1.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: jinja2>=2.11.3 in /usr/local/lib/python3.10/dist-packages (from llama-cpp-python==0.2.39) (3.1.3)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2>=2.11.3->llama-cpp-python==0.2.39) (2.1.5)\n", + "Installing collected packages: diskcache, llama-cpp-python\n", + "Successfully installed diskcache-5.6.3 llama-cpp-python-0.2.39\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "repo_id = \"TheBloke/CodeLlama-7B-Instruct-GGUF\"\n", + "file_name=\"codellama-7b-instruct.Q2_K.gguf\"\n", + "\n", + "from huggingface_hub import hf_hub_download\n", + "hf_hub_download(repo_id=repo_id, filename=file_name,local_dir=\"/kaggle/working\")" + ], + "metadata": { + "id": "L8oDP-oP3o18", + "outputId": "308d055b-c2ee-4f74-9496-7ac8c4f35ff8", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 67, + "referenced_widgets": [ + "170aaac40a084f4f8794fc409c4094c7", + "aca3ba766bf843888ce6abb335707f07", + "e9572463294049dfa0428bc51851af44", + "cb27c1ef215c407da8e9c90959d17560", + "4a2f923d36a241928958c552d5535140", + "af001d0fb6594ccea5029fda79124c51", + "2cc5d1eeb3dc4c67a19c20afa4997fa0", + "4f6e435fa1cd4a209af3132635b5414f", + "f8e4fa05285c41e0b8ee3ba27d746ce8", + "8fd4d6dfd5c64af09b1a729df75232d3", + "bd656ec2ee95401d8798e8365e8da283" + ] + } + }, + "execution_count": 2, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "codellama-7b-instruct.Q2_K.gguf: 0%| | 0.00/2.83G [00:00\", \"\", \"\", \"<0x00>\", \"<...\n", + "llama_model_loader: - kv 14: tokenizer.ggml.scores arr[f32,32016] = [0.000000, 0.000000, 0.000000, 0.0000...\n", + "llama_model_loader: - kv 15: tokenizer.ggml.token_type arr[i32,32016] = [2, 3, 3, 6, 6, 6, 6, 6, 6, 6, 6, 6, ...\n", + "llama_model_loader: - kv 16: tokenizer.ggml.bos_token_id u32 = 1\n", + "llama_model_loader: - kv 17: tokenizer.ggml.eos_token_id u32 = 2\n", + "llama_model_loader: - kv 18: tokenizer.ggml.unknown_token_id u32 = 0\n", + "llama_model_loader: - kv 19: general.quantization_version u32 = 2\n", + "llama_model_loader: - type f32: 65 tensors\n", + "llama_model_loader: - type q2_K: 65 tensors\n", + "llama_model_loader: - type q3_K: 160 tensors\n", + "llama_model_loader: - type q6_K: 1 tensors\n", + "llm_load_vocab: mismatch in special tokens definition ( 264/32016 vs 259/32016 ).\n", + "llm_load_print_meta: format = GGUF V2\n", + "llm_load_print_meta: arch = llama\n", + "llm_load_print_meta: vocab type = SPM\n", + "llm_load_print_meta: n_vocab = 32016\n", + "llm_load_print_meta: n_merges = 0\n", + "llm_load_print_meta: n_ctx_train = 16384\n", + "llm_load_print_meta: n_embd = 4096\n", + "llm_load_print_meta: n_head = 32\n", + "llm_load_print_meta: n_head_kv = 32\n", + "llm_load_print_meta: n_layer = 32\n", + "llm_load_print_meta: n_rot = 128\n", + "llm_load_print_meta: n_embd_head_k = 128\n", + "llm_load_print_meta: n_embd_head_v = 128\n", + "llm_load_print_meta: n_gqa = 1\n", + "llm_load_print_meta: n_embd_k_gqa = 4096\n", + "llm_load_print_meta: n_embd_v_gqa = 4096\n", + "llm_load_print_meta: f_norm_eps = 0.0e+00\n", + "llm_load_print_meta: f_norm_rms_eps = 1.0e-05\n", + "llm_load_print_meta: f_clamp_kqv = 0.0e+00\n", + "llm_load_print_meta: f_max_alibi_bias = 0.0e+00\n", + "llm_load_print_meta: n_ff = 11008\n", + "llm_load_print_meta: n_expert = 0\n", + "llm_load_print_meta: n_expert_used = 0\n", + "llm_load_print_meta: rope scaling = linear\n", + "llm_load_print_meta: freq_base_train = 1000000.0\n", + "llm_load_print_meta: freq_scale_train = 1\n", + "llm_load_print_meta: n_yarn_orig_ctx = 16384\n", + "llm_load_print_meta: rope_finetuned = unknown\n", + "llm_load_print_meta: model type = 7B\n", + "llm_load_print_meta: model ftype = Q2_K - Medium\n", + "llm_load_print_meta: model params = 6.74 B\n", + "llm_load_print_meta: model size = 2.63 GiB (3.35 BPW) \n", + "llm_load_print_meta: general.name = codellama_codellama-7b-instruct-hf\n", + "llm_load_print_meta: BOS token = 1 ''\n", + "llm_load_print_meta: EOS token = 2 ''\n", + "llm_load_print_meta: UNK token = 0 ''\n", + "llm_load_print_meta: LF token = 13 '<0x0A>'\n", + "llm_load_tensors: ggml ctx size = 0.22 MiB\n", + "llm_load_tensors: offloading 32 repeating layers to GPU\n", + "llm_load_tensors: offloading non-repeating layers to GPU\n", + "llm_load_tensors: offloaded 33/33 layers to GPU\n", + "llm_load_tensors: CPU buffer size = 41.04 MiB\n", + "llm_load_tensors: CUDA0 buffer size = 2653.36 MiB\n", + ".................................................................................................\n", + "llama_new_context_with_model: n_ctx = 3584\n", + "llama_new_context_with_model: freq_base = 1000000.0\n", + "llama_new_context_with_model: freq_scale = 1\n", + "llama_kv_cache_init: CUDA0 KV buffer size = 1792.00 MiB\n", + "llama_new_context_with_model: KV self size = 1792.00 MiB, K (f16): 896.00 MiB, V (f16): 896.00 MiB\n", + "llama_new_context_with_model: CUDA_Host input buffer size = 15.28 MiB\n", + "llama_new_context_with_model: CUDA0 compute buffer size = 285.43 MiB\n", + "llama_new_context_with_model: CUDA_Host compute buffer size = 8.95 MiB\n", + "llama_new_context_with_model: graph splits (measure): 3\n", + "AVX = 1 | AVX_VNNI = 0 | AVX2 = 1 | AVX512 = 1 | AVX512_VBMI = 0 | AVX512_VNNI = 0 | FMA = 1 | NEON = 0 | ARM_FMA = 0 | F16C = 1 | FP16_VA = 0 | WASM_SIMD = 0 | BLAS = 1 | SSE3 = 1 | SSSE3 = 1 | VSX = 0 | \n", + "Model metadata: {'tokenizer.ggml.unknown_token_id': '0', 'tokenizer.ggml.eos_token_id': '2', 'general.architecture': 'llama', 'llama.rope.freq_base': '1000000.000000', 'llama.context_length': '16384', 'general.name': 'codellama_codellama-7b-instruct-hf', 'llama.embedding_length': '4096', 'llama.feed_forward_length': '11008', 'llama.attention.layer_norm_rms_epsilon': '0.000010', 'llama.rope.dimension_count': '128', 'tokenizer.ggml.bos_token_id': '1', 'llama.attention.head_count': '32', 'llama.block_count': '32', 'llama.attention.head_count_kv': '32', 'general.quantization_version': '2', 'tokenizer.ggml.model': 'llama', 'general.file_type': '10'}\n", + "\n", + "llama_print_timings: load time = 457.00 ms\n", + "llama_print_timings: sample time = 20.80 ms / 32 runs ( 0.65 ms per token, 1538.46 tokens per second)\n", + "llama_print_timings: prompt eval time = 456.45 ms / 21 tokens ( 21.74 ms per token, 46.01 tokens per second)\n", + "llama_print_timings: eval time = 904.17 ms / 31 runs ( 29.17 ms per token, 34.29 tokens per second)\n", + "llama_print_timings: total time = 1511.20 ms / 52 tokens\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Q: python如何用time计算开始结束时间 A: 可以使用time模块,调用clock_gettime获取开始时间,然后在函数中调用clock\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!pip install 'llama-cpp-python[server]'\n" + ], + "metadata": { + "id": "e0hpTiqX32aU", + "outputId": "2b9e2b0d-4fa7-4771-accf-64b392929429", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: llama-cpp-python[server] in /usr/local/lib/python3.10/dist-packages (0.2.39)\n", + "Requirement already satisfied: typing-extensions>=4.5.0 in /usr/local/lib/python3.10/dist-packages (from llama-cpp-python[server]) (4.10.0)\n", + "Requirement already satisfied: numpy>=1.20.0 in /usr/local/lib/python3.10/dist-packages (from llama-cpp-python[server]) (1.25.2)\n", + "Requirement already satisfied: diskcache>=5.6.1 in /usr/local/lib/python3.10/dist-packages (from llama-cpp-python[server]) (5.6.3)\n", + "Requirement already satisfied: jinja2>=2.11.3 in /usr/local/lib/python3.10/dist-packages (from llama-cpp-python[server]) (3.1.3)\n", + "Collecting uvicorn>=0.22.0 (from llama-cpp-python[server])\n", + " Downloading uvicorn-0.28.0-py3-none-any.whl (60 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m60.6/60.6 kB\u001b[0m \u001b[31m1.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting fastapi>=0.100.0 (from llama-cpp-python[server])\n", + " Downloading fastapi-0.110.0-py3-none-any.whl (92 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m92.1/92.1 kB\u001b[0m \u001b[31m5.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting pydantic-settings>=2.0.1 (from llama-cpp-python[server])\n", + " Downloading pydantic_settings-2.2.1-py3-none-any.whl (13 kB)\n", + "Collecting sse-starlette>=1.6.1 (from llama-cpp-python[server])\n", + " Downloading sse_starlette-2.0.0-py3-none-any.whl (9.0 kB)\n", + "Collecting starlette-context<0.4,>=0.3.6 (from llama-cpp-python[server])\n", + " Downloading starlette_context-0.3.6-py3-none-any.whl (12 kB)\n", + "Requirement already satisfied: pydantic!=1.8,!=1.8.1,!=2.0.0,!=2.0.1,!=2.1.0,<3.0.0,>=1.7.4 in /usr/local/lib/python3.10/dist-packages (from fastapi>=0.100.0->llama-cpp-python[server]) (2.6.4)\n", + "Collecting starlette<0.37.0,>=0.36.3 (from fastapi>=0.100.0->llama-cpp-python[server])\n", + " Downloading starlette-0.36.3-py3-none-any.whl (71 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m71.5/71.5 kB\u001b[0m \u001b[31m10.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2>=2.11.3->llama-cpp-python[server]) (2.1.5)\n", + "Collecting python-dotenv>=0.21.0 (from pydantic-settings>=2.0.1->llama-cpp-python[server])\n", + " Downloading python_dotenv-1.0.1-py3-none-any.whl (19 kB)\n", + "Requirement already satisfied: anyio in /usr/local/lib/python3.10/dist-packages (from sse-starlette>=1.6.1->llama-cpp-python[server]) (3.7.1)\n", + "Requirement already satisfied: click>=7.0 in /usr/local/lib/python3.10/dist-packages (from uvicorn>=0.22.0->llama-cpp-python[server]) (8.1.7)\n", + "Collecting h11>=0.8 (from uvicorn>=0.22.0->llama-cpp-python[server])\n", + " Downloading h11-0.14.0-py3-none-any.whl (58 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.3/58.3 kB\u001b[0m \u001b[31m8.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: annotated-types>=0.4.0 in /usr/local/lib/python3.10/dist-packages (from pydantic!=1.8,!=1.8.1,!=2.0.0,!=2.0.1,!=2.1.0,<3.0.0,>=1.7.4->fastapi>=0.100.0->llama-cpp-python[server]) (0.6.0)\n", + "Requirement already satisfied: pydantic-core==2.16.3 in /usr/local/lib/python3.10/dist-packages (from pydantic!=1.8,!=1.8.1,!=2.0.0,!=2.0.1,!=2.1.0,<3.0.0,>=1.7.4->fastapi>=0.100.0->llama-cpp-python[server]) (2.16.3)\n", + "Requirement already satisfied: idna>=2.8 in /usr/local/lib/python3.10/dist-packages (from anyio->sse-starlette>=1.6.1->llama-cpp-python[server]) (3.6)\n", + "Requirement already satisfied: sniffio>=1.1 in /usr/local/lib/python3.10/dist-packages (from anyio->sse-starlette>=1.6.1->llama-cpp-python[server]) (1.3.1)\n", + "Requirement already satisfied: exceptiongroup in /usr/local/lib/python3.10/dist-packages (from anyio->sse-starlette>=1.6.1->llama-cpp-python[server]) (1.2.0)\n", + "Installing collected packages: python-dotenv, h11, uvicorn, starlette, starlette-context, sse-starlette, pydantic-settings, fastapi\n", + "Successfully installed fastapi-0.110.0 h11-0.14.0 pydantic-settings-2.2.1 python-dotenv-1.0.1 sse-starlette-2.0.0 starlette-0.36.3 starlette-context-0.3.6 uvicorn-0.28.0\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab.output import eval_js\n", + "print(eval_js(\"google.colab.kernel.proxyPort(5000)\"))\n", + "!python3 -m llama_cpp.server --host 0.0.0.0 --port 5000 --model /kaggle/working/codellama-7b-instruct.Q2_K.gguf" + ], + "metadata": { + "id": "Kx881xqt35Vw", + "outputId": "42938059-487e-45e9-c8f9-ae381bf70cc3", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + } + }, + "execution_count": 10, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "https://id91m21m2t-496ff2e9c6d22116-5000-colab.googleusercontent.com/\n", + "ggml_init_cublas: GGML_CUDA_FORCE_MMQ: no\n", + "ggml_init_cublas: CUDA_USE_TENSOR_CORES: yes\n", + "ggml_init_cublas: found 1 CUDA devices:\n", + " Device 0: Tesla T4, compute capability 7.5, VMM: yes\n", + "llama_model_loader: loaded meta data with 20 key-value pairs and 291 tensors from /kaggle/working/codellama-7b-instruct.Q2_K.gguf (version GGUF V2)\n", + "llama_model_loader: Dumping metadata keys/values. Note: KV overrides do not apply in this output.\n", + "llama_model_loader: - kv 0: general.architecture str = llama\n", + "llama_model_loader: - kv 1: general.name str = codellama_codellama-7b-instruct-hf\n", + "llama_model_loader: - kv 2: llama.context_length u32 = 16384\n", + "llama_model_loader: - kv 3: llama.embedding_length u32 = 4096\n", + "llama_model_loader: - kv 4: llama.block_count u32 = 32\n", + "llama_model_loader: - kv 5: llama.feed_forward_length u32 = 11008\n", + "llama_model_loader: - kv 6: llama.rope.dimension_count u32 = 128\n", + "llama_model_loader: - kv 7: llama.attention.head_count u32 = 32\n", + "llama_model_loader: - kv 8: llama.attention.head_count_kv u32 = 32\n", + "llama_model_loader: - kv 9: llama.attention.layer_norm_rms_epsilon f32 = 0.000010\n", + "llama_model_loader: - kv 10: llama.rope.freq_base f32 = 1000000.000000\n", + "llama_model_loader: - kv 11: general.file_type u32 = 10\n", + "llama_model_loader: - kv 12: tokenizer.ggml.model str = llama\n", + "llama_model_loader: - kv 13: tokenizer.ggml.tokens arr[str,32016] = [\"\", \"\", \"\", \"<0x00>\", \"<...\n", + "llama_model_loader: - kv 14: tokenizer.ggml.scores arr[f32,32016] = [0.000000, 0.000000, 0.000000, 0.0000...\n", + "llama_model_loader: - kv 15: tokenizer.ggml.token_type arr[i32,32016] = [2, 3, 3, 6, 6, 6, 6, 6, 6, 6, 6, 6, ...\n", + "llama_model_loader: - kv 16: tokenizer.ggml.bos_token_id u32 = 1\n", + "llama_model_loader: - kv 17: tokenizer.ggml.eos_token_id u32 = 2\n", + "llama_model_loader: - kv 18: tokenizer.ggml.unknown_token_id u32 = 0\n", + "llama_model_loader: - kv 19: general.quantization_version u32 = 2\n", + "llama_model_loader: - type f32: 65 tensors\n", + "llama_model_loader: - type q2_K: 65 tensors\n", + "llama_model_loader: - type q3_K: 160 tensors\n", + "llama_model_loader: - type q6_K: 1 tensors\n", + "llm_load_vocab: mismatch in special tokens definition ( 264/32016 vs 259/32016 ).\n", + "llm_load_print_meta: format = GGUF V2\n", + "llm_load_print_meta: arch = llama\n", + "llm_load_print_meta: vocab type = SPM\n", + "llm_load_print_meta: n_vocab = 32016\n", + "llm_load_print_meta: n_merges = 0\n", + "llm_load_print_meta: n_ctx_train = 16384\n", + "llm_load_print_meta: n_embd = 4096\n", + "llm_load_print_meta: n_head = 32\n", + "llm_load_print_meta: n_head_kv = 32\n", + "llm_load_print_meta: n_layer = 32\n", + "llm_load_print_meta: n_rot = 128\n", + "llm_load_print_meta: n_embd_head_k = 128\n", + "llm_load_print_meta: n_embd_head_v = 128\n", + "llm_load_print_meta: n_gqa = 1\n", + "llm_load_print_meta: n_embd_k_gqa = 4096\n", + "llm_load_print_meta: n_embd_v_gqa = 4096\n", + "llm_load_print_meta: f_norm_eps = 0.0e+00\n", + "llm_load_print_meta: f_norm_rms_eps = 1.0e-05\n", + "llm_load_print_meta: f_clamp_kqv = 0.0e+00\n", + "llm_load_print_meta: f_max_alibi_bias = 0.0e+00\n", + "llm_load_print_meta: n_ff = 11008\n", + "llm_load_print_meta: n_expert = 0\n", + "llm_load_print_meta: n_expert_used = 0\n", + "llm_load_print_meta: rope scaling = linear\n", + "llm_load_print_meta: freq_base_train = 1000000.0\n", + "llm_load_print_meta: freq_scale_train = 1\n", + "llm_load_print_meta: n_yarn_orig_ctx = 16384\n", + "llm_load_print_meta: rope_finetuned = unknown\n", + "llm_load_print_meta: model type = 7B\n", + "llm_load_print_meta: model ftype = Q2_K - Medium\n", + "llm_load_print_meta: model params = 6.74 B\n", + "llm_load_print_meta: model size = 2.63 GiB (3.35 BPW) \n", + "llm_load_print_meta: general.name = codellama_codellama-7b-instruct-hf\n", + "llm_load_print_meta: BOS token = 1 ''\n", + "llm_load_print_meta: EOS token = 2 ''\n", + "llm_load_print_meta: UNK token = 0 ''\n", + "llm_load_print_meta: LF token = 13 '<0x0A>'\n", + "llm_load_tensors: ggml ctx size = 0.11 MiB\n", + "llm_load_tensors: offloading 0 repeating layers to GPU\n", + "llm_load_tensors: offloaded 0/33 layers to GPU\n", + "llm_load_tensors: CPU buffer size = 2694.39 MiB\n", + "warning: failed to mlock 43773952-byte buffer (after previously locking 0 bytes): Cannot allocate memory\n", + "Try increasing RLIMIT_MEMLOCK ('ulimit -l' as root).\n", + ".................................................................................................\n", + "llama_new_context_with_model: n_ctx = 2048\n", + "llama_new_context_with_model: freq_base = 1000000.0\n", + "llama_new_context_with_model: freq_scale = 1\n", + "llama_kv_cache_init: CUDA_Host KV buffer size = 1024.00 MiB\n", + "llama_new_context_with_model: KV self size = 1024.00 MiB, K (f16): 512.00 MiB, V (f16): 512.00 MiB\n", + "llama_new_context_with_model: CUDA_Host input buffer size = 12.01 MiB\n", + "llama_new_context_with_model: CUDA_Host compute buffer size = 167.20 MiB\n", + "llama_new_context_with_model: graph splits (measure): 1\n", + "AVX = 1 | AVX_VNNI = 0 | AVX2 = 1 | AVX512 = 1 | AVX512_VBMI = 0 | AVX512_VNNI = 0 | FMA = 1 | NEON = 0 | ARM_FMA = 0 | F16C = 1 | FP16_VA = 0 | WASM_SIMD = 0 | BLAS = 1 | SSE3 = 1 | SSSE3 = 1 | VSX = 0 | \n", + "Model metadata: {'tokenizer.ggml.unknown_token_id': '0', 'tokenizer.ggml.eos_token_id': '2', 'general.architecture': 'llama', 'llama.rope.freq_base': '1000000.000000', 'llama.context_length': '16384', 'general.name': 'codellama_codellama-7b-instruct-hf', 'llama.embedding_length': '4096', 'llama.feed_forward_length': '11008', 'llama.attention.layer_norm_rms_epsilon': '0.000010', 'llama.rope.dimension_count': '128', 'tokenizer.ggml.bos_token_id': '1', 'llama.attention.head_count': '32', 'llama.block_count': '32', 'llama.attention.head_count_kv': '32', 'general.quantization_version': '2', 'tokenizer.ggml.model': 'llama', 'general.file_type': '10'}\n", + "\u001b[32mINFO\u001b[0m: Started server process [\u001b[36m12857\u001b[0m]\n", + "\u001b[32mINFO\u001b[0m: Waiting for application startup.\n", + "\u001b[32mINFO\u001b[0m: Application startup complete.\n", + "\u001b[32mINFO\u001b[0m: Uvicorn running on \u001b[1mhttp://0.0.0.0:5000\u001b[0m (Press CTRL+C to quit)\n", + "\u001b[32mINFO\u001b[0m: 127.0.0.1:51698 - \"\u001b[1mGET /docs HTTP/1.1\u001b[0m\" \u001b[32m200 OK\u001b[0m\n", + "\u001b[32mINFO\u001b[0m: 127.0.0.1:52900 - \"\u001b[1mGET /openapi.json HTTP/1.1\u001b[0m\" \u001b[32m200 OK\u001b[0m\n", + "\u001b[32mINFO\u001b[0m: 127.0.0.1:44572 - \"\u001b[1mGET /v1/models HTTP/1.1\u001b[0m\" \u001b[32m200 OK\u001b[0m\n", + "\u001b[32mINFO\u001b[0m: 127.0.0.1:44584 - \"\u001b[1mGET /favicon.ico HTTP/1.1\u001b[0m\" \u001b[31m404 Not Found\u001b[0m\n", + "\u001b[32mINFO\u001b[0m: Shutting down\n", + "\u001b[32mINFO\u001b[0m: Finished server process [\u001b[36m12857\u001b[0m]\n", + "\u001b[31mERROR\u001b[0m: Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.10/dist-packages/starlette/routing.py\", line 743, in lifespan\n", + " await receive()\n", + " File \"/usr/local/lib/python3.10/dist-packages/uvicorn/lifespan/on.py\", line 137, in receive\n", + " return await self.receive_queue.get()\n", + " File \"/usr/lib/python3.10/asyncio/queues.py\", line 159, in get\n", + " await getter\n", + "asyncio.exceptions.CancelledError\n", + "\n" + ] + } + ] + } + ], + "metadata": { + "colab": { + "name": "歡迎使用 Colaboratory", + "provenance": [], + "gpuType": "T4", + "include_colab_link": true + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "accelerator": "GPU", + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "170aaac40a084f4f8794fc409c4094c7": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "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_aca3ba766bf843888ce6abb335707f07", + "IPY_MODEL_e9572463294049dfa0428bc51851af44", + "IPY_MODEL_cb27c1ef215c407da8e9c90959d17560" + ], + "layout": "IPY_MODEL_4a2f923d36a241928958c552d5535140" + } + }, + "aca3ba766bf843888ce6abb335707f07": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_af001d0fb6594ccea5029fda79124c51", + "placeholder": "​", + "style": "IPY_MODEL_2cc5d1eeb3dc4c67a19c20afa4997fa0", + "value": "codellama-7b-instruct.Q2_K.gguf: 100%" + } + }, + "e9572463294049dfa0428bc51851af44": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "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_4f6e435fa1cd4a209af3132635b5414f", + "max": 2826016448, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f8e4fa05285c41e0b8ee3ba27d746ce8", + "value": 2826016448 + } + }, + "cb27c1ef215c407da8e9c90959d17560": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "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_8fd4d6dfd5c64af09b1a729df75232d3", + "placeholder": "​", + "style": "IPY_MODEL_bd656ec2ee95401d8798e8365e8da283", + "value": " 2.83G/2.83G [00:19<00:00, 131MB/s]" + } + }, + "4a2f923d36a241928958c552d5535140": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "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 + } + }, + "af001d0fb6594ccea5029fda79124c51": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "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 + } + }, + "2cc5d1eeb3dc4c67a19c20afa4997fa0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "4f6e435fa1cd4a209af3132635b5414f": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "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 + } + }, + "f8e4fa05285c41e0b8ee3ba27d746ce8": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "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": "" + } + }, + "8fd4d6dfd5c64af09b1a729df75232d3": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "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 + } + }, + "bd656ec2ee95401d8798e8365e8da283": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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": 0 +} \ No newline at end of file