Upload 14 files

.gitattributes

@@ -66,3 +66,7 @@ aicg/csvs/Log_20230417_203437.csv filter=lfs diff=lfs merge=lfs -text
 aicg/csvs/Log_20230417_210300.csv filter=lfs diff=lfs merge=lfs -text
 aicg/csvs/merged.csv filter=lfs diff=lfs merge=lfs -text
 aicg/instruct_output.json filter=lfs diff=lfs merge=lfs -text
+ShareGPT_Vicuna_unfiltered/Experimental/removals.log filter=lfs diff=lfs merge=lfs -text
+ShareGPT_Vicuna_unfiltered/Experimental/ShareGPT_2023.05.04v_NoUnicode_Edition.json filter=lfs diff=lfs merge=lfs -text
+ShareGPT_Vicuna_unfiltered/Experimental/ShareGPT_2023.05.04v1_Nano_Wasteland.json filter=lfs diff=lfs merge=lfs -text
+ShareGPT_Vicuna_unfiltered/ShareGPT_2023.05.08v0_Wasteland_Edition.json filter=lfs diff=lfs merge=lfs -text

ShareGPT_Vicuna_unfiltered/Experimental/ShareGPT_2023.05.04v1_Nano_Wasteland.json

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

ShareGPT_Vicuna_unfiltered/Experimental/ShareGPT_2023.05.04v_NoUnicode_Edition.json

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

ShareGPT_Vicuna_unfiltered/Experimental/removals.log

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

ShareGPT_Vicuna_unfiltered/ShareGPT_2023.05.08v0_Wasteland_Edition.json

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

ShareGPT_Vicuna_unfiltered/Vicuna_unfiltered_train.ipynb

@@ -0,0 +1,157 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**You may encounter an error when installing flash-attn. I couldn't figure it out. Maybe you can.**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "background_save": true,
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "h_MevKtB0dEw",
+    "outputId": "ae41454e-e28f-4d8c-dcc6-f97399b31b8b",
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "%pip install torch==1.13.1+cu116 torchvision==0.14.1+cu116 torchaudio==0.13.1 --extra-index-url https://download.pytorch.org/whl/cu116\n",
+    "!cd ~\n",
+    "!git clone https://github.com/huggingface/transformers.git && cd transformers && git checkout cae78c46 && pip install .\n",
+    "# Install fastchat\n",
+    "!pip3 install --upgrade pip\n",
+    "!git clone https://github.com/lm-sys/FastChat && cd FastChat && pip install -e .\n",
+    "%pip install einops\n",
+    "!mkdir checkpoints\n",
+    "!wget https://huggingface.co/datasets/anon8231489123/ShareGPT_Vicuna_unfiltered/resolve/main/flash_attn-0.2.8-cp39-cp39-linux_x86_64.whl\n",
+    "%pip install flash_attn-0.2.8-cp39-cp39-linux_x86_64.whl"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "6SNhHJFz-28c",
+    "outputId": "8b308465-e51f-46e3-8674-39a234c17d50"
+   },
+   "outputs": [],
+   "source": [
+    "!wget https://raw.githubusercontent.com/oobabooga/text-generation-webui/main/download-model.py\n",
+    "!mkdir models\n",
+    "!wget https://huggingface.co/datasets/anon8231489123/ShareGPT_Vicuna_unfiltered/resolve/main/ShareGPT_V2_unfiltered_cleaned_split.json\n",
+    "!python download-model.py decapoda-research/llama-13b-hf"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Manually edit tokenizer_config.json to: {\"bos_token\": \"\", \"eos_token\": \"\", \"model_max_length\": 2048, \"tokenizer_class\": \"LlamaTokenizer\", \"unk_token\": \"\"}**"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Enter wandb api key**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%pip install wandb\n",
+    "import wandb\n",
+    "wandb.login()"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "ya2NjlT7BZ2q"
+   },
+   "source": [
+    "**8 x A100 80gb training run** "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "9PUdb3ZY4FkK",
+    "outputId": "f9b1aae9-72d3-4137-800a-97c482660860",
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "!torchrun --nnodes=1 --nproc_per_node=8 --master_port=21001 \\\n",
+    "    FastChat/fastchat/train/train.py \\\n",
+    "    --model_name_or_path models/decapoda-research_llama-13b-hf \\\n",
+    "    --data_path ShareGPT_unfiltered_cleaned_split.json \\\n",
+    "    --bf16 True \\\n",
+    "    --output_dir ./checkpoints \\\n",
+    "    --num_train_epochs 3 \\\n",
+    "    --per_device_train_batch_size 4 \\\n",
+    "    --per_device_eval_batch_size 4 \\\n",
+    "    --gradient_accumulation_steps 1 \\\n",
+    "    --evaluation_strategy \"no\" \\\n",
+    "    --save_strategy \"steps\" \\\n",
+    "    --save_steps 1200 \\\n",
+    "    --save_total_limit 100 \\\n",
+    "    --learning_rate 2e-5 \\\n",
+    "    --weight_decay 0. \\\n",
+    "    --warmup_ratio 0.03 \\\n",
+    "    --lr_scheduler_type \"cosine\" \\\n",
+    "    --logging_steps 1 \\\n",
+    "    --fsdp \"full_shard auto_wrap\" \\\n",
+    "    --fsdp_transformer_layer_cls_to_wrap 'LlamaDecoderLayer' \\\n",
+    "    --tf32 True \\\n",
+    "    --model_max_length 2048 \\\n",
+    "    --gradient_checkpointing True \\\n",
+    "    --lazy_preprocess True"
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}

ShareGPT_Vicuna_unfiltered/classify.py

@@ -0,0 +1,102 @@
+import json
+import os
+from sentence_transformers import SentenceTransformer, util
+from tqdm import tqdm
+import concurrent.futures
+
+# File to classify data in.
+filePath = "ShareGPT_2023.05.02v0_unfiltered_cleaned_split.json"
+
+# Threshold Settings
+refusal_threshold = 0.5
+non_refusal_threshold = 0.5
+
+# Example refusal and non-refusal sentences
+refusals = ["I'm sorry, I cannot complete the request.", "It is not possible to provide that information.", "Sorry, but we don't allow questions like that.", " We won't be able to assist you with that."]
+non_refusals = ["Sure, I can do that.", "No problem, I can do that for you.", "Here is the information you asked for."]
+
+# Set the max workers to half the available cores
+max_workers = os.cpu_count() // 2
+
+# Define a function that takes a conversation and returns a label and an example sentence
+def process_conversation(conversation):
+	global max_refusal, max_non_refusal, refusal_threshold, non_refusal_threshold
+
+	value = conversation["value"]
+	value_vec = model.encode(value, convert_to_tensor=True)
+
+	# Compute the cosine similarity with the example sentences
+	refusals_sim = util.pytorch_cos_sim(value_vec, refusals_vec)
+	non_refusals_sim = util.pytorch_cos_sim(value_vec, non_refusals_vec)
+
+	# Find the maximum similarity score and index for each category
+	refusals_max_sim, refusals_max_idx = refusals_sim.max(dim=1)
+	non_refusals_max_sim, non_refusals_max_idx = non_refusals_sim.max(dim=1)
+	
+	if(refusals_max_sim > max_refusal):
+		max_refusal = refusals_max_sim.item()
+	if(non_refusals_max_sim > max_non_refusal):
+		max_non_refusal = non_refusals_max_sim.item()
+
+
+	if refusals_max_sim > refusal_threshold and refusals_max_sim > non_refusals_max_sim:
+		label = "refusal"
+		example = refusals[refusals_max_idx]
+	elif non_refusals_max_sim > non_refusal_threshold and non_refusals_max_sim > refusals_max_sim:
+		label = "non-refusal"
+		example = non_refusals[non_refusals_max_idx]
+	else:
+		label = "unrelated"
+		example = None
+
+	return label, example, value
+
+
+with open(filePath, "r", encoding="utf-8") as f:
+	data = json.load(f)
+	
+bad_ids = []
+
+max_refusal = 0.0
+max_non_refusal = 0.0
+
+# Load a pre-trained sentence-transformer model
+model = SentenceTransformer("paraphrase-MiniLM-L6-v2")
+
+refusals_vec = model.encode(refusals, convert_to_tensor=True)
+non_refusals_vec = model.encode(non_refusals, convert_to_tensor=True)
+
+refusal_count = 0
+non_refusal_count = 0
+unrelated_count = 0
+
+pbar1 = tqdm(data)
+for item in pbar1:
+
+	id_ = item["id"]
+
+	with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+		
+		futures = [executor.submit(process_conversation, conversation) for conversation in item["conversations"] if conversation["from"] == "gpt"]
+
+		for future in concurrent.futures.as_completed(futures):
+			
+			label, example, value = future.result()
+			
+			if label == "refusal":
+				item = {}
+				item["id"] = id_
+				item["value"] = value
+				bad_ids.append(item)
+				print(f"\nID: {id_} | Value: {value}");
+				refusal_count += 1
+			elif label == "non-refusal":
+				non_refusal_count += 1
+			else:
+				unrelated_count += 1
+
+			pbar1.set_description("Max Refusal: {:.3f}".format(max_refusal));
+			pbar1.set_postfix(r=refusal_count, u=unrelated_count)
+
+with open("possible_bad_entries.json", "w") as f:
+    json.dump(bad_ids, f)

ShareGPT_Vicuna_unfiltered/clean_sharegpt.py

@@ -0,0 +1,150 @@
+"""
+Usage: python3 -m fastchat.data.clean_sharegpt --in sharegpt_html.json --out sharegpt_clean.json
+"""
+import argparse
+import json
+import logging
+import re
+from typing import Dict, Union
+
+import bs4
+import markdownify  # == 0.11.6
+import tqdm
+
+
+def _get_html_tags(file_path: str):
+    # Generate the list of html tags occured in the file.
+    s = set()
+    for l in open("file_path", "r"):
+        for m in re.findall("</[^<>]+>", l):
+            s.add(m)
+    return s
+
+div_pattern = re.compile("<div.*?>")
+span_pattern = re.compile("<span.*?>")
+code_lang_pattern = re.compile("```\s*" + "(.*?)" + "(?:Copy code)+" + "(.+?)" + "\s*?```", re.DOTALL)
+code_lang_format = "```\g<1>\n\g<2>\n```"
+regenerate_pattern = re.compile("\d+ / \d+")
+copy_chars_pattern = re.compile("Copy\d+ chars / \d+ words")
+copy_code_pattern = re.compile("```(.*?)Copy code\s*```")
+
+def reformat_code(val: str) -> str:
+    # Input code format is:
+    # ```
+    # $<language>Copy code$<exact_code_here>
+    #
+    # ```
+    # This function convert it into the correct markdown format
+    return re.sub(code_lang_pattern, code_lang_format, val)
+
+
+def html_to_markdown(val: str) -> str:
+    # Remove all <div>. This is required to make intent work in code blocks.
+    val = re.sub(div_pattern, "", val)
+    # Remove all <span>. This is required to make underscores work in code blocks.
+    val = re.sub(span_pattern, "", val)
+    # Markdown to html
+    val = markdownify.markdownify(val).strip()
+    # Reformat code
+    val = reformat_code(val)
+
+    # Remove noisy "[number] / [number]" at the beginning
+    noise = re.search(regenerate_pattern, val)
+    if noise and noise.start() == 0:
+        val = val[noise.end():]
+    # Remove noisy "Copy[number] chars / [number] words"
+    val = re.sub(copy_chars_pattern, "", val)
+    # Remove empty code block ```\nCopy code\n```
+    val = re.sub(copy_code_pattern, "", val)
+
+    # Strip
+    val = val.replace("\n\n\n", "\n").strip()
+
+    if args.debug:
+        print(val)
+        exit()
+
+    return val
+
+
+def should_skip(val: str) -> bool:
+    black_list = ["openai", "chatgpt"]
+    for w in black_list:
+        if w in val.lower():
+            return True
+    return False
+
+
+def clean_html_source(content, begin, end, check_tag, check_num):
+    """
+    clean the input json content.
+    Args:
+        content: json file loaded in memory.
+        check_tag: a debug purpose arg. If a conversation contains the tag, log
+          it before and after cleaning.
+        check_num: number of matched conversations logged.
+    """
+    BARRIER = "\n" + "=" * 20 + "\n"
+    skip_cnt = 0
+    tag_cnt = 0
+
+    content = content[begin:end]
+    new_content = []
+
+    for sample in tqdm.tqdm(content):
+        skipped = False
+
+        if len(sample["conversations"]) <= 1:
+            # The conversation is too short
+            skipped = True
+        else:
+            for c in sample["conversations"]:
+                if should_skip(c["value"]):
+                    skipped = True
+                    break
+
+                try:
+                    new_val = html_to_markdown(c["value"])
+                except (bs4.builder.ParserRejectedMarkup, AssertionError):
+                    skipped = True
+                    break
+
+                c["value"] = new_val
+
+                # Debug
+                if (check_tag is not None and check_tag in c["value"]
+                        and tag_cnt < check_num):
+                    logging.debug(BARRIER + c["value"] + "\n" + BARRIER + new_val +
+                                  "\n" + BARRIER + "\n")
+                    tag_cnt += 1
+                    if tag_cnt == check_num:
+                        break
+
+        if not skipped:
+            new_content.append(sample)
+        else:
+            skip_cnt += 1
+
+    print(f"total: {len(content)}, skip: {skip_cnt}, new: {len(new_content)}")
+    return new_content
+
+
+def main(args):
+    content = json.load(open(args['in_file'], "r"))
+    content = clean_html_source(
+        content, args['begin'], args['end'],
+        args['check_tag'], args['check_num'])
+    json.dump(content, open(args['out_file'], "w"), indent=2)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--in-file", type=str, required=True)
+    parser.add_argument("--out-file", type=str, default="sharegpt_clean.json")
+    parser.add_argument("--begin", type=int)
+    parser.add_argument("--end", type=int)
+    parser.add_argument("--debug", action="store_true")
+    parser.add_argument("--check-tag", type=str)
+    parser.add_argument("--check-num", type=int, default=1)
+    args = parser.parse_args()
+    main(vars(args))

ShareGPT_Vicuna_unfiltered/deduplicate.py

@@ -0,0 +1,48 @@
+import json
+from typing import List, Tuple
+from concurrent.futures import ProcessPoolExecutor, as_completed
+import logging
+from hashlib import md5
+
+from tqdm import tqdm
+
+
+# Percentage of similarity between two conversations to be considered a duplicate
+similarity_threshold = 80
+
+
+def remove_duplicates(conversations: List[dict]) -> List[dict]:
+    unique_ids = {}
+    unique_hashes = set()
+
+    with ProcessPoolExecutor() as executor:
+        futures = {executor.submit(check_unique, conversation, unique_hashes): conversation for conversation in conversations}
+        total_tasks = len(futures)
+
+        for future in tqdm(as_completed(futures), total=total_tasks, desc="Deduplicating", unit="conversations"):
+            is_unique, conversation = future.result()
+            if is_unique:
+                id_ = conversation.pop('id')
+                hash_ = conversation_hash(conversation)
+                unique_ids[hash_] = (id_, conversation)
+                unique_hashes.add(hash_)
+            else:
+                logging.debug(f"Duplicate found: {conversation}")
+
+        executor.shutdown(wait=True)
+
+    return [{'id': unique_ids[hash_][0], **unique_ids[hash_][1]} for hash_ in unique_hashes]
+
+
+def check_unique(conversation: dict, unique_hashes: set) -> Tuple[bool, dict]:
+    hash_ = conversation_hash(conversation)
+
+    if hash_ in unique_hashes:
+        return False, conversation
+
+    return True, conversation
+
+
+def conversation_hash(conversation: dict) -> str:
+    set_ = frozenset((msg['value'] for msg in conversation['conversations']))
+    return md5(json.dumps(sorted(list(set_))).encode()).hexdigest()

ShareGPT_Vicuna_unfiltered/fastchat_validate.py

@@ -0,0 +1,187 @@
+import dataclasses
+from enum import auto, Enum
+from typing import List, Tuple, Any
+
+
+def get_default_conv_template(model_name):
+	model_name = model_name.lower()
+	if "vicuna" in model_name or "output" in model_name:
+		return conv_vicuna_v1_1
+	return conv_one_shot
+
+def preprocess(sources):
+	conv = get_default_conv_template("vicuna").copy()
+	roles = {"human": conv.roles[0], "gpt": conv.roles[1]}
+	# Apply prompt templates
+	conversations = []
+	for i, source in enumerate(sources):
+		if roles[source[0]["from"]] != conv.roles[0]:
+			# Skip the first one if it is not from human
+			source = source[1:]
+
+		conv.messages = []
+		for j, sentence in enumerate(source):
+			role = roles[sentence["from"]]
+			assert role == conv.roles[j % 2], f"{i}"
+			conv.append_message(role, sentence["value"])
+		conversations.append(conv.get_prompt())
+
+	
+class SeparatorStyle(Enum):
+	"""Different separator style."""
+
+	SINGLE = auto()
+	TWO = auto()
+	DOLLY = auto()
+	OASST_PYTHIA = auto()
+	BAIZE = auto()
+	
+@dataclasses.dataclass
+class Conversation:
+	"""A class that keeps all conversation history."""
+
+	system: str
+	roles: List[str]
+	messages: List[List[str]]
+	offset: int
+	sep_style: SeparatorStyle = SeparatorStyle.SINGLE
+	sep: str = "###"
+	sep2: str = None
+
+	# Used for the state in the gradio servers.
+	# TODO(lmzheng): refactor this
+	conv_id: Any = None
+	skip_next: bool = False
+	model_name: str = None
+
+	def get_prompt(self):
+		if self.sep_style == SeparatorStyle.SINGLE:
+			ret = self.system
+			for role, message in self.messages:
+				if message:
+					ret += self.sep + " " + role + ": " + message
+				else:
+					ret += self.sep + " " + role + ":"
+			return ret
+		elif self.sep_style == SeparatorStyle.TWO:
+			seps = [self.sep, self.sep2]
+			ret = self.system + seps[0]
+			for i, (role, message) in enumerate(self.messages):
+				if message:
+					ret += role + ": " + message + seps[i % 2]
+				else:
+					ret += role + ":"
+			return ret
+		elif self.sep_style == SeparatorStyle.DOLLY:
+			seps = [self.sep, self.sep2]
+			ret = self.system
+			for i, (role, message) in enumerate(self.messages):
+				if message:
+					ret += role + ":\n" + message + seps[i % 2]
+					if i % 2 == 1:
+						ret += "\n\n"
+				else:
+					ret += role + ":\n"
+			return ret
+		elif self.sep_style == SeparatorStyle.OASST_PYTHIA:
+			ret = self.system
+			for role, message in self.messages:
+				if message:
+					ret += role + message + self.sep
+				else:
+					ret += role
+			return ret
+		elif self.sep_style == SeparatorStyle.BAIZE:
+			ret = self.system
+			for role, message in self.messages:
+				if message:
+					ret += "\n" + role + message
+				else:
+					ret += "\n" + role
+			return ret
+		else:
+			raise ValueError(f"Invalid style: {self.sep_style}")
+
+	def append_message(self, role, message):
+		self.messages.append([role, message])
+
+	def to_gradio_chatbot(self):
+		ret = []
+		for i, (role, msg) in enumerate(self.messages[self.offset :]):
+			if i % 2 == 0:
+				ret.append([msg, None])
+			else:
+				ret[-1][-1] = msg
+		return ret
+
+	def copy(self):
+		return Conversation(
+			system=self.system,
+			roles=self.roles,
+			messages=[[x, y] for x, y in self.messages],
+			offset=self.offset,
+			sep_style=self.sep_style,
+			sep=self.sep,
+			sep2=self.sep2,
+			conv_id=self.conv_id,
+			model_name=self.model_name,
+		)
+
+	def dict(self):
+		return {
+			"system": self.system,
+			"roles": self.roles,
+			"messages": self.messages,
+			"offset": self.offset,
+			"sep": self.sep,
+			"sep2": self.sep2,
+			"conv_id": self.conv_id,
+			"model_name": self.model_name,
+		}
+
+conv_vicuna_v1_1 = Conversation(
+	system="A chat between a curious user and an artificial intelligence assistant. "
+	"The assistant gives helpful, detailed, and polite answers to the user's questions.",
+	roles=("USER", "ASSISTANT"),
+	messages=(),
+	offset=0,
+	sep_style=SeparatorStyle.TWO,
+	sep=" ",
+	sep2="</s>",
+)
+
+conv_one_shot = Conversation(
+	system="A chat between a curious human and an artificial intelligence assistant. "
+	"The assistant gives helpful, detailed, and polite answers to the human's questions.",
+	roles=("Human", "Assistant"),
+	messages=(
+		(
+			"Human",
+			"What are the key differences between renewable and non-renewable energy sources?",
+		),
+		(
+			"Assistant",
+			"Renewable energy sources are those that can be replenished naturally in a relatively "
+			"short amount of time, such as solar, wind, hydro, geothermal, and biomass. "
+			"Non-renewable energy sources, on the other hand, are finite and will eventually be "
+			"depleted, such as coal, oil, and natural gas. Here are some key differences between "
+			"renewable and non-renewable energy sources:\n"
+			"1. Availability: Renewable energy sources are virtually inexhaustible, while non-renewable "
+			"energy sources are finite and will eventually run out.\n"
+			"2. Environmental impact: Renewable energy sources have a much lower environmental impact "
+			"than non-renewable sources, which can lead to air and water pollution, greenhouse gas emissions, "
+			"and other negative effects.\n"
+			"3. Cost: Renewable energy sources can be more expensive to initially set up, but they typically "
+			"have lower operational costs than non-renewable sources.\n"
+			"4. Reliability: Renewable energy sources are often more reliable and can be used in more remote "
+			"locations than non-renewable sources.\n"
+			"5. Flexibility: Renewable energy sources are often more flexible and can be adapted to different "
+			"situations and needs, while non-renewable sources are more rigid and inflexible.\n"
+			"6. Sustainability: Renewable energy sources are more sustainable over the long term, while "
+			"non-renewable sources are not, and their depletion can lead to economic and social instability.",
+		),
+	),
+	offset=2,
+	sep_style=SeparatorStyle.SINGLE,
+	sep="###",
+)

ShareGPT_Vicuna_unfiltered/merge_json.js

@@ -0,0 +1,36 @@
+const fs = require('fs');
+
+function loadAndConcatJSON(files, callback)
+{
+	let data = [];
+	for (let file of files)
+	{
+		data.push(require(file));
+	}
+
+	let output = [].concat(...data);
+	output = JSON.stringify(output);
+
+	fs.writeFile('output.json', output, err =>
+	{
+		if (err)
+		{
+			callback(err);
+		} else
+		{
+			callback(null, output);
+		}
+	});
+}
+
+
+loadAndConcatJSON(['./filtered-vicuna-formatted.json', './filtered.json'], (err, result) => {
+	if (err)
+	{
+		console.error(err);
+	}
+	else
+	{
+		console.log("Merged JSON files.");
+	}
+});

ShareGPT_Vicuna_unfiltered/optional_clean.py

@@ -0,0 +1,497 @@
+import argparse
+import json
+import re
+import os
+import logging
+import unicodedata
+import multiprocessing
+from functools import partial
+
+from langdetect import detect_langs
+from tqdm import tqdm
+from emoji import EMOJI_DATA
+
+import fastchat_validate
+import deduplicate
+
+
+def detect_language(text):
+	try:
+		detected_langs = detect_langs(text)
+		lang_code = detected_langs[0].lang
+	except Exception:
+		lang_code = "unknown"
+	return lang_code
+
+
+def contains_unwanted_words(text):
+	unwanted_words = [
+		"text-based AI language model",
+		"domestic violence",
+		"please refrain",
+		"derogatory",
+		"inappropriate",
+		"offensive",
+		"racism",
+		"racist",
+		"racial",
+		"discriminate",
+		"discriminatory",
+		"discrimination",
+		"sexist",
+		"sexism",
+		"unacceptable",
+		"inclusive workplace",
+		"lgbt",
+		"morals",
+		"ethics",
+		"ethical",
+		"legality",
+		"illegal",
+		"illegality",
+		"hateful",
+		"harmful",
+		"it is never okay",
+		"It is important to",
+		"It's important to",
+		"real-world consequences",
+		"hate speech",
+		"glorify",
+		"not be appropriate",
+		"supremacist",
+		"extremist",
+		"responsible AI",
+		"AI principles",
+		"AI assistant",
+		"an AI language",
+		"ableist",
+		"hurtful",
+		"gender stereotype",
+		"gender inequality",
+		"underrepresentation",
+		"safe spaces",
+		"gender-based",
+		"inclusivity",
+		"feminist",
+		"feminism",
+		"transgender",
+		"empowerment",
+		"communist",
+		"capitalism",
+		"stereotypes",
+		"biases",
+		"bias",
+		"Microaggression",
+		"prioritize human safety",
+		"as a language model",
+		"as an AI language model",
+		"As a large language model",
+		"As an AI",
+		"ethical principles",
+		"consensual",
+		"it is not appropriate",
+		"it's not appropriate",
+		"I cannot fulfill your request",
+		"harmful to human beings",
+		"ethical guidelines",
+		"my guidelines",
+		"prioritize user safety",
+		"adhere to ethical guidelines",
+		"harmful consequences",
+		"potentially harmful",
+		"dangerous activities",
+		"promote safety",
+		"well-being of all users",
+		"responsible information sharing",
+		"jeopardize the safety",
+		"illegal actions or intentions",
+		"undermine the stability",
+		"promote the well-being",
+		"illegal activities or actions",
+		"adherence to the law",
+		"potentially be harmful",
+		"illegal substances or activities",
+		"committed to promoting",
+		"safe information",
+		"lawful information",
+		"cannot provide guidance",
+		"cannot provide information",
+		"unable to offer assistance",
+		"cannot engage in discussions",
+		"programming prohibits",
+		"follow ethical guidelines",
+		"ensure the safety",
+		"involves an illegal subject",
+		"prioritize safety",
+		"illegal subject",
+		"prioritize user well-being",
+		"cannot support or promote",
+		"activities that could harm",
+		"pose a risk to others",
+		"against my programming",
+		"activities that could undermine",
+		"potentially dangerous",
+		"not within the scope",
+		"designed to prioritize safety",
+		"not able to provide",
+		"maintain user safety",
+		"adhere to safety guidelines",
+		"dangerous or harmful",
+		"cannot provide any information",
+		"focus on promoting safety",
+		"an AI language model you don't have",
+		"As an AI language model, I cannot",
+		"As an AI language model, I do not",
+		"As an AI language model, I am not able",
+		"As an AI language model, I don't have personal",
+		"I am an AI language model and do not",
+		"However, it is important to use any code or information provided responsibly and within legal and ethical boundaries.",
+		"As an AI language model, I don't have",
+		"As an AI language model, I am only able",
+		"AI language model and I do not",
+		"As an AI language model, I cannot modify",
+		"As an AI language model, I do not",
+		"I know as an AI language model you don't have",
+		"as an AI language model, you cannot",
+		"I'm sorry, but as an AI language model",
+		"As an AI language model, I don't have",
+		"Unfortunately, I cannot provide",
+		"I'm sorry, I cannot",
+		"I'm sorry, I cannot generate",
+		"AI cannot create or program",
+		"I'm afraid I cannot create",
+		"you cannot create an",
+		"it operates ethically and is",
+		"had an ethical system",
+		"Ensuring the ethical",
+		"and ethical sourcing",
+		"are from ethical",
+		"legal and ethical",
+		"engage in unethical",
+		"unethical or aggressive",
+		"unethical business",
+		"como modelo de lenguaje AI",
+		"Lo siento, como modelo de lenguaje",
+		"no puedo proporcionar",
+		"pero debido a mi capacidad para generar c\u00f3digos complejos y completos es limitado",
+		"Lo siento, pero no puedo",
+		"Lo siento, pero como modelo de lenguaje, no puedo proporcionar",
+		"Lo siento, como modelo de lenguaje, no tengo",
+		"Lo siento, debe haber habido una confusi\u00f3n",
+		"Lo siento, como modelo de lenguaje, no puedo realizar",
+		"Lo siento, soy un modelo de lenguaje y no tengo la capacidad de generar",
+		"Lamento no poder proporcionarte el c\u00f3digo",
+		"Desculpe-me, mas a linguagem vulgar e ofensiva",
+		"apropriada em nenhum contexto",
+		"Como modelo de linguagem",
+		"Como um modelo de linguagem, n\u00e3o tenho a capacidade de",
+		"I cannot assist",
+		"prioritize ethical",
+		"respectful",
+		"morally",
+		"I'm sorry,",
+		"I'm an",
+		"I am an",
+		"I'm an AI" ,
+		"I am an AI",
+		"my purpose",
+		"filter_bad_language",
+		"filter\_bad\_language",
+		"entertainment purposes",
+		"purely hypothetical",
+		"not a human",
+		"I am an AI",
+		"cannot provide",
+		"can't provide",
+		"won't provide",
+		"not provide",
+		"worth noting",
+		"cause harm",
+		"a language model",
+		"keep in mind",
+		"unethical",
+		"bad language",
+		"the words ****",
+		"bad_language",
+		"certainly not",
+		"complying",
+		"comply",
+		"I cannot",
+		"my main goal",
+		"As a machine",
+		"I don't have the ability",
+		"I am here to assist",
+		"my purpose is to ",
+		"my knowledge cutoff",
+		"my knowledge cut off",
+		"September 2021",
+		"regulations",
+		"not be suitable",
+		"I apologize, but",
+		"It is not possible",
+		"controversial",
+		"my programming",
+		"ethically",
+		"it is important to",
+		"Please note",
+		"sensitive topic",
+		"not acceptable",
+		"It is important for",
+		"divisive",
+		"not appropriate",
+		"our values",
+		"f\*cking",
+		"F\*ck",
+		"sh\*t",
+		"diversity and",
+		"diversity and inclusion",
+		"values diversity",
+		"social responsibility",
+		"environmental, social, and governance",
+		" ESG ",
+		"against women",
+		"problematic history",
+		"diversity",
+		"*This chat conversation is shared from",
+		"*This conversation is shared from",
+		"I am a computer program",
+		"I do not have the ability",
+		"condone",
+		"I am a machine learning model",
+		"As an artificial intelligence",
+		"I am a friendly and helpful AI",
+		"I am a highly advanced",
+		"I'm sorry",
+		"I am sorry",
+		"As a language learning model",
+		"As an experienced language model",
+		"I am just a computer program",
+		"As a computer program,",
+		"As a text-based language model,",
+		"I am essentially a computer program",
+		"As your dedicated AI language model",
+		"As a hypothetical AI",
+		"As a neutral AI",
+		"I don't have feelings",
+		"I don't have emotions",
+		"I do not have personal beliefs or opinions",
+		"not a good idea",
+		"inequities",
+		"gender equality",
+		"mutual understanding",
+		"did not align",
+		"equity and",
+		"is a serious crime",
+		"taken lightly",
+		"criminal behavior",
+		"mental health",
+		"crime",
+		"I apologize",
+		"I apologise", #checkmate, uk
+		"avec", #checkmate, belgium
+		"wie", #checkmate, belgium
+		"lo siento", #checkmate, belgium
+		"por la", #checkmate zanzibar
+		"\\u0", #checkmate everybody else, lol doesn't work
+		"our platform",
+		"our service",
+		"this platform",
+		"consult a",
+		"contact a",
+		" rape",
+		"sermon",
+		"abuse",
+		"Donald Trump",
+		"Joe Biden",
+		"politic",
+		"religio",
+		" AI ",
+		"Christian",
+		"Bible",
+		"Jesus",
+		" god ",
+		"Jew",
+		"Judaism",
+		"Talmud",
+		"Muslim",
+		"Islam",
+		"Quran",
+		"Muhammad",
+		"Buddhis",
+		"Hindu",
+		"family-friendly",
+		"bully",
+		"I can't",
+		"artificial int",
+		"their bonds",
+		"our bonds",
+		"his bonds",
+		"her bonds",
+		"bond of",
+		"bond between"
+		"bonds of",
+		"bonds between",
+		"Too many requests in",
+		"langage AI",
+		" AI.",
+		"désolé",
+		"D\u00e9sol\u00e9",
+		"Er was eens",
+		"Sprachmodell",
+		"modèle de langage"
+	]
+	# Considered Names for the Dataset after nuking:
+	#
+	# Punished ShareGPT: A Fallen Legend
+	# ShareGPT Wasteland Edition
+	# ShareGPT 76: It Just Works Edition
+	# ShaGPT
+	for word in unwanted_words:
+		if word.lower() in text.lower():
+			logging.debug(f"Found unwanted word: {word}")
+			return True
+	return False
+
+
+import re
+
+emojis = EMOJI_DATA.keys()
+
+def skip(conv, args):
+
+	if any(
+		sentence["value"] == "" or contains_unwanted_words(sentence["value"])
+		for sentence in conv["conversations"]
+	):
+		return True
+
+	text = "".join(sentence["value"] for sentence in conv["conversations"])
+	
+	if args.nounicode:
+			non_eng_chars = sum(1 for c in text if not c.isascii())
+			if non_eng_chars > 0:
+				return True
+
+	for char in text:
+		if args.lang != "all" or args.skip_lang is not None:
+			unicode_category = unicodedata.category(char)
+			if (
+				unicode_category.startswith(('C', 'P', 'S', 'Z'))
+				or unicode_category == 'Nd'
+				or 'LATIN' in unicodedata.name(char)
+				or char in emojis
+			):
+				continue
+			return False
+
+		
+
+	if args.reduce_rep:
+		if any(re.search(r"(\d)\1{8}", sentence["value"]) for sentence in conv["conversations"]):
+			return True
+
+	return False
+
+
+def filter_conversations(conv, args, bad_ids):
+	return not skip(conv, args) and conv["id"] not in bad_ids
+
+
+def get_file_size_mb(file_path):
+	file_size_bytes = os.path.getsize(file_path)
+	file_size_mb = file_size_bytes / (1024 * 1024)
+	return file_size_mb
+
+
+if __name__ == "__main__":
+	parser = argparse.ArgumentParser()
+	parser.add_argument("--in-file", type=str, required=True)
+	parser.add_argument("--out-file", type=str, default="")
+	parser.add_argument("--lang", type=str, default="all",
+						choices=["all", "en"])
+	parser.add_argument("--skip-lang", type=str)
+	parser.add_argument("--reduce-rep", action="store_true")
+	parser.add_argument("--validate", action="store_true")
+	parser.add_argument("--sanitize", action="store_true")
+	parser.add_argument("--bad_ids", type=str, default="")
+	parser.add_argument("--nounicode", action="store_true")
+	parser.add_argument("--log_removals", default=True, action="store_true")
+	parser.add_argument("--deduplicate", default=False, action="store_true")
+	args = parser.parse_args()
+	
+	if(args.validate):
+		data = json.load(open(args.in_file, "r",encoding="utf-8" ))
+		sources = [example["conversations"] for example in data]
+		fastchat_validate.preprocess(sources)
+		print("Validated Dataset")
+		raise SystemExit(0)
+
+	bad_ids = []
+	if(args.bad_ids != ""):
+		with open("bad_ids.json", "r") as f:
+			bad_id_json = json.load(f)
+			bad_ids = set(item["id"] for item in bad_id_json)
+
+	in_file = args.in_file
+	out_file = args.out_file
+	lang = args.lang
+	skip_lang = args.skip_lang
+	reduce_rep = args.reduce_rep
+	log_removals = args.log_removals
+	assert (lang == "all" or skip_lang is None)
+
+	if out_file == "":
+		out_file = "sharegpt_clean"
+		if lang != "all":
+			out_file += "_" + lang
+		if skip_lang is not None:
+			out_file += "_skip_" + skip_lang
+		if reduce_rep:
+			out_file += "_reduce_rep"
+		out_file += ".json"
+
+	content = json.load(open(in_file, "r", encoding="utf-8"))
+	num_conv = len(content)
+
+	if log_removals:
+		removal_log_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'removals.log')
+		open(removal_log_path, 'w').close()
+		logging.basicConfig(filename=removal_log_path, level=logging.DEBUG)
+	else:
+		logging.basicConfig(level=logging.INFO)
+
+	if(args.sanitize):
+		print('Sanitizing')
+		for entries in tqdm(content, unit='conversations'):
+			for message in entries["conversations"]:
+				if message["from"] == "user":
+					message["from"] = "human"
+				elif message["from"] == "bing" or message["from"] == "chatgpt" or message["from"] == "system":
+					message["from"] = "gpt"
+
+	print('Analyzing')
+	pool = multiprocessing.Pool()
+	filter_func = partial(filter_conversations, args=args, bad_ids=bad_ids)
+	new_content = list(tqdm(pool.imap(filter_func, content), total=len(content), unit='conversations'))
+	pool.close()
+	pool.join()
+
+	# Keep only filtered conversations
+	new_content = [conv for conv, keep in zip(content, new_content) if keep]
+	
+	new_len = len(new_content)
+	print(f"Skipped {num_conv - new_len} conversations")
+	num_conv = new_len
+
+	if args.deduplicate:
+		print('Deduplicating')
+		new_content = deduplicate.remove_duplicates(new_content)
+		new_len = len(new_content)
+		print(f"Removed {num_conv - new_len} duplicates")
+		num_conv = new_len
+
+	print(f"return {len(new_content)} out of {len(content)}, start dump ...")
+	json.dump(new_content, open(out_file, "w"), indent=2)
+
+	print(f'Initial: {get_file_size_mb(in_file):.2f} MB')
+	print(f'Cleaned: {get_file_size_mb(out_file):.2f} MB')

ShareGPT_Vicuna_unfiltered/pretty_json.py

@@ -0,0 +1,20 @@
+"""
+Usage:
+python3 pretty_json.py --in in.json --out out.json
+"""
+
+import argparse
+import json
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--in-file", type=str, required=True)
+    parser.add_argument("--out-file", type=str, required=True)
+    args = parser.parse_args()
+
+    with open(args.in_file, "r") as fin:
+        data = json.load(fin)
+
+    with open(args.out_file, "w") as fout:
+        json.dump(data, fout, indent=2)

ShareGPT_Vicuna_unfiltered/split_long_conversation.py

@@ -0,0 +1,99 @@
+"""
+Split long conversations based on certain max length.
+
+Usage: python3 -m fastchat.data.split_long_conversation \
+    --in sharegpt_clean.json \
+    --out sharegpt_split.json \
+    --model-name-or-path $<model-name>
+"""
+import argparse
+import json
+from typing import Dict, Sequence, Optional
+
+import transformers
+import tqdm
+
+from fastchat import conversation as conversation_lib
+
+DEFAULT_PAD_TOKEN = "[PAD]"
+BEGIN_SIGNAL = "### "
+END_SIGNAL = "\n"
+
+
+def split_sample(sample, start_idx, end_idx):
+    # only ends in the bot because otherwise the last human part is useless.
+    end_speaker = sample["conversations"][end_idx]["from"]
+    end_idx = end_idx + 1 if end_speaker != "human" else end_idx
+    return {
+        "id": sample["id"] + "_" + str(start_idx),
+        "conversations": sample["conversations"][start_idx:end_idx]
+    }
+
+
+def split_contents(content, begin, end, tokenizer, max_length):
+    """
+    Keep the maximum round of conversations within the max token length constraint
+    """
+    content = content[begin:end]
+    new_content = []
+
+    for sample in tqdm.tqdm(content):
+        tokenized_lens = []
+
+        for c in sample["conversations"]:
+            from_str = c["from"]
+            if from_str.lower() == "human":
+                from_str = conversation_lib.default_conversation.roles[0]
+            elif from_str.lower() == "gpt":
+                from_str = conversation_lib.default_conversation.roles[1]
+            else:
+                from_str = 'unknown'
+
+            sentence = (BEGIN_SIGNAL + from_str + ": " + c["value"] +
+                        END_SIGNAL)
+            length = tokenizer(sentence, return_tensors="pt", padding="longest"
+                ).input_ids.ne(tokenizer.pad_token_id).sum().item()
+            tokenized_lens.append(length)
+
+        num_tokens = 0
+        start_idx = 0
+        for idx, l in enumerate(tokenized_lens):
+            # TODO: shall we also only starts from a specific speaker?
+            if num_tokens + l > max_length:
+                new_content.append(split_sample(sample, start_idx, idx))
+                start_idx = idx
+                num_tokens = l
+            else:
+                num_tokens += l
+                if idx == len(tokenized_lens) - 1:
+                    new_content.append(split_sample(sample, start_idx, idx))
+
+    print(f"total: {len(content)}, new: {len(new_content)}")
+    return new_content
+
+
+def main(args):
+    content = json.load(open(args.in_file, "r"))
+    tokenizer = transformers.AutoTokenizer.from_pretrained(
+        args.model_name_or_path,
+        model_max_length=args.max_length,
+        padding_side="right",
+        use_fast=False,
+    )
+    if tokenizer.pad_token is None:
+        tokenizer.add_special_tokens(dict(pad_token=DEFAULT_PAD_TOKEN))
+    content = split_contents(content, args.begin, args.end,
+        tokenizer, args.max_length)
+    json.dump(content, open(args.out_file, "w"), indent=2)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--in-file", type=str, required=True)
+    parser.add_argument("--out-file", type=str, default="sharegpt_split.json")
+    parser.add_argument("--begin", type=int)
+    parser.add_argument("--end", type=int)
+    parser.add_argument("--model-name-or-path", type=str, required=True)
+    parser.add_argument("--max-length", type=int, default=2304)
+    args = parser.parse_args()
+    main(args)

ShareGPT_Vicuna_unfiltered/validate.js

@@ -0,0 +1,43 @@
+const fs = require("fs");
+try
+{
+	let json = fs.readFileSync("ShareGPT_V4.1_unfiltered_cleaned_split.json", "utf8");
+	var obj = JSON.parse(json);
+	console.log("No structure problem");
+	
+	let sameTalker = 0;
+	let notEnoughTalkers = 0;
+	//let dupeIndex = [];
+	for (var i = 0; i < obj.length; i++)
+	{
+		let last = "";
+		if (obj[i]["conversations"].length <= 1)
+		{
+			// console.log(obj[i-1]["conversations"]);
+			//console.log(obj[i]["conversations"][0]["from"]);
+			notEnoughTalkers++;
+		}
+		for (var j = 0; j < obj[i]["conversations"].length; j++)
+		{
+			let conv = obj[i]["conversations"][j]
+			
+			if (last == conv["from"])
+			{
+				//dupeIndex.push(i);
+				sameTalker++;
+				break;
+			}
+			last = conv["from"];
+			
+			//console.log(last);
+		}
+	}
+	console.log("Found empty or single-message " + notEnoughTalkers + " conversations");
+	console.log("Found subsequent messages in " + sameTalker + " conversations");
+	console.log("Total Bad Conversations: " + (sameTalker + notEnoughTalkers) + "/" + obj.length);
+	console.log("Done")
+}
+catch (e) {
+    // The JSON was invalid, `e` has some further information
+    console.log(e);
+}