Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+SimHei.ttf filter=lfs diff=lfs merge=lfs -text
+examples/dubai.png filter=lfs diff=lfs merge=lfs -text
+examples/liuxiang.mp4 filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,290 @@
+---
+license: other
+pipeline_tag: visual-question-answering
+---
+
+
+<p align="center">
+    <img src="logo_en.png" width="600"/>
+<p>
+
+<p align="center">
+    <b><font size="6">InternLM-XComposer-2.5</font></b> 
+<p>
+
+<div align="center">
+
+[💻Github Repo](https://github.com/InternLM/InternLM-XComposer)
+
+[Online Demo](https://huggingface.co/spaces/Willow123/InternLM-XComposer)
+
+[Paper](https://huggingface.co/papers/2407.03320)
+
+</div>
+
+**InternLM-XComposer2.5** excels in various text-image comprehension and composition applications, achieving GPT-4V level capabilities with merely 7B LLM backend. IXC2.5 is trained with 24K interleaved image-text contexts, it can seamlessly extend to 96K long contexts via RoPE extrapolation. This long-context capability allows IXC-2.5 to excel in tasks requiring extensive input and output contexts. 
+
+
+### Import from Transformers
+To load the InternLM-XComposer2-4KHD model using Transformers, use the following code:
+```python
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+ckpt_path = "internlm/internlm-xcomposer2d5-7b"
+tokenizer = AutoTokenizer.from_pretrained(ckpt_path, trust_remote_code=True).cuda()
+# Set `torch_dtype=torch.floatb16` to load model in bfloat16, otherwise it will be loaded as float32 and might cause OOM Error.
+model = AutoModelForCausalLM.from_pretrained(ckpt_path, torch_dtype=torch.bfloat16, trust_remote_code=True).cuda()
+model = model.eval()
+```
+
+## Quickstart
+
+We provide a simple example to show how to use InternLM-XComposer2.5 with 🤗 Transformers. 
+
+<details>
+  <summary>
+    <b>Video Understanding</b>
+  </summary>
+
+```python
+import torch
+from transformers import AutoModel, AutoTokenizer
+
+torch.set_grad_enabled(False)
+
+# init model and tokenizer
+model = AutoModel.from_pretrained('internlm/internlm-xcomposer2d5-7b', torch_dtype=torch.bfloat16, trust_remote_code=True).cuda().eval()
+tokenizer = AutoTokenizer.from_pretrained('internlm/internlm-xcomposer2d5-7b', trust_remote_code=True)
+model.tokenizer = tokenizer
+
+query = 'Here are some frames of a video. Describe this video in detail'
+image = ['./examples/liuxiang.mp4',]
+with torch.autocast(device_type='cuda', dtype=torch.float16):
+    response, his = model.chat(tokenizer, query, image, do_sample=False, num_beams=3, use_meta=True)
+print(response)
+#The video opens with a shot of an athlete, dressed in a red and yellow uniform with the word "CHINA" emblazoned across the front, preparing for a race. 
+#The athlete, Liu Xiang, is seen in a crouched position, focused and ready, with the Olympic rings visible in the background, indicating the prestigious setting of the Olympic Games. As the race commences, the athletes are seen sprinting towards the hurdles, their determination evident in their powerful strides. 
+#The camera captures the intensity of the competition, with the athletes' numbers and times displayed on the screen, providing a real-time update on their performance. The race reaches a climax as Liu Xiang, still in his red and yellow uniform, triumphantly crosses the finish line, his arms raised in victory. 
+#The crowd in the stands erupts into cheers, their excitement palpable as they witness the athlete's success. The video concludes with a close-up shot of Liu Xiang, still basking in the glory of his victory, as the Olympic rings continue to symbolize the significance of the event.
+
+query = 'tell me the athlete code of Liu Xiang'
+image = ['./examples/liuxiang.mp4',]
+with torch.autocast(device_type='cuda', dtype=torch.float16):
+    response, _ = model.chat(tokenizer, query, image, history=his, do_sample=False, num_beams=3, use_meta=True)
+print(response)
+#The athlete code of Liu Xiang, as displayed on his uniform in the video, is "1363".
+```
+
+</details>
+
+<details>
+  <summary>
+    <b>Multi-Image Mutli-Tune Dialog</b>
+  </summary>
+
+```python
+import torch
+from transformers import AutoModel, AutoTokenizer
+
+torch.set_grad_enabled(False)
+
+# init model and tokenizer
+model = AutoModel.from_pretrained('internlm/internlm-xcomposer2d5-7b', torch_dtype=torch.bfloat16, trust_remote_code=True).cuda().eval()
+tokenizer = AutoTokenizer.from_pretrained('internlm/internlm-xcomposer2d5-7b', trust_remote_code=True)
+model.tokenizer = tokenizer
+
+query = 'Image1 <ImageHere>; Image2 <ImageHere>; Image3 <ImageHere>; I want to buy a car from the three given cars, analyze their advantages and weaknesses one by one'
+image = ['./examples/cars1.jpg',
+        './examples/cars2.jpg',
+        './examples/cars3.jpg',]
+with torch.autocast(device_type='cuda', dtype=torch.float16):
+    response, his = model.chat(tokenizer, query, image, do_sample=False, num_beams=3, use_meta=True)
+print(response)
+#To analyze the advantages and disadvantages of each car, we need to consider factors such as brand reputation, performance, design, cost, and maintenance. 
+#1. Mercedes-Benz: - Advantages: Known for its luxury and reliability, the Mercedes-Benz brand offers a high level of comfort, advanced technology, and superior craftsmanship. The vehicle in the image appears to be an SUV, which is versatile for both city driving and off-road conditions. - Disadvantages: Typically, Mercedes-Benz vehicles are more expensive compared to other brands, and they may require more frequent maintenance due to their luxury status. 
+#2. Bugatti: - Advantages: Bugatti is renowned for producing some of the fastest and most powerful cars in the world. The vehicle in the image is a sports car, likely offering an exhilarating driving experience with its high-performance engine and advanced aerodynamics. - Disadvantages: Bugatti cars are extremely expensive, making them less accessible to the average consumer. They also require specialized knowledge for maintenance and may not be suitable for everyday driving due to their high-performance nature. 
+#3. BMW: - Advantages: BMW is a well-respected manufacturer known for its innovative engineering and design. The car in the image appears to be an electric vehicle (EV), which offers advantages such as lower emissions, reduced noise pollution, and potentially lower operating costs. - Disadvantages: EVs like the one in the image may have a shorter range compared to traditional gasoline-powered vehicles, limiting their suitability for long-distance travel. 
+#Additionally, the initial cost of purchasing an EV can be higher than that of a conventional car. In conclusion, each car has its own set of advantages and disadvantages. The Mercedes-Benz offers luxury and versatility, the Bugatti provides high performance and exclusivity, and the BMW represents innovation in electric vehicle technology. The choice ultimately depends on the buyer's priorities, such as comfort, performance, environmental impact, and budget.
+
+query = 'Image4 <ImageHere>; How about the car in Image4'
+image.append('./examples/cars4.jpg')        
+with torch.autocast(device_type='cuda', dtype=torch.float16):
+    response, _ = model.chat(tokenizer, query, image, do_sample=False, num_beams=3, history= his, use_meta=True)
+print(response)
+#The car in Image4 is a red sports car, which appears to be a Ferrari. Ferrari is a renowned Italian manufacturer known for producing some of the most iconic and high-performance sports cars in the world. - Advantages: Ferrari vehicles are synonymous with speed, luxury, and engineering excellence. 
+#The car in the image likely offers an exhilarating driving experience with its powerful engine, advanced aerodynamics, and high-quality craftsmanship. The red color adds to the car's aesthetic appeal, making it stand out on the road. - Disadvantages: Ferrari cars are extremely expensive, making them less accessible to the average consumer. 
+#They also require specialized knowledge for maintenance and may not be suitable for everyday driving due to their high-performance nature. In conclusion, the Ferrari in Image4 represents a pinnacle of automotive engineering and design, offering unmatched performance and luxury. 
+#However, its high cost and specialized maintenance requirements make it less practical for everyday use compared to the other vehicles in the images.
+```
+
+
+</details>
+
+<details>
+  <summary>
+    <b>High Resolution Image Understanding</b>
+  </summary>
+
+```python
+import torch
+from transformers import AutoModel, AutoTokenizer
+
+torch.set_grad_enabled(False)
+
+# init model and tokenizer
+model = AutoModel.from_pretrained('internlm/internlm-xcomposer2d5-7b', torch_dtype=torch.bfloat16, trust_remote_code=True).cuda().eval()
+tokenizer = AutoTokenizer.from_pretrained('internlm/internlm-xcomposer2d5-7b', trust_remote_code=True)
+model.tokenizer = tokenizer
+
+query = 'Analyze the given image in a detail manner'
+image = ['./examples/dubai.png']
+with torch.autocast(device_type='cuda', dtype=torch.float16):
+    response, _ = model.chat(tokenizer, query, image, do_sample=False, num_beams=3, use_meta=True)
+print(response)
+#The infographic is a visual representation of various facts about Dubai. It begins with a statement about Palm Jumeirah, highlighting it as the largest artificial island visible from space. It then provides a historical context, noting that in 1968, there were only a few cars in Dubai, contrasting this with the current figure of more than 1.5 million vehicles. 
+#The infographic also points out that Dubai has the world's largest Gold Chain, with 7 of the top 10 tallest hotels located there. Additionally, it mentions that the crime rate is near 0%, and the income tax rate is also 0%, with 20% of the world's total cranes operating in Dubai. Furthermore, it states that 17% of the population is Emirati, and 83% are immigrants.
+#The Dubai Mall is highlighted as the largest shopping mall in the world, with 1200 stores. The infographic also notes that Dubai has no standard address system, with no zip codes, area codes, or postal services. It mentions that the Burj Khalifa is so tall that its residents on top floors need to wait longer to break fast during Ramadan. 
+#The infographic also includes information about Dubai's climate-controlled City, with the Royal Suite at Burj Al Arab costing $24,000 per night. Lastly, it notes that the net worth of the four listed billionaires is roughly equal to the GDP of Honduras.
+
+```
+
+</details>
+
+
+<details>
+  <summary>
+    <b>Instruction to Webpage</b>
+  </summary>
+
+```python
+import torch
+from transformers import AutoModel, AutoTokenizer
+
+torch.set_grad_enabled(False)
+
+# init model and tokenizer
+model = AutoModel.from_pretrained('internlm/internlm-xcomposer2d5-7b', torch_dtype=torch.bfloat16, trust_remote_code=True).cuda().eval()
+tokenizer = AutoTokenizer.from_pretrained('internlm/internlm-xcomposer2d5-7b', trust_remote_code=True)
+model.tokenizer = tokenizer
+
+query = 'A website for Research institutions. The name is Shanghai AI lab. Top Navigation Bar is blue.Below left, an image shows the logo of the lab. In the right, there is a passage of text below that describes the mission of the laboratory.There are several images to show the research projects of Shanghai AI lab.'
+with torch.autocast(device_type='cuda', dtype=torch.float16):
+    response = model.write_webpage(query, seed=202, task='Instruction-aware Webpage Generation', repetition_penalty=3.0)
+print(response)
+# see the Instruction-aware Webpage Generation.html 
+```
+ 
+See the [Instruction to Webpage](https://github.com/InternLM/InternLM-XComposer/blob/main/examples/Instruction-aware_Webpage_Generation.html) results here.
+</details>
+
+<details>
+  <summary>
+    <b>Resume to Webpage</b>
+  </summary>
+
+```python
+import torch
+from transformers import AutoModel, AutoTokenizer
+
+torch.set_grad_enabled(False)
+
+# init model and tokenizer
+model = AutoModel.from_pretrained('internlm/internlm-xcomposer2d5-7b', torch_dtype=torch.bfloat16, trust_remote_code=True).cuda().eval()
+tokenizer = AutoTokenizer.from_pretrained('internlm/internlm-xcomposer2d5-7b', trust_remote_code=True)
+model.tokenizer = tokenizer
+
+## the input should be a resume in markdown format
+query = './examples/resume.md'
+with torch.autocast(device_type='cuda', dtype=torch.float16):
+    response = model.resume_2_webpage(query, seed=202, repetition_penalty=3.0)
+print(response)
+```
+See the [Resume to Webpage](https://github.com/InternLM/InternLM-XComposer/blob/main/examples/Resume-to-Personal_Page.html) results here.
+
+
+</details>
+
+
+<details>
+  <summary>
+    <b>Screenshot to Webpage</b>
+  </summary>
+
+```python
+import torch
+from transformers import AutoModel, AutoTokenizer
+
+torch.set_grad_enabled(False)
+
+# init model and tokenizer
+model = AutoModel.from_pretrained('internlm/internlm-xcomposer2d5-7b', torch_dtype=torch.bfloat16, trust_remote_code=True).cuda().eval()
+tokenizer = AutoTokenizer.from_pretrained('internlm/internlm-xcomposer2d5-7b', trust_remote_code=True)
+model.tokenizer = tokenizer
+
+query = 'Generate the HTML code of this web image with Tailwind CSS.'
+image = ['./examples/screenshot.jpg']
+with torch.autocast(device_type='cuda', dtype=torch.float16):
+    response = model.screen_2_webpage(query, image, seed=202, repetition_penalty=3.0)
+print(response)
+```
+See the [Screenshot to Webpage](https://github.com/InternLM/InternLM-XComposer/blob/main/examples/Screenshot-to-Webpage.html) results here.
+
+</details>
+
+
+
+<details>
+  <summary>
+    <b>Write Article</b>
+  </summary>
+
+```python
+import torch
+from transformers import AutoModel, AutoTokenizer
+
+torch.set_grad_enabled(False)
+
+# init model and tokenizer
+model = AutoModel.from_pretrained('internlm/internlm-xcomposer2d5-7b', torch_dtype=torch.bfloat16, trust_remote_code=True).cuda().eval()
+tokenizer = AutoTokenizer.from_pretrained('internlm/internlm-xcomposer2d5-7b', trust_remote_code=True)
+model.tokenizer = tokenizer
+
+query = '阅读下面的材料，根据要求写作。 电影《长安三万里》的出现让人感慨，影片并未将重点全落在大唐风华上，也展现了恢弘气象的阴暗面，即旧门阀的资源垄断、朝政的日益衰败与青年才俊的壮志难酬。高适仕进无门，只能回乡>沉潜修行。李白虽得玉真公主举荐，擢入翰林，但他只是成为唐玄宗的御用文人，不能真正实现有益于朝政的志意。然而，片中高潮部分《将进酒》一节，人至中年、挂着肚腩的李白引众人乘仙鹤上天，一路从水面、瀑布飞升至银河进入仙>宫，李白狂奔着与仙人们碰杯，最后大家纵身飞向漩涡般的九重天。肉身的微贱、世路的“天生我材必有用，坎坷，拘不住精神的高蹈。“天生我材必有用，千金散尽还复来。” 古往今来，身处闲顿、遭受挫折、被病痛折磨，很多人都曾经历>了人生的“失意”，却反而成就了他们“诗意”的人生。对正在追求人生价值的当代青年来说，如何对待人生中的缺憾和困顿?诗意人生中又有怎样的自我坚守和自我认同?请结合“失意”与“诗意”这两个关键词写一篇文章。 要求:选准角度，确定>立意，明确文体，自拟标题;不要套作，不得抄袭;不得泄露个人信息;不少于 800 字。'
+with torch.autocast(device_type='cuda', dtype=torch.float16):
+    response = model.write_artical(query, seed=8192)
+print(response)
+#诗意人生，贵在坚守
+#《菜根谭》有云:“闲时要有吃紧的心思,忙里要留吃闲工夫。”人生在世,总有失意之时,当面对缺憾和困顿,诗意地生活着才能为人生增添一抹亮色。何谓诗意地生活? 所谓诗意地生活，便是在于坚守本心、直面遗憾、超越自我,在失意中寻找人生价值。
+#诗意地生活,需坚守本心,淡然处之。
+#陶渊明曾执意辞去彭泽县令,归隐田园,“采菊东篱下,悠然见南山”,在山水间寄情自娱；王维面对仕途失意,终日沉醉于诗酒之中,“兴来每独往,胜事空自知”,在诗酒中闲逸自如;李白仕途不顺,被赐金放还,但他依旧豪气干云,“天生我才必有用,千金散尽还复来”,在失意中坦然豁达。坚守本心，便能在遭遇失意之时守住自己的精神家园,让生活充满诗意。反之,若不能坚守本心,而只是一味迎合世俗以求得升迁,那纵使身居高位,亦会丧失生活的乐趣。
+#诗意地生活,需直面遗憾,超越自我。
+#“西塞山前白鹭飞,桃花流水鳜鱼肥。青箬笠,绿柳枝,半斤酒,一纶丝。五湖四海皆如此,何妨到此处归。”白居易的《渔歌子》写出了多少人的愿望:没有权势纷扰,没有贫困凄凉,只有青山绿水、白鹭鸥鸟作伴,如此自由自在的生活令人神往。然而,白居易却并没有因此真的归隐山林,而是直面人生,超越自我,写下了一首首诗意而富有现实关怀的作品。如果白居易只顾逃避人生,那又怎会拥有“大弦嘈嘈如急雨,小弦切切如私语”的绝美比喻呢?如果白居易只顾归隐山林,那又怎会写出“此曲只应天上有,人间哪得配白居易”这样的诗句呢?
+#诗意地生活,需直面遗憾,坚守本心。
+#李文波患有渐冻症,医生说他活不过五年,但他没有因此放弃对音乐的热爱,而是与病魔作斗争,演奏出美妙的乐曲;孙家林自幼患有脑瘫,但他不甘于命运的捉弄,终成全国最美教师;史铁生饱受疾病折磨,但他仍能发出“我常常在我的心头清点,我有什么?”的叩问,并由此走上文学道路,为后世留下丰厚的文化遗产。这些人没有逃避,而是选择直面人生的缺憾,在坚守本心的同时超越自我,最终实现了自己的价值。
+#诗意地生活,是于失意中坚守本心,于缺憾中超越自我。当面对人生的缺憾与挫折,坚守本心、超越自我的同时,也必将书写属于自己的辉煌篇章。
+#愿你我都能诗意地生活着!
+
+query = 'Please write a blog based on the title: French Pastries: A Sweet Indulgence'
+with torch.autocast(device_type='cuda', dtype=torch.float16):
+    response = model.write_artical(query, seed=8192)
+print(response)
+#French Pastries: A Sweet Indulgence
+#The French are well known for their love of pastries, and it’s a love that is passed down through generations. When one visits France, they are treated to an assortment of baked goods that can range from the delicate macaron to the rich and decadent chocolate mousse. While there are many delicious types of pastries found in France, five stand out as being the most iconic. Each of these pastries has its own unique qualities that make it special.
+#1. Croissant
+#One of the most famous pastries from France is the croissant. It is a buttery, flaky pastry that is best enjoyed fresh from the bakery. The dough is laminated with butter, giving it its signature layers. Croissants are typically eaten for breakfast or brunch, often accompanied by coffee or hot chocolate.
+#2. Macaron
+#The macaron is a small, delicate French confection made from almond flour, powdered sugar, and egg whites. The macaron itself is sandwiched with a ganache or jam filling. They come in a variety of colors and flavors, making them a popular choice for both casual snacking and upscale desserts.
+#3. Madeleine
+#The madeleine is a small shell-shaped cake that is light and sponge-like. It is often flavored with lemon or orange zest and sometimes dipped in chocolate. Madeleines are perfect for an afternoon snack with tea or coffee.
+#4. Éclair
+#The éclair is a long, thin pastry filled with cream and topped with chocolate glaze. It is a classic French treat that is both sweet and satisfying. Éclairs can be found in bakeries all over France and are often enjoyed with a cup of hot chocolate.
+#5. Tarte Tatin
+#The tarte Tatin is an apple tart that is known for its caramelized apples and puff pastry crust. It is named after the Tatin sisters who created the recipe in the late 19th century. Tarte Tatin is best served warm with a scoop of vanilla ice cream.
+#These pastries are just a few of the many delicious treats that France has to offer. Whether you are a seasoned traveler or a first-time visitor, indulging in French pastries is a must-do activity. So go ahead, treat yourself—you deserve it!
+```
+
+</details>
+
+
+### Open Source License
+The code is licensed under Apache-2.0, while model weights are fully open for academic research and also allow free commercial usage. To apply for a commercial license, please fill in the application form (English)/申请表（中文）. For other questions or collaborations, please contact internlm@pjlab.org.cn.

SimHei.ttf

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

added_tokens.json

@@ -0,0 +1,8 @@
+{
+  "<|action_end|>": 92547,
+  "<|action_start|>": 92546,
+  "<|im_end|>": 92545,
+  "<|im_start|>": 92544,
+  "<|interpreter|>": 92548,
+  "<|plugin|>": 92549
+}

build_mlp.py

@@ -0,0 +1,271 @@
+import math
+import re
+
+import torch
+import torch.nn as nn
+from transformers import CLIPVisionModel
+
+
+def build_vision_tower():
+    vision_tower = "internlm/internlm-xcomposer2d5-clip"
+    return CLIPVisionTower(vision_tower)
+
+
+def build_vision_projector():
+    projector_type = "mlp2x_gelu"
+    mm_hidden_size = 4096
+    mid_hidden_size = 4096
+    hidden_size = 4096
+
+    mlp_gelu_match = re.match(r"^mlp(\d+)x_gelu$", projector_type)
+    if mlp_gelu_match:
+        mlp_depth = int(mlp_gelu_match.group(1))
+        modules = [nn.Linear(mm_hidden_size, mid_hidden_size)]
+        for _ in range(1, mlp_depth):
+            modules.append(nn.GELU())
+            modules.append(nn.Linear(mid_hidden_size, mid_hidden_size))
+
+        return nn.Sequential(*modules)
+
+    if projector_type == "identity":
+        return IdentityMap()
+
+    raise ValueError(f"Unknown projector type: {projector_type}")
+
+
+class IdentityMap(nn.Module):
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, x, *args, **kwargs):
+        return x
+
+    @property
+    def config(self):
+        return {"mm_projector_type": "identity"}
+
+
+class CLIPVisionTower(nn.Module):
+    def __init__(self, vision_tower):
+        super().__init__()
+
+        self.is_loaded = False
+
+        self.vision_tower_name = vision_tower
+        # self.conv_dim = 8192
+        # self.conv = torch.nn.Conv2d(1024, self.conv_dim,3,2,1)
+        self.select_layer = -1
+        self.select_feature = "patch"
+        self.load_model()
+
+    def load_model(self):
+        self.vision_tower = CLIPVisionModel.from_pretrained(self.vision_tower_name)
+        self.vision_tower.requires_grad_(False)
+
+        self.is_loaded = True
+
+    def resize_pos(self):
+        print("Dummy Resized")
+
+    def feature_select(self, image_forward_outs):
+        image_features = image_forward_outs.hidden_states[self.select_layer]
+        if self.select_feature == "patch":
+            image_features = image_features[:, 1:]
+        elif self.select_feature == "cls_patch":
+            image_features = image_features
+        else:
+            raise ValueError(f"Unexpected select feature: {self.select_feature}")
+        return image_features
+
+    def forward(self, images, glb_GN, sub_GN) -> tuple[torch.Tensor, list[int]]:
+        if not self.is_loaded:
+            self.load_model()
+        assert type(images) is list
+        shapes = []
+        input_imgs = []
+        for img in images:
+            _, C, H, W = img.shape
+            shapes.append([H // 560, W // 560])
+            sub_img = (
+                img.reshape(1, 3, H // 560, 560, W // 560, 560)
+                .permute(0, 2, 4, 1, 3, 5)
+                .reshape(-1, 3, 560, 560)
+                .contiguous()
+            )
+            glb_img = torch.nn.functional.interpolate(
+                img.float(),
+                size=(560, 560),
+                mode="bicubic",
+            ).to(sub_img.dtype)
+            input_imgs.append(glb_img)
+            input_imgs.append(sub_img)
+        input_imgs = torch.cat(input_imgs, dim=0)
+
+        image_forward_outs = self.vision_tower(
+            input_imgs.to(device=self.device, dtype=self.dtype),
+            output_hidden_states=True,
+        )
+        image_features = self.feature_select(image_forward_outs).to(
+            input_imgs.dtype
+        )  ### B*?, N, C
+        _, N, C = image_features.shape
+        H = int(math.sqrt(N))
+        assert N == 40**2
+
+        output_imgs = []
+        output_len = []
+        for [h, w] in shapes:
+            B_ = h * w
+            glb_img = image_features[:1]  ### 1, N, C
+            glb_img = (
+                glb_img.reshape(1, H, H, C)
+                .reshape(1, H // 2, 2, H // 2, 2, C)
+                .contiguous()
+                .permute(0, 1, 3, 2, 4, 5)
+                .reshape(1, H // 2, H // 2, 4 * C)
+                .contiguous()
+            )
+            temp_glb_GN = sub_GN.repeat(1, H // 2, 1, 1)
+            glb_img = torch.cat([glb_img, temp_glb_GN], dim=2).reshape(1, -1, 4 * C)
+
+            sub_img = image_features[1 : 1 + B_]  ### ?, N, C
+            sub_img = (
+                sub_img.reshape(B_, H, H, C)
+                .reshape(B_, H // 2, 2, H // 2, 2, C)
+                .contiguous()
+                .permute(0, 1, 3, 2, 4, 5)
+                .reshape(B_, -1, 4 * C)
+                .contiguous()
+            )
+            sub_img = (
+                sub_img.reshape(1, h, w, 20, 20, -1)
+                .permute(0, 1, 3, 2, 4, 5)
+                .reshape(1, h * 20, w * 20, 4 * C)
+            )
+            temp_sub_GN = sub_GN.repeat(1, h * 20, 1, 1)
+            sub_img = torch.cat([sub_img, temp_sub_GN], dim=2).reshape(1, -1, 4 * C)
+
+            output_imgs.append(torch.cat([glb_img, glb_GN, sub_img], dim=1))
+            temp_len = int((h * w + 1) * 400 + 1 + (h + 1) * 20)
+            assert temp_len == output_imgs[-1].shape[1]
+            output_len.append(temp_len)
+
+            image_features = image_features[1 + h * w :]
+
+        output_imgs = torch.cat(output_imgs, dim=1)
+
+        return output_imgs, output_len
+
+    @property
+    def dummy_feature(self):
+        return torch.zeros(1, self.hidden_size, device=self.device, dtype=self.dtype)
+
+    @property
+    def dtype(self):
+        return self.vision_tower.dtype
+
+    @property
+    def device(self):
+        return self.vision_tower.device
+
+    @property
+    def config(self):
+        if self.is_loaded:
+            return self.vision_tower.config
+        else:
+            return self.cfg_only
+
+    @property
+    def hidden_size(self):
+        return self.config.hidden_size
+
+    @property
+    def num_patches(self):
+        return (self.config.image_size // self.config.patch_size) ** 2
+
+
+class PLoRA(nn.Linear):
+    def __init__(
+        self,
+        in_features: int,
+        out_features: int,
+        bias: bool = True,
+        device=None,
+        dtype=None,
+        lora_r=8,
+        lora_alpha=16,
+        lora_dropout=0.05,
+        lora_len=0,
+        **kwargs,
+    ) -> None:
+        super().__init__(in_features, out_features, bias, device, dtype)
+        self.lora_r = lora_r
+        self.lora_alpha = lora_alpha
+        self.lora_len = lora_len
+        if lora_dropout > 0.0:
+            self.lora_dropout = nn.Dropout(p=lora_dropout)
+        else:
+            self.lora_dropout = lambda x: x
+        self.lora_scaling = self.lora_alpha / self.lora_r
+
+        self.Plora_A = nn.Linear(
+            in_features, self.lora_r, bias=False, device=device, dtype=dtype
+        )
+        self.Plora_B = nn.Linear(
+            self.lora_r, out_features, bias=False, device=device, dtype=dtype
+        )
+
+        self.lora_sft_A = nn.Linear(
+            in_features, 256, bias=False, device=device, dtype=dtype
+        )
+        self.lora_sft_B = nn.Linear(
+            256, out_features, bias=False, device=device, dtype=dtype
+        )
+
+        self.lora_dpo_A = nn.Linear(
+            in_features, 256, bias=False, device=device, dtype=dtype
+        )
+        self.lora_dpo_B = nn.Linear(
+            256, out_features, bias=False, device=device, dtype=dtype
+        )
+
+        self.lora_web_A = nn.Linear(
+            in_features, 512, bias=False, device=device, dtype=dtype
+        )
+        self.lora_web_B = nn.Linear(
+            512, out_features, bias=False, device=device, dtype=dtype
+        )
+
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        if hasattr(self, "lora_A"):
+            # initialize A the same way as the default for nn.Linear and B to zero
+            nn.init.kaiming_uniform_(self.lora_A.weight, a=math.sqrt(5))
+            nn.init.zeros_(self.lora_B.weight)
+            # print ("lora weight init {} {}".format(torch.mean(self.lora_A.weight), torch.mean(self.lora_B.weight)))
+
+    def forward(self, x, im_mask=None, infer_mode="base"):
+        B, N, C = x.shape
+        im_mask = im_mask.view(-1)
+        x = x.reshape(-1, C)
+        res = super().forward(x)
+        if infer_mode == "web":
+            res += self.lora_web_B(self.lora_web_A(x))
+        elif infer_mode == "write":
+            res += self.lora_sft_B(self.lora_sft_A(x))
+            res += self.lora_dpo_B(self.lora_dpo_A(x))
+        else:
+            pass
+        if im_mask is not None:
+            if torch.sum(im_mask) > 0:
+                part_x = x[im_mask]
+                res[im_mask] += (
+                    self.Plora_B(self.Plora_A(self.lora_dropout(part_x)))
+                    * self.lora_scaling
+                )
+            else:
+                part_x = x[:1]
+                res[:1] += self.Plora_B(self.Plora_A(self.lora_dropout(part_x))) * 0
+
+        return res.reshape(B, N, -1)

config.json

@@ -0,0 +1,37 @@
+{
+  "_name_or_path": "/mnt/petrelfs/dongxiaoyi/gittest/temp_model/internlm-xcomposer2d5-7b",
+  "architectures": [
+    "InternLMXComposer2ForCausalLM"
+  ],
+  "attn_implementation": "flash_attention_2",
+  "auto_map": {
+    "AutoConfig": "configuration_internlm_xcomposer2.InternLMXcomposer2Config",
+    "AutoModel": "modeling_internlm_xcomposer2.InternLMXComposer2ForCausalLM",
+    "AutoModelForCausalLM": "modeling_internlm_xcomposer2.InternLMXComposer2ForCausalLM"
+  },
+  "bias": false,
+  "bos_token_id": 1,
+  "eos_token_id": 2,
+  "hidden_act": "silu",
+  "hidden_size": 4096,
+  "initializer_range": 0.02,
+  "intermediate_size": 14336,
+  "max_length": 16384,
+  "max_position_embeddings": 24576,
+  "model_type": "internlm2",
+  "num_attention_heads": 32,
+  "num_hidden_layers": 32,
+  "num_key_value_heads": 8,
+  "pad_token_id": 2,
+  "rms_norm_eps": 1e-05,
+  "rope_scaling": {
+    "type": "dynamic",
+    "factor": 2.0
+  },
+  "rope_theta": 1000000,
+  "tie_word_embeddings": false,
+  "torch_dtype": "bfloat16",
+  "transformers_version": "4.33.1",
+  "use_cache": false,
+  "vocab_size": 92544
+}

configuration_internlm_xcomposer2.py

@@ -0,0 +1,150 @@
+# coding=utf-8
+# Copyright (c) The InternLM team and The HuggingFace Inc. team. All rights reserved.
+#
+# This code is based on transformers/src/transformers/models/llama/configuration_llama.py
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""" InternLM2 model configuration"""
+
+from transformers.configuration_utils import PretrainedConfig
+from transformers.utils import logging
+
+logger = logging.get_logger(__name__)
+
+INTERNLM2_PRETRAINED_CONFIG_ARCHIVE_MAP = {}
+
+
+class InternLMXcomposer2Config(PretrainedConfig):
+    r"""
+    This is the configuration class to store the configuration of a [`InternLM2Model`]. It is used to instantiate
+    an InternLM2 model according to the specified arguments, defining the model architecture. Instantiating a
+    configuration with the defaults will yield a similar configuration to that of the InternLM2-7B.
+
+    Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
+    documentation from [`PretrainedConfig`] for more information.
+
+
+    Args:
+        vocab_size (`int`, *optional*, defaults to 32000):
+            Vocabulary size of the InternLM2 model. Defines the number of different tokens that can be represented by the
+            `inputs_ids` passed when calling [`InternLM2Model`]
+        hidden_size (`int`, *optional*, defaults to 4096):
+            Dimension of the hidden representations.
+        intermediate_size (`int`, *optional*, defaults to 11008):
+            Dimension of the MLP representations.
+        num_hidden_layers (`int`, *optional*, defaults to 32):
+            Number of hidden layers in the Transformer encoder.
+        num_attention_heads (`int`, *optional*, defaults to 32):
+            Number of attention heads for each attention layer in the Transformer encoder.
+        num_key_value_heads (`int`, *optional*):
+            This is the number of key_value heads that should be used to implement Grouped Query Attention. If
+            `num_key_value_heads=num_attention_heads`, the model will use Multi Head Attention (MHA), if
+            `num_key_value_heads=1 the model will use Multi Query Attention (MQA) otherwise GQA is used. When
+            converting a multi-head checkpoint to a GQA checkpoint, each group key and value head should be constructed
+            by meanpooling all the original heads within that group. For more details checkout [this
+            paper](https://arxiv.org/pdf/2305.13245.pdf). If it is not specified, will default to
+            `num_attention_heads`.
+        hidden_act (`str` or `function`, *optional*, defaults to `"silu"`):
+            The non-linear activation function (function or string) in the decoder.
+        max_position_embeddings (`int`, *optional*, defaults to 2048):
+            The maximum sequence length that this model might ever be used with. Typically set this to something large
+            just in case (e.g., 512 or 1024 or 2048).
+        initializer_range (`float`, *optional*, defaults to 0.02):
+            The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
+        rms_norm_eps (`float`, *optional*, defaults to 1e-12):
+            The epsilon used by the rms normalization layers.
+        use_cache (`bool`, *optional*, defaults to `True`):
+            Whether or not the model should return the last key/values attentions (not used by all models). Only
+            relevant if `config.is_decoder=True`.
+        tie_word_embeddings(`bool`, *optional*, defaults to `False`):
+            Whether to tie weight embeddings
+        Example:
+
+    """
+    model_type = "internlm2"
+    _auto_class = "AutoConfig"
+
+    def __init__(  # pylint: disable=W0102
+        self,
+        vocab_size=103168,
+        hidden_size=4096,
+        intermediate_size=11008,
+        num_hidden_layers=32,
+        num_attention_heads=32,
+        num_key_value_heads=None,
+        hidden_act="silu",
+        max_position_embeddings=2048,
+        initializer_range=0.02,
+        rms_norm_eps=1e-6,
+        use_cache=True,
+        pad_token_id=0,
+        bos_token_id=1,
+        eos_token_id=2,
+        tie_word_embeddings=False,
+        bias=True,
+        rope_theta=10000,
+        rope_scaling=None,
+        attn_implementation="flash_attention_2",
+        **kwargs,
+    ):
+        self.vocab_size = vocab_size
+        self.max_position_embeddings = max_position_embeddings
+        self.hidden_size = hidden_size
+        self.intermediate_size = intermediate_size
+        self.num_hidden_layers = num_hidden_layers
+        self.num_attention_heads = num_attention_heads
+        self.bias = bias
+
+        if num_key_value_heads is None:
+            num_key_value_heads = num_attention_heads
+        self.num_key_value_heads = num_key_value_heads
+
+        self.hidden_act = hidden_act
+        self.initializer_range = initializer_range
+        self.rms_norm_eps = rms_norm_eps
+        self.use_cache = use_cache
+        self.rope_theta = rope_theta
+        self.rope_scaling = rope_scaling
+        self._rope_scaling_validation()
+
+        self.attn_implementation = attn_implementation
+        if self.attn_implementation is None:
+            self.attn_implementation = "flash_attention_2"
+        super().__init__(
+            pad_token_id=pad_token_id,
+            bos_token_id=bos_token_id,
+            eos_token_id=eos_token_id,
+            tie_word_embeddings=tie_word_embeddings,
+            **kwargs,
+        )
+
+    def _rope_scaling_validation(self):
+        """
+        Validate the `rope_scaling` configuration.
+        """
+        if self.rope_scaling is None:
+            return
+
+        if not isinstance(self.rope_scaling, dict) or len(self.rope_scaling) != 2:
+            raise ValueError(
+                "`rope_scaling` must be a dictionary with with two fields, `type` and `factor`, "
+                f"got {self.rope_scaling}"
+            )
+        rope_scaling_type = self.rope_scaling.get("type", None)
+        rope_scaling_factor = self.rope_scaling.get("factor", None)
+        if rope_scaling_type is None or rope_scaling_type not in ["linear", "dynamic"]:
+            raise ValueError(
+                f"`rope_scaling`'s type field must be one of ['linear', 'dynamic'], got {rope_scaling_type}"
+            )
+        if rope_scaling_factor is None or not isinstance(rope_scaling_factor, float) or rope_scaling_factor < 1.0:
+            raise ValueError(f"`rope_scaling`'s factor field must be a float >= 1, got {rope_scaling_factor}")

examples/liuxiang.mp4

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

examples/resume.md

@@ -0,0 +1,51 @@
+# Qidong Huang
+
+Building No.7, USTC West CampusHefei, Anhui, China
+
+Ph.D, University of Science and Technology of China
+
+H (+86) 13085060686
+
+B hqd0037@mail.ustc.edu.cn
+
+# Short Biography
+
+Qidong Huang is a PhD student at University of Science and Technology of China. He has published more than 7 papers at top1-tier conferences and journals, such as CVPR/ICCV/AAAI/TIP/TCSVT. His research interests focus on vision transfer learning (e.g., prompt learning for vision pretrained models) and artificial intelligence security (e.g., adversarial examples and anti-DeepFake). He is the reviewer of many top conferences (including CVPR, ICCV, ECCV) and top journals (TNNLS, PR).
+
+# Education
+
+|09/2020–present|PhD of Cyberspace Security, University of Science and Technology of China, Hefei, China, CAS Key Laboratory of Electromagnetic Space Information. Supervised by Prof. Weiming Zhang.|
+|---|---|
+|09/2016–06/2020|Bachelor of Information Security, School of Information Science and Technology, University of Science and Technology of China, Hefei, China.|
+
+# Skills
+
+- Expertise in vision prompt learning: I have been researching the prompt learning for large-scale vision pretrained models and published one paper on top-tier computer vision conferences, in which I propose DAM-VP, a data diversity-aware method for efficient and adaptive vision prompt learning. This work alleviates the mismatch between vision prompts and downstream data diversity.
+- Expertise in artificial intelligence security: I have been studying artificial intelligence security since 2020, including adversarial attack&defense and anti-DeepFake. For adversarial attack, I propose SI-Adv, a shape-invariant attack for 3D point cloud recognition which great boosts the imperceptibility of adversarial examples. For adversarial defense, I propose a contrastive adversarial training framework for robust point cloud recognition named PointCAT. Besides, our work for improving adversarial robustness of masked autoencoders has been recently accepted by ICCV 2023. For anti-DeepFake, we are the first to propose the concept of “initiative defense” against DeepFakes by proactively protecting users’ facial privacy before the manipulation, unlike previous ex-post countermeasures like DeepFake detection.
+
+# Publications (First Author)
+
+Qidong Huang, Xiaoyi Dong, Dongdong Chen, Yinpeng Chen, Lu Yuan, Gang Hua, Weiming Zhang, Nenghai Yu. Improving Adversarial Robustness of Masked Autoencoders via Test-time Frequency-domain Prompting. International Conference on Computer Vision (ICCV), 2023.
+Qidong Huang, Xiaoyi Dong, Dongdong Chen, Weiming Zhang, Feifei Wang, Gang Hua, Nenghai Yu. Diversity-Aware Meta Visual Prompting. Conference on Computer Vision and Pattern Recognition (CVPR), 2023.
+Qidong Huang, Xiaoyi Dong, Dongdong Chen, Hang Zhou, Weiming Zhang, Nenghai Yu. Shape-invariant 3D Adversarial Point Clouds. Conference on Computer Vision and Pattern Recognition (CVPR), 2022.
+---
+# Publications
+
+Qidong Huang*, Jie Zhang*, Wenbo Zhou, Weiming Zhang, Nenghai Yu. Initiative Defense against Facial Manipulation. AAAI Conference on Artificial Intelligence (AAAI), 2021. (*Qidong Huang and Jie Zhang contribute equally.)
+Qidong Huang, Xiaoyi Dong, Dongdong Chen, Hang Zhou, Weiming Zhang, Kui Zhang, Gang Hua, Nenghai Yu. PointCAT : Contrastive Adversarial Training for Robust Point Cloud Recognition. IEEE Transactions on Image Processing (TIP), Major Revision.
+Kui Zhang, Hang Zhou, Jie Zhang, Qidong Huang, Weiming Zhang, Nenghai Yu. Ada3Diff : Defending against 3D Adversarial Point Clouds via Adaptive Diffusion. Under Review
+Han Fang, Dongdong Chen, Qidong Huang, Jie Zhang, Zehua Ma, Weiming Zhang* and Nenghai Yu. Deep Template-based Watermarking. IEEE Transactions on Circuits and Systems for Video Technology (TCSVT), 2020.
+Jie Zhang, Dongdong Chen, Qidong Huang, Jing Liao, Weiming Zhang, Huamin Feng, Gang Hua, Nenghai Yu. Poison ink : Robust and invisible backdoor attack. IEEE Transactions on Image Processing (TIP), 2022.
+
+# Services
+
+- Reviewer for CVPR 2022, 2023
+- Reviewer for ICCV 2023
+- Reviewer for ECCV 2022
+- Reviewer for ICPR 2022
+- Reviewer for IEEE Transactions on Neural Networks and Learning Systems (TNNLS)
+- Reviewer for Pattern Recognition (PR)
+
+# Awards & Honors
+
+2021 China National Scholarship

generation_config.json

@@ -0,0 +1,9 @@
+{
+  "_from_model_config": true,
+  "bos_token_id": 1,
+  "eos_token_id": 2,
+  "max_length": 16384,
+  "pad_token_id": 2,
+  "transformers_version": "4.33.1",
+  "use_cache": false
+}

ixc_utils.py

@@ -0,0 +1,145 @@
+import os
+import torch
+import numpy as np
+import torchvision
+from urllib.request import urlopen
+from PIL import Image, ImageDraw, ImageFont
+from torchvision.transforms.functional import InterpolationMode
+import torchvision.transforms as transforms
+from decord import VideoReader
+
+def get_font():
+    truetype_url = 'https://huggingface.co/internlm/internlm-xcomposer2d5-7b/resolve/main/SimHei.ttf?download=true'
+    ff = urlopen(truetype_url)
+    font = ImageFont.truetype(ff, size=40)
+    return font
+
+def padding_336(b, pad=336):
+    width, height = b.size
+    tar = int(np.ceil(height / pad) * pad)
+    top_padding = 0 # int((tar - height)/2)
+    bottom_padding = tar - height - top_padding
+    left_padding = 0
+    right_padding = 0
+    b = transforms.functional.pad(b, [left_padding, top_padding, right_padding, bottom_padding], fill=[255,255,255])
+
+    return b
+
+def Image_transform(img, hd_num=25):
+    width, height = img.size
+    trans = False
+    if width < height:
+        img = img.transpose(Image.TRANSPOSE)
+        trans = True
+        width, height = img.size
+    ratio = (width/ height)
+    scale = 1
+    while scale*np.ceil(scale/ratio) <= hd_num:
+        scale += 1
+    scale -= 1
+    scale = min(np.ceil(width / 560), scale)
+    new_w = int(scale * 560)
+    new_h = int(new_w / ratio)
+    #print (scale, f'{height}/{new_h}, {width}/{new_w}')
+
+    img = transforms.functional.resize(img, [new_h, new_w],)
+    img = padding_336(img, 560)
+    width, height = img.size
+    if trans:
+        img = img.transpose(Image.TRANSPOSE)
+
+    return img
+
+
+def Video_transform(img, hd_num=25):
+    width, height = img.size
+    trans = False
+    if width < height:
+        img = img.transpose(Image.TRANSPOSE)
+        trans = True
+        width, height = img.size
+    ratio = (width/ height)
+    scale = 1
+    new_h = int(scale * 560)
+    new_w = int(new_h * ratio)
+    #print (new_h, new_w)
+
+    img = transforms.functional.resize(img, [new_h, new_w],)
+    img = img.transpose(Image.TRANSPOSE)
+    img = padding_336(img, 560)
+    width, height = img.size
+    if not trans:
+        img = img.transpose(Image.TRANSPOSE)
+
+    return img
+
+def frame2img(imgs, font):
+    new_imgs = []
+    for img in imgs:
+        w, h = img.size
+        scale = w/h
+        if w > h:
+            new_w = 560 * 2
+            new_h = int(560 * 2 / scale)
+        else:
+            new_w = int(560 * 2 * scale)
+            new_h = 560 * 2
+        img = transforms.functional.resize(img, [new_h, new_w],)
+        new_imgs.append(img)
+    imgs = new_imgs
+    new_w = 0
+    new_h = 0
+    pad = 40
+    if w > h:
+        for im in imgs:
+            w,h = im.size
+            new_w = max(new_w, w)
+            new_h += h + 10 + pad
+        new_img = Image.new('RGB', (new_w, new_h), 'white')
+        draw = ImageDraw.Draw(new_img)
+        curr_h = 0
+        for idx, im in enumerate(imgs):
+            w,h = im.size
+            new_img.paste(im, (0, pad + curr_h))
+            draw.text((0, curr_h ), f'<IMAGE {idx}>', font=font, fill='black')
+            if idx + 1 < len(imgs):
+                draw.line([(0, pad +curr_h + h +5), (new_w, pad +curr_h + h +5)], fill = 'black', width=2)
+            curr_h += h + 10 + pad
+        #print (new_w, new_h)
+    else:
+        for im in imgs:
+            w,h = im.size
+            new_w += w + 10
+            new_h = max(new_h, h)
+        new_h += pad
+        new_img = Image.new('RGB', (new_w, new_h), 'white')
+        draw = ImageDraw.Draw(new_img)
+        curr_w = 0
+        for idx, im in enumerate(imgs):
+            w,h = im.size
+            new_img.paste(im, (curr_w, pad))
+            draw.text((curr_w, 0), f'<IMAGE {idx}>', font=font, fill='black')
+            if idx + 1 < len(imgs):
+                draw.line([(curr_w + w + 5, 0), (curr_w + w + 5, new_h)], fill = 'black', width=2)
+            curr_w += w + 10
+    return new_img
+
+def load_video(video_path, num_frm=32, start=None, end=None):
+    vid = VideoReader(video_path, num_threads=1)
+    fps = vid.get_avg_fps()
+    t_stride = int(round(float(fps) / int(1)))
+    start_idx = 0 if start is None else start
+    end_idx = len(vid) if end is None else end
+    all_pos = list(range(start_idx, end_idx, t_stride))
+    try:
+        images = [vid[i].numpy() for i in all_pos]
+    except:
+        images = [vid[i].asnumpy() for i in all_pos]
+    if len(images) > num_frm:
+        num_frm = min(num_frm, len(images))
+        step_size = len(images) / (num_frm + 1)
+        indices = [int(i*step_size) for i in range(num_frm)]
+        images = [images[i] for i in indices]
+    images = [Image.fromarray(arr) for arr in images]
+    return images
+

modeling_internlm2.py

@@ -0,0 +1,1174 @@
+# Copyright (c) The InternLM team and The HuggingFace Inc. team. All rights reserved.
+#
+# This code is based on transformers/src/transformers/models/llama/modeling_llama.py
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""PyTorch InternLM2 model."""
+
+import math
+import warnings
+from typing import List, Optional, Tuple, Union
+
+import torch
+import torch.nn.functional as F
+import torch.utils.checkpoint
+from einops import rearrange
+from torch import nn
+from transformers.activations import ACT2FN
+from transformers.modeling_outputs import BaseModelOutputWithPast
+from transformers.modeling_utils import PreTrainedModel
+from transformers.utils import (
+    add_start_docstrings,
+    add_start_docstrings_to_model_forward,
+    logging,
+)
+
+try:
+    from transformers.generation.streamers import BaseStreamer
+except:  # noqa # pylint: disable=bare-except
+    BaseStreamer = None
+
+from .build_mlp import PLoRA
+from .configuration_internlm_xcomposer2 import (
+    InternLMXcomposer2Config as InternLM2Config,
+)
+
+logger = logging.get_logger(__name__)
+
+_CONFIG_FOR_DOC = "InternLM2Config"
+
+flash_attn_func, flash_attn_varlen_func = None, None
+pad_input, index_first_axis, unpad_input = None, None, None
+
+
+def _import_flash_attn():
+    global flash_attn_func, flash_attn_varlen_func
+    global pad_input, index_first_axis, unpad_input
+    try:
+        from flash_attn import flash_attn_func as _flash_attn_func
+        from flash_attn import flash_attn_varlen_func as _flash_attn_varlen_func
+        from flash_attn.bert_padding import index_first_axis as _index_first_axis
+        from flash_attn.bert_padding import pad_input as _pad_input
+        from flash_attn.bert_padding import unpad_input as _unpad_input
+
+        flash_attn_func, flash_attn_varlen_func = (
+            _flash_attn_func,
+            _flash_attn_varlen_func,
+        )
+        pad_input, index_first_axis, unpad_input = (
+            _pad_input,
+            _index_first_axis,
+            _unpad_input,
+        )
+    except ImportError:
+        raise ImportError("flash_attn is not installed.")
+
+
+# Copied from transformers.models.llama.modeling_llama._get_unpad_data
+def _get_unpad_data(attention_mask):
+    seqlens_in_batch = attention_mask.sum(dim=-1, dtype=torch.int32)
+    indices = torch.nonzero(attention_mask.flatten(), as_tuple=False).flatten()
+    max_seqlen_in_batch = seqlens_in_batch.max().item()
+    cu_seqlens = F.pad(
+        torch.cumsum(seqlens_in_batch, dim=0, dtype=torch.torch.int32), (1, 0)
+    )
+    return (
+        indices,
+        cu_seqlens,
+        max_seqlen_in_batch,
+    )
+
+
+# Copied from transformers.models.bart.modeling_bart._make_causal_mask
+def _make_causal_mask(
+    input_ids_shape: torch.Size,
+    dtype: torch.dtype,
+    device: torch.device,
+    past_key_values_length: int = 0,
+):
+    """
+    Make causal mask used for bi-directional self-attention.
+    """
+    bsz, tgt_len = input_ids_shape
+    mask = torch.full(
+        (tgt_len, tgt_len),
+        torch.tensor(torch.finfo(dtype).min, device=device),
+        device=device,
+    )
+    mask_cond = torch.arange(mask.size(-1), device=device)
+    mask.masked_fill_(mask_cond < (mask_cond + 1).view(mask.size(-1), 1), 0)
+    mask = mask.to(dtype)
+
+    if past_key_values_length > 0:
+        mask = torch.cat(
+            [
+                torch.zeros(
+                    tgt_len, past_key_values_length, dtype=dtype, device=device
+                ),
+                mask,
+            ],
+            dim=-1,
+        )
+    return mask[None, None, :, :].expand(
+        bsz, 1, tgt_len, tgt_len + past_key_values_length
+    )
+
+
+# Copied from transformers.models.bart.modeling_bart._expand_mask
+def _expand_mask(mask: torch.Tensor, dtype: torch.dtype, tgt_len: Optional[int] = None):
+    """
+    Expands attention_mask from `[bsz, seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`.
+    """
+    bsz, src_len = mask.size()
+    tgt_len = tgt_len if tgt_len is not None else src_len
+
+    expanded_mask = mask[:, None, None, :].expand(bsz, 1, tgt_len, src_len).to(dtype)
+
+    inverted_mask = 1.0 - expanded_mask
+
+    return inverted_mask.masked_fill(
+        inverted_mask.to(torch.bool), torch.finfo(dtype).min
+    )
+
+
+# Copied from transformers.models.llama.modeling_llama.LlamaRMSNorm with Llama->InternLM2
+class InternLM2RMSNorm(nn.Module):
+    def __init__(self, hidden_size, eps=1e-6):
+        """
+        InternLM2RMSNorm is equivalent to T5LayerNorm
+        """
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(hidden_size))
+        self.variance_epsilon = eps
+
+    def forward(self, hidden_states):
+        input_dtype = hidden_states.dtype
+        hidden_states = hidden_states.to(torch.float32)
+        variance = hidden_states.pow(2).mean(-1, keepdim=True)
+        hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
+        return self.weight * hidden_states.to(input_dtype)
+
+
+# Copied from transformers.model.llama.modeling_llama.LlamaRotaryEmbedding with Llama->InternLM2
+class InternLM2RotaryEmbedding(nn.Module):
+    def __init__(self, dim, max_position_embeddings=2048, base=10000, device=None):
+        super().__init__()
+
+        self.dim = dim
+        self.max_position_embeddings = max_position_embeddings
+        self.base = base
+        inv_freq = 1.0 / (
+            self.base ** (torch.arange(0, self.dim, 2).float().to(device) / self.dim)
+        )
+        self.register_buffer("inv_freq", inv_freq, persistent=False)
+
+        # Build here to make `torch.jit.trace` work.
+        self._set_cos_sin_cache(
+            seq_len=max_position_embeddings,
+            device=self.inv_freq.device,
+            dtype=torch.get_default_dtype(),
+        )
+
+    def _set_cos_sin_cache(self, seq_len, device, dtype):
+        self.max_seq_len_cached = seq_len
+        t = torch.arange(
+            self.max_seq_len_cached, device=device, dtype=self.inv_freq.dtype
+        )
+
+        freqs = torch.einsum("i,j->ij", t, self.inv_freq)
+        # Different from paper, but it uses a different permutation in order to obtain the same calculation
+        emb = torch.cat((freqs, freqs), dim=-1)
+        self.register_buffer("cos_cached", emb.cos().to(dtype), persistent=False)
+        self.register_buffer("sin_cached", emb.sin().to(dtype), persistent=False)
+
+    def forward(self, x, seq_len=None):
+        # x: [bs, num_attention_heads, seq_len, head_size]
+        if seq_len > self.max_seq_len_cached:
+            self._set_cos_sin_cache(
+                seq_len=seq_len, device=x.device, dtype=torch.float32
+            )
+
+        return (
+            self.cos_cached[:seq_len].to(dtype=x.dtype),
+            self.sin_cached[:seq_len].to(dtype=x.dtype),
+        )
+
+
+# Copied from transformers.model.llama.modeling_llama.LlamaLinearScalingRotaryEmbedding with Llama->InternLM2
+class InternLM2LinearScalingRotaryEmbedding(InternLM2RotaryEmbedding):
+    """InternLM2RotaryEmbedding extended with linear scaling. Credits to the Reddit user /u/kaiokendev"""
+
+    def __init__(
+        self,
+        dim,
+        max_position_embeddings=2048,
+        base=10000,
+        device=None,
+        scaling_factor=1.0,
+    ):
+        self.scaling_factor = scaling_factor
+        super().__init__(dim, max_position_embeddings, base, device)
+
+    def _set_cos_sin_cache(self, seq_len, device, dtype):
+        self.max_seq_len_cached = seq_len
+        t = torch.arange(
+            self.max_seq_len_cached, device=device, dtype=self.inv_freq.dtype
+        )
+        t = t / self.scaling_factor
+
+        freqs = torch.einsum("i,j->ij", t, self.inv_freq)
+        # Different from paper, but it uses a different permutation in order to obtain the same calculation
+        emb = torch.cat((freqs, freqs), dim=-1)
+        self.register_buffer("cos_cached", emb.cos().to(dtype), persistent=False)
+        self.register_buffer("sin_cached", emb.sin().to(dtype), persistent=False)
+
+
+# Copied from transformers.model.llama.modeling_llama.LlamaDynamicNTKScalingRotaryEmbedding with Llama->InternLM2
+class InternLM2DynamicNTKScalingRotaryEmbedding(InternLM2RotaryEmbedding):
+    """InternLM2RotaryEmbedding extended with Dynamic NTK scaling.
+    Credits to the Reddit users /u/bloc97 and /u/emozilla.
+    """
+
+    def __init__(
+        self,
+        dim,
+        max_position_embeddings=2048,
+        base=10000,
+        device=None,
+        scaling_factor=1.0,
+    ):
+        self.scaling_factor = scaling_factor
+        super().__init__(dim, max_position_embeddings, base, device)
+
+    def _set_cos_sin_cache(self, seq_len, device, dtype):
+        self.max_seq_len_cached = seq_len
+
+        if seq_len > self.max_position_embeddings:
+            base = self.base * (
+                (self.scaling_factor * seq_len / self.max_position_embeddings)
+                - (self.scaling_factor - 1)
+            ) ** (self.dim / (self.dim - 2))
+            inv_freq = 1.0 / (
+                base ** (torch.arange(0, self.dim, 2).float().to(device) / self.dim)
+            )
+            self.register_buffer("inv_freq", inv_freq, persistent=False)
+
+        t = torch.arange(
+            self.max_seq_len_cached, device=device, dtype=self.inv_freq.dtype
+        )
+
+        freqs = torch.einsum("i,j->ij", t, self.inv_freq)
+        # Different from paper, but it uses a different permutation in order to obtain the same calculation
+        emb = torch.cat((freqs, freqs), dim=-1)
+        self.register_buffer("cos_cached", emb.cos().to(dtype), persistent=False)
+        self.register_buffer("sin_cached", emb.sin().to(dtype), persistent=False)
+
+
+# Copied from transformers.model.llama.modeling_llama.rotate_half
+def rotate_half(x):
+    """Rotates half the hidden dims of the input."""
+    x1 = x[..., : x.shape[-1] // 2]
+    x2 = x[..., x.shape[-1] // 2 :]
+    return torch.cat((-x2, x1), dim=-1)
+
+
+# Copied from transformers.model.llama.modeling_llama.apply_rotary_pos_emb
+def apply_rotary_pos_emb(q, k, cos, sin, position_ids, unsqueeze_dim=1):
+    """Applies Rotary Position Embedding to the query and key tensors."""
+    cos = cos[position_ids].unsqueeze(unsqueeze_dim)
+    sin = sin[position_ids].unsqueeze(unsqueeze_dim)
+    q_embed = (q * cos) + (rotate_half(q) * sin)
+    k_embed = (k * cos) + (rotate_half(k) * sin)
+    return q_embed, k_embed
+
+
+class InternLM2MLP(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        self.hidden_size = config.hidden_size
+        self.intermediate_size = config.intermediate_size
+        # self.w1 = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
+        # self.w3 = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
+        # self.w2 = nn.Linear(self.intermediate_size, self.hidden_size, bias=False)
+
+        self.w1 = PLoRA(
+            self.hidden_size,
+            self.intermediate_size,
+            bias=False,
+            lora_r=256,
+            lora_alpha=256,
+            lora_len=1225,
+        )
+        self.w3 = PLoRA(
+            self.hidden_size,
+            self.intermediate_size,
+            bias=False,
+            lora_r=256,
+            lora_alpha=256,
+            lora_len=1225,
+        )
+        self.w2 = PLoRA(
+            self.intermediate_size,
+            self.hidden_size,
+            bias=False,
+            lora_r=256,
+            lora_alpha=256,
+            lora_len=1225,
+        )
+
+        self.act_fn = ACT2FN[config.hidden_act]
+
+    def forward(self, x, im_mask, infer_mode):
+        down_proj = self.w2(
+            self.act_fn(self.w1(x, im_mask, infer_mode))
+            * self.w3(x, im_mask, infer_mode),
+            im_mask,
+            infer_mode,
+        )
+
+        return down_proj
+
+
+# Copied from transformers.model.llama.modeling_llama.repeat_kv
+def repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor:
+    """
+    This is the equivalent of torch.repeat_interleave(x, dim=1, repeats=n_rep). The hidden states go from (batch,
+    num_key_value_heads, seqlen, head_dim) to (batch, num_attention_heads, seqlen, head_dim)
+    """
+    batch, num_key_value_heads, slen, head_dim = hidden_states.shape
+    if n_rep == 1:
+        return hidden_states
+    hidden_states = hidden_states[:, :, None, :, :].expand(
+        batch, num_key_value_heads, n_rep, slen, head_dim
+    )
+    return hidden_states.reshape(batch, num_key_value_heads * n_rep, slen, head_dim)
+
+
+# Modified from transformers.model.llama.modeling_llama.LlamaAttention
+class InternLM2Attention(nn.Module):
+    """Multi-headed attention from 'Attention Is All You Need' paper"""
+
+    def __init__(self, config: InternLM2Config):
+        super().__init__()
+        self.config = config
+        self.hidden_size = config.hidden_size
+        self.num_heads = config.num_attention_heads
+        self.head_dim = self.hidden_size // self.num_heads
+        self.num_key_value_heads = config.num_key_value_heads
+        self.num_key_value_groups = self.num_heads // self.num_key_value_heads
+        self.max_position_embeddings = config.max_position_embeddings
+        self.is_causal = True
+
+        if (self.head_dim * self.num_heads) != self.hidden_size:
+            raise ValueError(
+                f"hidden_size must be divisible by num_heads (got `hidden_size`: {self.hidden_size}"
+                f" and `num_heads`: {self.num_heads})."
+            )
+
+        # self.wqkv = nn.Linear(
+        self.wqkv = PLoRA(
+            self.hidden_size,
+            (self.num_heads + 2 * self.num_key_value_heads) * self.head_dim,
+            bias=config.bias,
+            lora_r=256,
+            lora_alpha=256,
+            lora_len=1225,
+        )
+
+        # self.wo = nn.Linear(self.num_heads * self.head_dim, self.hidden_size, bias=config.bias)
+        self.wo = PLoRA(
+            self.num_heads * self.head_dim,
+            self.hidden_size,
+            bias=config.bias,
+            lora_r=256,
+            lora_alpha=256,
+            lora_len=1225,
+        )
+        self._init_rope()
+
+    def _init_rope(self):
+        if self.config.rope_scaling is None:
+            self.rotary_emb = InternLM2RotaryEmbedding(
+                self.head_dim,
+                max_position_embeddings=self.max_position_embeddings,
+                base=self.config.rope_theta,
+            )
+        else:
+            scaling_type = self.config.rope_scaling["type"]
+            scaling_factor = self.config.rope_scaling["factor"]
+            if scaling_type == "dynamic":
+                self.rotary_emb = InternLM2DynamicNTKScalingRotaryEmbedding(
+                    self.head_dim,
+                    max_position_embeddings=self.max_position_embeddings,
+                    base=self.config.rope_theta,
+                    scaling_factor=scaling_factor,
+                )
+            elif scaling_type == "linear":
+                self.rotary_emb = InternLM2LinearScalingRotaryEmbedding(
+                    self.head_dim,
+                    max_position_embeddings=self.max_position_embeddings,
+                    base=self.config.rope_theta,
+                    scaling_factor=scaling_factor,
+                )
+            else:
+                raise ValueError(
+                    "Currently we only support rotary embedding's type being 'dynamic' or 'linear'."
+                )
+        return self.rotary_emb
+
+    def _shape(self, tensor: torch.Tensor, seq_len: int, bsz: int):
+        return (
+            tensor.view(bsz, seq_len, self.num_heads, self.head_dim)
+            .transpose(1, 2)
+            .contiguous()
+        )
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_value: Optional[Tuple[torch.Tensor]] = None,
+        output_attentions: bool = False,
+        use_cache: bool = False,
+        im_mask: Optional[Tuple[torch.Tensor]] = None,
+        infer_mode: str = "base",
+        **kwargs,
+    ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]:
+        if "padding_mask" in kwargs:
+            warnings.warn(
+                "Passing `padding_mask` is deprecated and will be removed in v4.37. "
+                "Please make sure use `attention_mask` instead.`"
+            )
+
+        bsz, q_len, _ = hidden_states.size()
+
+        qkv_states = self.wqkv(hidden_states, im_mask, infer_mode)
+
+        qkv_states = rearrange(
+            qkv_states,
+            "b q (h gs d) -> b q h gs d",
+            gs=2 + self.num_key_value_groups,
+            d=self.head_dim,
+        )
+
+        query_states = qkv_states[..., : self.num_key_value_groups, :]
+        query_states = rearrange(query_states, "b q h gs d -> b q (h gs) d")
+        key_states = qkv_states[..., -2, :]
+        value_states = qkv_states[..., -1, :]
+
+        query_states = query_states.transpose(1, 2)
+        key_states = key_states.transpose(1, 2)
+        value_states = value_states.transpose(1, 2)
+
+        kv_seq_len = key_states.shape[-2]
+        if past_key_value is not None:
+            kv_seq_len += past_key_value[0].shape[-2]
+        cos, sin = self.rotary_emb(value_states, seq_len=kv_seq_len)
+        query_states, key_states = apply_rotary_pos_emb(
+            query_states, key_states, cos, sin, position_ids
+        )
+
+        if past_key_value is not None:
+            # reuse k, v, self_attention
+            key_states = torch.cat([past_key_value[0], key_states], dim=2)
+            value_states = torch.cat([past_key_value[1], value_states], dim=2)
+
+        past_key_value = (key_states, value_states) if use_cache else None
+
+        key_states = repeat_kv(key_states, self.num_key_value_groups)
+        value_states = repeat_kv(value_states, self.num_key_value_groups)
+
+        attn_weights = torch.matmul(
+            query_states, key_states.transpose(2, 3)
+        ) / math.sqrt(self.head_dim)
+
+        if attn_weights.size() != (bsz, self.num_heads, q_len, kv_seq_len):
+            raise ValueError(
+                f"Attention weights should be of size {(bsz, self.num_heads, q_len, kv_seq_len)}, but is"
+                f" {attn_weights.size()}"
+            )
+
+        if attention_mask is not None:
+            if attention_mask.size() != (bsz, 1, q_len, kv_seq_len):
+                raise ValueError(
+                    f"Attention mask should be of size {(bsz, 1, q_len, kv_seq_len)}, but is {attention_mask.size()}"
+                )
+            attn_weights = attn_weights + attention_mask
+
+        # upcast attention to fp32
+        attn_weights = nn.functional.softmax(
+            attn_weights, dim=-1, dtype=torch.float32
+        ).to(query_states.dtype)
+        attn_output = torch.matmul(attn_weights, value_states)
+
+        if attn_output.size() != (bsz, self.num_heads, q_len, self.head_dim):
+            raise ValueError(
+                f"`attn_output` should be of size {(bsz, self.num_heads, q_len, self.head_dim)}, but is"
+                f" {attn_output.size()}"
+            )
+
+        attn_output = attn_output.transpose(1, 2).contiguous()
+        attn_output = attn_output.reshape(bsz, q_len, self.hidden_size)
+
+        attn_output = self.wo(attn_output, im_mask, infer_mode)
+
+        if not output_attentions:
+            attn_weights = None
+
+        return attn_output, attn_weights, past_key_value
+
+
+# Modified from transformers.model.llama.modeling_llama.InternLM2FlashAttention2
+class InternLM2FlashAttention2(InternLM2Attention):
+    """
+    InternLM2 flash attention module. This module inherits from `InternLM2Attention` as the weights of the module stays
+    untouched. The only required change would be on the forward pass where it needs to correctly call the public API of
+    flash attention and deal with padding tokens in case the input contains any of them.
+    """
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: Optional[torch.LongTensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_value: Optional[Tuple[torch.Tensor]] = None,
+        output_attentions: bool = False,
+        use_cache: bool = False,
+        im_mask: Optional[Tuple[torch.Tensor]] = None,
+        infer_mode: str = "base",
+        **kwargs,
+    ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]:
+        # InternLM2FlashAttention2 attention does not support output_attentions
+        if "padding_mask" in kwargs:
+            warnings.warn(
+                "Passing `padding_mask` is deprecated and will be removed in v4.37. "
+                "Please make sure use `attention_mask` instead.`"
+            )
+
+            # overwrite attention_mask with padding_mask
+            attention_mask = kwargs.pop("padding_mask")
+
+        output_attentions = False
+
+        bsz, q_len, _ = hidden_states.size()
+
+        qkv_states = self.wqkv(hidden_states, im_mask, infer_mode)
+
+        qkv_states = rearrange(
+            qkv_states,
+            "b q (h gs d) -> b q h gs d",
+            gs=2 + self.num_key_value_groups,
+            d=self.head_dim,
+        )
+
+        query_states = qkv_states[..., : self.num_key_value_groups, :]
+        query_states = rearrange(query_states, "b q h gs d -> b q (h gs) d")
+        key_states = qkv_states[..., -2, :]
+        value_states = qkv_states[..., -1, :]
+
+        query_states = query_states.transpose(1, 2)
+        key_states = key_states.transpose(1, 2)
+        value_states = value_states.transpose(1, 2)
+
+        kv_seq_len = key_states.shape[-2]
+        if past_key_value is not None:
+            kv_seq_len += past_key_value[0].shape[-2]
+
+        cos, sin = self.rotary_emb(value_states, seq_len=kv_seq_len)
+
+        query_states, key_states = apply_rotary_pos_emb(
+            query_states, key_states, cos, sin, position_ids
+        )
+
+        if past_key_value is not None:
+            # reuse k, v, self_attention
+            key_states = torch.cat([past_key_value[0], key_states], dim=2)
+            value_states = torch.cat([past_key_value[1], value_states], dim=2)
+
+        past_key_value = (key_states, value_states) if use_cache else None
+
+        query_states = query_states.transpose(1, 2)
+        key_states = key_states.transpose(1, 2)
+        value_states = value_states.transpose(1, 2)
+
+        attn_output = self._flash_attention_forward(
+            query_states, key_states, value_states, attention_mask, q_len
+        )
+
+        attn_output = attn_output.reshape(bsz, q_len, self.hidden_size).contiguous()
+        attn_output = self.wo(attn_output, im_mask, infer_mode)
+
+        if not output_attentions:
+            attn_weights = None
+
+        return attn_output, attn_weights, past_key_value
+
+    def _flash_attention_forward(
+        self,
+        query_states,
+        key_states,
+        value_states,
+        attention_mask,
+        query_length,
+        dropout=0.0,
+        softmax_scale=None,
+    ):
+        """
+        Calls the forward method of Flash Attention - if the input hidden states contain at least one padding token
+        first unpad the input, then computes the attention scores and pad the final attention scores.
+
+        Args:
+            query_states (`torch.Tensor`):
+                Input query states to be passed to Flash Attention API
+            key_states (`torch.Tensor`):
+                Input key states to be passed to Flash Attention API
+            value_states (`torch.Tensor`):
+                Input value states to be passed to Flash Attention API
+            attention_mask (`torch.Tensor`):
+                The padding mask - corresponds to a tensor of size `(batch_size, seq_len)` where 0 stands for the
+                position of padding tokens and 1 for the position of non-padding tokens.
+            dropout (`int`, *optional*):
+                Attention dropout
+            softmax_scale (`float`, *optional*):
+                The scaling of QK^T before applying softmax. Default to 1 / sqrt(head_dim)
+        """
+        # Contains at least one padding token in the sequence
+        causal = self.is_causal and query_length != 1
+        if attention_mask is not None:
+            batch_size = query_states.shape[0]
+            (
+                query_states,
+                key_states,
+                value_states,
+                indices_q,
+                cu_seq_lens,
+                max_seq_lens,
+            ) = self._unpad_input(
+                query_states, key_states, value_states, attention_mask, query_length
+            )
+
+            cu_seqlens_q, cu_seqlens_k = cu_seq_lens
+            max_seqlen_in_batch_q, max_seqlen_in_batch_k = max_seq_lens
+
+            attn_output_unpad = flash_attn_varlen_func(
+                query_states,
+                key_states,
+                value_states,
+                cu_seqlens_q=cu_seqlens_q,
+                cu_seqlens_k=cu_seqlens_k,
+                max_seqlen_q=max_seqlen_in_batch_q,
+                max_seqlen_k=max_seqlen_in_batch_k,
+                dropout_p=dropout,
+                softmax_scale=softmax_scale,
+                causal=causal,
+            )
+
+            attn_output = pad_input(
+                attn_output_unpad, indices_q, batch_size, query_length
+            )
+        else:
+            attn_output = flash_attn_func(
+                query_states,
+                key_states,
+                value_states,
+                dropout,
+                softmax_scale=softmax_scale,
+                causal=causal,
+            )
+
+        return attn_output
+
+    def _unpad_input(
+        self, query_layer, key_layer, value_layer, attention_mask, query_length
+    ):
+        indices_k, cu_seqlens_k, max_seqlen_in_batch_k = _get_unpad_data(attention_mask)
+        batch_size, kv_seq_len, num_key_value_heads, head_dim = key_layer.shape
+
+        key_layer = index_first_axis(
+            key_layer.reshape(batch_size * kv_seq_len, num_key_value_heads, head_dim),
+            indices_k,
+        )
+        value_layer = index_first_axis(
+            value_layer.reshape(batch_size * kv_seq_len, num_key_value_heads, head_dim),
+            indices_k,
+        )
+
+        if query_length == kv_seq_len:
+            query_layer = index_first_axis(
+                query_layer.reshape(batch_size * kv_seq_len, self.num_heads, head_dim),
+                indices_k,
+            )
+            cu_seqlens_q = cu_seqlens_k
+            max_seqlen_in_batch_q = max_seqlen_in_batch_k
+            indices_q = indices_k
+        elif query_length == 1:
+            max_seqlen_in_batch_q = 1
+            cu_seqlens_q = torch.arange(
+                batch_size + 1, dtype=torch.int32, device=query_layer.device
+            )  # There is a memcpy here, that is very bad.
+            indices_q = cu_seqlens_q[:-1]
+            query_layer = query_layer.squeeze(1)
+        else:
+            # The -q_len: slice assumes left padding.
+            attention_mask = attention_mask[:, -query_length:]
+            query_layer, indices_q, cu_seqlens_q, max_seqlen_in_batch_q = unpad_input(
+                query_layer, attention_mask
+            )
+
+        return (
+            query_layer,
+            key_layer,
+            value_layer,
+            indices_q.to(torch.int64),
+            (cu_seqlens_q, cu_seqlens_k),
+            (max_seqlen_in_batch_q, max_seqlen_in_batch_k),
+        )
+
+
+INTERNLM2_ATTENTION_CLASSES = {
+    "eager": InternLM2Attention,
+    "flash_attention_2": InternLM2FlashAttention2,
+}
+
+
+# Modified from transformers.model.llama.modeling_llama.LlamaDecoderLayer
+class InternLM2DecoderLayer(nn.Module):
+    def __init__(self, config: InternLM2Config):
+        super().__init__()
+        self.hidden_size = config.hidden_size
+
+        self.attention = INTERNLM2_ATTENTION_CLASSES[config.attn_implementation](
+            config=config
+        )
+
+        self.feed_forward = InternLM2MLP(config)
+        self.attention_norm = InternLM2RMSNorm(
+            config.hidden_size, eps=config.rms_norm_eps
+        )
+        self.ffn_norm = InternLM2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_value: Optional[Tuple[torch.Tensor]] = None,
+        output_attentions: Optional[bool] = False,
+        use_cache: Optional[bool] = False,
+        im_mask: Optional[Tuple[torch.Tensor]] = None,
+        infer_mode: str = "base",
+        **kwargs,
+    ) -> Tuple[
+        torch.FloatTensor, Optional[Tuple[torch.FloatTensor, torch.FloatTensor]]
+    ]:
+        """
+        Args:
+            hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)`
+            attention_mask (`torch.FloatTensor`, *optional*):
+                attention mask of size `(batch_size, sequence_length)` if flash attention is used or `(batch_size, 1,
+                query_sequence_length, key_sequence_length)` if default attention is used.
+            output_attentions (`bool`, *optional*):
+                Whether or not to return the attentions tensors of all attention layers. See `attentions` under
+                returned tensors for more detail.
+            use_cache (`bool`, *optional*):
+                If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding
+                (see `past_key_values`).
+            past_key_value (`Tuple(torch.FloatTensor)`, *optional*): cached past key and value projection states
+        """
+        if "padding_mask" in kwargs:
+            warnings.warn(
+                "Passing `padding_mask` is deprecated and will be removed in v4.37. "
+                "Please make sure use `attention_mask` instead.`"
+            )
+
+        residual = hidden_states
+
+        hidden_states = self.attention_norm(hidden_states)
+
+        # Self Attention
+        hidden_states, self_attn_weights, present_key_value = self.attention(
+            hidden_states=hidden_states,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            past_key_value=past_key_value,
+            output_attentions=output_attentions,
+            use_cache=use_cache,
+            im_mask=im_mask,
+            infer_mode=infer_mode,
+            **kwargs,
+        )
+        hidden_states = residual + hidden_states
+
+        # Fully Connected
+        residual = hidden_states
+        hidden_states = self.ffn_norm(hidden_states)
+        hidden_states = self.feed_forward(hidden_states, im_mask, infer_mode)
+        hidden_states = residual + hidden_states
+
+        outputs = (hidden_states,)
+
+        if output_attentions:
+            outputs += (self_attn_weights,)
+
+        if use_cache:
+            outputs += (present_key_value,)
+
+        return outputs
+
+
+InternLM2_START_DOCSTRING = r"""
+    This model inherits from [`PreTrainedModel`]. Check the superclass documentation for the generic methods the
+    library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads
+    etc.)
+
+    This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass.
+    Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
+    and behavior.
+
+    Parameters:
+        config ([`InternLM2Config`]):
+            Model configuration class with all the parameters of the model. Initializing with a config file does not
+            load the weights associated with the model, only the configuration. Check out the
+            [`~PreTrainedModel.from_pretrained`] method to load the model weights.
+"""
+
+
+# Copied from transformers.models.llama.modeling_llama.LlamaPreTrainedModel with Llama->InternLM2
+@add_start_docstrings(
+    "The bare InternLM2 Model outputting raw hidden-states without any specific head on top.",
+    InternLM2_START_DOCSTRING,
+)
+class InternLM2PreTrainedModel(PreTrainedModel):
+    config_class = InternLM2Config
+    base_model_prefix = "model"
+    supports_gradient_checkpointing = True
+    _no_split_modules = ["InternLM2DecoderLayer"]
+    _skip_keys_device_placement = "past_key_values"
+
+    def _init_weights(self, module):
+        std = self.config.initializer_range
+        if isinstance(module, nn.Linear):
+            module.weight.data.normal_(mean=0.0, std=std)
+            if module.bias is not None:
+                module.bias.data.zero_()
+        elif isinstance(module, nn.Embedding):
+            module.weight.data.normal_(mean=0.0, std=std)
+            if module.padding_idx is not None:
+                module.weight.data[module.padding_idx].zero_()
+
+
+InternLM2_INPUTS_DOCSTRING = r"""
+    Args:
+        input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+            Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide
+            it.
+
+            Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+            [`PreTrainedTokenizer.__call__`] for details.
+
+            [What are input IDs?](../glossary#input-ids)
+        attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
+            Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
+
+            - 1 for tokens that are **not masked**,
+            - 0 for tokens that are **masked**.
+
+            [What are attention masks?](../glossary#attention-mask)
+
+            Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+            [`PreTrainedTokenizer.__call__`] for details.
+
+            If `past_key_values` is used, optionally only the last `input_ids` have to be input (see
+            `past_key_values`).
+
+            If you want to change padding behavior, you should read [`modeling_opt._prepare_decoder_attention_mask`]
+            and modify to your needs. See diagram 1 in [the paper](https://arxiv.org/abs/1910.13461) for more
+            information on the default strategy.
+
+            - 1 indicates the head is **not masked**,
+            - 0 indicates the head is **masked**.
+        position_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+            Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0,
+            config.n_positions - 1]`.
+
+            [What are position IDs?](../glossary#position-ids)
+        past_key_values (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `use_cache=True` is passed or
+            when `config.use_cache=True`):
+            Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of shape
+            `(batch_size, num_heads, sequence_length, embed_size_per_head)`) and 2 additional tensors of shape
+            `(batch_size, num_heads, decoder_sequence_length, embed_size_per_head)`.
+
+            Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention
+            blocks) that can be used (see `past_key_values` input) to speed up sequential decoding.
+
+            If `past_key_values` are used, the user can optionally input only the last `input_ids` (those that don't
+            have their past key value states given to this model) of shape `(batch_size, 1)` instead of all `input_ids`
+            of shape `(batch_size, sequence_length)`.
+        inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
+            Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This
+            is useful if you want more control over how to convert `input_ids` indices into associated vectors than the
+            model's internal embedding lookup matrix.
+        use_cache (`bool`, *optional*):
+            If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see
+            `past_key_values`).
+        output_attentions (`bool`, *optional*):
+            Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
+            tensors for more detail.
+        output_hidden_states (`bool`, *optional*):
+            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
+            more detail.
+        return_dict (`bool`, *optional*):
+            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
+"""
+
+
+# Modified from transformers.model.llama.modeling_llama.LlamaModel
+@add_start_docstrings(
+    "The bare InternLM2 Model outputting raw hidden-states without any specific head on top.",
+    InternLM2_START_DOCSTRING,
+)
+class InternLM2Model(InternLM2PreTrainedModel):
+    """
+    Transformer decoder consisting of *config.num_hidden_layers* layers. Each layer is a [`InternLM2DecoderLayer`]
+
+    Args:
+        config: InternLM2Config
+    """
+
+    _auto_class = "AutoModel"
+
+    def __init__(self, config: InternLM2Config):
+        super().__init__(config)
+        self.padding_idx = config.pad_token_id
+        self.vocab_size = config.vocab_size
+        self.config = config
+
+        self.tok_embeddings = nn.Embedding(
+            config.vocab_size, config.hidden_size, self.padding_idx
+        )
+
+        self.layers = nn.ModuleList(
+            [InternLM2DecoderLayer(config) for _ in range(config.num_hidden_layers)]
+        )
+        self.norm = InternLM2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+        self.gradient_checkpointing = False
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_input_embeddings(self):
+        return self.tok_embeddings
+
+    def set_input_embeddings(self, value):
+        self.tok_embeddings = value
+
+    def _prepare_decoder_attention_mask(
+        self, attention_mask, input_shape, inputs_embeds, past_key_values_length
+    ):
+        # create causal mask
+        # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]
+        combined_attention_mask = None
+        if input_shape[-1] > 1:
+            combined_attention_mask = _make_causal_mask(
+                input_shape,
+                inputs_embeds.dtype,
+                device=inputs_embeds.device,
+                past_key_values_length=past_key_values_length,
+            )
+
+        if attention_mask is not None:
+            # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]
+            expanded_attn_mask = _expand_mask(
+                attention_mask, inputs_embeds.dtype, tgt_len=input_shape[-1]
+            ).to(inputs_embeds.device)
+            combined_attention_mask = (
+                expanded_attn_mask
+                if combined_attention_mask is None
+                else expanded_attn_mask + combined_attention_mask
+            )
+
+        return combined_attention_mask
+
+    @add_start_docstrings_to_model_forward(InternLM2_INPUTS_DOCSTRING)
+    def forward(
+        self,
+        input_ids: torch.LongTensor = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_values: Optional[List[torch.FloatTensor]] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        **kwargs,
+    ) -> Union[Tuple, BaseModelOutputWithPast]:
+        im_mask = kwargs.get("im_mask", None)
+        infer_mode = kwargs.get("infer_mode", "base")
+
+        output_attentions = (
+            output_attentions
+            if output_attentions is not None
+            else self.config.output_attentions
+        )
+        output_hidden_states = (
+            output_hidden_states
+            if output_hidden_states is not None
+            else self.config.output_hidden_states
+        )
+        use_cache = use_cache if use_cache is not None else self.config.use_cache
+
+        return_dict = (
+            return_dict if return_dict is not None else self.config.use_return_dict
+        )
+
+        if self.config.attn_implementation == "flash_attention_2":
+            _import_flash_attn()
+
+        # retrieve input_ids and inputs_embeds
+        if input_ids is not None and inputs_embeds is not None:
+            raise ValueError(
+                "You cannot specify both input_ids and inputs_embeds at the same time"
+            )
+        elif input_ids is not None:
+            batch_size, seq_length = input_ids.shape[:2]
+        elif inputs_embeds is not None:
+            batch_size, seq_length = inputs_embeds.shape[:2]
+        else:
+            raise ValueError("You have to specify either input_ids or inputs_embeds")
+
+        seq_length_with_past = seq_length
+        past_key_values_length = 0
+        if past_key_values is not None:
+            past_key_values_length = past_key_values[0][0].shape[2]
+            seq_length_with_past = seq_length_with_past + past_key_values_length
+
+        if position_ids is None:
+            device = input_ids.device if input_ids is not None else inputs_embeds.device
+            position_ids = torch.arange(
+                past_key_values_length,
+                seq_length + past_key_values_length,
+                dtype=torch.long,
+                device=device,
+            )
+            position_ids = position_ids.unsqueeze(0)
+
+        if inputs_embeds is None:
+            inputs_embeds = self.tok_embeddings(input_ids)
+            im_mask = (
+                torch.zeros(inputs_embeds.shape[:2]).to(inputs_embeds.device).bool()
+            )
+
+        if self.config.attn_implementation == "flash_attention_2":
+            # 2d mask is passed through the layers
+            attention_mask = (
+                attention_mask
+                if (attention_mask is not None and 0 in attention_mask)
+                else None
+            )
+        else:
+            if attention_mask is None:
+                attention_mask = torch.ones(
+                    (batch_size, seq_length_with_past),
+                    dtype=torch.bool,
+                    device=inputs_embeds.device,
+                )
+            attention_mask = self._prepare_decoder_attention_mask(
+                attention_mask,
+                (batch_size, seq_length),
+                inputs_embeds,
+                past_key_values_length,
+            )
+
+        # embed positions
+        hidden_states = inputs_embeds
+
+        if self.gradient_checkpointing and self.training:
+            if use_cache:
+                logger.warning_once(
+                    "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
+                )
+                use_cache = False
+
+        # decoder layers
+        all_hidden_states = () if output_hidden_states else None
+        all_self_attns = () if output_attentions else None
+        next_decoder_cache = () if use_cache else None
+
+        for idx, decoder_layer in enumerate(self.layers):
+            if output_hidden_states:
+                all_hidden_states += (hidden_states,)
+
+            past_key_value = (
+                past_key_values[idx] if past_key_values is not None else None
+            )
+
+            if self.gradient_checkpointing and self.training:
+
+                def create_custom_forward(module):
+                    def custom_forward(*inputs):
+                        # None for past_key_value
+                        return module(
+                            *inputs, output_attentions, None, im_mask, infer_mode
+                        )
+
+                    return custom_forward
+
+                layer_outputs = torch.utils.checkpoint.checkpoint(
+                    create_custom_forward(decoder_layer),
+                    hidden_states,
+                    attention_mask,
+                    position_ids,
+                    None,
+                )
+            else:
+                layer_outputs = decoder_layer(
+                    hidden_states,
+                    attention_mask=attention_mask,
+                    position_ids=position_ids,
+                    past_key_value=past_key_value,
+                    output_attentions=output_attentions,
+                    use_cache=use_cache,
+                    im_mask=im_mask,
+                    infer_mode=infer_mode,
+                )
+
+            hidden_states = layer_outputs[0]
+
+            if use_cache:
+                next_decoder_cache += (layer_outputs[2 if output_attentions else 1],)
+
+            if output_attentions:
+                all_self_attns += (layer_outputs[1],)
+
+        hidden_states = self.norm(hidden_states)
+
+        # add hidden states from the last decoder layer
+        if output_hidden_states:
+            all_hidden_states += (hidden_states,)
+
+        next_cache = next_decoder_cache if use_cache else None
+        if not return_dict:
+            return tuple(
+                v
+                for v in [hidden_states, next_cache, all_hidden_states, all_self_attns]
+                if v is not None
+            )
+        return BaseModelOutputWithPast(
+            last_hidden_state=hidden_states,
+            past_key_values=next_cache,
+            hidden_states=all_hidden_states,
+            attentions=all_self_attns,
+        )

modeling_internlm_xcomposer2.py

@@ -0,0 +1,997 @@
+# Copyright (c) The InternLM team and The HuggingFace Inc. team. All rights reserved.
+#
+# This code is based on transformers/src/transformers/models/llama/modeling_llama.py
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""PyTorch InternLMXComposer2 model."""
+
+import copy
+import os
+import random
+import re
+from pathlib import Path
+from typing import List, Optional, Tuple, Union
+
+import numpy as np
+import torch
+import torch.utils.checkpoint
+from PIL import Image
+from torch import nn
+from torch.nn import CrossEntropyLoss
+from torchvision import transforms
+from transformers import (
+    StoppingCriteria,
+    StoppingCriteriaList,
+    set_seed,
+)
+from transformers.generation.streamers import BaseStreamer
+from transformers.modeling_outputs import CausalLMOutputWithPast
+from transformers.utils import (
+    add_start_docstrings_to_model_forward,
+    replace_return_docstrings,
+)
+
+from .build_mlp import build_vision_projector, build_vision_tower
+from .ixc_utils import Image_transform, Video_transform, frame2img, get_font, load_video
+from .modeling_internlm2 import (
+    InternLM2_INPUTS_DOCSTRING,
+    InternLM2Config,
+    InternLM2Model,
+    InternLM2PreTrainedModel,
+)
+
+_CONFIG_FOR_DOC = "InternLMXcomposer2Config"
+
+image_extensions = {".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp"}
+video_extensions = {".mp4", ".avi", ".mkv", ".mov", ".wmv"}
+
+
+class StoppingCriteriaSub(StoppingCriteria):
+    def __init__(self, stops=[], encounters=1):
+        super().__init__()
+        self.stops = stops
+
+    def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor):
+        for stop in self.stops:
+            if torch.all((stop == input_ids[0][-len(stop) :])).item():
+                return True
+        return False
+
+
+def get_stopping_criteria(stop_words_ids):
+    stop_words_ids = [torch.tensor([i]).cuda() for i in stop_words_ids]
+    stopping_criteria = StoppingCriteriaList(
+        [StoppingCriteriaSub(stops=stop_words_ids)]
+    )
+    return stopping_criteria
+
+
+def set_random_seed(seed, set_cudnn=False):
+    """Set the random seed for reproducibility.
+
+    Parameters:
+    seed (int): The seed to use for generating random numbers.
+    """
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)  # For multi-GPU.
+    np.random.seed(seed)
+    random.seed(seed)
+    if set_cudnn and torch.backends.cudnn.is_available():
+        torch.backends.cudnn.deterministic = True
+        torch.backends.cudnn.benchmark = False
+
+
+class InternLMXComposer2ForCausalLM(InternLM2PreTrainedModel):
+    _auto_class = "AutoModelForCausalLM"
+
+    _tied_weights_keys = ["output.weight"]
+
+    def __init__(self, config: InternLM2Config):
+        super().__init__(config)
+        self.model = InternLM2Model(config)
+        self.vocab_size = config.vocab_size
+        self.output = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
+        self.tokenizer = None
+        self.hd_num = 25
+        self.font = get_font()
+
+        self.max_length = config.max_length
+        print(f"Set max length to {self.max_length}")
+        # Initialize weights and apply final processing
+        self.post_init()
+        self.plora_glb_GN = nn.Parameter(torch.zeros([1, 1, 4096]))
+        self.plora_sub_GN = nn.Parameter(torch.zeros([1, 1, 1, 4096]))
+
+        self.vit = build_vision_tower()
+        self.vision_proj = build_vision_projector()
+
+        self.vis_processor = transforms.Compose(
+            [
+                transforms.ToTensor(),
+                transforms.Normalize(
+                    (0.48145466, 0.4578275, 0.40821073),
+                    (0.26862954, 0.26130258, 0.27577711),
+                ),
+            ]
+        )
+
+    def _set_gradient_checkpointing(self, module, value=False):
+        if isinstance(module, InternLM2Model):
+            module.gradient_checkpointing = value
+        if value:
+            self.vit.vision_tower.vision_model.encoder.gradient_checkpointing = value
+
+    def get_input_embeddings(self):
+        return self.model.tok_embeddings
+
+    def set_input_embeddings(self, value):
+        self.model.tok_embeddings = value
+
+    def get_output_embeddings(self):
+        return self.output
+
+    def set_output_embeddings(self, new_embeddings):
+        self.output = new_embeddings
+
+    def set_decoder(self, decoder):
+        self.model = decoder
+
+    def get_decoder(self):
+        return self.model
+
+    def encode_text(self, text, add_special_tokens=False):
+        token = self.tokenizer(
+            text, return_tensors="pt", add_special_tokens=add_special_tokens
+        ).input_ids.to(self.device)  # type: ignore
+        embs = self.model.tok_embeddings(token)
+        return embs
+
+    def encode_img(
+        self, image: torch.Tensor | str | Path, hd_num: int = 25
+    ) -> torch.Tensor:
+        if image is None:
+            return None  # UNREACHABLE # type: ignore
+        if isinstance(image, str):
+            _, ext = os.path.splitext(image)
+            if ext.lower() in image_extensions:
+                image_pil = Image.open(image)
+                image_pt = Image_transform(image_pil, hd_num=hd_num)
+            elif ext.lower() in video_extensions:
+                image_pil_list = load_video(image)
+                image_pil_list = frame2img(image_pil_list, self.font)
+                image_pt = Video_transform(image_pil_list, hd_num=hd_num)
+            else:
+                print("Unknow input format", image)
+                return None  # UNREACHABLE # type: ignore
+            image = self.vis_processor(image_pt).unsqueeze(0).to(self.device)
+        else:
+            assert isinstance(image, torch.Tensor)
+
+        img_embeds, atts_img, img_target = self.img2emb(image)
+        return img_embeds
+
+    def img2emb(self, image):
+        img_embeds, img_split = self.vit([image], self.plora_glb_GN, self.plora_sub_GN)
+        if len(img_split) > 1:
+            print("Batch Size >1 is not supported.")
+            assert 0
+        # print (img_embeds.shape)
+        img_embeds = self.vision_proj(img_embeds)
+        atts_img = torch.ones(img_embeds.size()[:-1], dtype=torch.long).to(
+            img_embeds.device
+        )
+
+        img_target = (
+            torch.ones(img_embeds.size()[:2], dtype=torch.long).to(img_embeds.device)
+            * -100
+        )
+
+        return img_embeds, atts_img, img_target
+
+    def prompt_wrap(self, img_embeds, prompt):
+        batch_size = img_embeds.shape[0]
+        p_before, p_after = prompt.split("<ImageHere>")
+        p_before_tokens = self.tokenizer(
+            p_before, return_tensors="pt", add_special_tokens=True
+        ).to(img_embeds.device)  # type: ignore
+
+        p_before_embeds = self.model.tok_embeddings(p_before_tokens.input_ids).expand(
+            batch_size, -1, -1
+        )
+        wrapped_img_embeds = torch.cat([p_before_embeds, img_embeds], dim=1)
+
+        wrapped_atts_img = torch.ones(
+            wrapped_img_embeds.size()[:-1], dtype=torch.long
+        ).to(img_embeds.device)
+
+        wrapped_target = (
+            torch.ones(batch_size, wrapped_img_embeds.shape[1], dtype=torch.long).to(
+                img_embeds.device
+            )
+            * -100
+        )
+
+        return wrapped_img_embeds, wrapped_atts_img, wrapped_target
+
+    def text2emb(self, text, add_special_tokens=False):
+        to_regress_tokens = self.tokenizer(
+            text,
+            return_tensors="pt",
+            padding="longest",
+            truncation=True,
+            max_length=self.max_length,
+            add_special_tokens=add_special_tokens,
+        ).to(self.device)  # type: ignore
+
+        targets = self.mask_human_targets(to_regress_tokens.input_ids)
+        targets = targets.to(self.device)
+        return to_regress_tokens, targets
+
+    def interleav_wrap_chat(
+        self, query, image, history=[], meta_instruction="", max_length=16384, hd_num=24
+    ):
+        self.max_length = max_length
+        prompt = ""
+        if meta_instruction:
+            prompt += (
+                f"""[UNUSED_TOKEN_146]system\n{meta_instruction}[UNUSED_TOKEN_145]\n"""
+            )
+        for record in history:
+            prompt += f"""[UNUSED_TOKEN_146]user\n{record[0]}[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n{record[1]}[UNUSED_TOKEN_145]\n"""
+        prompt += f"""[UNUSED_TOKEN_146]user\n{query}[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n"""
+
+        image_nums = len(image)
+        if image_nums == 1 and prompt.find("<ImageHere>") == -1:
+            # print ('auto append image at the begining')
+            prompt = "<ImageHere>" + prompt
+
+        parts = prompt.split("<ImageHere>")
+        wrap_embeds, wrap_im_mask = [], []
+        temp_len = 0
+        need_bos = True
+
+        if len(parts) != image_nums + 1:
+            # raise ValueError('Invalid <ImageHere> prompt format.')
+            print("Waring! The image number != given position!")
+        if image_nums > 1:
+            hd_num = 6
+
+        for idx, part in enumerate(parts):
+            if need_bos or len(part) > 0:
+                part_tokens = self.tokenizer(
+                    part,
+                    return_tensors="pt",
+                    padding="longest",
+                    add_special_tokens=need_bos,
+                ).to(self.device)  # type: ignore
+                if need_bos:
+                    need_bos = False
+
+                part_embeds = self.model.tok_embeddings(part_tokens.input_ids)
+                wrap_embeds.append(part_embeds)
+                wrap_im_mask.append(torch.zeros(part_embeds.shape[:2]))
+                temp_len += part_embeds.shape[1]
+            if idx < image_nums:
+                img = self.encode_img(image[idx], hd_num)
+                wrap_embeds.append(img)
+                wrap_im_mask.append(torch.ones(img.shape[:2]))
+                temp_len += img.shape[1]
+
+            if temp_len > self.max_length:
+                break
+
+        wrap_embeds = torch.cat(wrap_embeds, dim=1)
+        wrap_im_mask = torch.cat(wrap_im_mask, dim=1)
+        wrap_embeds = wrap_embeds[:, : self.max_length].to(self.device)
+        wrap_im_mask = wrap_im_mask[:, : self.max_length].to(self.device).bool()
+        inputs = {"inputs_embeds": wrap_embeds}
+        return inputs, wrap_im_mask, temp_len
+
+    def interleav_wrap(self, img_list: list[torch.Tensor], text_list, image_nums):
+        temp_embeds = []
+        temp_im_mask = []
+        temp_tars = []
+
+        # encode_image
+        if len(img_list) > 0:
+            img_embeds, img_split = self.vit(
+                img_list, self.plora_glb_GN, self.plora_sub_GN
+            )
+            img_embeds = self.vision_proj(img_embeds)
+        else:
+            img_embeds = None
+            img_split = []
+
+        text_list = text_list[0]
+        for idx, text in enumerate(text_list):
+            image_num = image_nums[idx]
+            im_id = int(np.sum(image_nums[:idx]))
+            images = []
+            for i in range(image_nums[idx]):
+                st = int(np.sum(img_split[: im_id + i]))
+                sp = img_split[im_id + i]
+                temp_img = img_embeds[:, st : st + sp]  # type: ignore
+                images.append(temp_img)
+
+            if image_num == 1 and text.find("<ImageHere>") == -1:
+                text = "<ImageHere>" + text
+            parts = text.split("<ImageHere>")
+
+            wrap_tokens, wrap_embeds, wrap_im_mask = [], [], []
+            temp_len = 0
+            need_bos = True
+            for idx, part in enumerate(parts):
+                if len(part) > 0:
+                    part_tokens = self.tokenizer(
+                        part,
+                        return_tensors="pt",
+                        padding="longest",
+                        add_special_tokens=need_bos,
+                    ).to(self.device)  # type: ignore
+                    if need_bos:
+                        need_bos = False
+                    wrap_tokens.append(part_tokens.input_ids)
+                    part_embeds = self.model.tok_embeddings(part_tokens.input_ids)
+                    wrap_embeds.append(part_embeds)
+                    wrap_im_mask.append(
+                        torch.zeros(part_embeds.shape[:2]).to(self.device)
+                    )
+                    temp_len += part_embeds.shape[1]
+                if idx < image_num:
+                    wrap_embeds.append(images[idx])
+                    wrap_token = (
+                        torch.ones(images[idx].shape[:2], dtype=torch.long).to(
+                            self.device
+                        )
+                        * -100
+                    )
+                    wrap_tokens.append(wrap_token)
+                    wrap_im_mask.append(
+                        torch.ones(images[idx].shape[:2]).to(self.device)
+                    )
+                    temp_len += images[idx].shape[1]
+                if temp_len > self.max_length:
+                    break
+            wrap_tokens = torch.cat(wrap_tokens, dim=1)
+            wrap_embeds = torch.cat(wrap_embeds, dim=1)
+            wrap_im_mask = torch.cat(wrap_im_mask, dim=1)
+
+            wrap_target = self.mask_human_targets(wrap_tokens).to(self.device)
+
+            temp_embeds.append(wrap_embeds)
+            temp_im_mask.append(wrap_im_mask)
+            temp_tars.append(wrap_target)
+
+        temp_max_len = np.max([i.shape[1] for i in temp_embeds])
+        temp_max_len = min(temp_max_len, self.max_length)
+
+        final_input, final_atts, final_tars, final_mask = [], [], [], []
+        pad = torch.ones([1, 1]) * self.tokenizer.pad_token_id  # type: ignore
+        pad = pad.long().to(self.device)
+        pad_emb = self.model.tok_embeddings(pad)
+
+        for idx in range(len(temp_embeds)):
+            temp_len = temp_embeds[idx].shape[1]
+            if temp_len >= temp_max_len:
+                final_input.append(temp_embeds[idx][:, :temp_max_len])
+                final_atts.append(
+                    torch.ones(1, temp_max_len).to(wrap_target.dtype).to(self.device)
+                )
+                final_tars.append(temp_tars[idx][:, :temp_max_len])
+                final_mask.append(temp_im_mask[idx][:, :temp_max_len])
+            else:
+                final_input.append(
+                    torch.cat(
+                        [
+                            temp_embeds[idx],
+                            pad_emb.repeat(1, temp_max_len - temp_len, 1),
+                        ],
+                        dim=1,
+                    )
+                )
+                final_atts.append(
+                    torch.cat(
+                        [
+                            torch.ones(1, temp_len),
+                            torch.zeros(1, temp_max_len - temp_len),
+                        ],
+                        dim=1,
+                    )
+                    .to(wrap_target.dtype)
+                    .to(self.device)
+                )
+                final_tars.append(
+                    torch.cat(
+                        [
+                            temp_tars[idx],
+                            (torch.ones(1, temp_max_len - temp_len) * -100)
+                            .to(wrap_target.dtype)
+                            .to(self.device),
+                        ],
+                        dim=1,
+                    )
+                )
+                final_mask.append(
+                    torch.cat(
+                        [
+                            temp_im_mask[idx],
+                            (torch.zeros(1, temp_max_len - temp_len))
+                            .to(wrap_target.dtype)
+                            .to(self.device),
+                        ],
+                        dim=1,
+                    )
+                )
+
+        inputs_embeds = torch.cat(final_input, dim=0)
+        attention_mask = torch.cat(final_atts, dim=0)
+        targets = torch.cat(final_tars, dim=0)
+        im_mask = torch.cat(final_mask, dim=0)
+
+        return inputs_embeds, attention_mask, targets, im_mask
+
+    def mask_human_targets(self, input_ids, pure=False):
+        target_batch = []
+        for bs in range(input_ids.shape[0]):
+            ids = input_ids[bs]
+            targets = copy.deepcopy(ids)
+            end_count = 0
+            last_eoa = 0
+            for i, temp_id in enumerate(ids):
+                if temp_id == 92542:
+                    if end_count % 2 == 0:
+                        targets[last_eoa : i + 6] = -100
+                    else:
+                        last_eoa = i + 1
+                    end_count += 1
+                # # eos and following pad
+                elif temp_id == 2:
+                    # loss on eos, but not on pad
+                    targets[i + 1 :] = -100
+                    break
+            # trunction, end at last question
+            if temp_id != 2 and end_count % 2 == 0:
+                # mask all after the last answer
+                targets[last_eoa + 1 :] = -100
+            target_batch.append(targets.unsqueeze(0))
+        target_batch = torch.cat(target_batch, dim=0)
+        return target_batch
+
+    @add_start_docstrings_to_model_forward(InternLM2_INPUTS_DOCSTRING)
+    @replace_return_docstrings(
+        output_type=CausalLMOutputWithPast, config_class=_CONFIG_FOR_DOC
+    )
+    def forward(
+        self,
+        input_ids: torch.LongTensor | None = None,
+        attention_mask: Optional[torch.Tensor] | None = None,
+        position_ids: Optional[torch.LongTensor] | None = None,
+        past_key_values: Optional[List[torch.FloatTensor]] | None = None,
+        inputs_embeds: Optional[torch.FloatTensor] | None = None,
+        labels: Optional[torch.LongTensor] | None = None,
+        use_cache: Optional[bool] | None = None,
+        output_attentions: Optional[bool] | None = None,
+        output_hidden_states: Optional[bool] | None = None,
+        return_dict: Optional[bool] | None = None,
+        **kwargs,
+    ) -> Union[Tuple, CausalLMOutputWithPast]:
+        r"""
+        Args:
+            labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+                Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
+                config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored
+                (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.
+        Returns:
+        """
+
+        samples = kwargs.get("samples", None)
+        if samples:
+            infer_mode = samples.get("infer_mode", "base")
+            if samples["data_type"][0] == "multi":
+                has_img = True
+            else:
+                has_img = False
+
+            # encode text
+            text = samples["text_input"]
+            # encode image
+            if has_img:
+                image = samples["image"][0]
+                bs = len(samples["text_input"][0])
+                image_nums = []
+                temp_image = []
+                for im in image:
+                    if type(im) is list:
+                        image_nums.append(len(im))
+                        temp_image.extend(im)
+                    else:
+                        image_nums.append(1)
+                        temp_image.append(im)
+                image = temp_image
+                assert type(image) is list and len(image_nums) == bs
+
+                to_regress_embeds, attention_mask, targets, im_mask = (
+                    self.interleav_wrap(image, text, image_nums)
+                )
+            else:
+                to_regress_tokens, targets = self.text2emb(
+                    text, add_special_tokens=True
+                )
+                to_regress_embeds = self.model.tok_embeddings(
+                    to_regress_tokens.input_ids
+                )
+                attention_mask = to_regress_tokens.attention_mask
+                im_mask = torch.zeros(to_regress_embeds.shape[:2]).cuda()
+
+            inputs_embeds = to_regress_embeds[:, : self.max_length]  # type: ignore
+            attention_mask = attention_mask[:, : self.max_length]  # type: ignore
+            targets = targets[:, : self.max_length]
+            im_mask = im_mask[:, : self.max_length].bool()
+            labels = targets  # type: ignore
+        else:
+            im_mask = kwargs.get("im_mask", None)
+            infer_mode = kwargs.get("infer_mode", "base")
+            if im_mask is None and inputs_embeds is not None:
+                im_mask = torch.zeros(inputs_embeds.shape[:2]).to(inputs_embeds.device)
+                im_mask = im_mask.bool()
+
+        output_attentions = (
+            output_attentions
+            if output_attentions is not None
+            else self.config.output_attentions
+        )
+        output_hidden_states = (
+            output_hidden_states
+            if output_hidden_states is not None
+            else self.config.output_hidden_states
+        )
+        return_dict = (
+            return_dict if return_dict is not None else self.config.use_return_dict
+        )
+
+        # decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn)
+        outputs = self.model(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            past_key_values=past_key_values,
+            inputs_embeds=inputs_embeds,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+            im_mask=im_mask,
+            infer_mode=infer_mode,
+        )
+
+        hidden_states = outputs[0]
+        logits = self.output(hidden_states)
+        logits = logits.float()
+
+        loss = None
+        if labels is not None:
+            # Shift so that tokens < n predict n
+            shift_logits = logits[..., :-1, :].contiguous()
+            shift_labels = labels[..., 1:].contiguous()
+            # Flatten the tokens
+            loss_fct = CrossEntropyLoss()
+            shift_logits = shift_logits.view(-1, self.config.vocab_size)
+            shift_labels = shift_labels.view(-1)
+            # Enable model parallelism
+            shift_labels = shift_labels.to(shift_logits.device)
+            loss = loss_fct(shift_logits, shift_labels)
+
+        if not return_dict:
+            output = (logits,) + outputs[1:]
+            return (loss,) + output if loss is not None else output
+
+        return CausalLMOutputWithPast(
+            loss=loss,
+            logits=logits,
+            past_key_values=outputs.past_key_values,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+
+    def prepare_inputs_for_generation(
+        self,
+        input_ids,
+        past_key_values=None,
+        attention_mask=None,
+        inputs_embeds=None,
+        im_mask=None,
+        infer_mode="base",
+        **kwargs,
+    ):
+        if past_key_values is not None:
+            past_length = past_key_values[0][0].shape[2]
+
+            # Some generation methods already pass only the last input ID
+            if input_ids.shape[1] > past_length:
+                remove_prefix_length = past_length
+            else:
+                # Default to old behavior: keep only final ID
+                remove_prefix_length = input_ids.shape[1] - 1
+
+            input_ids = input_ids[:, remove_prefix_length:]
+
+        position_ids = kwargs.get("position_ids", None)
+        if attention_mask is not None and position_ids is None:
+            # create position_ids on the fly for batch generation
+            position_ids = attention_mask.long().cumsum(-1) - 1
+            position_ids.masked_fill_(attention_mask == 0, 1)
+            if past_key_values:
+                position_ids = position_ids[:, -input_ids.shape[1] :]
+
+        # if `inputs_embeds` are passed, we only want to use them in the 1st generation step
+        if inputs_embeds is not None and past_key_values is None:
+            model_inputs = {"inputs_embeds": inputs_embeds}
+        else:
+            model_inputs = {"input_ids": input_ids}
+
+        im_mask = im_mask
+
+        model_inputs.update(
+            {
+                "position_ids": position_ids,
+                "past_key_values": past_key_values,
+                "use_cache": kwargs.get("use_cache"),
+                "attention_mask": attention_mask,
+                "im_mask": im_mask,
+                "infer_mode": infer_mode,
+            }
+        )
+        return model_inputs
+
+    @staticmethod
+    def _reorder_cache(past_key_values, beam_idx):
+        reordered_past = ()
+        for layer_past in past_key_values:
+            reordered_past += (
+                tuple(
+                    past_state.index_select(0, beam_idx.to(past_state.device))
+                    for past_state in layer_past
+                ),
+            )
+        return reordered_past
+
+    def build_inputs(
+        self,
+        tokenizer,
+        query: str,
+        history: List[Tuple[str, str]] = [],
+        meta_instruction="",
+    ):
+        prompt = ""
+        if meta_instruction:
+            prompt += f"""<s>[UNUSED_TOKEN_146]system\n{meta_instruction}[UNUSED_TOKEN_145]\n"""
+        else:
+            prompt += "<s>"
+        for record in history:
+            prompt += f"""[UNUSED_TOKEN_146]user\n{record[0]}[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n{record[1]}[UNUSED_TOKEN_145]\n"""
+        prompt += f"""[UNUSED_TOKEN_146]user\n{query}[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n"""
+        return tokenizer([prompt], return_tensors="pt")
+
+    @torch.no_grad()
+    def chat(
+        self,
+        tokenizer,
+        query: str,
+        image: List[Tuple[str, str]] = [],
+        hd_num: int = 24,
+        history: List[Tuple[str, str]] = [],
+        streamer: Optional[BaseStreamer] = None,
+        max_new_tokens: int = 1024,
+        do_sample: bool = True,
+        num_beams: int = 1,
+        temperature: float = 1.0,
+        top_p: float = 0.8,
+        repetition_penalty: float = 1.005,
+        infer_mode: str = "base",
+        use_meta: bool = False,
+        meta_instruction: str = "You are an AI assistant whose name is InternLM-XComposer (浦语·灵笔).\n"
+        "- InternLM-XComposer (浦语·灵笔) is a multi-modality conversational language model that is developed by Shanghai AI Laboratory (上海人工智能实验室). It is designed to be helpful, honest, and harmless.\n"
+        "- InternLM-XComposer (浦语·灵笔) can understand and communicate fluently in the language chosen by the user such as English and 中文.\n"
+        "- InternLM-XComposer (浦语·灵笔) is capable of comprehending and articulating responses effectively based on the provided image.",
+        **kwargs,
+    ):
+        if not use_meta:
+            meta_instruction = ""
+        if image is None:
+            inputs = self.build_inputs(tokenizer, query, history, meta_instruction)
+            im_mask = torch.zeros(inputs["input_ids"].shape[:2]).cuda().bool()
+        else:
+            inputs, im_mask, _ = self.interleav_wrap_chat(
+                query,
+                image,
+                history=history,
+                meta_instruction=meta_instruction,
+                hd_num=hd_num,
+            )
+        inputs = {k: v.to(self.device) for k, v in inputs.items() if torch.is_tensor(v)}
+        # also add end-of-assistant token in eos token id to avoid unnecessary generation
+        eos_token_id = [
+            tokenizer.eos_token_id,
+            tokenizer.convert_tokens_to_ids(["[UNUSED_TOKEN_145]"])[0],
+        ]
+        outputs = self.generate(
+            **inputs,
+            streamer=streamer,
+            max_new_tokens=max_new_tokens,
+            num_beams=num_beams,
+            do_sample=do_sample,
+            temperature=temperature,
+            top_p=top_p,
+            eos_token_id=eos_token_id,
+            repetition_penalty=repetition_penalty,
+            im_mask=im_mask,
+            infer_mode=infer_mode,
+            **kwargs,
+        )
+        if image is None:
+            outputs = outputs[0].cpu().tolist()[len(inputs["input_ids"][0]) :]
+        else:
+            outputs = outputs[0].cpu().tolist()
+        response = tokenizer.decode(outputs, skip_special_tokens=True)
+        response = response.split("[UNUSED_TOKEN_145]")[0]
+        history = history + [(query, response)]
+        return response, history
+
+    @torch.no_grad()
+    def write_artical(
+        self,
+        inst: str,
+        image: List[Tuple[str, str]] = [],
+        hd_num: int = 25,
+        history: List[Tuple[str, str]] = [],
+        streamer: Optional[BaseStreamer] = None,  # type: ignore
+        max_new_tokens: int = 1024,
+        do_sample: bool = True,
+        num_beams: int = 1,
+        temperature: float = 1.0,
+        top_p: float = 0.8,
+        repetition_penalty: float = 1.005,
+        max_length: int = 8192,
+        seed: int = -1,
+        use_meta: bool = False,
+        **kwargs,
+    ):
+        meta_instruction = """You are an AI assistant whose name is InternLM-XComposer (浦语·灵笔).
+- InternLM-XComposer (浦语·灵笔) is a conversational language model that is developed by Shanghai AI Laboratory (上海人工智能实验室). It is designed to be helpful, honest, and harmless.
+- InternLM-XComposer (浦语·灵笔) can understand and communicate fluently in the language chosen by the user such as English and 中文.
+"""
+        if seed != -1:
+            set_seed(seed)
+        if len(history):
+            print(
+                "Only chat function support multi round now, history will be ignored in the artical mode"
+            )
+        stop_words_ids = [92542]
+        stopping_criteria = get_stopping_criteria(stop_words_ids)
+
+        if not use_meta:
+            meta_instruction = ""
+        with torch.no_grad():
+            inputs, im_mask, len_input_tokens = self.interleav_wrap_chat(
+                inst, image, meta_instruction=meta_instruction, max_length=max_length
+            )
+        with torch.autocast(device_type="cuda", dtype=torch.float16):
+            with torch.no_grad():
+                generate = self.generate(
+                    inputs_embeds=inputs["inputs_embeds"],
+                    do_sample=do_sample,
+                    num_beams=num_beams,
+                    temperature=temperature,
+                    repetition_penalty=repetition_penalty,
+                    stopping_criteria=stopping_criteria,
+                    max_new_tokens=max_length - len_input_tokens,
+                    top_p=0.8,
+                    top_k=40,
+                    length_penalty=1.0,
+                    im_mask=im_mask,
+                    infer_mode="write",
+                )
+
+        response = generate[0].tolist()
+        response = self.tokenizer.decode(response, skip_special_tokens=True)  # type: ignore
+        # remove eoa
+        response = response.replace("[UNUSED_TOKEN_145]", "")
+        response = response.replace("[UNUSED_TOKEN_146]", "")
+
+        return response
+
+    @torch.no_grad()
+    def write_webpage(
+        self,
+        inst: str,
+        image: List[Tuple[str, str]] = [],
+        max_new_tokens: int = 4800,
+        do_sample: bool = True,
+        num_beams: int = 2,
+        temperature: float = 1.0,
+        repetition_penalty: float = 3.0,
+        seed: int = -1,
+        use_meta: bool = False,
+        task: str = "Instruction-aware Webpage Generation",
+        **kwargs,
+    ):
+        if seed != -1:
+            set_random_seed(seed, set_cudnn=True)
+        with torch.no_grad():
+            inputs, im_mask, len_input_tokens = self.interleav_wrap_chat(inst, image)
+
+        with torch.autocast(device_type="cuda", dtype=torch.float16):
+            with torch.no_grad():
+                generate = self.generate(
+                    inputs_embeds=inputs["inputs_embeds"],
+                    do_sample=do_sample,
+                    temperature=temperature,
+                    num_beams=num_beams,
+                    repetition_penalty=repetition_penalty,
+                    max_new_tokens=max_new_tokens,
+                    im_mask=im_mask,
+                    infer_mode="web",
+                )
+        response = generate[0].tolist()
+        response = self.tokenizer.decode(response, skip_special_tokens=True)  # type: ignore
+        # remove eoa
+        response = response.replace("[UNUSED_TOKEN_145]", "")
+        out = response.replace("[UNUSED_TOKEN_146]", "")
+        image_type = "random"
+        pattern = r"""https://source\.unsplash\.com/random/(\d+)x(\d+)/\?([^'"]+)"""
+        if image_type == "placeholder":
+            out = re.sub(pattern, r"https://placehold.co/\1x\2", out)
+        elif image_type == "random":
+            out = re.sub(pattern, r"https://picsum.photos/\1/\2", out)
+
+        with open(task.replace(" ", "_") + ".html", "w") as f:
+            f.write(out)
+        return out
+
+    @torch.no_grad()
+    def resume_2_webpage(
+        self,
+        inst: str,
+        image: List[Tuple[str, str]] = [],
+        max_new_tokens: int = 4800,
+        do_sample: bool = True,
+        num_beams: int = 2,
+        temperature: float = 1.0,
+        repetition_penalty: float = 3.0,
+        seed: int = -1,
+        use_meta: bool = False,
+        task: str = "Resume-to-Personal Page",
+        **kwargs,
+    ):
+        if seed != -1:
+            set_random_seed(seed, set_cudnn=True)
+        try:
+            with open(inst) as fd:
+                resume = fd.read()
+        except Exception:
+            print("The input should be a resume with markdown format.")
+        inst = " Generate a personal page using the content in the resume:" + resume
+        with torch.no_grad():
+            inputs, im_mask, len_input_tokens = self.interleav_wrap_chat(inst, image)
+        with torch.autocast(device_type="cuda", dtype=torch.float16):
+            with torch.no_grad():
+                generate = self.generate(
+                    inputs_embeds=inputs["inputs_embeds"],
+                    do_sample=do_sample,
+                    temperature=temperature,
+                    num_beams=num_beams,
+                    repetition_penalty=repetition_penalty,
+                    max_new_tokens=max_new_tokens,
+                    im_mask=im_mask,
+                    infer_mode="web",
+                )
+        response = generate[0].tolist()
+        response = self.tokenizer.decode(response, skip_special_tokens=True)  # type: ignore
+        # remove eoa
+        response = response.replace("[UNUSED_TOKEN_145]", "")
+        html = response.replace("[UNUSED_TOKEN_146]", "")
+
+        if seed != -1:
+            set_random_seed(seed, set_cudnn=True)
+        js_inst = " Generate JavaScript events for the html code:" + html
+        with torch.no_grad():
+            inputs, im_mask, len_input_tokens = self.interleav_wrap_chat(js_inst, image)
+        with torch.autocast(device_type="cuda", dtype=torch.float16):
+            with torch.no_grad():
+                generate = self.generate(
+                    inputs_embeds=inputs["inputs_embeds"],
+                    do_sample=do_sample,
+                    temperature=temperature,
+                    num_beams=num_beams,
+                    repetition_penalty=repetition_penalty,
+                    max_new_tokens=max_new_tokens,
+                    im_mask=im_mask,
+                    infer_mode="web",
+                )
+        response = generate[0].tolist()
+        response = self.tokenizer.decode(response, skip_special_tokens=True)  # type: ignore
+        # remove eoa
+        response = response.replace("[UNUSED_TOKEN_145]", "")
+        js = response.replace("[UNUSED_TOKEN_146]", "")
+
+        if re.search(r"</script>", html):
+            js = re.findall(r"<script>([\s\S]*?)<\/script>", js)
+            html = re.sub(r"(</script>)", f"\n{js}\n" + r"\1", html)
+        elif re.search(r"</html>", html):
+            html = re.sub(r"(</html>)", f"\n{js}\n" + r"\1", html)
+        out = html
+
+        image_type = "random"
+        pattern = r"""https://source\.unsplash\.com/random/(\d+)x(\d+)/\?([^'"]+)"""
+        if image_type == "placeholder":
+            out = re.sub(pattern, r"https://placehold.co/\1x\2", out)
+        elif image_type == "random":
+            out = re.sub(pattern, r"https://picsum.photos/\1/\2", out)
+
+        with open(task.replace(" ", "_") + ".html", "w") as f:
+            f.write(out)
+        return out
+
+    @torch.no_grad()
+    def screen_2_webpage(
+        self,
+        inst: str,
+        image: List[Tuple[str, str]] = [],
+        max_new_tokens: int = 4800,
+        do_sample: bool = True,
+        num_beams: int = 2,
+        temperature: float = 1.0,
+        repetition_penalty: float = 3.0,
+        seed: int = -1,
+        use_meta: bool = False,
+        task: str = "Screenshot-to-Webpage",
+        **kwargs,
+    ):
+        if seed != -1:
+            set_random_seed(seed, set_cudnn=True)
+        if len(image) == 0:
+            print("No image is provided, skip")
+            return ""
+        inst = " Generate the HTML code of this web image with Tailwind CSS."
+        with torch.no_grad():
+            inputs, im_mask, len_input_tokens = self.interleav_wrap_chat(inst, image)
+
+        with torch.autocast(device_type="cuda"):
+            with torch.no_grad():
+                generate = self.generate(
+                    inputs_embeds=inputs["inputs_embeds"],
+                    do_sample=do_sample,
+                    temperature=temperature,
+                    num_beams=num_beams,
+                    repetition_penalty=repetition_penalty,
+                    max_new_tokens=max_new_tokens,
+                    im_mask=im_mask,
+                    infer_mode="web",
+                )
+        response = generate[0].tolist()
+        response = self.tokenizer.decode(response, skip_special_tokens=True)  # type: ignore
+        # remove eoa
+        response = response.replace("[UNUSED_TOKEN_145]", "")
+        out = response.replace("[UNUSED_TOKEN_146]", "")
+        image_type = "random"
+        pattern = r"""https://source\.unsplash\.com/random/(\d+)x(\d+)/\?([^'"]+)"""
+        if image_type == "placeholder":
+            out = re.sub(pattern, r"https://placehold.co/\1x\2", out)
+        elif image_type == "random":
+            out = re.sub(pattern, r"https://picsum.photos/\1/\2", out)
+
+        with open(task.replace(" ", "_") + ".html", "w") as f:
+            f.write(out)
+        return out

pytorch_model-00001-of-00003.bin

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

pytorch_model-00002-of-00003.bin

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

pytorch_model-00003-of-00003.bin

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

special_tokens_map.json

@@ -0,0 +1,38 @@
+{
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|action_start|>",
+    "<|action_end|>",
+    "<|interpreter|>",
+    "<|plugin|>"
+  ],
+  "bos_token": {
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

tokenization_internlm2.py

@@ -0,0 +1,236 @@
+# coding=utf-8
+# Copyright (c) The InternLM team and The HuggingFace Inc. team. All rights reserved.
+#
+# This code is based on transformers/src/transformers/models/llama/tokenization_llama.py
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Tokenization classes for InternLM."""
+import os
+from shutil import copyfile
+from typing import Any, Dict, List, Optional, Tuple
+
+import sentencepiece as spm
+from transformers.tokenization_utils import PreTrainedTokenizer
+from transformers.utils import logging
+
+logger = logging.get_logger(__name__)
+
+VOCAB_FILES_NAMES = {"vocab_file": "./tokenizer.model"}
+
+PRETRAINED_VOCAB_FILES_MAP = {}
+
+
+# Modified from transformers.model.llama.tokenization_llama.LlamaTokenizer
+class InternLM2Tokenizer(PreTrainedTokenizer):
+    """
+    Construct a InternLM2 tokenizer. Based on byte-level Byte-Pair-Encoding.
+
+    Args:
+        vocab_file (`str`):
+            Path to the vocabulary file.
+    """
+
+    vocab_files_names = VOCAB_FILES_NAMES
+    pretrained_vocab_files_map = PRETRAINED_VOCAB_FILES_MAP
+    model_input_names = ["input_ids", "attention_mask"]
+    _auto_class = "AutoTokenizer"
+
+    def __init__(
+        self,
+        vocab_file,
+        unk_token="<unk>",
+        bos_token="<s>",
+        eos_token="</s>",
+        pad_token="</s>",
+        sp_model_kwargs: Optional[Dict[str, Any]] = None,
+        add_bos_token=True,
+        add_eos_token=False,
+        decode_with_prefix_space=False,
+        clean_up_tokenization_spaces=False,
+        **kwargs,
+    ):
+        self.sp_model_kwargs = {} if sp_model_kwargs is None else sp_model_kwargs
+        self.vocab_file = vocab_file
+        self.add_bos_token = add_bos_token
+        self.add_eos_token = add_eos_token
+        self.decode_with_prefix_space = decode_with_prefix_space
+        self.sp_model = spm.SentencePieceProcessor(**self.sp_model_kwargs)
+        self.sp_model.Load(vocab_file)
+        self._no_prefix_space_tokens = None
+        super().__init__(
+            bos_token=bos_token,
+            eos_token=eos_token,
+            unk_token=unk_token,
+            pad_token=pad_token,
+            clean_up_tokenization_spaces=clean_up_tokenization_spaces,
+            **kwargs,
+        )
+
+    @property
+    def no_prefix_space_tokens(self):
+        if self._no_prefix_space_tokens is None:
+            vocab = self.convert_ids_to_tokens(list(range(self.vocab_size)))
+            self._no_prefix_space_tokens = {i for i, tok in enumerate(vocab) if not tok.startswith("▁")}
+        return self._no_prefix_space_tokens
+
+    @property
+    def vocab_size(self):
+        """Returns vocab size"""
+        return self.sp_model.get_piece_size()
+
+    @property
+    def bos_token_id(self) -> Optional[int]:
+        return self.sp_model.bos_id()
+
+    @property
+    def eos_token_id(self) -> Optional[int]:
+        return self.sp_model.eos_id()
+
+    def get_vocab(self):
+        """Returns vocab as a dict"""
+        vocab = {self.convert_ids_to_tokens(i): i for i in range(self.vocab_size)}
+        vocab.update(self.added_tokens_encoder)
+        return vocab
+
+    def _tokenize(self, text):
+        """Returns a tokenized string."""
+        return self.sp_model.encode(text, out_type=str)
+
+    def _convert_token_to_id(self, token):
+        """Converts a token (str) in an id using the vocab."""
+        return self.sp_model.piece_to_id(token)
+
+    def _convert_id_to_token(self, index):
+        """Converts an index (integer) in a token (str) using the vocab."""
+        token = self.sp_model.IdToPiece(index)
+        return token
+
+    def _maybe_add_prefix_space(self, tokens, decoded):
+        if tokens and tokens[0] not in self.no_prefix_space_tokens:
+            return " " + decoded
+        else:
+            return decoded
+
+    def convert_tokens_to_string(self, tokens):
+        """Converts a sequence of tokens (string) in a single string."""
+        current_sub_tokens = []
+        out_string = ""
+        prev_is_special = False
+        for token in tokens:
+            # make sure that special tokens are not decoded using sentencepiece model
+            if token in self.all_special_tokens:
+                if not prev_is_special:
+                    out_string += " "
+                out_string += self.sp_model.decode(current_sub_tokens) + token
+                prev_is_special = True
+                current_sub_tokens = []
+            else:
+                current_sub_tokens.append(token)
+                prev_is_special = False
+        out_string += self.sp_model.decode(current_sub_tokens)
+        out_string = self.clean_up_tokenization(out_string)
+        out_string = self._maybe_add_prefix_space(tokens=tokens, decoded=out_string)
+        return out_string[1:]
+
+    def save_vocabulary(self, save_directory, filename_prefix: Optional[str] = None) -> Tuple[str]:
+        """
+        Save the vocabulary and special tokens file to a directory.
+
+        Args:
+            save_directory (`str`):
+                The directory in which to save the vocabulary.
+
+        Returns:
+            `Tuple(str)`: Paths to the files saved.
+        """
+        if not os.path.isdir(save_directory):
+            logger.error(f"Vocabulary path ({save_directory}) should be a directory")
+            return
+        out_vocab_file = os.path.join(
+            save_directory, (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]
+        )
+
+        if os.path.abspath(self.vocab_file) != os.path.abspath(out_vocab_file) and os.path.isfile(self.vocab_file):
+            copyfile(self.vocab_file, out_vocab_file)
+        elif not os.path.isfile(self.vocab_file):
+            with open(out_vocab_file, "wb") as fi:
+                content_spiece_model = self.sp_model.serialized_model_proto()
+                fi.write(content_spiece_model)
+
+        return (out_vocab_file,)
+
+    def build_inputs_with_special_tokens(self, token_ids_0, token_ids_1=None):
+        if self.add_bos_token:
+            bos_token_ids = [self.bos_token_id]
+        else:
+            bos_token_ids = []
+
+        output = bos_token_ids + token_ids_0
+
+        if token_ids_1 is not None:
+            output = output + token_ids_1
+
+        if self.add_eos_token:
+            output = output + [self.eos_token_id]
+
+        return output
+
+    def get_special_tokens_mask(
+        self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None, already_has_special_tokens: bool = False
+    ) -> List[int]:
+        """
+        Retrieve sequence ids from a token list that has no special tokens added. This method is called when adding
+        special tokens using the tokenizer `prepare_for_model` method.
+
+        Args:
+            token_ids_0 (`List[int]`):
+                List of IDs.
+            token_ids_1 (`List[int]`, *optional*):
+                Optional second list of IDs for sequence pairs.
+            already_has_special_tokens (`bool`, *optional*, defaults to `False`):
+                Whether or not the token list is already formatted with special tokens for the model.
+
+        Returns:
+            `List[int]`: A list of integers in the range [0, 1]: 1 for a special token, 0 for a sequence token.
+        """
+        if already_has_special_tokens:
+            return super().get_special_tokens_mask(
+                token_ids_0=token_ids_0, token_ids_1=token_ids_1, already_has_special_tokens=True
+            )
+
+        if token_ids_1 is None:
+            return [1] + ([0] * len(token_ids_0)) + [1]
+        return [1] + ([0] * len(token_ids_0)) + [1, 1] + ([0] * len(token_ids_1)) + [1]
+
+    def create_token_type_ids_from_sequences(
+        self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None
+    ) -> List[int]:
+        """
+        Create a mask from the two sequences passed to be used in a sequence-pair classification task. T5 does not make
+        use of token type ids, therefore a list of zeros is returned.
+
+        Args:
+            token_ids_0 (`List[int]`):
+                List of IDs.
+            token_ids_1 (`List[int]`, *optional*):
+                Optional second list of IDs for sequence pairs.
+
+        Returns:
+            `List[int]`: List of zeros.
+        """
+        eos = [self.eos_token_id]
+
+        if token_ids_1 is None:
+            return len(token_ids_0 + eos) * [0]
+        return len(token_ids_0 + eos + token_ids_1 + eos) * [0]

tokenizer.model

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

tokenizer_config.json

@@ -0,0 +1,99 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "<unk>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "<s>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "</s>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "92538": {
+      "content": "<|plugin|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "92539": {
+      "content": "<|interpreter|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "92540": {
+      "content": "<|action_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "92541": {
+      "content": "<|action_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "92542": {
+      "content": "<|im_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "92543": {
+      "content": "<|im_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|action_start|>",
+    "<|action_end|>",
+    "<|interpreter|>",
+    "<|plugin|>"
+  ],
+  "auto_map": {
+    "AutoTokenizer": [
+      "tokenization_internlm2.InternLM2Tokenizer",
+      null
+    ]
+  },
+  "bos_token": "<s>",
+  "chat_template": "{{ bos_token }}{% for message in messages %}{{'<|im_start|>' + message['role'] + '\n' + message['content'] + '<|im_end|>' + '\n'}}{% endfor %}{% if add_generation_prompt %}{{ '<|im_start|>assistant\n' }}{% endif %}",
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "</s>",
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": "</s>",
+  "padding_side": "right",
+  "tokenizer_class": "InternLM2Tokenizer",
+  "unk_token": "<unk>"
+}