From d69c84adf939c351a775e487aeac6bbfd81ab6df Mon Sep 17 00:00:00 2001
From: Alemax067 <2657236382@qq.com>
Date: Sat, 28 Dec 2024 02:23:35 +0800
Subject: [PATCH 1/2] =?UTF-8?q?=E3=80=90=E5=BC=80=E6=BA=90=E5=AE=9E?=
 =?UTF-8?q?=E4=B9=A0=E3=80=91blip=E6=A8=A1=E5=9E=8B=E5=BE=AE=E8=B0=83?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 llm/finetune/blip/README.md             |  49 ++
 llm/finetune/blip/blip_finetune.ipynb   | 982 ++++++++++++++++++++++++
 llm/finetune/blip/results_visible.ipynb |  94 +++
 3 files changed, 1125 insertions(+)
 create mode 100644 llm/finetune/blip/README.md
 create mode 100644 llm/finetune/blip/blip_finetune.ipynb
 create mode 100644 llm/finetune/blip/results_visible.ipynb

diff --git a/llm/finetune/blip/README.md b/llm/finetune/blip/README.md
new file mode 100644
index 000000000..b96261c15
--- /dev/null
+++ b/llm/finetune/blip/README.md
@@ -0,0 +1,49 @@
+# FineTune BLIP
+- reference [repo](https://github.com/eeshashetty/captionary-api)
+
+## Requirements
+- python 3.9
+- mindspore 2.3.1
+- mindnlp 0.4.1
+
+## args for training the model
+- args.device_target : Ascend
+- args.device_id 
+- args.model_name_or_path : 'Salesforce/blip-image-captioning-base' or the path to the model
+- args.dataset_name_or_path : 'eeshclusive/captionary-dataset' or the path to the data directory
+- args.batch_size : batch size
+- args.max_eps : maximum number of epochs
+- args.save_path : path to save the model, if not provided the model will not be saved, such as './outputs/'
+
+## Results
+### my results on mindspore
+20 epochs:  
+- train loss: 0.0132  
+- val loss: 0.0126
+
+requirements:
+- Ascend 910B
+- Python 3.9
+- MindSpore 2.3.1
+- MindNLP 0.4.1
+
+### my results on pytorch
+10 epochs:  
+- train loss: 0.0135  
+- val loss: 0.0125
+
+requirements:
+- GPU 1080ti
+- CUDA 11.1.1
+- Python 3.9
+- Pytorch 1.10.2
+- Transformers 4.45.2
+
+### Original results from the repo
+20 epochs:  
+- train loss: 1.3579
+- val loss: 1.3584
+
+### 其他
+- 训练loss可视化见results_visible.ipynb文件   
+- 愿仓库的损失不知为何特别高，复现时训练参数保持一致，但pytorch开启了混合精度，而mindnlp暂不支持，所以pytorch训练收敛的更快一些
\ No newline at end of file
diff --git a/llm/finetune/blip/blip_finetune.ipynb b/llm/finetune/blip/blip_finetune.ipynb
new file mode 100644
index 000000000..54f58edcd
--- /dev/null
+++ b/llm/finetune/blip/blip_finetune.ipynb
@@ -0,0 +1,982 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ddaf1c40",
+   "metadata": {},
+   "source": [
+    "## requirements\n",
+    "### mindspore==2.3.1\n",
+    "### mindnlp==0.4.1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5c8be3d0",
+   "metadata": {},
+   "source": [
+    "导入所需库"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bb9816da",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n",
+      "Building prefix dict from the default dictionary ...\n",
+      "Dumping model to file cache /tmp/jieba.cache\n",
+      "Loading model cost 1.383 seconds.\n",
+      "Prefix dict has been built successfully.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import time\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "import mindspore\n",
+    "import mindspore.numpy as np\n",
+    "from mindspore.dataset import GeneratorDataset\n",
+    "from mindspore import save_checkpoint\n",
+    "\n",
+    "from mindnlp.transformers import AutoProcessor, BlipForConditionalGeneration\n",
+    "from mindnlp.core.optim import Adam\n",
+    "from mindnlp.core import value_and_grad\n",
+    "\n",
+    "from datasets import load_dataset"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6c29932c",
+   "metadata": {},
+   "source": [
+    "数据集加载"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "54a601b4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class ImageCaptioningDataset():\n",
+    "    def __init__(self, dataset, processor):\n",
+    "        self.dataset = dataset\n",
+    "        self.processor = processor\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        return len(self.dataset)\n",
+    "\n",
+    "    def __getitem__(self, idx):\n",
+    "        if not isinstance(idx, int):\n",
+    "            idx = int(idx)\n",
+    "        item = self.dataset[idx]\n",
+    "        encoding = self.processor(images=item['image'], text=item['text'], padding=\"max_length\")\n",
+    "        return np.asarray(encoding[\"pixel_values\"]), np.asarray(encoding[\"input_ids\"]), np.asarray(encoding[\"attention_mask\"])\n",
+    "\n",
+    "def get_loader(dataset, processor, batch_size, shuffle=True, num_workers=1, drop_remainder=True):\n",
+    "    dataset = ImageCaptioningDataset(dataset, processor)\n",
+    "    return GeneratorDataset(source=dataset, \n",
+    "                            column_names=[\"pixel_values\", \"input_ids\", \"attention_mask\"],\n",
+    "                            shuffle=shuffle,\n",
+    "                            num_parallel_workers=num_workers\n",
+    "                           ).batch(batch_size=batch_size, \n",
+    "                                   drop_remainder=drop_remainder)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9a4c4ee5",
+   "metadata": {},
+   "source": [
+    "自定义Trainer类"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "38a964f9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Trainer:\n",
+    "    def __init__(self, net, optimizer, args,\n",
+    "                 train_dataset, eval_dataset=None\n",
+    "                 ):\n",
+    "        self.net = net\n",
+    "        self.opt = optimizer\n",
+    "        self.args = args\n",
+    "        self.train_dataset = train_dataset\n",
+    "        self.weights = self.net.trainable_params()\n",
+    "        self.value_and_grad = value_and_grad(fn=self.forward_fn, params_or_argnums=self.weights)\n",
+    "        self.run_eval = eval_dataset is not None\n",
+    "        if self.run_eval:\n",
+    "            self.eval_dataset = eval_dataset\n",
+    "    \n",
+    "    def forward_fn(self, input_ids, pixel_values, attention_mask):\n",
+    "        outputs = self.net(input_ids=input_ids, pixel_values=pixel_values, attention_mask=attention_mask, labels=input_ids)\n",
+    "        loss = outputs.loss\n",
+    "        return loss\n",
+    "\n",
+    "    def train_single(self, input_ids, pixel_values, attention_mask):\n",
+    "        self.opt.zero_grad()\n",
+    "        loss = self.value_and_grad(input_ids, pixel_values, attention_mask)\n",
+    "        self.opt.step()\n",
+    "        return loss\n",
+    "\n",
+    "    def train(self, epochs):\n",
+    "        best_val_loss = float('inf')\n",
+    "        for epoch in range(0, epochs):\n",
+    "            print(\"\\nEpoch {}/{}\".format(epoch+1, epochs))\n",
+    "            self.net.set_train(True)\n",
+    "            tloss = 0\n",
+    "            step = 0\n",
+    "            for batch in tqdm(self.train_dataset.create_dict_iterator()):\n",
+    "                input_ids = batch[\"input_ids\"]\n",
+    "                pixel_values = batch[\"pixel_values\"].squeeze(1)\n",
+    "                attention_mask = batch[\"attention_mask\"]\n",
+    "                \n",
+    "                loss = self.train_single(input_ids, pixel_values, attention_mask)\n",
+    "                \n",
+    "                tloss = tloss + loss.asnumpy()\n",
+    "                step = step + 1\n",
+    "                \n",
+    "            tloss /= step\n",
+    "            print(\"\\tTrain Loss {:.04f}\".format(tloss))\n",
+    "            \n",
+    "            if self.run_eval:\n",
+    "                self.net.set_train(False)\n",
+    "                val_loss = self.val()\n",
+    "                print(\"Epoch {} complete! Validation Loss : {}\".format(epoch + 1, val_loss))\n",
+    "                if val_loss < best_val_loss:\n",
+    "                    print(\"Best validation Loss improved from {} to {}\".format(best_val_loss, val_loss))\n",
+    "                    best_val_loss = val_loss\n",
+    "                    if self.args.save_path is not None:\n",
+    "                        print(\"saving model...\")\n",
+    "                        save_checkpoint(self.net, self.args.save_path + 'best_model.ckpt')\n",
+    "    \n",
+    "    def val(self):\n",
+    "        vloss = 0\n",
+    "        step = 0\n",
+    "        with mindspore._no_grad():\n",
+    "            for batch in tqdm(self.eval_dataset.create_dict_iterator()):\n",
+    "                input_ids = batch[\"input_ids\"]\n",
+    "                pixel_values = batch[\"pixel_values\"].squeeze(1)\n",
+    "                attention_mask = batch[\"attention_mask\"]\n",
+    "\n",
+    "                outputs = self.net(input_ids=input_ids, pixel_values=pixel_values, attention_mask=attention_mask, labels=input_ids)\n",
+    "                loss = outputs.loss\n",
+    "                    \n",
+    "                vloss = vloss + loss.asnumpy()\n",
+    "                step = step + 1\n",
+    "\n",
+    "        return vloss / step"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "782bd6c0",
+   "metadata": {},
+   "source": [
+    "主函数入口，完整训练流程"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "20138545",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def main(args):    \n",
+    "    #load the blip model\n",
+    "    print(\"Building model! (This might take time if you are running this for first time)\")\n",
+    "    st = time.time()\n",
+    "    mindspore.set_context(device_target=args.device_target, device_id=args.device_id, pynative_synchronize=True)\n",
+    "    processor = AutoProcessor.from_pretrained(args.model_name_or_path)\n",
+    "    model = BlipForConditionalGeneration.from_pretrained(args.model_name_or_path)\n",
+    "    print(\"Done in {} seconds\".format(time.time() - st))\n",
+    "\n",
+    "    print(\"Creating optimizer objects\")\n",
+    "    st = time.time()\n",
+    "    optimizer = Adam(model.trainable_params(), lr=5e-5)\n",
+    "    print(\"Done in {} seconds\".format(time.time() - st))\n",
+    "\n",
+    "    #Creating dataloaders\n",
+    "    print(\"Creating train and val dataloaders\")\n",
+    "    st = time.time()\n",
+    "    data = load_dataset(args.dataset_name_or_path)\n",
+    "    train_loader = get_loader(data['train'], processor, args.batch_size, shuffle=True, drop_remainder=True)\n",
+    "    val_loader = get_loader(data['test'], processor, args.batch_size, shuffle=True, drop_remainder=False)\n",
+    "    print(\"Done in {} seconds\".format(time.time() - st))\n",
+    "\n",
+    "    print(\"Let the training begin\")\n",
+    "    st = time.time()\n",
+    "    trainer = Trainer(net=model, optimizer=optimizer, args=args, train_dataset=train_loader, eval_dataset=val_loader)\n",
+    "    trainer.train(epochs=args.max_eps)\n",
+    "    print(\"Done in {} seconds\".format(time.time() - st))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cf64a755",
+   "metadata": {},
+   "source": [
+    "设置训练参数，开始训练"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "01fecad1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Building model! (This might take time if you are running this for first time)\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages/mindnlp/transformers/tokenization_utils_base.py:1526: FutureWarning: `clean_up_tokenization_spaces` was not set. It will be set to `True` by default. This behavior will be depracted, and will be then set to `False` by default. \n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[MS_ALLOC_CONF]Runtime config:  enable_vmm:True  vmm_align_size:2MB\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "BlipTextLMHeadModel has generative capabilities, as `prepare_inputs_for_generation` is explicitly overwritten. However, it doesn't directly inherit from `GenerationMixin`.`PreTrainedModel` will NOT inherit from `GenerationMixin`, and this model will lose the ability to call `generate` and other related functions.\n",
+      "  - If you are the owner of the model architecture code, please modify your model class such that it inherits from `GenerationMixin` (after `PreTrainedModel`, otherwise you'll get an exception).\n",
+      "  - If you are not the owner of the model architecture class, please contact the model code owner to update it.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Done in 17.581424474716187 seconds\n",
+      "Creating optimizer objects\n",
+      "Done in 0.0065310001373291016 seconds\n",
+      "Creating train and val dataloaders\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Generating train split: 100%|██████████| 162/162 [00:00<00:00, 440.00 examples/s]\n",
+      "Generating test split: 100%|██████████| 51/51 [00:00<00:00, 728.11 examples/s]\n",
+      "[WARNING] ME(200:281472890875920,MainProcess):2024-12-28-00:27:44.642.659 [mindspore/dataset/engine/datasets_user_defined.py:796] Input 'source' of 'GeneratorDataset' includes network computing operators like in mindspore.nn, mindspore.ops, mindspore.numpy module and etc, which do not support multi-thread compiling, recommend to replace it with python implemented operator like numpy etc. Here decrease 'num_parallel_workers' into 1.\n",
+      "[WARNING] ME(200:281472890875920,MainProcess):2024-12-28-00:27:44.647.061 [mindspore/dataset/engine/datasets_user_defined.py:796] Input 'source' of 'GeneratorDataset' includes network computing operators like in mindspore.nn, mindspore.ops, mindspore.numpy module and etc, which do not support multi-thread compiling, recommend to replace it with python implemented operator like numpy etc. Here decrease 'num_parallel_workers' into 1.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Done in 15.54231882095337 seconds\n",
+      "Let the training begin\n",
+      "\n",
+      "Epoch 1/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "0it [00:00, ?it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "-\r"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "40it [01:41,  2.54s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tTrain Loss 7.3443\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "13it [00:04,  2.77it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1 complete! Validation Loss : 4.915086085979755\n",
+      "Best validation Loss improved from inf to 4.915086085979755\n",
+      "\n",
+      "Epoch 2/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "40it [00:49,  1.24s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tTrain Loss 3.2319\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "13it [00:04,  2.89it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 2 complete! Validation Loss : 1.8268253069657545\n",
+      "Best validation Loss improved from 4.915086085979755 to 1.8268253069657545\n",
+      "\n",
+      "Epoch 3/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "40it [00:48,  1.22s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tTrain Loss 1.1534\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "13it [00:04,  2.81it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 3 complete! Validation Loss : 0.5436725112108084\n",
+      "Best validation Loss improved from 1.8268253069657545 to 0.5436725112108084\n",
+      "\n",
+      "Epoch 4/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "40it [00:48,  1.21s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tTrain Loss 0.3363\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "13it [00:04,  2.92it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 4 complete! Validation Loss : 0.20180132755866417\n",
+      "Best validation Loss improved from 0.5436725112108084 to 0.20180132755866417\n",
+      "\n",
+      "Epoch 5/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "40it [00:52,  1.31s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tTrain Loss 0.1522\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "13it [00:04,  2.79it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 5 complete! Validation Loss : 0.1140028633750402\n",
+      "Best validation Loss improved from 0.20180132755866417 to 0.1140028633750402\n",
+      "\n",
+      "Epoch 6/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "40it [00:50,  1.27s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tTrain Loss 0.0940\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "13it [00:04,  2.75it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 6 complete! Validation Loss : 0.07747195661067963\n",
+      "Best validation Loss improved from 0.1140028633750402 to 0.07747195661067963\n",
+      "\n",
+      "Epoch 7/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "40it [00:50,  1.26s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tTrain Loss 0.0668\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "13it [00:04,  2.74it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 7 complete! Validation Loss : 0.05752776018702067\n",
+      "Best validation Loss improved from 0.07747195661067963 to 0.05752776018702067\n",
+      "\n",
+      "Epoch 8/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "40it [00:51,  1.29s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tTrain Loss 0.0514\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "13it [00:04,  2.92it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 8 complete! Validation Loss : 0.045433574284498505\n",
+      "Best validation Loss improved from 0.05752776018702067 to 0.045433574284498505\n",
+      "\n",
+      "Epoch 9/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "40it [00:50,  1.27s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tTrain Loss 0.0413\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "13it [00:04,  2.77it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 9 complete! Validation Loss : 0.03752241713496355\n",
+      "Best validation Loss improved from 0.045433574284498505 to 0.03752241713496355\n",
+      "\n",
+      "Epoch 10/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "40it [00:50,  1.25s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tTrain Loss 0.0345\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "13it [00:04,  2.94it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 10 complete! Validation Loss : 0.03150226190113104\n",
+      "Best validation Loss improved from 0.03752241713496355 to 0.03150226190113104\n",
+      "\n",
+      "Epoch 11/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "40it [00:49,  1.24s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tTrain Loss 0.0294\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "13it [00:04,  2.91it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 11 complete! Validation Loss : 0.027369202186281864\n",
+      "Best validation Loss improved from 0.03150226190113104 to 0.027369202186281864\n",
+      "\n",
+      "Epoch 12/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "40it [00:49,  1.23s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tTrain Loss 0.0258\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "13it [00:04,  2.65it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 12 complete! Validation Loss : 0.024082990936361827\n",
+      "Best validation Loss improved from 0.027369202186281864 to 0.024082990936361827\n",
+      "\n",
+      "Epoch 13/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "40it [00:48,  1.21s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tTrain Loss 0.0230\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "13it [00:04,  2.76it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 13 complete! Validation Loss : 0.021563996345951006\n",
+      "Best validation Loss improved from 0.024082990936361827 to 0.021563996345951006\n",
+      "\n",
+      "Epoch 14/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "40it [00:50,  1.26s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tTrain Loss 0.0206\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "13it [00:04,  2.79it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 14 complete! Validation Loss : 0.019490097291194476\n",
+      "Best validation Loss improved from 0.021563996345951006 to 0.019490097291194476\n",
+      "\n",
+      "Epoch 15/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "40it [00:50,  1.26s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tTrain Loss 0.0188\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "13it [00:04,  2.95it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 15 complete! Validation Loss : 0.018077760504988525\n",
+      "Best validation Loss improved from 0.019490097291194476 to 0.018077760504988525\n",
+      "\n",
+      "Epoch 16/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "40it [00:48,  1.22s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tTrain Loss 0.0172\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "13it [00:04,  2.78it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 16 complete! Validation Loss : 0.01667449616182309\n",
+      "Best validation Loss improved from 0.018077760504988525 to 0.01667449616182309\n",
+      "\n",
+      "Epoch 17/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "40it [00:48,  1.21s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tTrain Loss 0.0160\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "13it [00:04,  2.77it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 17 complete! Validation Loss : 0.015317266162198324\n",
+      "Best validation Loss improved from 0.01667449616182309 to 0.015317266162198324\n",
+      "\n",
+      "Epoch 18/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "40it [00:48,  1.21s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tTrain Loss 0.0149\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "13it [00:04,  2.72it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 18 complete! Validation Loss : 0.014371497556567192\n",
+      "Best validation Loss improved from 0.015317266162198324 to 0.014371497556567192\n",
+      "\n",
+      "Epoch 19/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "40it [00:49,  1.24s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tTrain Loss 0.0139\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "13it [00:04,  2.84it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 19 complete! Validation Loss : 0.013473815069748806\n",
+      "Best validation Loss improved from 0.014371497556567192 to 0.013473815069748806\n",
+      "\n",
+      "Epoch 20/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "40it [00:47,  1.19s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tTrain Loss 0.0132\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "13it [00:04,  2.86it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 20 complete! Validation Loss : 0.012598874477239756\n",
+      "Best validation Loss improved from 0.013473815069748806 to 0.012598874477239756\n",
+      "Done in 1139.0716316699982 seconds\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from types import SimpleNamespace\n",
+    "\n",
+    "args = SimpleNamespace()\n",
+    "args.device_target = 'Ascend'\n",
+    "args.device_id = 0\n",
+    "args.model_name_or_path = 'Salesforce/blip-image-captioning-base'\n",
+    "args.dataset_name_or_path = 'eeshclusive/captionary-dataset'\n",
+    "args.batch_size = 4\n",
+    "args.max_eps = 20\n",
+    "args.save_path = None\n",
+    "\n",
+    "main(args)"
+   ]
+  }
+ ],
+ "metadata": {
+  "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.9.18"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/llm/finetune/blip/results_visible.ipynb b/llm/finetune/blip/results_visible.ipynb
new file mode 100644
index 000000000..c0b823016
--- /dev/null
+++ b/llm/finetune/blip/results_visible.ipynb
@@ -0,0 +1,94 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "train_loss_orig = [8.1256, 3.1276, 1.4304, 1.3708, 1.3636, 1.3608, 1.3595, 1.3589, 1.3585, 1.3583, 1.3582, 1.3581, 1.3580, 1.3580, 1.3580, 1.3579, 1.3579, 1.3579, 1.3579, 1.3579]\n",
+    "val_loss_orig = [5.3221, 1.5943, 1.3788, 1.3662, 1.3631, 1.3605, 1.3596, 1.3591, 1.3589, 1.3586, 1.3586, 1.3585, 1.3585, 1.3584, 1.3584, 1.3584, 1.3584, 1.3584, 1.3584, 1.3584]\n",
+    "\n",
+    "train_loss_torch = [8.1981, 2.1381, 0.1474, 0.0526, 0.0347, 0.0258, 0.0207, 0.0175, 0.0151, 0.0135, 0.0121, 0.0111, 0.0104, 0.0097, 0.0092, 0.0088, 0.0082, 0.0078, 0.0077, 0.0073]\n",
+    "val_loss_torch = [4.6963, 0.3585, 0.0691, 0.0406, 0.0290, 0.0228, 0.0187, 0.0163, 0.0140, 0.0125, 0.0115, 0.0105, 0.0098, 0.0095, 0.0090, 0.0084, 0.0078, 0.0078, 0.0076, 0.0073]\n",
+    "\n",
+    "train_loss_mindspore = [7.3443, 3.2319, 1.1534, 0.3363, 0.1522, 0.094, 0.0668, 0.0514, 0.0413, 0.0345, 0.0294, 0.0258, 0.023, 0.0206, 0.0188, 0.0172, 0.016, 0.0149, 0.0139, 0.0132]\n",
+    "val_loss_mindspore = [4.9151, 1.8268, 0.5437, 0.2018, 0.114, 0.0775, 0.0575, 0.0454, 0.0375, 0.0315, 0.0274, 0.0241, 0.0216, 0.0195, 0.0181, 0.0167, 0.0153, 0.0144, 0.0135, 0.0126]\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "def plot_losses(epochs_to_plot):\n",
+    "    epochs = range(1, len(train_loss_orig) + 1)\n",
+    "    plt.figure(figsize=(10, 10))\n",
+    "\n",
+    "    # Plot for original losses\n",
+    "    plt.subplot(2, 2, 1)\n",
+    "    plt.plot(epochs[:epochs_to_plot], train_loss_orig[:epochs_to_plot], 'r-', label='Train Loss Orig')\n",
+    "    plt.plot(epochs[:epochs_to_plot], val_loss_orig[:epochs_to_plot], 'g-', label='Val Loss Orig')\n",
+    "    plt.xlabel('Epochs')\n",
+    "    plt.ylabel('Loss')\n",
+    "    plt.title('Original Losses')\n",
+    "    plt.legend()\n",
+    "    plt.ylim(0, 9)  # 设置纵坐标范围\n",
+    "\n",
+    "    # Plot for torch losses\n",
+    "    plt.subplot(2, 2, 2)\n",
+    "    plt.plot(epochs[:epochs_to_plot], train_loss_torch[:epochs_to_plot], 'r-', label='Train Loss Torch')\n",
+    "    plt.plot(epochs[:epochs_to_plot], val_loss_torch[:epochs_to_plot], 'g-', label='Val Loss Torch')\n",
+    "    plt.xlabel('Epochs')\n",
+    "    plt.ylabel('Loss')\n",
+    "    plt.title('Torch Losses')\n",
+    "    plt.legend()\n",
+    "    plt.ylim(0, 9)  # 设置纵坐标范围\n",
+    "\n",
+    "    # Plot for mindspore losses\n",
+    "    plt.subplot(2, 2, 3)\n",
+    "    plt.plot(epochs[:epochs_to_plot], train_loss_mindspore[:epochs_to_plot], 'r-', label='Train Loss Mindspore')\n",
+    "    plt.plot(epochs[:epochs_to_plot], val_loss_mindspore[:epochs_to_plot], 'g-', label='Val Loss Mindspore')\n",
+    "    plt.xlabel('Epochs')\n",
+    "    plt.ylabel('Loss')\n",
+    "    plt.title('Mindspore Losses')\n",
+    "    plt.legend()\n",
+    "    plt.ylim(0, 9)  # 设置纵坐标范围\n",
+    "\n",
+    "    plt.tight_layout()\n",
+    "    plt.show()\n",
+    "\n",
+    "# Example usage:\n",
+    "plot_losses(10)\n",
+    "\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "llm_torch251",
+   "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.15"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

From 634c8dae29f4f51fd557c550c0984c8227b3a4f4 Mon Sep 17 00:00:00 2001
From: Alemax067 <2657236382@qq.com>
Date: Mon, 24 Feb 2025 15:56:14 +0800
Subject: [PATCH 2/2] =?UTF-8?q?=E5=88=A0=E9=99=A4=E5=A4=9A=E4=BD=99?=
 =?UTF-8?q?=E7=A9=BA=E6=A0=BC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 llm/finetune/blip/blip_finetune.ipynb   | 16 ++++++++--------
 llm/finetune/blip/results_visible.ipynb |  5 ++---
 2 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/llm/finetune/blip/blip_finetune.ipynb b/llm/finetune/blip/blip_finetune.ipynb
index 54f58edcd..0d74744a9 100644
--- a/llm/finetune/blip/blip_finetune.ipynb
+++ b/llm/finetune/blip/blip_finetune.ipynb
@@ -103,7 +103,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "38a964f9",
    "metadata": {},
    "outputs": [],
@@ -121,7 +121,7 @@
     "        self.run_eval = eval_dataset is not None\n",
     "        if self.run_eval:\n",
     "            self.eval_dataset = eval_dataset\n",
-    "    \n",
+    "\n",
     "    def forward_fn(self, input_ids, pixel_values, attention_mask):\n",
     "        outputs = self.net(input_ids=input_ids, pixel_values=pixel_values, attention_mask=attention_mask, labels=input_ids)\n",
     "        loss = outputs.loss\n",
@@ -144,15 +144,15 @@
     "                input_ids = batch[\"input_ids\"]\n",
     "                pixel_values = batch[\"pixel_values\"].squeeze(1)\n",
     "                attention_mask = batch[\"attention_mask\"]\n",
-    "                \n",
+    "\n",
     "                loss = self.train_single(input_ids, pixel_values, attention_mask)\n",
-    "                \n",
+    "\n",
     "                tloss = tloss + loss.asnumpy()\n",
     "                step = step + 1\n",
-    "                \n",
+    "\n",
     "            tloss /= step\n",
     "            print(\"\\tTrain Loss {:.04f}\".format(tloss))\n",
-    "            \n",
+    "\n",
     "            if self.run_eval:\n",
     "                self.net.set_train(False)\n",
     "                val_loss = self.val()\n",
@@ -163,7 +163,7 @@
     "                    if self.args.save_path is not None:\n",
     "                        print(\"saving model...\")\n",
     "                        save_checkpoint(self.net, self.args.save_path + 'best_model.ckpt')\n",
-    "    \n",
+    "\n",
     "    def val(self):\n",
     "        vloss = 0\n",
     "        step = 0\n",
@@ -175,7 +175,7 @@
     "\n",
     "                outputs = self.net(input_ids=input_ids, pixel_values=pixel_values, attention_mask=attention_mask, labels=input_ids)\n",
     "                loss = outputs.loss\n",
-    "                    \n",
+    "\n",
     "                vloss = vloss + loss.asnumpy()\n",
     "                step = step + 1\n",
     "\n",
diff --git a/llm/finetune/blip/results_visible.ipynb b/llm/finetune/blip/results_visible.ipynb
index c0b823016..1767c3ebb 100644
--- a/llm/finetune/blip/results_visible.ipynb
+++ b/llm/finetune/blip/results_visible.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -65,8 +65,7 @@
     "    plt.show()\n",
     "\n",
     "# Example usage:\n",
-    "plot_losses(10)\n",
-    "\n"
+    "plot_losses(10)"
    ]
   }
  ],