NLP_知识图谱_三元组实战

文章目录

  • 三元组含义
  • 如何构建知识图谱
  • 模型的整体结构
  • 基于transformers框架的三元组抽取baseline
    • how to use
    • 预训练模型下载地址
    • 训练数据下载地址
  • 结构图
  • 代码及数据
    • bert
      • config.json
      • vocab.txt
    • data
      • dev.json
      • schemas.json
      • train.json
      • vocab.json
    • 与bert跟data同个目录
      • model.py
      • train.py
  • 三元组实战小结


三元组含义

知识图谱的三元组,指的是 <subject, predicate/relation, object> 。同学们会发现很多人类的知识都可以用这样的三元组来表示。例如:<中国,首都,北京>,<美国,总统,特朗普> 等等。

所有图谱中的数据都是由三元组构成

工业场景通常把三元组存储在图数据库中如neo4j,图数据的优势在于能快捷查询数据。
学术界会采用RDF的格式存储数据,RDF的优点在于易于共享数据。

如何构建知识图谱

构建知识图谱通常有两种数据源

1、结构化数据,存储在关系型数据库中的数据,通过定义好图谱的schema,然后按照schema的格式,把关系型数据转化为图数据。

2、非结构化数据,通常又包括了纯文本形式和基于表格的形式,通常采用模板或者模型的方式,从文本中抽取出三元组再入库。

在实际的工业场景中,数据往往是最难处理的,这和比赛情况完全不同,比赛的数据较为干净、公整。但是在工业场景中,会出现难以构建schema、数据量极少、无标注数据等情况。

所以,对于不同的情况我们应该采用不同的处理方式,而不是一味的去采用模型处理。例如表格数据,其实采用规则的方式效果会很不错。

模型的整体结构

该模型只是一个baseline,还有很多的优化空间,大家可以根据自己的理解与想法,去迭代升级模型。

模型的整体结构如左图所示,输入是一段文本信息,经过encoder层进行编码,提取出头实体,再对头实体编码并复用文本编码,接下来用了个小trick,同时预测尾实体与关系,当然你也可以分开先预测尾实体,再预测关系。

对于实体的预测,我们可以使用BIO的方式,这里我们换一种思路,半指针半标注。

接下里我们看个具体的例子
在这里插入图片描述

句子案例:周星驰主演了喜剧之王,周星驰还演了其它的电影…
在这里插入图片描述

基于transformers框架的三元组抽取baseline

how to use

下载预训练模型,放到bert目录下,下载训练数据放到data目录下
安装transformers,pip install transformers
执行train.py文件

预训练模型下载地址

bert https://huggingface.co/bert-base-chinese/tree/main

roberta https://huggingface.co/hfl/chinese-roberta-wwm-ext/tree/main

训练数据下载地址

链接:https://pan.baidu.com/s/1rNfJ88OD40r26RR0Lg6Geg 提取码:a9ph

结构图

在这里插入图片描述

代码及数据

bert

config.json

{
  "architectures": [
    "BertForMaskedLM"
  ],
  "attention_probs_dropout_prob": 0.1,
  "directionality": "bidi",
  "hidden_act": "gelu",
  "hidden_dropout_prob": 0.1,
  "hidden_size": 768,
  "initializer_range": 0.02,
  "intermediate_size": 3072,
  "layer_norm_eps": 1e-12,
  "max_position_embeddings": 512,
  "model_type": "bert",
  "num_attention_heads": 12,
  "num_hidden_layers": 12,
  "output_past": true,
  "pad_token_id": 0,
  "pooler_fc_size": 768,
  "pooler_num_attention_heads": 12,
  "pooler_num_fc_layers": 3,
  "pooler_size_per_head": 128,
  "pooler_type": "first_token_transform",
  "type_vocab_size": 2,
  "vocab_size": 21128
}

vocab.txt

在这里插入图片描述
在这里插入图片描述

data

dev.json

[
    {
        "text": "查尔斯·阿兰基斯(Charles Aránguiz),1989年4月17日出生于智利圣地亚哥,智利职业足球运动员,司职中场,效力于德国足球甲级联赛勒沃库森足球俱乐部",
        "spo_list": [
            [
                "查尔斯·阿兰基斯",
                "出生地",
                "圣地亚哥"
            ],
            [
                "查尔斯·阿兰基斯",
                "出生日期",
                "1989年4月17日"
            ]
        ]
    },
    ......
]

schemas.json

[
    {
        "0": "所属专辑",
        "1": "出品公司",
        "2": "作曲",
        "3": "总部地点",
        "4": "目",
        "5": "制片人",
        "6": "导演",
        "7": "成立日期",
        "8": "出生日期",
        "9": "嘉宾",
        "10": "专业代码",
        "11": "所在城市",
        "12": "母亲",
        "13": "妻子",
        "14": "编剧",
        "15": "身高",
        "16": "出版社",
        "17": "邮政编码",
        "18": "主角",
        "19": "主演",
        "20": "父亲",
        "21": "官方语言",
        "22": "出生地",
        "23": "改编自",
        "24": "董事长",
        "25": "国籍",
        "26": "海拔",
        "27": "祖籍",
        "28": "朝代",
        "29": "气候",
        "30": "号",
        "31": "作词",
        "32": "面积",
        "33": "连载网站",
        "34": "上映时间",
        "35": "创始人",
        "36": "丈夫",
        "37": "作者",
        "38": "首都",
        "39": "歌手",
        "40": "修业年限",
        "41": "简称",
        "42": "毕业院校",
        "43": "主持人",
        "44": "字",
        "45": "民族",
        "46": "注册资本",
        "47": "人口数量",
        "48": "占地面积"
    },
    {
        "所属专辑": 0,
        "出品公司": 1,
        "作曲": 2,
        "总部地点": 3,
        "目": 4,
        "制片人": 5,
        "导演": 6,
        "成立日期": 7,
        "出生日期": 8,
        "嘉宾": 9,
        "专业代码": 10,
        "所在城市": 11,
        "母亲": 12,
        "妻子": 13,
        "编剧": 14,
        "身高": 15,
        "出版社": 16,
        "邮政编码": 17,
        "主角": 18,
        "主演": 19,
        "父亲": 20,
        "官方语言": 21,
        "出生地": 22,
        "改编自": 23,
        "董事长": 24,
        "国籍": 25,
        "海拔": 26,
        "祖籍": 27,
        "朝代": 28,
        "气候": 29,
        "号": 30,
        "作词": 31,
        "面积": 32,
        "连载网站": 33,
        "上映时间": 34,
        "创始人": 35,
        "丈夫": 36,
        "作者": 37,
        "首都": 38,
        "歌手": 39,
        "修业年限": 40,
        "简称": 41,
        "毕业院校": 42,
        "主持人": 43,
        "字": 44,
        "民族": 45,
        "注册资本": 46,
        "人口数量": 47,
        "占地面积": 48
    }
]

train.json

[
    {
        "text": "如何演好自己的角色,请读《演员自我修养》《喜剧之王》周星驰崛起于穷困潦倒之中的独门秘笈",
        "spo_list": [
            [
                "喜剧之王",
                "主演",
                "周星驰"
            ]
        ]
    },
    ......
]

vocab.json

[
    {
        "2": "如",
        "3": "何",
        ......
        "7028": "鸏",
        "7029": "溞"
    },
    {
        "如": 2,
        "何": 3,
        ......
        "鸏": 7028,
        "溞": 7029
    }
]

与bert跟data同个目录

model.py

from transformers import BertModel, BertPreTrainedModel
import torch.nn as nn
import torch


class SubjectModel(BertPreTrainedModel):
    def __init__(self, config):
        super().__init__(config)
        self.bert = BertModel(config)
        self.dense = nn.Linear(config.hidden_size, 2)

    def forward(self,
                input_ids,
                attention_mask=None):
        output = self.bert(input_ids, attention_mask=attention_mask)
        subject_out = self.dense(output[0])
        subject_out = torch.sigmoid(subject_out)

        return output[0], subject_out


class ObjectModel(nn.Module):
    def __init__(self, subject_model):
        super().__init__()
        self.encoder = subject_model
        self.dense_subject_position = nn.Linear(2, 768)
        self.dense_object = nn.Linear(768, 49 * 2)

    def forward(self,
                input_ids,
                subject_position,
                attention_mask=None):
        output, subject_out = self.encoder(input_ids, attention_mask)

        subject_position = self.dense_subject_position(subject_position).unsqueeze(1)
        object_out = output + subject_position
        # [bs, 768] -> [bs, 98]
        object_out = self.dense_object(object_out)
        # [bs, 98] -> [bs, 49, 2]
        object_out = torch.reshape(object_out, (object_out.shape[0], object_out.shape[1], 49, 2))
        object_out = torch.sigmoid(object_out)
        object_out = torch.pow(object_out, 4)
        return subject_out, object_out

train.py

import json
from tqdm import tqdm
import os
import numpy as np
from transformers import BertTokenizer, AdamW, BertTokenizerFast
import torch
from model import ObjectModel, SubjectModel


GPU_NUM = 0

device = torch.device(f'cuda:{GPU_NUM}') if torch.cuda.is_available() else torch.device('cpu')

vocab = {}
with open('bert/vocab.txt', encoding='utf_8')as file:
    for l in file.readlines():
        vocab[len(vocab)] = l.strip()


def load_data(filename):
    """加载数据
    单条格式:{'text': text, 'spo_list': [[s, p, o],[s, p, o]]}
    """
    with open(filename, encoding='utf-8') as f:
        json_list = json.load(f)
    return json_list


# 加载数据集
train_data = load_data('data/train.json')
valid_data = load_data('data/dev.json')

tokenizer = BertTokenizerFast.from_pretrained('bert')

with open('data/schemas.json', encoding='utf-8') as f:
    json_list = json.load(f)
    id2predicate = json_list[0]
    predicate2id = json_list[1]


def search(pattern, sequence):
    """从sequence中寻找子串pattern
    如果找到,返回第一个下标;否则返回-1。
    """
    n = len(pattern)
    for i in range(len(sequence)):
        if sequence[i:i + n] == pattern:
            return i
    return -1


def sequence_padding(inputs, length=None, padding=0, mode='post'):
    """Numpy函数,将序列padding到同一长度
    """
    if length is None:
        length = max([len(x) for x in inputs])

    pad_width = [(0, 0) for _ in np.shape(inputs[0])]
    outputs = []
    for x in inputs:
        x = x[:length]
        if mode == 'post':
            pad_width[0] = (0, length - len(x))
        elif mode == 'pre':
            pad_width[0] = (length - len(x), 0)
        else:
            raise ValueError('"mode" argument must be "post" or "pre".')
        x = np.pad(x, pad_width, 'constant', constant_values=padding)
        outputs.append(x)

    return np.array(outputs)


def data_generator(data, batch_size=3):
    batch_input_ids, batch_attention_mask = [], []
    batch_subject_labels, batch_subject_ids, batch_object_labels = [], [], []
    texts = []
    for i, d in enumerate(data):
        text = d['text']

        texts.append(text)
        encoding = tokenizer(text=text)
        input_ids, attention_mask = encoding.input_ids, encoding.attention_mask
        # 整理三元组 {s: [(o, p)]}
        spoes = {}
        for s, p, o in d['spo_list']:
            # cls x x x sep
            s_encoding = tokenizer(text=s).input_ids[1:-1]
            o_encoding = tokenizer(text=o).input_ids[1:-1]
            # 找对应的s与o的起始位置
            s_idx = search(s_encoding, input_ids)
            o_idx = search(o_encoding, input_ids)

            p = predicate2id[p]

            if s_idx != -1 and o_idx != -1:
                s = (s_idx, s_idx + len(s_encoding) - 1)
                o = (o_idx, o_idx + len(o_encoding) - 1, p)
                if s not in spoes:
                    spoes[s] = []
                spoes[s].append(o)
        if spoes:
            # subject标签
            subject_labels = np.zeros((len(input_ids), 2))
            for s in spoes:
                # 注意要+1,因为有cls符号
                subject_labels[s[0], 0] = 1
                subject_labels[s[1], 1] = 1
            # 一个s对应多个o时,随机选一个subject
            start, end = np.array(list(spoes.keys())).T
            start = np.random.choice(start)
            # end = np.random.choice(end[end >= start])
            end = end[end >= start][0]
            subject_ids = (start, end)
            # 对应的object标签
            object_labels = np.zeros((len(input_ids), len(predicate2id), 2))
            for o in spoes.get(subject_ids, []):
                object_labels[o[0], o[2], 0] = 1
                object_labels[o[1], o[2], 1] = 1
            # 构建batch
            batch_input_ids.append(input_ids)
            batch_attention_mask.append(attention_mask)
            batch_subject_labels.append(subject_labels)
            batch_subject_ids.append(subject_ids)
            batch_object_labels.append(object_labels)
            if len(batch_subject_labels) == batch_size or i == len(data) - 1:
                batch_input_ids = sequence_padding(batch_input_ids)
                batch_attention_mask = sequence_padding(batch_attention_mask)
                batch_subject_labels = sequence_padding(batch_subject_labels)
                batch_subject_ids = np.array(batch_subject_ids)
                batch_object_labels = sequence_padding(batch_object_labels)
                yield [
                          torch.from_numpy(batch_input_ids).long(), torch.from_numpy(batch_attention_mask).long(),
                          torch.from_numpy(batch_subject_labels), torch.from_numpy(batch_subject_ids),
                          torch.from_numpy(batch_object_labels)
                      ]
                batch_input_ids, batch_attention_mask = [], []
                batch_subject_labels, batch_subject_ids, batch_object_labels = [], [], []


if os.path.exists('graph_model.bin'):
    print('load model')
    model = torch.load('graph_model.bin').to(device)
    subject_model = model.encoder
else:
    subject_model = SubjectModel.from_pretrained('./bert')
    subject_model.to(device)

    model = ObjectModel(subject_model)
    model.to(device)

train_loader = data_generator(train_data, batch_size=8)

optim = AdamW(model.parameters(), lr=5e-5)
loss_func = torch.nn.BCELoss()

model.train()


class SPO(tuple):
    """用来存三元组的类
    表现跟tuple基本一致,只是重写了 __hash__ 和 __eq__ 方法,
    使得在判断两个三元组是否等价时容错性更好。
    """

    def __init__(self, spo):
        self.spox = (
            spo[0],
            spo[1],
            spo[2],
        )

    def __hash__(self):
        return self.spox.__hash__()

    def __eq__(self, spo):
        return self.spox == spo.spox


def train_func():
    train_loss = 0
    pbar = tqdm(train_loader)
    for step, batch in enumerate(pbar):
        optim.zero_grad()
        input_ids = batch[0].to(device)
        attention_mask = batch[1].to(device)
        subject_labels = batch[2].to(device)
        subject_ids = batch[3].to(device)
        object_labels = batch[4].to(device)
        subject_out, object_out = model(input_ids, subject_ids.float(), attention_mask)
        subject_out = subject_out * attention_mask.unsqueeze(-1)
        object_out = object_out * attention_mask.unsqueeze(-1).unsqueeze(-1)

        subject_loss = loss_func(subject_out, subject_labels.float())
        object_loss = loss_func(object_out, object_labels.float())

        # subject_loss = torch.mean(subject_loss, dim=2)
        # subject_loss = torch.sum(subject_loss * attention_mask) / torch.sum(attention_mask)

        loss = subject_loss + object_loss

        train_loss += loss.item()
        loss.backward()
        optim.step()

        pbar.update()
        pbar.set_description(f'train loss:{loss.item()}')

        if step % 1000 == 0 and step != 0:
            torch.save(model, 'graph_model.bin')
            with torch.no_grad():
                # texts = ['如何演好自己的角色,请读《演员自我修养》《喜剧之王》周星驰崛起于穷困潦倒之中的独门秘笈',
                #          '茶树茶网蝽,Stephanitis chinensis Drake,属半翅目网蝽科冠网椿属的一种昆虫',
                #          '爱德华·尼科·埃尔南迪斯(1986-),是一位身高只有70公分哥伦比亚男子,体重10公斤,只比随身行李高一些,2010年获吉尼斯世界纪录正式认证,成为全球当今最矮的成年男人']
                X, Y, Z = 1e-10, 1e-10, 1e-10
                pbar = tqdm()
                for data in valid_data[0:100]:
                    spo = []
                    # for text in texts:
                    text = data['text']
                    spo_ori = data['spo_list']
                    en = tokenizer(text=text, return_tensors='pt')
                    _, subject_preds = subject_model(en.input_ids.to(device), en.attention_mask.to(device))
                    # !!!
                    subject_preds = subject_preds.cpu().data.numpy()
                    start = np.where(subject_preds[0, :, 0] > 0.6)[0]
                    end = np.where(subject_preds[0, :, 1] > 0.5)[0]

                    subjects = []
                    for i in start:
                        j = end[end >= i]
                        if len(j) > 0:
                            j = j[0]
                            subjects.append((i, j))
                    # print(subjects)
                    if subjects:
                        for s in subjects:
                            index = en.input_ids.cpu().data.numpy().squeeze(0)[s[0]:s[1] + 1]
                            subject = ''.join([vocab[i] for i in index])
                            # print(subject)

                            _, object_preds = model(en.input_ids.to(device),
                                                    torch.from_numpy(np.array([s])).float().to(device),
                                                    en.attention_mask.to(device))
                            object_preds = object_preds.cpu().data.numpy()
                            for object_pred in object_preds:
                                start = np.where(object_pred[:, :, 0] > 0.2)
                                end = np.where(object_pred[:, :, 1] > 0.2)
                                for _start, predicate1 in zip(*start):
                                    for _end, predicate2 in zip(*end):
                                        if _start <= _end and predicate1 == predicate2:
                                            index = en.input_ids.cpu().data.numpy().squeeze(0)[_start:_end + 1]
                                            object = ''.join([vocab[i] for i in index])
                                            predicate = id2predicate[str(predicate1)]
                                            # print(object, '\t', predicate)
                                            spo.append([subject, predicate, object])
                    print(spo)
                    # 预测结果
                    R = set([SPO(_spo) for _spo in spo])
                    # 真实结果
                    T = set([SPO(_spo) for _spo in spo_ori])
                    # R = set(spo_ori)
                    # T = set(spo)
                    # 交集
                    X += len(R & T)
                    Y += len(R)
                    Z += len(T)
                    f1, precision, recall = 2 * X / (Y + Z), X / Y, X / Z
                    pbar.update()
                    pbar.set_description(
                        'f1: %.5f, precision: %.5f, recall: %.5f' % (f1, precision, recall)
                    )
                pbar.close()
                print('f1:', f1, 'precision:', precision, 'recall:', recall)


for epoch in range(100):
    print('************start train************')
    # 训练
    train_func()
    # min_loss = float('inf')
    # dev_loss = dev_func()
    # if min_loss > dev_loss:
    #     min_loss = dev_loss
    #     torch.save(model,'model.p')

在这里插入图片描述

三元组实战小结

模型的整体结构:输入是一段文本信息,经过encoder层进行编码,提取出头实体,再对头实体编码并复用文本编码,接下来用了个小trick,同时预测尾实体与关系。对于实体的预测思路是,半指针半标注。
在这里插入图片描述


学习的参考资料:
七月在线NLP高级班

代码参考:
https://github.com/terrifyzhao/spo_extract

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/560308.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

华为ensp中rip和ospf路由重分发 原理及配置命令

作者主页&#xff1a;点击&#xff01; ENSP专栏&#xff1a;点击&#xff01; 创作时间&#xff1a;2024年4月20日20点21分 路由重分发&#xff08;Route Redistribution&#xff09;是指路由器将从一种路由协议学习到的路由信息&#xff0c;通过另一种路由协议通告出去的功…

Linux环境变量深度解析

文章目录 一、引言二、环境变量的基本概念1、环境变量的定义2、环境变量的作用与意义 三、环境变量的导入1、导入所需文件2、登陆时的导入 四、环境变量的设置方法1、查看环境变量的方式2、使用export命令临时设置环境变量3、修改配置文件以永久设置环境变量 五、命令行参数与环…

Python编程与算法面试-编程面试的重点

在求职面试的过程中&#xff0c;编程能力也是面试官非常看重的一项能力。而对于编程这项能力主要的考察点也有三个维度&#xff1a; 初级&#xff1a;编程的基本功 编程的基本功主要考察的编程语言的基本语法&#xff0c;原理知识&#xff0c;以及一些在编程过程中的常见问题…

基于unity+c#的随机点名系统(简单UI界面+列表+数组)

目录 一、功能界面显示 二、UI 1、视频的使用 &#xff08;1&#xff09;渲染纹理 &#xff08;2&#xff09; 视频铺全屏 &#xff08;3&#xff09;视频的调用 2、 下拉文本框的使用&#xff08;旧版&#xff09; 3、输入文本框的使用&#xff08;旧版&#xff09; …

OpenHarmony 视图加载——ImageViewZoom

简介 ImageViewZoom 支持加载 Resource 或 PixelMap 图片&#xff0c;支持设置图像显示类型功能&#xff0c;支持缩放功能&#xff0c;支持平移功能&#xff0c;双击放大功能&#xff0c;可以监听图片大小&#xff0c;资源变化事件&#xff0c;支持清除显示图片功能。 效果展示…

pg内核之日志管理器(五)WAL日志

概念 WAL日志 数据库运行过程中&#xff0c;数据一般是会保存在内存和磁盘中&#xff0c;为保证数据的安全性&#xff0c;防止数据库崩溃时数据不丢失&#xff0c;一般都是要保证数据实时落盘的&#xff0c;但是又由于磁盘随机IO读写速率与内存相比慢很多&#xff0c;如果每个…

RocketMQ5.x的pop模式如何解决消费堆积问题

RocketMQ4.X现存问题 消费能力不能随POD增加而增加。 理想情况下&#xff0c;POD数量小于QUEUE的数量&#xff0c;增加机器是能提高消能力的。 现实情况下&#xff0c;如果POD数量大于QUEUE的数量&#xff0c;那么多的POD机器就不会处理消费&#xff0c;是一种资源的浪费。 单…

苹果 IPA 应用部署软件 iMazing 3 Windows 版获 3.0.0.4 Beta 4

在数字化时代&#xff0c;我们的iOS设备已经成为生活中不可或缺的一部分。为了更加高效、便捷地管理这些设备&#xff0c;iMazing 3.0.0.3 应运而生&#xff0c;它以其独特的功能和卓越的性能&#xff0c;为用户带来了前所未有的全新体验。 首先&#xff0c;iMazing 3.0.0.3 提…

集简云数据表新增批量操作功能,一键实现批量触发执行对应自动化流程

在使用数据表时&#xff0c;某些情况下可能希望人工触发自动化流程执行&#xff0c;例如&#xff1a;开发票、提交工单、同步帐套信息等场景。 通过数据表按钮字段&#xff0c;可手动触发执行对应自动化流程&#xff0c;实现将数据推送到其他表单、应用系统&#xff0c;或从其…

C++必修:从C语言到C++的过渡(上)

✨✨ 欢迎大家来到贝蒂大讲堂✨✨ &#x1f388;&#x1f388;养成好习惯&#xff0c;先赞后看哦~&#x1f388;&#x1f388; 所属专栏&#xff1a;C学习 贝蒂的主页&#xff1a;Betty’s blog 1. 什么是C C&#xff08;c plus plus&#xff09;是一种计算机高级程序设计语言&…

新型大数据架构之湖仓一体(Lakehouse)架构特性说明——Lakehouse 架构(一)

文章目录 为什么需要新的数据架构&#xff1f;湖仓一体&#xff08;Lakehouse&#xff09;——新的大数据架构模式同时具备数仓与数据湖的优点湖仓一体架构存储层计算层 湖仓一体特性单一存储拥有数据仓库的查询性能存算分离开放式架构支持各种数据源类型支持各种使用方式架构简…

csdn的编写教程(官方给的)

自定义的目录标题 欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题&#xff0c;有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants 创建一个自定义列表如何创建一个注脚…

ubuntu 16.04.7连不上网的解决方案

首先在编辑选项卡里找到虚拟网络编辑器&#xff0c; 点击更改设置 点击添加网络 点击确定 选择桥接模式&#xff0c;自动后点击应用&#xff0c;最后点击确定即可。

4.20+C语言感想,有趣的思考题,case的省略操作,统计位数,终止循环,break和continue语句, 准备下一篇见。

鹏哥C语言感想 一.高级 这可不是什么煎饼&#xff0c;这种食物叫做蓝莓&#xff0c;俗称苹果。生长在撒哈拉沙漠的雨林地带。因外形酷似企鹅&#xff0c;所以我们又喜欢叫他北极熊。你们这些人&#xff0c;连仙人掌都不知道&#xff0c;就不要乱说他是西瓜好吗&#xff1f;再…

嵌入式4-20

客户端 #include <myhead.h> #define SER_IP "192.168.125.244" #define SER_PORT 8888 typedef struct Node { char username[20];struct sockaddr_in cin;struct Node *next; }Node,*Node_p; typedef struct {int flag;char username[20];char data[1024]…

java中File类和输入输出流的用法

目录 针对文件系统进行操作 针对文件内容进行操作 java针对文件操作可以分为两种&#xff1a;1&#xff09;针对文件系统进行操作&#xff0c;如创建文件&#xff0c;删除文件&#xff0c;创建目录&#xff0c;重命名文件等。 2&#xff09;针对文件内容进行操作&#xff0c…

【webrtc】m98 RoundRobinPacketQueue的优先级处理

m98 代码 PacedSender::EnqueuePackets 的调用者可能是多个地方,所以这个要加锁保护。RoundRobinPacketQueue 本身是没有锁的发现m98和新版本不同,参考:【webrtc】m114自己实现的PrioritizedPacketQueuepush和pop都是RtpPacketToSend 但是实际上,内部是封装为QueuedPacket 处…

Darknet框架优化介绍

一、DarkNet框架简介 1.DarkNet的简介 Darknet是一个完全使用C语言编写的人工智能框架&#xff0c;可以使用CUDA的开源框架。主要应用于图像识别领域。 它具有可移植性好&#xff0c;安装间接&#xff0c;查看源码方便等优势&#xff0c;提供了OpenCV等附加选项&#xff0c;还…

基于SSM+Jsp+Mysql的电子商城系统

开发语言&#xff1a;Java框架&#xff1a;ssm技术&#xff1a;JSPJDK版本&#xff1a;JDK1.8服务器&#xff1a;tomcat7数据库&#xff1a;mysql 5.7&#xff08;一定要5.7版本&#xff09;数据库工具&#xff1a;Navicat11开发软件&#xff1a;eclipse/myeclipse/ideaMaven包…

hackthebox - Redeemer

2024.4.19 TASK 1 Which TCP port is open on the machine? 6379 TASK 2 Which service is running on the port that is open on the machine? redis TASK 3 What type of database is Redis? Choose from the following options: (i) In-memory Database, (ii) Traditiona…