Upload 7 files

code/app.py

@@ -1,14 +1,32 @@
-import flask
-import os
+from flask import Flask, request, jsonify, make_response, render_template
+from do_predict import predict_single
 
-from dotenv import load_dotenv
-load_dotenv()
-
-app = flask.Flask(__name__, template_folder="static")
+app = Flask(__name__)
+app.config["JSON_AS_ASCII"] = False
 
 @app.route("/")
 def index():
-    return flask.render_template("index.html")
+        return render_template("index.html")
+
+@app.before_request
+def before():
+    # handle preflight
+    if request.method == "OPTIONS":
+        resp = make_response()
+        resp.headers["Access-Control-Allow-Origin"] = "*"
+        resp.headers["Access-Control-Allow-Methods"] = "GET, POST"
+        resp.headers["Access-Control-Allow-Headers"] = "Content-Type"
+        return resp
+
+
+@app.post("/api/predict_single")
+def api_predict_single():
+    text = request.json["text"]
+    result = predict_single(text)
+    resp = jsonify(result)
+    resp.headers["Access-Control-Allow-Origin"] = "*"
+    return resp
+
 
 if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=7860)
+    app.run(host="0.0.0.0", port=22222)

code/args.py

@@ -0,0 +1,21 @@
+class args():
+    DATA_PATH = "../Dataset/"
+    SAVE_MODEL_PATH = "model/"
+    
+    #pre_model_name = "bert-base-chinese"
+    #pre_model_name = "hfl/chinese-macbert-base"
+    pre_model_name = "hfl/chinese-roberta-wwm-ext"
+    save_model_name = "roberta_crf"
+    
+    LOG_DIR = "../log/long_term/"+save_model_name+"/"
+    
+    use_crf = False
+    label_dict = {"O":0, "B":1, "I":2}
+    epoch_num = 10
+    batch_size = 2
+    label_size = 3
+    max_length = 512
+
+class config():
+    hidden_dropout_prob = 0.1
+    hidden_size = 768

code/do_predict.py

@@ -0,0 +1,187 @@
+from args import args, config
+from items_dataset import items_dataset
+from torch.utils.data import DataLoader
+from models import Model_Crf, Model_Softmax
+from transformers import AutoTokenizer
+from tqdm import tqdm
+import prediction
+import torch
+import math
+
+directory = args.SAVE_MODEL_PATH
+model_name = "roberta_CRF.pt"
+device = torch.device("cuda", 0) if torch.cuda.is_available() else torch.device("cpu")
+model_crf = Model_Crf(config).to(device)
+model_crf.load_state_dict(
+    state_dict=torch.load(directory + model_name, map_location=device)
+)
+
+model_name = "roberta_softmax.pt"
+device = torch.device("cuda", 0) if torch.cuda.is_available() else torch.device("cpu")
+model_roberta = Model_Softmax(config).to(device)
+model_roberta.load_state_dict(
+    state_dict=torch.load(directory + model_name, map_location=device)
+)
+
+
+def prepare_span_data(dataset):
+    for sample in dataset:
+        spans = items_dataset.cal_agreement_span(
+            None,
+            agreement_table=sample["predict_sentence_table"],
+            min_agree=1,
+            max_agree=2,
+        )
+        sample["span_labels"] = spans
+        sample["original_text"] = sample["text_a"]
+        del sample["text_a"]
+
+
+def rank_spans(test_loader, device, model, reverse=True):
+    """Calculate each span probability by e**(word average log likelihood)"""
+    model.eval()
+    result = []
+
+    for i, test_batch in enumerate(tqdm(test_loader)):
+        batch_text = test_batch["batch_text"]
+        input_ids = test_batch["input_ids"].to(device)
+        token_type_ids = test_batch["token_type_ids"].to(device)
+        attention_mask = test_batch["attention_mask"].to(device)
+        labels = test_batch["labels"]
+        crf_mask = test_batch["crf_mask"].to(device)
+        sample_mapping = test_batch["overflow_to_sample_mapping"]
+        output = model(
+            input_ids=input_ids,
+            token_type_ids=token_type_ids,
+            attention_mask=attention_mask,
+            labels=None,
+            crf_mask=crf_mask,
+        )
+        output = torch.nn.functional.softmax(output[0], dim=-1)
+
+        # make result of every sample
+        sample_id = 0
+        sample_result = {
+            "original_text": test_batch["batch_text"][sample_id],
+            "span_ranked": [],
+        }
+        for batch_id in range(len(sample_mapping)):
+            change_sample = False
+
+            # make sure status
+            if sample_id != sample_mapping[batch_id]:
+                change_sample = True
+            if change_sample:
+                sample_id = sample_mapping[batch_id]
+                result.append(sample_result)
+                sample_result = {
+                    "original_text": test_batch["batch_text"][sample_id],
+                    "span_ranked": [],
+                }
+
+            encoded_spans = items_dataset.cal_agreement_span(
+                None, agreement_table=labels[batch_id], min_agree=1, max_agree=2
+            )
+            # print(encoded_spans)
+            for encoded_span in encoded_spans:
+                # calculate span loss
+                span_lenght = encoded_span[1] - encoded_span[0]
+                # print(span_lenght)
+                span_prob_table = torch.log(
+                    output[batch_id][encoded_span[0] : encoded_span[1]]
+                )
+                if (
+                    not change_sample and encoded_span[0] == 0 and batch_id != 0
+                ):  # span cross two tensors
+                    span_loss += span_prob_table[0][1]  # Begin
+                else:
+                    span_loss = span_prob_table[0][1]  # Begin
+                for token_id in range(1, span_prob_table.shape[0]):
+                    span_loss += span_prob_table[token_id][2]  # Inside
+                span_loss /= span_lenght
+
+                # span decode
+                decode_start = test_batch[batch_id].token_to_chars(encoded_span[0] + 1)[
+                    0
+                ]
+                decode_end = test_batch[batch_id].token_to_chars(encoded_span[1])[0] + 1
+                # print((decode_start, decode_end))
+                span_text = test_batch["batch_text"][sample_mapping[batch_id]][
+                    decode_start:decode_end
+                ]
+                if (
+                    not change_sample and encoded_span[0] == 0 and batch_id != 0
+                ):  # span cross two tensors
+                    presample = sample_result["span_ranked"].pop(-1)
+                    sample_result["span_ranked"].append(
+                        [presample[0] + span_text, math.e ** float(span_loss)]
+                    )
+                else:
+                    sample_result["span_ranked"].append(
+                        [span_text, math.e ** float(span_loss)]
+                    )
+        result.append(sample_result)
+
+    # sorted spans by probability
+    # for sample in result:
+    #     sample["span_ranked"] = sorted(
+    #         sample["span_ranked"], key=lambda x: x[1], reverse=reverse
+    #     )
+    return result
+
+
+def predict_single(text):
+    input_dict = [{"span_labels": []}]
+    input_dict[0]["original_text"] = text
+    tokenizer = AutoTokenizer.from_pretrained(
+        args.pre_model_name, add_prefix_space=True
+    )
+    prediction_dataset = items_dataset(tokenizer, input_dict, args.label_dict)
+    prediction_loader = DataLoader(
+        prediction_dataset,
+        batch_size=args.batch_size,
+        shuffle=True,
+        collate_fn=prediction_dataset.collate_fn,
+    )
+    predict_data = prediction.test_predict(prediction_loader, device, model_crf)
+    prediction.add_sentence_table(predict_data)
+
+    prepare_span_data(predict_data)
+    tokenizer = AutoTokenizer.from_pretrained(
+        args.pre_model_name, add_prefix_space=True
+    )
+    prediction_dataset = items_dataset(tokenizer, predict_data, args.label_dict)
+    prediction_loader = DataLoader(
+        prediction_dataset,
+        batch_size=args.batch_size,
+        shuffle=False,
+        collate_fn=prediction_dataset.collate_fn,
+    )
+    span_ranked = rank_spans(prediction_loader, device, model_roberta)
+    # for sample in span_ranked:
+    #     print(sample["original_text"])
+    #     print(sample["span_ranked"])
+
+    result = []
+    sample = span_ranked[0]
+    orig = sample["original_text"]
+    cur = 0
+    for s, score in sample["span_ranked"]:
+        # print()
+        # print('ORIG', repr(orig))
+        # print('CCUR', repr(orig[cur:]))
+        # print('SSSS', repr(s))
+        # print()
+        end = orig.index(s, cur)
+        if cur != end:
+            result.append([orig[cur:end], 0])
+        result.append([s, score])
+        cur = end + len(s)
+    if cur < len(orig):
+        result.append([orig[cur:], 0])
+    return result
+
+
+if __name__ == "__main__":
+    s = """貓咪犯錯後，以下5種懲罰方法很有效，飼主可以試試樂享網 2021-03-06 繼續閱讀 繼續閱讀 繼續閱讀 繼續閱讀 繼續閱讀 貓咪雖然高冷，但也是會犯錯的，那貓咪犯錯後，怎麼懲罰它才最有效呢？今天就來說一些懲罰貓咪最有效的5個方法！1、把痛感形成條件反射 這裡說的是「痛感」，而不是「暴打」。在貓咪犯錯後，寵主不需要打它，可以彈鼻頭或者是輕拍它的頭頂，給它造成痛感，這樣讓貓咪有一些畏懼心理，知道你在懲罰它。這樣時間長了，貓咪就會形成條件反射，以後就會少犯錯了。  2、大聲呵斥比起打貓，大聲呵斥貓咪會更加有效。因為貓咪對聲音很敏感，它能從主人的語氣中判斷主人的情緒，當大聲呵斥它的時候，它往往會楞一下，這時你繼續大聲呵斥它，那它就會明白你不允許它做這件事，這樣犯錯地方幾率就會減少了。  3、限制自由限制自由說白了，就是把貓咪關進籠子裡。因為貓咪都是很愛外出玩耍，當它犯錯咯，主人可以把它關進籠子裡，不搭理它，讓它自己反思。但要注意，這個方法不能經常用，而且不能把貓咪關進籠子太久。  4、利用水都知道貓咪很怕水的，所以當貓咪犯錯後，寵主也可以利用水來懲罰貓咪，這也是很效果的方法。寵主可以給貓咪臉上或是頭頂噴一些水，從而讓貓知道這個行為是錯誤的，以後就不會再犯了。  5、冷淡雖然貓咪不是很粘主人，但它還是很愛主人的，所以在貓咪犯錯後，寵主也可以採取冷淡的方法來懲罰貓。對貓咪採取不理睬、不靠近、不擁抱等策略，這樣貓咪就會知道自己錯了。當然懲罰的時間不要太長，不然貓咪就會以為你不愛它了。"""
+    print(predict_single(s))

code/items_dataset.py

@@ -0,0 +1,153 @@
+import torch
+from torch.utils.data import Dataset
+from args import args
+class items_dataset(Dataset):
+    def __init__(self, tokenizer, data_set, label_dict, stride=0, max_length=args.max_length):
+        self.data_set = data_set
+        self.tokenizer = tokenizer
+        self.label_dict = label_dict
+        self.max_length = max_length
+        self.encode_max_length = max_length-2 #[CLS] [SEP]
+        self.batch_max_lenght = max_length
+        self.stride = stride
+
+    def __getitem__(self, index):
+        result = self.data_set[index]
+        return result
+    
+    def __len__(self):
+        return len(self.data_set)
+
+    def create_label_list(self, span_label, max_len):
+      #ans = []
+      table = torch.zeros(max_len)
+      for start, end in span_label:
+        table[start:end] = 2 #"I"
+        table[start] = 1 #"B"
+      """
+      for label in table.tolist():
+        if label == 0:
+            ans.append("O")
+        elif label == 1:
+            ans.append("B")
+        elif label == 2:
+            ans.append("I")
+        else:
+            print("error")
+      """
+      return table
+    def encode_lable(self, encoded, batch_table):
+      batch_encode_seq_lens = []
+      sample_mapping = encoded["overflow_to_sample_mapping"]
+      offset_mapping = encoded["offset_mapping"]
+      encoded_label = torch.zeros(len(sample_mapping) ,self.encode_max_length, dtype=torch.long)
+      for id_in_batch in range(len(sample_mapping)):
+        encode_len=0
+        table = batch_table[sample_mapping[id_in_batch]]
+        for i in range(self.max_length):
+          char_start, char_end = offset_mapping[id_in_batch][i]
+          # ignore [CLS], [SEP] token
+          if char_start!=0 or char_end!=0:
+              encode_len+=1
+              #print(encoded_label.shape, table.shape)
+              encoded_label[id_in_batch][i-1] = table[char_start].long()
+        batch_encode_seq_lens.append(encode_len)
+      return encoded_label, batch_encode_seq_lens
+
+      
+    def create_crf_mask(self, batch_encode_seq_lens):
+        mask = torch.zeros(len(batch_encode_seq_lens), self.encode_max_length, dtype=torch.bool)
+        #print(len(batch_table), len(batch_lens), seq_lens, batch_lens)
+        for i, batch_len in enumerate(batch_encode_seq_lens):
+            mask[i][:batch_len]=True
+        return mask
+    
+    def boundary_encoded(self, encodings, batch_boundary):
+      batch_boundary_encoded = []
+      for batch_id, span_labels in enumerate(batch_boundary):
+        boundary_encoded = []
+        end = 0
+        for boundary in span_labels:
+          end += boundary
+
+          encoded_end = encodings[batch_id].char_to_token(end-1)
+          
+          #
+          tmp_end = end
+          while encoded_end==None and tmp_end>0:
+            tmp_end-=1
+            encoded_end = encodings[batch_id].char_to_token(tmp_end-1)
+          if end!=None: encoded_end+=1
+
+          if encoded_end>self.encode_max_length:
+            boundary_encoded.append(self.encode_max_length)
+            break
+          else:
+            boundary_encoded.append(encoded_end)
+        for i in range(len(boundary_encoded)-1, 0, -1):
+          boundary_encoded[i]=boundary_encoded[i]-boundary_encoded[i-1]
+            
+        batch_boundary_encoded.append(boundary_encoded)
+      return batch_boundary_encoded
+    def cal_agreement_span(self, agreement_table, min_agree=2, max_agree=3):
+      """
+      find the spans from agreement table
+      """
+      ans_span=[]
+      start, end =(0, 0)
+      pre_p = agreement_table[0]
+      for i, word_agreement in enumerate(agreement_table):
+        curr_p = word_agreement
+        if curr_p != pre_p:
+          if start != end: ans_span.append([start, end])
+          start=i
+          end=i
+          pre_p = curr_p
+        if word_agreement<min_agree:
+          start+=1
+        if word_agreement<=max_agree:
+          end+=1
+        #print([start, end])
+        pre_p = curr_p
+      if start != end: ans_span.append([start, end])
+      #print(ans_span)
+      if len(ans_span)<=1 or min_agree == max_agree:
+        return ans_span
+      #span 合併
+      span_concate = []
+      start, end = [ans_span[0][0], ans_span[0][1]]
+      for span_id in range(1, len(ans_span)):
+        if ans_span[span_id-1][1]==ans_span[span_id][0]:
+          ans_span[span_id]=[ans_span[span_id-1][0], ans_span[span_id][1]]
+          if span_id==len(ans_span)-1: span_concate.append(ans_span[span_id])
+          #span_concate.append()
+        elif span_id==len(ans_span)-1:
+          span_concate.extend([ans_span[span_id-1], ans_span[span_id]])
+        else:
+          span_concate.append(ans_span[span_id-1])
+      return span_concate
+
+    def collate_fn(self, batch_sample):
+        batch_text = []
+        batch_table = []
+        batch_span_label= []
+        seq_lens = []
+        for sample in batch_sample:
+          batch_text.append(sample['original_text'])
+          batch_table.append(self.create_label_list(sample["span_labels"], len(sample['original_text'])))
+          #batch_boundary = [sample['data_len_c'] for sample in batch_sample]
+          batch_span_label.append(sample["span_labels"])
+          seq_lens.append(len(sample['original_text']))
+        self.batch_max_lenght = max(seq_lens)
+        if self.batch_max_lenght > self.encode_max_length : self.batch_max_lenght = self.encode_max_length 
+
+        encoded = self.tokenizer(batch_text, truncation=True, max_length=512, padding='max_length', stride=self.stride, return_overflowing_tokens=True, return_tensors="pt", return_offsets_mapping=True)
+        #encoded = self.tokenizer(batch_text, truncation=True, padding=True, return_tensors="pt", max_length=self.max_length)
+        
+        encoded['labels'], batch_encode_seq_lens = self.encode_lable(encoded, batch_table)
+        encoded["crf_mask"] = self.create_crf_mask(batch_encode_seq_lens)
+        #encoded["boundary"] = batch_boundary
+        #encoded["boundary_encode"] = self.boundary_encoded(encoded, batch_boundary)
+        encoded["span_labels"] = batch_span_label
+        encoded["batch_text"] = batch_text
+        return encoded

code/models.py

@@ -0,0 +1,53 @@
+import torch
+from torch.nn import functional, CrossEntropyLoss, Softmax
+from torchcrf import CRF
+from transformers import RobertaModel, BertModel
+
+from args import args, config
+class Model_Crf(torch.nn.Module):
+    def __init__(self, config):
+        super(Model_Crf, self).__init__()
+        self.bert = BertModel.from_pretrained(args.pre_model_name)
+        self.dropout = torch.nn.Dropout(config.hidden_dropout_prob)
+        self.classifier = torch.nn.Linear(config.hidden_size, args.label_size)
+        self.crf = CRF(num_tags=args.label_size, batch_first=True)
+
+    def forward(self, input_ids, token_type_ids=None, attention_mask=None,  context_mask=None, labels=None, span_labels=None, start_positions=None, end_positions=None, testing=False, crf_mask=None):
+        outputs =self.bert(input_ids = input_ids,attention_mask=attention_mask,token_type_ids=token_type_ids)
+        sequence_output = outputs[0]
+        sequence_output = self.dropout(sequence_output)
+        sequence_output = sequence_output[:,1:-1,:] #remove [CLS], [SEP]
+        logits = self.classifier(sequence_output)#[batch, max_len, label_size]
+        outputs = (logits,)
+        if labels is not None:
+            #print('logits = ', logits.size())
+            #print('labels = ', labels.size())
+            #print('crf_mask = ', crf_mask.size())
+            loss = self.crf(emissions = logits, tags=labels, mask = crf_mask, reduction="mean")
+            outputs =(-1*loss,)+outputs
+        return outputs
+
+class Model_Softmax(torch.nn.Module):
+    def __init__(self, config):
+        super(Model_Softmax, self).__init__()
+        self.bert = BertModel.from_pretrained(args.pre_model_name)
+        self.dropout = torch.nn.Dropout(config.hidden_dropout_prob)
+        self.classifier = torch.nn.Linear(config.hidden_size, args.label_size)
+        self.loss_calculater = CrossEntropyLoss()
+        self.softmax = Softmax(dim=-1)
+
+    def forward(self, input_ids, token_type_ids=None, attention_mask=None,  context_mask=None, labels=None, span_labels=None, start_positions=None, end_positions=None, testing=False, crf_mask=None):
+        outputs =self.bert(input_ids = input_ids,attention_mask=attention_mask,token_type_ids=token_type_ids)
+        sequence_output = outputs[0]
+        sequence_output = self.dropout(sequence_output)
+        sequence_output = sequence_output[:,1:-1,:] #remove [CLS], [SEP]
+        logits = self.classifier(sequence_output)#[batch, max_len, label_size]
+        logits = self.softmax(logits)
+        outputs = (logits,)
+        if labels is not None:
+            #print('logits = ', logits.size())
+            #print('labels = ', labels.size())
+            labels = functional.one_hot(labels, num_classes=args.label_size).float()
+            loss = self.loss_calculater(logits, labels)
+            outputs =(loss,)+outputs
+        return outputs

code/prediction.py

@@ -0,0 +1,92 @@
+import torch
+from args import args, config
+from tqdm import tqdm
+from items_dataset import items_dataset
+
+def test_predict(test_loader, device, model, min_label=1, max_label=3):
+  model.eval()
+  result = []
+  
+  for i, test_batch in enumerate(tqdm(test_loader)):
+    batch_text = test_batch['batch_text']
+    input_ids = test_batch['input_ids'].to(device)
+    token_type_ids = test_batch['token_type_ids'].to(device)
+    attention_mask = test_batch['attention_mask'].to(device)
+    #labels = test_batch['labels'].to(device)
+    crf_mask = test_batch["crf_mask"].to(device)
+    sample_mapping = test_batch["overflow_to_sample_mapping"]
+    output = model(input_ids=input_ids, token_type_ids=token_type_ids, attention_mask=attention_mask, labels=None, crf_mask=crf_mask)
+    if args.use_crf:
+      prediction = model.crf.decode(output[0], crf_mask)
+    else:
+      prediction = torch.max(output[0], -1).indices
+
+    #make result of every sample
+    sample_id = -1
+    sample_result= {"text_a" : test_batch['batch_text'][0]}
+    for batch_id in range(len(sample_mapping)):
+        change_sample = False
+        if sample_id != sample_mapping[batch_id]: change_sample = True
+        #print(i, id)
+        if change_sample:
+          sample_id = sample_mapping[batch_id]
+          sample_result= {"text_a" : test_batch['batch_text'][sample_id]}
+          decode_span_table = torch.zeros(len(test_batch['batch_text'][sample_id]))
+
+        spans = items_dataset.cal_agreement_span(None, agreement_table=prediction[batch_id], min_agree=min_label, max_agree=max_label)
+        #decode spans
+        for span in spans:
+            #print(span)
+            if span[0]==0: span[0]+=1
+            if span[1]==1: span[1]+=1
+
+            while(True):
+              start = test_batch[batch_id].token_to_chars(span[0])
+              if start != None or span[0]>=span[1]:
+                break
+              span[0]+=1
+              
+            while(True):
+              end = test_batch[batch_id].token_to_chars(span[1])
+              if end != None or span[0]>=span[1]:
+                break
+              span[1]-=1
+
+            if span[0]<span[1]:
+              de_start = test_batch[batch_id].token_to_chars(span[0])[0]
+              de_end = test_batch[batch_id].token_to_chars(span[1]-1)[0]
+              #print(de_start, de_end)
+              #if(de_start>512): print(de_start, de_end)
+              decode_span_table[de_start:de_end]=2 #insite
+              decode_span_table[de_start]=1 #begin
+        if change_sample:
+          sample_result["predict_span_table"] = decode_span_table
+          #sample_result["boundary"] = test_batch["boundary"][id]
+          result.append(sample_result)
+  model.train()
+  return result
+
+def add_sentence_table(result):
+  
+  pattern =":；。，？!～！： "
+  for sample in result:
+    boundary_list = []
+    for i, char in enumerate(sample['text_a']):
+      if char in pattern:
+        boundary_list.append(i)
+    boundary_list.append(len(sample['text_a'])+1)
+    start=0
+    end =0
+    pre_states =False
+    sample["predict_sentence_table"] = torch.zeros(len(sample["predict_span_table"]))
+    for boundary in boundary_list:
+      end = boundary
+      if(sum(sample["predict_span_table"][start:end])>0):
+        if pre_states:
+          sample["predict_sentence_table"][start-1:end] = 2
+        else: 
+          sample["predict_sentence_table"][start:end] = 2
+          sample["predict_sentence_table"][start] = 1
+        pre_states=True
+      else: pre_states =False
+      start = end+1

code/rank.ipynb

@@ -0,0 +1,201 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from args import args, config\n",
+    "from items_dataset import items_dataset\n",
+    "from torch.utils.data import DataLoader\n",
+    "from models import Model_Crf, Model_Softmax\n",
+    "from transformers import AutoTokenizer\n",
+    "from tqdm import tqdm\n",
+    "import prediction\n",
+    "import torch\n",
+    "import math"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "directory = \"../model/\"\n",
+    "model_name = \"roberta_CRF.pt\"\n",
+    "device = torch.device('cuda', 0) if torch.cuda.is_available() else torch.device('cpu')\n",
+    "model = Model_Crf(config).to(device)\n",
+    "model.load_state_dict(state_dict=torch.load(directory + model_name, map_location=device))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "input_dict = [{\"span_labels\":[]}]\n",
+    "input_dict[0][\"original_text\"] = \"\"\"貓咪犯錯後，以下5種懲罰方法很有效，飼主可以試試樂享網 2021-03-06 繼續閱讀 繼續閱讀 繼續閱讀 繼續閱讀 繼續閱讀 貓咪雖然高冷，但也是會犯錯的，那貓咪犯錯後，怎麼懲罰它才最有效呢？今天就來說一些懲罰貓咪最有效的5個方法！1、把痛感形成條件反射 這裡說的是「痛感」，而不是「暴打」。在貓咪犯錯後，寵主不需要打它，可以彈鼻頭或者是輕拍它的頭頂，給它造成痛感，這樣讓貓咪有一些畏懼心理，知道你在懲罰它。這樣時間長了，貓咪就會形成條件反射，以後就會少犯錯了。  2、大聲呵斥比起打貓，大聲呵斥貓咪會更加有效。因為貓咪對聲音很敏感，它能從主人的語氣中判斷主人的情緒，當大聲呵斥它的時候，它往往會楞一下，這時你繼續大聲呵斥它，那它就會明白你不允許它做這件事，這樣犯錯地方幾率就會減少了。  3、限制自由限制自由說白了，就是把貓咪關進籠子裡。因為貓咪都是很愛外出玩耍，當它犯錯咯，主人可以把它關進籠子裡，不搭理它，讓它自己反思。但要注意，這個方法不能經常用，而且不能把貓咪關進籠子太久。  4、利用水都知道貓咪很怕水的，所以當貓咪犯錯後，寵主也可以利用水來懲罰貓咪，這也是很效果的方法。寵主可以給貓咪臉上或是頭頂噴一些水，從而讓貓知道這個行為是錯誤的，以後就不會再犯了。  5、冷淡雖然貓咪不是很粘主人，但它還是很愛主人的，所以在貓咪犯錯後，寵主也可以採取冷淡的方法來懲罰貓。對貓咪採取不理睬、不靠近、不擁抱等策略，這樣貓咪就會知道自己錯了。當然懲罰的時間不要太長，不然貓咪就會以為你不愛它了。\"\"\"\n",
+    "tokenizer = AutoTokenizer.from_pretrained(args.pre_model_name, add_prefix_space=True)\n",
+    "prediction_dataset = items_dataset(tokenizer, input_dict, args.label_dict)\n",
+    "prediction_loader = DataLoader(prediction_dataset, batch_size=args.batch_size, shuffle=True, collate_fn=prediction_dataset.collate_fn)\n",
+    "predict_data = prediction.test_predict(prediction_loader, device, model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prediction.add_sentence_table(predict_data)\n",
+    "print(predict_data[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def prepare_span_data(dataset):\n",
+    "    \"\"\"prepare spans labels for each sample\"\"\"\n",
+    "    for sample in dataset:\n",
+    "        spans = items_dataset.cal_agreement_span(None, agreement_table=sample[\"predict_sentence_table\"], min_agree=1, max_agree=2)\n",
+    "        sample[\"span_labels\"] = spans\n",
+    "        sample[\"original_text\"] = sample[\"text_a\"]\n",
+    "        del sample[\"text_a\"]\n",
+    "prepare_span_data(predict_data)\n",
+    "tokenizer = AutoTokenizer.from_pretrained(args.pre_model_name, add_prefix_space=True)\n",
+    "prediction_dataset = items_dataset(tokenizer, predict_data, args.label_dict)\n",
+    "prediction_loader = DataLoader(prediction_dataset, batch_size=args.batch_size, shuffle=False, collate_fn=prediction_dataset.collate_fn)\n",
+    "\n",
+    "index=0\n",
+    "print(predict_data[index][\"original_text\"])\n",
+    "print(predict_data[index][\"span_labels\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "directory = \"../model/\"\n",
+    "model_name = \"roberta_softmax.pt\"\n",
+    "device = torch.device('cuda', 0) if torch.cuda.is_available() else torch.device('cpu')\n",
+    "model = Model_Softmax(config).to(device)\n",
+    "model.load_state_dict(state_dict=torch.load(directory + model_name, map_location=device))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def rank_spans(test_loader, device, model, reverse=True):\n",
+    "  \"\"\"Calculate each span probability by e**(word average log likelihood)\"\"\"\n",
+    "  model.eval()\n",
+    "  result = []\n",
+    "  \n",
+    "  for i, test_batch in enumerate(tqdm(test_loader)):\n",
+    "    batch_text = test_batch['batch_text']\n",
+    "    input_ids = test_batch['input_ids'].to(device)\n",
+    "    token_type_ids = test_batch['token_type_ids'].to(device)\n",
+    "    attention_mask = test_batch['attention_mask'].to(device)\n",
+    "    labels = test_batch['labels']\n",
+    "    crf_mask = test_batch[\"crf_mask\"].to(device)\n",
+    "    sample_mapping = test_batch[\"overflow_to_sample_mapping\"]\n",
+    "    output = model(input_ids=input_ids, token_type_ids=token_type_ids, attention_mask=attention_mask, labels=None, crf_mask=crf_mask)\n",
+    "    output = torch.nn.functional.softmax(output[0], dim=-1)\n",
+    "    \n",
+    "    #make result of every sample\n",
+    "    sample_id = 0\n",
+    "    sample_result= {\"original_text\" : test_batch['batch_text'][sample_id], \"span_ranked\" : []}\n",
+    "    for batch_id in range(len(sample_mapping)):\n",
+    "      change_sample = False\n",
+    "        \n",
+    "      #make sure status\n",
+    "      if sample_id != sample_mapping[batch_id]: change_sample = True\n",
+    "      if change_sample:\n",
+    "        sample_id = sample_mapping[batch_id]\n",
+    "        result.append(sample_result)\n",
+    "        sample_result= {\"original_text\" : test_batch['batch_text'][sample_id], \"span_ranked\" : []}\n",
+    "        \n",
+    "      encoded_spans = items_dataset.cal_agreement_span(None, agreement_table=labels[batch_id], min_agree=1, max_agree=2)\n",
+    "      #print(encoded_spans)\n",
+    "      for encoded_span in encoded_spans:\n",
+    "        #calculate span loss\n",
+    "        span_lenght = encoded_span[1]-encoded_span[0]\n",
+    "        #print(span_lenght)\n",
+    "        span_prob_table = torch.log(output[batch_id][encoded_span[0]:encoded_span[1]])\n",
+    "        if not change_sample and encoded_span[0]==0 and batch_id!=0: #span cross two tensors\n",
+    "          span_loss += span_prob_table[0][1] #Begin\n",
+    "        else:\n",
+    "          span_loss = span_prob_table[0][1] #Begin\n",
+    "        for token_id in range(1, span_prob_table.shape[0]):\n",
+    "          span_loss+=span_prob_table[token_id][2] #Inside\n",
+    "        span_loss /= span_lenght\n",
+    "        \n",
+    "        #span decode\n",
+    "        decode_start = test_batch[batch_id].token_to_chars(encoded_span[0]+1)[0]\n",
+    "        decode_end =  test_batch[batch_id].token_to_chars(encoded_span[1])[0]+1\n",
+    "        #print((decode_start, decode_end))\n",
+    "        span_text = test_batch['batch_text'][sample_mapping[batch_id]][decode_start:decode_end]\n",
+    "        if not change_sample and encoded_span[0]==0 and batch_id!=0: #span cross two tensors\n",
+    "          presample = sample_result[\"span_ranked\"].pop(-1)\n",
+    "          sample_result[\"span_ranked\"].append([presample[0]+span_text, math.e**float(span_loss)])\n",
+    "        else:\n",
+    "          sample_result[\"span_ranked\"].append([span_text, math.e**float(span_loss)])\n",
+    "    result.append(sample_result)\n",
+    "    \n",
+    "  #sorted spans by probability\n",
+    "  for sample in result:\n",
+    "    sample[\"span_ranked\"] = sorted(sample[\"span_ranked\"], key=lambda x:x[1], reverse=reverse)\n",
+    "  return result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "span_ranked = rank_spans(prediction_loader, device, model)\n",
+    "for sample in span_ranked:\n",
+    "    print(sample[\"original_text\"])\n",
+    "    print(sample[\"span_ranked\"])"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "for_project",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "7d6017e34087523a14d1e41a3fef2927de5697dc5dbb9b7906df99909cc5c8a1"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}