【腾讯云HAI域探密】- HAI为NPL保驾护航
原创【腾讯云HAI域探密】- HAI为NPL保驾护航
原创
近些年，随着机器学习技术的蓬勃发展，以GPU为代表的一系列专用芯片以优越的高性能计算能力和愈发低廉的成本，在机器学习领域得到广泛认可和青睐。GPU等专用芯片以较低的成本提供海量算力，已经成为机器学习和AI人工智能领域的核心利器，在人工智能时代发挥着越来越重要的作用。
今天给大家推荐和介绍的“高性能应用服务HAI”，是一款大幅降低GPU云服务器使用门槛，多角度优化产品使用体验，开箱即用。拥有澎湃算力，即开即用。以应用为中心，匹配GPU云算力资源，助力中小企业及开发者快速部署LLM、AI作画、数据科学等高性能应用。
探讨一下如何利用“高性能应用服务HAI”进行业务场景赋能，已经是很多公司目前需要面临的问题。本文分享一下“高性能应用服务HAI”在医疗NLP体系中的实践过程，希望能通过“高性能应用服务HAI”的方案对公司的业务进行将本增效。
一、为什么在AI的领域需要使用GPU呢？
在这些领域中，GPU 可以加速训练模型、处理海量数据等计算密集型任务，显著提高了计算效率和速度。因此，GPU 已成为现代计算机的重要组成部分，被广泛应用于各种领域。
1. GPU 和 CPU 的主要区别体现在以下几个方面：
2. GPU 的工作原理：
二、“高性能应用服务HAI”能够带来什么？
“高性能应用服务HAI”通过整合专门为机器学习 (ML) 构建的广泛功能集，帮助数据科学家和开发人员快速准备、构建、训练和部署高质量的机器学习模型。
1. 什么是HAI呢？
高性能应用服务(Hyper Application Inventor，HAI)是一款面向 Al、科学计算的GPU 应用服务产品，提供即插即用的澎湃算力与常见环境。助力中小企业及开发者快速部署LLM、AI作画、数据科学等高性能应用，原生集成配套的开发工具与组件，大幅提高应用层的开发生产效率。
“高性能应用服务HAI”是面向开发者和企业的机器学习/深度学习工程平台，提供包含模型框架、模型构建、模型训练、模型部署、推理优化在内的AI开发全链路服务，内置6种AI应用，具备丰富的行业场景插件，为用户提供低门槛、高性能的云原生AI工程化能力。
2. 平时在使用AIGC应用的痛点：
在AIGC浪潮下，AI应用部署及使用困难，中小企业和开发者望尘莫及，需要花费大量的人力、物力、知识储备来探索。
AI绘画、AI写作、SD、chtapt/chatgol,中小型企业应用，个人开发者对这些有序的AI应用尝试、体验、使用。在部署和使用AI应用之前，都要考虑各方面的因素。等一系列的环境问题，都让大家感到头痛。
3. 高性能应用服务HAI可以让我们干什么？
通过“高性能应用服务HAI”的StableDiffusion模型可以进行AI绘画，是一种利用深度学习算法进行创作的绘图方式，被广泛应用于游戏、数字媒体、电影、广告设计、动画等领域，可以让设计师加快绘图相关的工作，从“人工”GC逐渐的转向AIGC人工智生产内容。
4. “高性能应用服务HAI”降本增效的结果：
5. “高性能应用服务HAI”全面的AI应用托管服务：
“高性能应用服务HAI”是根据应用匹配推选GPU算力资源，实现最高性价比，是面向开发者和企业的AI工程化平台，提供了覆盖数据提供、模型开发、模型训练、模型部署的全流程服务。
同时，打通必备云服务组件，大幅简化云服务配置流程，为机器学习开发的每个步骤加速创新，包括：
- 分钟级自动构建LLM、AI作画等应用环境，适合模型开发、模型训练、模型部署
- 提供多种预装模型环境，包含如StableDiffusion、ChatGLM等热门模型
- 提供开发者友好的图形界面，支持JupyterLab、WebUI等多种算力连接方，AI研究调试超低门槛。
- 学术加速为企业提供训练加速和推理加速的能力，提高AI训练和推理的速度、易用性和稳定性，极大提升AI计算的效率。
“高性能应用服务HAI”基于软硬件一体优化技术，超大规模分布式深度学习任务运行，具备高性能、高效率、高利用率等核心优势，实现AI开发及应用过程的降本增效。
三、对比GPU云服务器，高性能应用服务HAI解决的业务痛点问题：
1. 总结优势与劣势：
四、“高性能应用服务HAI”的应用场景有哪些？
五、基于ChatGLM2-6B实现智能客服系统：
六、基于PyTorch 实现NLP自然语言处理：
基于NLP和自然语言处理技术将门诊/住院病历、检查检验报告、处方/医嘱等医疗文档自动识别、转换为结构化数据，支持下游可视化、统计分析、推理等应用，可用于健康档案、质控、保险理赔及临床科研等业务场景，获取医疗知识，节约医疗资源。
在公司的业务场景中，患者的病例需要手动去针对性的打标签，比如，标注这个患者是眼疾，实际上会有很多的问题存在：
- 工作的性质比较单一枯燥的动作，纯粹的人工作业方式
- 有人工成本的消耗
- 操作不准确，评判的标准不一致，容易产出错误
1. 文本csv内容准备，如下为一些患者的病例一些常见的症状描述。
2. 安装jieba库：
3. 使用结巴jieba库将语句进行分词库统计词频：
为了对中文文本数据进行预处理，以便进行NLP分析，代码使用中文分词库jieba对患者的数据进行处理。代码读取患者数据的csv文件，去除第一行（其中包含每列的标签），然后循环处理每一行数据。对于每一行，提取内容并使用jieba进行分词。
import jieba
data_path = "sources/data.csv"
data_list = open("data_path").readlines()[1:]
for item in data_list:
label = item[0]
content = item[2:].strip()
seg_list = jieba.cut(content, cut_all = False)
for seg_item in seg_list:
print(seg_item)可以看到一些标点符号，和一些没有语义的词也会被匹配出来，得到的分词结果被过滤以去除任何停用词（不具有意义的词，如“和”或“的”）。
4. 停用词stopwords处理：
停用词的作用是在文本分析过程中过滤掉这些常见词语，从而减少处理的复杂度，提高算法效率，并且在某些任务中可以改善结果的质量，避免分析结果受到这些词的干扰。
在自然语言处理（NLP）研究中，停用词stopwords是指在文本中频繁出现但通常没有太多有意义的词语。这些词语往往是一些常见的功能词、虚词甚至是一些标点符号，如介词、代词、连词、助动词等，比如中文里的"的"、"是"、"和"、"了"、"。"等等，英文里的"the"、"is"、"and"、"..."等等。
import jieba
data_path = "./sources/his.csv"
data_stop_path = "./sources/hit_stopwords.txt"
data_list = open(data_path).readlines()[1:]
stops_word = open(data_stop_path, encoding='UTF-8').readlines()
stops_word = [line.strip() for line in stops_word]
stops_word.append(" ")
stops_word.append("\n")
for item in data_list:
label = item[0]
content = item[2:].strip()
seg_list = jieba.cut(content, cut_all = False)
seg_res = []
for seg_item in seg_list:
if seg_item in stops_word:
continue
seg_res.append(seg_item)
print(content)
print(seg_res)
5. 加载数据集：
使用PyTorch的提供的dataset的接口，根据项目重写dataset和dataloader。
import jieba
data_path = "./sources/his.csv"
data_stop_path = "./sources/hit_stopwords.txt"
data_list = open(data_path).readlines()[1:]
stops_word = open(data_stop_path, encoding='UTF-8').readlines()
stops_word = [line.strip() for line in stops_word]
stops_word.append(" ")
stops_word.append("\n")
voc_dict = {}
min_seq = 1
top_n = 1000
UNK = "<UNK>"
PAD = "<PAD>"
for item in data_list:
label = item[0]
content = item[2:].strip()
seg_list = jieba.cut(content, cut_all = False)
seg_res = []
for seg_item in seg_list:
if seg_item in stops_word:
continue
seg_res.append(seg_item)
if seg_item in voc_dict.keys():
voc_dict[seg_item] += 1
else:
voc_dict[seg_item] = 1
voc_list = sorted([_ for _ in voc_dict.items() if _[1] > min_seq],
key=lambda x: x[1],
reverse=True)[:top_n]
voc_dict = {word_count[0]: idx for idx, word_count in enumerate(voc_list)}
voc_dict.update({UNK: len(voc_dict), PAD: len(voc_dict) + 1})
print(voc_dict)
# 保存字典
ff = open("./sources/dict.txt", "w")
for item in voc_dict.keys():
ff.writelines("{},{}\n".format(item, voc_dict[item]))
6. 搭建模型结构：
import numpy as np
import jieba
from torch.utils.data import Dataset, DataLoader
def read_dict(voc_dict_path):
voc_dict = {}
dict_list = open(voc_dict_path).readlines()
print(dict_list[0])
for item in dict_list:
item = item.split(",")
voc_dict[item[0]] = int(item[1].strip())
return voc_dict
# 将数据集进行处理(分词，过滤...)
def load_data(data_path, data_stop_path):
data_list = open(data_path, encoding='utf-8').readlines()[1:]
stops_word = open(data_stop_path, encoding='utf-8').readlines()
stops_word = [line.strip() for line in stops_word]
stops_word.append(" ")
stops_word.append("\n")
voc_dict = {}
data = []
max_len_seq = 0
np.random.shuffle(data_list)
for item in data_list[:]:
label = item[0]
content = item[2:].strip()
seg_list = jieba.cut(content, cut_all=False)
seg_res = []
for seg_item in seg_list:
if seg_item in stops_word:
continue
seg_res.append(seg_item)
if seg_item in voc_dict.keys():
voc_dict[seg_item] = voc_dict[seg_item] + 1
else:
voc_dict[seg_item] = 1
if len(seg_res) > max_len_seq:
max_len_seq = len(seg_res)
data.append([label, seg_res])
# print(max_len_seq)
return data, max_len_seq
# 定义Dataset
class text_CLS(Dataset):
def __init__(self, voc_dict_path, data_path, data_stop_path):
self.data_path = data_path
self.data_stop_path = data_stop_path
self.voc_dict = read_dict(voc_dict_path)
self.data, self.max_len_seq = load_data(self.data_path, self.data_stop_path)
np.random.shuffle(self.data)
def __len__(self):
return len(self.data)
def __getitem__(self, item):
data = self.data[item]
label = int(data[0])
word_list = data[1]
input_idx = []
for word in word_list:
if word in self.voc_dict.keys():
input_idx.append(self.voc_dict[word])
else:
input_idx.append(self.voc_dict["<UNK>"])
if len(input_idx) < self.max_len_seq:
input_idx += [self.voc_dict["<PAD>"] for _ in range(self.max_len_seq - len(input_idx))]
# input_idx += [1001 for _ in range(self.max_len_seq - len(input_idx))]
data = np.array(input_idx)
return label, data
# 定义DataLoader
def data_loader(data_path, data_stop_path, dict_path):
dataset = text_CLS(dict_path, data_path, data_stop_path)
return DataLoader(dataset, batch_size=10, shuffle=True)
data_path = "./sources/his.csv"
data_stop_path = "./sources/hit_stopwords.txt"
dict_path = "./sources/dict.txt"
train_dataLoader = data_loader(data_path, data_stop_path, dict_path)
for i, batch in enumerate(train_dataLoader):
print(batch[0], batch[1].size())
print(batch[0], batch[1])
7. 网络模型的配置：
import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
class Config():
def __init__(self):
'''
self.embeding = nn.Embedding(config.n_vocab,
config.embed_size,
padding_idx=config.n_vocab - 1)
self.lstm = nn.LSTM(config.embed_size,
config.hidden_size,
config.num_layers,
bidirectional=True, batch_first=True,
dropout=config.dropout)
self.maxpool = nn.MaxPool1d(config.pad_size)
self.fc = nn.Linear(config.hidden_size * 2 + config.embed_size,
config.num_classes)
self.softmax = nn.Softmax(dim=1)
'''
self.n_vocab = 1002
self.embed_size = 128
self.hidden_size = 128
self.num_layers = 3
self.dropout = 0.8
self.num_classes = 2
self.pad_size = 32
self.batch_size = 128
self.is_shuffle = True
self.learn_rate = 0.001
self.num_epochs = 100
self.devices = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
class Model(nn.Module):
def __init__(self, config):
super(Model, self).__init__()
self.embeding = nn.Embedding(config.n_vocab,
padding_idx=config.n_vocab - 1)
self.lstm = nn.LSTM(input_size=config.embed_size,
hidden_size=config.hidden_size,
num_layers=config.num_layers,
bidirectional=True,
batch_first=True, dropout=config.dropout)
self.maxpooling = nn.MaxPool1d(config.pad_size)
self.fc = nn.Linear(config.hidden_size * 2 + config.embed_size, config.num_classes)
self.softmax = nn.Softmax(dim=1)
def forward(self, x):
embed = self.embeding(x)
out, _ = self.lstm(embed)
out = torch.cat((embed, out), 2)
out = F.relu(out)
out = out.permute(0, 2, 1)
out = self.maxpooling(out).reshape(out.size()[0], -1)
out = self.fc(out)
out = self.softmax(out)
return out
# 测试网络是否正确
cfg = Config()
cfg.pad_size = 640
model_textcls = Model(config=cfg)
input_tensor = torch.tensor([i for i in range(640)]).reshape([1, 640])
out_tensor = model_textcls.forward(input_tensor)
print(out_tensor.size())
print(out_tensor)
8. 训练脚本的搭建：
model_text_cls = Model(cfg)
model_text_cls.to(cfg.devices)
loss_func = nn.CrossEntropyLoss()
optimizer = optim.Adam(model_text_cls.parameters(), lr=cfg.learn_rate)
for epoch in range(cfg.num_epochs):
for i, batch in enumerate(train_dataloader):
label, data = batch
# data1 = torch.tensor(data).to(cfg.devices)
# label1 = torch.tensor(label).to(cfg.devices)
data1 = data.sourceTensor.clone().detach().to(cfg.devices)
label1 = label.sourceTensor.clone().detach().to(cfg.devices)
optimizer.zero_grad()
pred = model_text_cls.forward(data1)
loss_val = loss_func(pred, label1)
print("epoch is {},ite is {},val is {}".format(epoch, i, loss_val))
loss_val.backward()
optimizer.step()
if epoch % 10 == 0:
torch.save(model_text_cls.state_dict(), "./models/{}.pth".format(epoch))
9. 小结：
可以通过基于PyTorch 实现NLP自然语言处理将患者病例实现AI技术进行转换，从而让业务能够快速实现自动化打标签，可以起到降本增效的结果。
“高性能应用服务HAI”基于PyTorch 优化的其它类似的场景应用方案：
总结：
“高性能应用服务HAI”具有澎湃算力，即开即用，基于腾讯云GPU云服务器底层算力，提供开箱即用的高性能云服务。以应用为中心，匹配GPU云算力资源，助力中小企业及开发者快速部署LLM、AI作画、数据科学等高性能应用。
“高性能应用服务HAI”是面向开发者和企业的云原生机器学习/深度学习工程平台，服务覆盖AI开发全链路，内置6+AI框架和模型，具备丰富的行业场景插件。
原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。
如有侵权，请联系 cloudcommunity@tencent.com 删除。
原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。
如有侵权，请联系 cloudcommunity@tencent.com 删除。