Upload 19 files

.gitattributes

@@ -32,3 +32,4 @@ 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
+Pretrained/HSS_Task2pth filter=lfs diff=lfs merge=lfs -text

CheckGPT/dnn.py

@@ -0,0 +1,298 @@
+import os
+import copy
+import h5py
+import time
+import argparse
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import torch.utils.data as data
+from torch.utils.data import DataLoader
+from configparser import ConfigParser
+
+from model import AttenLSTM
+
+parser = argparse.ArgumentParser(description='Demo of argparse')
+parser.add_argument('domain', type=str)
+parser.add_argument('task', type=int)
+parser.add_argument('expid', type=str)
+parser.add_argument('--early', type=float, default=99.8)
+parser.add_argument('--save', type=int, default=1)
+parser.add_argument('--pretrain', type=int, default=0)
+parser.add_argument('--dataamount', type=int, default=1000)
+parser.add_argument('--trans', type=int, default=0)
+parser.add_argument('--splitr', type=float, default=0.8)
+parser.add_argument('--test', type=int, default=0)
+parser.add_argument('--mdomain', type=str, default="CS")
+parser.add_argument('--mtask', type=int, default=1)
+parser.add_argument('--printall', type=int, default=1)
+parser.add_argument('--cont', type=int, default=0)
+parser.add_argument('--adam', type=int, default=1)
+parser.add_argument('--seed', type=int, default=100)
+parser.add_argument('--dropout', type=float, default=0.5)
+parser.add_argument('--batchsize', type=int, default=320)
+parser.add_argument('--meta', type=int, default=0)
+args = parser.parse_args()
+
+LOG_INTERVAL = 50
+ID = args.expid
+
+if not os.path.exists("./exp/{}".format(ID)):
+    os.mkdir("./exp/{}".format(ID))
+
+SEED = args.seed
+DEVICE_NAME = "cuda" if torch.cuda.is_available() else "cpu"
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+PRETRAINED = bool(args.pretrain)
+TRANSFER = bool(args.trans)
+SGD_OR_ADAM = "adam" if args.adam else "sgd"
+LEARNING_RATE = 2e-4 if SGD_OR_ADAM == "adam" else 1e-3
+N_EPOCH = 200 if (TRANSFER or SGD_OR_ADAM == "sgd") else 100
+CONTINUE = args.cont
+BATCH_SIZE = args.batchsize
+EARLYSTOP = args.early
+SAVE = bool(args.save)
+TEST = bool(args.test)
+PRINT_ALL = bool(args.printall)
+TEST_SIZE = 512 if TEST else BATCH_SIZE
+# torch.backends.cudnn.deterministic = False
+# torch.backends.cudnn.benchmark = True
+
+domain, task = args.domain, str(args.task)
+m_domain, m_task = args.mdomain, str(args.mtask)
+
+if TRANSFER:
+    assert m_domain is not None
+
+
+class MyDataset(data.Dataset):
+    def __init__(self, archive):
+        self.archive = archive
+        self.length = len(h5py.File(self.archive, 'r')["data"])
+        self.dataset, self.labels = None, None
+
+    def __getitem__(self, index):
+        if self.dataset is None:
+            self.dataset = h5py.File(self.archive, 'r')["data"]
+            self.labels = h5py.File(self.archive, 'r')["label"]
+        x, y = torch.from_numpy(self.dataset[index]).float(), torch.from_numpy(self.labels[index]).long()
+        return x, y
+
+    def __len__(self):
+        return self.length
+
+
+class TransNet(nn.Module):
+    def __init__(self, host, mode=0):
+        super(TransNet, self).__init__()
+        self.host = host
+        self.mode = mode
+        self.dropout = nn.Dropout(p=0.05)
+        self.layers = copy.deepcopy(self.host.fc)
+
+    def forward(self, x):
+        x = self.layers(self.dropout(x))
+        return x
+
+
+def save_checkpoint(model, path, optimizer, scheduler, epoch, acc):
+    info_dict = {
+        "model_state_dict": model.state_dict(),
+        "optimizer_state_dict": optimizer.state_dict(),
+        "lr_scheduler_state_dict": scheduler.state_dict(),
+        "last_epoch": epoch,
+        "best_acc": acc
+    }
+
+    torch.save(info_dict, path)
+    return
+
+
+def load_checkpoint(model, path, optimizer, scheduler):
+    cp = torch.load(path)
+    model.load_state_dict(cp["model_state_dict"], strict=True)
+    optimizer.load_state_dict(cp["optimizer_state_dict"])
+    scheduler.load_state_dict(cp["lr_scheduler_state_dict"])
+    last_epoch = cp["last_epoch"]
+    best_acc = cp["best_acc"]
+    return last_epoch, best_acc
+
+
+def load_data(domain, task, size_train=96, size_test=96):
+    if not TRANSFER:
+        dir_ = './embeddings/{}_TASK{}_{}.{}'
+        full_dataset = MyDataset(dir_.format(domain, task, args.dataamount, "h5"))
+        torch.random.manual_seed(args.seed)
+        train_size = int(args.splitr * len(full_dataset))
+        test_size = len(full_dataset) - train_size
+        train_data, test_data = torch.utils.data.random_split(full_dataset, [train_size, test_size])
+    else:
+        torch.random.manual_seed(SEED)
+        full_data = MyDataset('./embeddings/s{}{}_t{}{}.h5'.format(m_domain, args.mtask,
+                                                                                     domain, task))
+        train_size = args.dataamount
+        test_size = len(full_data) - train_size
+
+        train_data, _ = torch.utils.data.random_split(full_data, [train_size, test_size])
+        test_data = MyDataset('./embeddings/s{}{}_t{}{}.h5'.format(m_domain, args.mtask,
+                                                                                     domain, task))
+
+    train_loader = DataLoader(dataset=train_data,
+                              num_workers=4,
+                              batch_size=size_train,
+                              drop_last=True,
+                              shuffle=True,
+                              pin_memory=True,
+                              prefetch_factor=2)
+    test_loader = DataLoader(dataset=test_data,
+                              num_workers=4,
+                              batch_size=size_test,
+                              drop_last=False,
+                              shuffle=False,
+                              pin_memory=True,
+                              prefetch_factor=2)
+    return train_loader, test_loader
+
+
+def test(model, dataloader, epoch, print_freq=1):
+    model.eval()
+    n_correct, correct_0, correct_1, sum_0, sum_1 = 0, 0, 0, 0, 0
+    start = time.time()
+
+    with torch.no_grad():
+        for i, (t_img, t_label) in enumerate(dataloader):
+            t_img, t_label = t_img.to(DEVICE), t_label.to(DEVICE).squeeze(1)
+            class_output = model(t_img)
+            pred = torch.max(class_output.data, 1)
+            n_correct += (pred[1] == t_label).sum().item()
+            correct_0 += ((pred[1] == t_label) * (t_label == 0)).sum().item()
+            correct_1 += ((pred[1] == t_label) * (t_label == 1)).sum().item()
+            sum_0 += (t_label == 0).sum().item()
+            sum_1 += (t_label == 1).sum().item()
+            if i % (LOG_INTERVAL*print_freq) == 0 and PRINT_ALL:
+                print('Batch: [{}/{}], Time used: {:.4f}s'.format(i, len(dataloader), time.time() - start))
+
+    accu = float(n_correct) / len(dataloader.dataset) * 100
+    accu_0 = float(correct_0) / sum_0 * 100
+    accu_1 = float(correct_1) / sum_1 * 100
+    if PRINT_ALL:
+        print('{}{}， Epoch:{}, Test accuracy: {:.4f}%, Acc_GPT: {:.4f}%, Acc_Human: {:.4f}%'.format(args.task,
+                                                                                                    args.domain, epoch,
+                                                        accu, accu_0, accu_1))
+    return accu, accu_0, accu_1
+
+
+def train(model, optimizer, scheduler, dataloader, test_loader):
+    loss_class = torch.nn.CrossEntropyLoss()
+    scaler = torch.cuda.amp.GradScaler(enabled=True)
+
+    if CONTINUE:
+        last_epoch, best_acc = load_checkpoint(model, "./exp/{}_Task{}.pth".format(domain, task),
+                                               optimizer, scheduler)
+        best_acc = test(model, test_loader, -1)
+        print("Checkpoint Loaded.")
+    else:
+        last_epoch, best_acc = 1, 0
+
+    len_dataloader = len(dataloader)
+    for epoch in range(last_epoch, N_EPOCH + 1):
+        start = time.time()
+        model.train()
+        data_iter = iter(dataloader)
+        n_correct = 0
+
+        i = 1
+        while i < len_dataloader + 1:
+            data_source = next(data_iter)
+            optimizer.zero_grad()
+
+            img, label = data_source[0].to(DEVICE), data_source[1].to(DEVICE).squeeze(1)
+
+            class_output = model(img)
+            pred = torch.max(class_output.data, 1)
+            n_correct += (pred[1] == label).sum().item()
+            err = loss_class(class_output, label)
+            scaler.scale(err).backward()
+            scaler.step(optimizer)
+            scaler.update()
+
+            if i % LOG_INTERVAL == 0 and PRINT_ALL:
+                print(
+                    'Epoch: [{}/{}], Batch: [{}/{}], Err: {:.4f}, Time used: {:.4f}s'.format(
+                        epoch, N_EPOCH, i, len_dataloader, err.item(), time.time() - start,
+                        ))
+            i += 1
+            # torch.cuda.empty_cache()
+
+        accu = float(n_correct) / (len(dataloader.dataset)) * 100
+        if PRINT_ALL:
+            print('{}_TASK{}， Epoch:{}, Train accuracy: {:.4f}%'.format(domain, task, epoch, accu))
+        if not TRANSFER and SAVE:
+            save_checkpoint(model, "./exp/{}/Checkpoint_{}_Task{}.pth".format(ID, domain, task),
+                            optimizer, scheduler, epoch, best_acc)
+        acc = test(model, test_loader, epoch)
+
+        scheduler.step()
+
+        if acc > best_acc:
+            old_acc, best_acc = best_acc, acc
+            if TRANSFER:
+                name = "./exp/{}/Best_s_{}{}_t_{}{}.pth".format(ID, m_domain, m_task, domain, task)
+            else:
+                name = "./exp/{}/Best_{}_Task{}.pth".format(ID, domain, task)
+            if SAVE:
+                torch.save(model.state_dict(), name)
+            if not TRANSFER:
+                print("Best model saved.")
+
+        if EARLYSTOP > 0 and best_acc > EARLYSTOP:
+            break
+
+    return best_acc
+
+
+if __name__ == '__main__':
+    torch.random.manual_seed(SEED)
+    train_loader, test_loader = load_data(domain, task, size_train=BATCH_SIZE, size_test=TEST_SIZE)
+    rnn = AttenLSTM(input_size=1024, hidden_size=256, batch_first=True, dropout=args.dropout, bidirectional=True, num_layers=2, device=DEVICE_NAME).to(DEVICE)
+
+    config = ConfigParser()
+
+    config.read('./exp/{}/config.ini'.format(ID))
+    config.add_section('main')
+    for key, value in vars(args).items():
+        config.set('main', key, str(value))
+
+    with open('./exp/{}/config.ini'.format(ID), 'w') as f:
+        config.write(f)
+
+    if PRETRAINED or TEST:
+        rnn.load_state_dict(torch.load("../Pretrained/{}_Task{}.pth".format(domain, task)), strict=True)
+        if args.meta:
+            rnn.load_state_dict(torch.load("../Pretrained/Unified_Task123.pth"), strict=True)
+
+    if TRANSFER:
+        rnn.load_state_dict(torch.load("../Pretrained/{}_Task{}.pth".format(m_domain, m_task)), strict=True)
+        model = TransNet(rnn)
+        del rnn
+    else:
+        model = rnn
+
+    if not TEST:
+        for param in model.parameters():
+            param.requires_grad = True
+
+    if SGD_OR_ADAM == "adam":
+        optimizer = optim.AdamW(model.parameters(), lr=LEARNING_RATE)
+    else:
+        optimizer = optim.SGD(model.parameters(), lr=LEARNING_RATE, momentum=0.9, weight_decay=5e-4)
+    scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, N_EPOCH)
+
+    if not TEST:
+        best_acc = train(model, optimizer, scheduler, train_loader, test_loader)
+    else:
+        best_acc, _, _ = test(model, test_loader, 0)
+
+    if TRANSFER:
+        print("Transfer Learning, S: {}, T: {}, Acc: {:.4f}%".format(m_domain+m_task, domain+task, best_acc))

CheckGPT/exp/0001/config.ini

@@ -0,0 +1,21 @@
+[main]
+domain = CS
+task = 3
+expid = 0001
+early = 99.8
+save = 1
+pretrain = 0
+dataamount = 1000
+trans = 0
+splitr = 0.8
+test = 1
+mdomain = CS
+mtask = 1
+printall = 1
+cont = 0
+adam = 1
+seed = 100
+dropout = 0.5
+batchsize = 320
+meta = 0
+

CheckGPT/features.py

@@ -0,0 +1,78 @@
+import torch
+import json
+import h5py
+import time
+import argparse
+import torch.nn.functional as F
+
+
+parser = argparse.ArgumentParser(description='Demo of argparse')
+parser.add_argument('domain', type=str)
+parser.add_argument('task', type=str)
+parser.add_argument('--pairs', type=int, default=0)
+args = parser.parse_args()
+
+domain = args.domain
+task = args.task
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+roberta = torch.hub.load('pytorch/fairseq', 'roberta.large').to(device)
+roberta.eval()
+
+with open("../GPABenchmark/{}_TASK{}/gpt.json".format(domain, task), 'r') as f1:
+    data1 = json.load(f1)
+f1.close()
+
+with open("../GPABenchmark/{}_TASK{}/hum.json".format(domain, task), 'r') as f2:
+    data2 = json.load(f2)
+f2.close()
+
+print(len(list(data1.keys())))
+print(len(list(data2.keys())))
+too_long = 0
+total_length = 2 * args.pairs if args.pairs else len(list(data1.keys())) + len(list(data2.keys()))
+
+start = time.time()
+data = h5py.File('./embeddings/{}_TASK{}_{}.h5'.format(domain, task, total_length), 'w')
+data.create_dataset('data', (total_length, 512, 1024), dtype='f4')
+data.create_dataset('label', (total_length, 1), dtype='i')
+
+
+def fetch_representation(text):
+    tokens = roberta.encode(text)
+    last_layer_features = None
+
+    if len(tokens) <= 512:
+        last_layer_features = roberta.extract_features(tokens)
+    return last_layer_features
+
+
+for i, (gpt, hum) in enumerate(zip(data1.values(), data2.values())):
+    gpt_features, hum_features = fetch_representation(gpt), fetch_representation(hum)
+
+    if gpt_features is None or hum_features is None:
+        too_long += 1
+        continue
+
+    gpt_features_ = F.pad(gpt_features, (0, 0, 0, 512 - gpt_features.size(1)))
+    hum_features_ = F.pad(hum_features, (0, 0, 0, 512 - hum_features.size(1)))
+
+    data["data"][2 * i] = gpt_features_.clone().detach().cpu()
+    data["label"][2 * i] = torch.zeros(1)
+
+    data["data"][2 * i + 1] = hum_features_.clone().detach().cpu()
+    data["label"][2 * i + 1] = torch.ones(1)
+
+    if i % 200 == 0:
+        print("{}{} at {}th pair. Time used: {}s. Outliers: {}".format(domain, task, i, time.time()-start, too_long))
+
+    i += 1
+    if i >= args.pairs:
+        break
+
+data.close()
+
+
+
+
+
+

CheckGPT/model.py

@@ -0,0 +1,76 @@
+import torch
+import torch.nn as nn
+import numpy as np
+import torch.nn.functional as F
+# from ptflops import get_model_complexity_info
+from transformers import RobertaTokenizer, RobertaModel, RobertaConfig, RobertaPreTrainedModel
+
+
+class Attention(nn.Module):
+    def __init__(self, hidden_size, batch_first=False, device="gpu"):
+        super(Attention, self).__init__()
+        self.batch_first = batch_first
+        self.hidden_size = hidden_size
+        stdv = 1.0 / np.sqrt(self.hidden_size)
+        self.att_weights = nn.Parameter(torch.Tensor(1, hidden_size), requires_grad=True)
+        self.device = device
+
+        for weight in self.att_weights:
+            nn.init.uniform_(weight, -stdv, stdv)
+
+    def get_mask(self):
+        pass
+
+    def forward(self, inputs):
+        if self.batch_first:
+            batch_size, max_len = inputs.size()[:2]
+        else:
+            max_len, batch_size = inputs.size()[:2]
+
+        weights = torch.bmm(inputs, self.att_weights.permute(1, 0).unsqueeze(0).repeat(batch_size, 1, 1))
+        attentions = torch.softmax(F.relu(weights.squeeze()), dim=-1)
+        mask = torch.ones(attentions.size(), requires_grad=True)
+        if self.device == "gpu":
+            mask = mask.cuda()
+        masked = attentions * mask
+        _sums = masked.sum(-1).unsqueeze(-1)
+        attentions = masked.div(_sums)
+        weighted = torch.mul(inputs, attentions.unsqueeze(-1).expand_as(inputs))
+        return weighted.sum(1), attentions
+
+
+class AttenLSTM(nn.Module):
+    def __init__(self, input_size=1024, hidden_size=256, batch_first=True, dropout=0.5, bidirectional=True,
+                 num_layers=2, device="gpu"):
+        super(AttenLSTM, self).__init__()
+        self.dropout = nn.Dropout(dropout)
+        self.lstm1 = nn.LSTM(input_size=input_size,
+                             hidden_size=hidden_size,
+                             num_layers=1,
+                             bidirectional=bidirectional,
+                             batch_first=batch_first)
+        self.atten1 = Attention(hidden_size * 2, batch_first=batch_first, device=device)
+        self.lstm2 = nn.LSTM(input_size=hidden_size * 2,
+                             hidden_size=hidden_size,
+                             num_layers=1,
+                             bidirectional=bidirectional,
+                             batch_first=batch_first)
+        self.atten2 = Attention(hidden_size * 2, batch_first=batch_first, device=device)
+        self.fc = nn.Linear(hidden_size * num_layers * 2, 2)
+
+    def forward(self, x):
+        out1, (_, _) = self.lstm1(x)
+        x, _ = self.atten1(out1)
+        out2, (_, _) = self.lstm2(out1)
+        y, _ = self.atten2(out2)
+
+        z = torch.cat([x, y], dim=1)
+        z = self.fc(self.dropout(z))
+        return z
+
+
+if __name__ == '__main__':
+    pass
+    # config = RobertaConfig.from_pretrained("roberta-large", num_labels=2)
+    # m = RobertaModel(config).cuda()
+    # print(get_model_complexity_info(m, (512,), as_strings=True, print_per_layer_stat=True))

CheckGPT/test.py

@@ -0,0 +1,56 @@
+import torch
+from transformers import RobertaTokenizer, RobertaModel, RobertaConfig, RobertaPreTrainedModel
+import torch.nn.functional as F
+from model import AttenLSTM
+
+
+class CustomRobertaForPipeline(RobertaPreTrainedModel):
+    def __init__(self, config, device="gpu"):
+        super().__init__(config)
+        self.roberta = RobertaModel(config)
+        self.classifier = AttenLSTM(input_size=1024, hidden_size=256, batch_first=True, dropout=0.5, bidirectional=True,
+                              num_layers=2, device=device)
+
+    def forward(self, input_ids, attention_mask=None, token_type_ids=None, position_ids=None, head_mask=None,
+                inputs_embeds=None):
+        outputs = self.roberta(input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids,
+                                   position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds)
+        features = F.pad(outputs.last_hidden_state, (0, 0, 0, 512 - outputs.last_hidden_state.size(1)))
+        logits = self.classifier(features)
+        return logits
+
+
+device_name = "cuda" if torch.cuda.is_available() else "cpu"
+device = torch.device(device_name)
+tokenizer = RobertaTokenizer.from_pretrained("roberta-large")
+config = RobertaConfig.from_pretrained("roberta-large", num_labels=2)
+model = CustomRobertaForPipeline.from_pretrained("roberta-large", config=config, device=device_name).to(device)
+model.eval()
+
+
+def eval_one(model, input):
+    item = input.replace("\n", " ").replace("  ", " ").strip()
+    tokens = tokenizer.encode(item)
+    if len(tokens) > 512:
+        tokens = tokens[:512]
+        print("!!!Input too long. Truncated to first 512 tokens.")
+    outputs = model(torch.tensor(tokens).unsqueeze(0).to(device))
+    pred = torch.max(outputs.data, 1)[1]
+    (gpt_prob, hum_prob) = F.softmax(outputs.data, dim=1)[0]
+    return pred[0].data, 100 * gpt_prob, 100 * hum_prob
+
+try:
+    while True:
+        a = input("Please input the text to be evaluated: (0 for gpt, 1 for human)\n")
+        if a == "exit":
+            raise KeyboardInterrupt
+        model.classifier.load_state_dict(torch.load("../Pretrained/Unified_Task1.pth"), map_location=device)
+        print("- Decision of GPT-Written: {}, Probability: GPT: {:.4f}%, Human: {:.4f}%.".format(*eval_one(model, a)))
+        model.classifier.load_state_dict(torch.load("../Pretrained/Unified_Task2.pth"), map_location=device)
+        print("- Decision of GPT-Completed: {}, Probability: GPT: {:.4f}%, Human: {:.4f}%.".format(*eval_one(model, a)))
+        model.classifier.load_state_dict(torch.load("../Pretrained/Unified_Task3.pth"), map_location=device)
+        print("- Decision of GPT-Polished: {}, Probability: GPT: {:.4f}%, Human: {:.4f}%.".format(*eval_one(model, a)))
+        model.classifier.load_state_dict(torch.load("../Pretrained/Unified_Task123.pth"), map_location=device)
+        print("- Decision of GPT-Generated (any kind): {}, Probability: GPT: {:.4f}%, Human: {:.4f}%.\n".format(*eval_one(model, a)))
+except KeyboardInterrupt:
+    exit()

Pretrained/CS_Task1.pth

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

Pretrained/CS_Task2.pth

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

Pretrained/CS_Task3.pth

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

Pretrained/HSS_Task1.pth

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

Pretrained/HSS_Task2pth

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

Pretrained/HSS_Task3.pth

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

Pretrained/PHY_Task1.pth

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

Pretrained/PHY_Task2.pth

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

Pretrained/PHY_Task3.pth

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

Pretrained/Unified_Task1.pth

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

Pretrained/Unified_Task123.pth

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

Pretrained/Unified_Task2.pth

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

Pretrained/Unified_Task3.pth

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

requirements.txt

@@ -0,0 +1,4 @@
+numpy~=1.23.5
+h5py~=3.8.0
+torch==1.13.1
+transformers==4.28.1