深度学习数据预处理

预处理数据存储存储为二进制格式（方便下一次不用再进行预处理了）：

with open(fp, ‘wb’) as f:
pickle.dump(data, f)

封装数据：

1.pytorch中数据处理：

from torch.utils.data import Dataset


自定义的类，继承Dataset
class CustomDataset(Dataset):
    """默认使用 List 存储数据"""
    def __init__(self, _T,_S1):
        self.x_data = _T
        self.y1_data = _S1
        self.len = len(self.x_data)

    def __getitem__(self, item):
        sample = self.file[item]
        return sample

    def __len__(self):
        return len
 def collate_fn(data):#数据转换
    t = np.array([item[0] for item in data], np.int32)
    s1 = np.array([item[1] for item in data], np.int32)
    return {
      'T': torch.LongTensor(t), # targets_i
      'S1': torch.FloatTensor(s1)
    }
train_dataset = CustomDataset(train_data_path)#进行数据集的封装
train_dataloader = DataLoader(train_dataset, batch_size=64, shuffle=True, collate_fn=collate_fn)
for step, loader_res in tqdm(iter(enumerate(train_dataloader))):
	# print(get_now_time())
	t_s = loader_res["T"]#.cuda()
	s1 = loader_res["S1"]#.cuda()
	s2 = loader_res["S2"]#.cuda()
	o1 = loader_res["O1"]#.cuda()
	o2 = loader_res["O2"]#.cuda()

进一步封装，按批次对刚才封装好的数据集封装
备注：
1.train_dataset必须是一个封装好的数据类，直接赋值的简单类
2.进阶:DataLoader的collate_fn参数设置
在该函数中可以对每一个批次中的数据进行进一步的加工处理，padding等等其他的处理，进行数据格式转换np->tensor等等。
collate_fn传入的batch是一个列表！列表的长度是batch_size,也就是说里面有batch_size个元素。每一个元素也是一个列表！这个列表里有两个元素，分别是train_x中的一个样本和train_y中的一个分类标签。我们要解决的就是train_x中的这一个样本，它的第0维(代表着单词数)，与其他样本的单词数会有所不同。
那么，我们先把batch中的各个列表，按照列表中第一个元素(也就是train_x的一个样本)的0维进行排序(降序)。
接着就很好理解了，max_num代表最大的单词数，每一个train_x中的样本，如果小于这个单词数。就先计算一下max_num - len(temp)，也就是缺了多少单词(n)，然后补充n个size大小的0向量。
使用封装后的数据：
for batch_idx, (x, y) in enumerate(dataloader, 1):#打包封装的数据，x是word，lens，head_pos，tail_pos字典【32,52】

细节

字典中包含字典类型{}的取值方法：使用dict.item（），多个循环一起做。

查找词在字符串中的位置

text.find(sp[0])#text为字符串

Index=[[0, 2]]:dim:1*2 取值：index[0][1],index[0][0]

文本分类数据处理

①　手动标注几万条训练数据，格式 第一列为类别，第二列为文本
②　定义一个类别文本类别对应数字，然后将标注的数据进行转换为数字。
③　取分类标签，为训练文本进行标注
④　制定词表以二进制存储pkl.dump(vocab_dic, open(‘vocab.pkl’, ‘wb’))

限制句子最大长度：

line={“text”: “Massachusetts ASTON MAGNA Great Barrington ; also at Bard College , Annandale-on-Hudson , N.Y. , July 1-Aug .”}
text = ’ '.join(line[‘text’].split()[:10])

分词

记录词或字母的标识和统计个数：
1.建立词典dict={}，用字母或词作为key，个数作为value记录
2.for i in range(0,len(t)-1):
3. if t[i+1] !=’ ‘:
4. subword=t[i]+’_’
5. else:
6. subword=t[i]
7. if subword not in mydict:
8. mydict[subword]=1
9. else:
mydict[subword]+=1

中文词频统计

1.统计词频，一种是笨的如上.
2.第二种就是利用collections.Counter()统计
word_count=collections.Counter()
for content in text:
word_count.update(content)
构建词典按照序号构建
for word in input_str:
dict_tmp[word]=dict_tmp.get(word,0)+1
word2id[content[0]] = len(word2id)#按照序号标记词
按字符级够字典
vocabulary = set(string)

词频排序
如何根据字典中值的大小，对字典中的项排序 sorted(dict2.item(),key=lambda item:item[1],reverse=True)
Item()是词典的内部属性,将值传给lambda中的item[1]，item[1]代表value，想要用元组中的词=key或者value，就用items()调用，reverse参数为True意味着按照降序排序
for i in word_freq_list:
d = i[0] + ’ ’ + str(i[1]) + ‘\n’
fw.write(d)
元组的构建过程
for line in data:
line=line.split(’ ')
w=line[0]
n=int(line[1])
label_w2n[w]=n
label_n2w[n]=w

构建词表
一般会用随机初始化，但也有一些技巧，比如对低频词对应的可以对全部低频词做采样后取平均来初始化。（或者表示0频词的初始化为1频词的采样平均）。
填充。一般取0
按照word2id构造，将UNK和PAD放到词表中相应的位置中。
批次
按批次取值计算：（封装的方法自己去查询高级的封装，例torchtext）
for i in range(batch_num+1):
#最好一个批次不够64，就直接剩余取。
t_len=len_list[i*batch_size:(i+1)batch_size] if ibatch_size:]
yield batch_len, batch_label
相当于一个循环封装一个批次传值的迭代器
分割字符：
tokenizer = lambda x: [y for y in x]
token = tokenizer(content)
将句子按字节分割，list
Word转id，如果存在词表，就去id，没有词，就去UNK的id
wdds_line.append(vocab.get(word, vocab.get(UNK)))
填充方法：
1.token.extend([vocab.get(PAD)] * (pad_size - len(token)))
方法
from keras.preprocessing.sequence import pad_sequences
pad_sequences(maxlen=input_shape, sequences=x, padding=‘post’, value=0)

打乱数据（对list处理）

RANDOM_SEED = 2019#只要数字一样，得到的随机数也是一样的
random_order = list(range(len(train_data)))
np.random.seed(RANDOM_SEED)#随机种子，在一个参数上变换值
np.random.shuffle(random_order)#随机打乱，用的是list
train_data = [train_data[i] for i in random_order]

分析：train_data是训练集，计算长度得到list，打乱random序号，重新组成训练集。
#第i个（i代表不是真正的位置）对应的值1232,重新排列训练集

数据统计

Pandas
（处理CSV数据函数），方便统计绘图等方面（要会统计）
df.to_excel(’./result.xlsx’, index=False) Df存储到xlsx文件中

df = pd.DataFrame({“text”: text_list, “spo_num”: spo_num} )
List转换为Datafame格式框架
df.to_excel(’./result.xlsx’, index=False) Df存储到xlsx文件中
len_df = df.groupby(‘length’).count()
对出现相同长度进行统计个数得到的是length | eval |label 2 |32|32 长度为2出现32次
sent_length = len_df.index.tolist()
sent_freq = len_df[‘evaluation’].tolist() 取出index=length
去重：labels, vocabulary = list(df[‘label’].unique()), list(df[‘evaluation’].unique()) 得到list，且不重复
Df=pd.read_csv(’./corpus.csv’) 导入CSV文件格式
pd.read_excel导入excel 导入excel
CSV格式 备注：逗号分隔值（Comma-Separated Values，CSVcsv格式的类似表格，第一行为每一列的属性，按逗号隔开）
df.groupby(‘label’)[‘label’].count() 计算label属性下不同词的总个数.groupby的作用，将label中出现的A和B进行分组求出所出现的次数。
Df[‘length’]= df[‘evaluation’].apply(lambda x: len(x)) 计算每一行长度且新增了一列长度在df中
df[‘eval’].apply(lambda x:len(x)) 计算eval列的每一行句子长度。
lambda介绍：x是传的eval句子参数，方法为len（x）
csv.DictReader(f, dialect=dialect)
导入csv是OrderDict类型

Matplotlib.pylot:

from matplotlib import font_manager as fm, rcParams
plt.rcParams[‘font.sans-serif’]=[‘SimHei’]
plt.rcParams[‘axes.unicode_minus’]=False #有中文在图上显示显示中文标签，防止出错
plt.bar(sent_length, sent_freq) 表示的是右上方的标志注释意义

plt.title(“句子长度及出现频数统计图”) 标题
plt.xlabel(“句子长度”)、plt.ylabel(“句子长度出现的频数”) X轴标签，y轴标签
plt.savefig("./句子长度频数统计图.png")
保存图片
plt.ylim(0, 500) Y轴范围
plt.hlines(quantile, 0, index, colors=“c”, linestyles=“dashed”)
plt.vlines(index, 0, quantile, colors=“c”, linestyles=“dashed”) 虚线表示横纵坐标点的虚线描绘
plt.text(0, quantile, str(quantile))
plt.text(index, 0, str(index))x=index，y=0，转换为string 在虚线上写字
图的表示方法
1.直方图
2.函数分布图：利用累积频率计算，即单个出现的频次除以总的频次的结果作为纵坐标，不能直接用频率作为纵坐标非常大

plt.plot(sent_length, sent_pentage_list)

sent_pentage_list = [(count/sum(sent_freq)) for count in accumulate(sent_freq)]

plt.xticks([index + 0.1 for index in x], label_list) plt.xticks(rotation=45) X轴的标签旋转45度

数据封装

dataloader是一个可迭代的对象，意味着我们可以像使用迭代器一样使用它 或者 or batch_datas, batch_labels in dataloader:
Dataset是一个包装类，用来将数据包装为Dataset类，然后传入DataLoader中，我们再使用DataLoader这个类来更加快捷的对数据进行操作。
if len(self.data) % self.batch_size != 0:
self.steps += 1

封装数据包括:数据集，封装的分词字典，关系，关系个数，句子最大长度，批次
data_generator(train_data, tokenizer, rel2id, num_rels, MAX_LEN, BATCH_SIZE)

logging日志显示

import logging

if not logger.handlers:
    # Logging to a file
    file_handler = logging.FileHandler(log_path)
    file_handler.setFormatter(logging.Formatter('%(asctime)s:%(levelname)s: %(message)s'))
    logger.addHandler(file_handler)

    # Logging to console
    stream_handler = logging.StreamHandler()
    stream_handler.setFormatter(logging.Formatter('%(message)s'))
    logger.addHandler(stream_handler)

logging.info("loading...")