使用最大边界相关算法处理文章自动摘要

一、需求背景

       对于博客或者文章来说，摘要是普遍性的需求。但是我们不可能让作者自己手动填写摘要或者直接暴力截取文章的部分段落作为摘要，这样既不符合逻辑又不具有代表性，那么，是否有相关的算法或者数学理论能够完成这个需求呢？我想，MMR(Maximal Marginal Relevance)是处理文章自动摘要的杰出代表。

二、最大边界相关算法—MMR

       MMR算法又叫最大边界相关算法，此算法在设计之初是用来计算Query文本与被搜索文档之间的相似度，然后对文档进行rank排序的算法。算法公式如下：
image.png

       仔细观察下公式方括号中的两项，其中前一项的物理意义指的是待抽取句子和整篇文档的相似程度，后一项指的是待抽取句子和已得摘要的相似程度，通过减号相连，其含义是希望：抽取的摘要既能表达整个文档的含义，有具备多样性 。而image.png则是控制摘要多样性程度的一个超参数，你可以根据自己的需求去调节。

三、使用MMR算法实现文章自动摘要

3.1 具体算法实现

       具体的代码实现如下：

import com.microblog.util.tools.FileUtils;
import org.wltea.analyzer.core.IKSegmenter;
import org.wltea.analyzer.core.Lexeme;

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.*;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 文本摘要提取文中重要的关键句子，使用top-n关键词在句子中的比例关系
 **/
public class SummaryUtil {
    //保留关键词数量
    int N = 50;

    //关键词间的距离阀值
    int CLUSTER_THRESHOLD = 5;

    //前top-n句子
    int TOP_SENTENCES = 20;

    //最大边缘相关阀值
    double λ = 0.4;

    //停用词列表
    private static final Set<String> stopWords = new HashSet<>();

    //句子编号及分词列表
    Map<Integer, List<String>> sentSegmentWords = null;

    /**
     * 加载停词(文章摘要的停顿/分割词)
     */
    public static void initStopWords(String[] paths) {
        for (String path : paths) {
            try {
                File file = new FileUtils().readFileFromNet(path);
                InputStreamReader read = new InputStreamReader(Files.newInputStream(file.toPath()), StandardCharsets.UTF_8);
                if (file.isFile() && file.exists()) {
                    BufferedReader br = new BufferedReader(read);
                    String txt = null;
                    while ((txt = br.readLine()) != null) {
                        stopWords.add(txt);
                    }
                    br.close();
                }
            }
            catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

    /**
     * 利用正则将文本拆分成句子
     */
    private List<String> SplitSentences(String text) {
        List<String> sentences = new ArrayList<String>();
        String regEx = "[!?。！？.]";
        Pattern p = Pattern.compile(regEx);
        String[] sents = p.split(text);
        Matcher m = p.matcher(text);
        int sentsLen = sents.length;
        if (sentsLen > 0) {  //把每个句子的末尾标点符号加上
            int index = 0;
            while (index < sentsLen) {
                if (m.find()) {
                    sents[index] += m.group();
                }
                index++;
            }
        }
        for (String sentence : sents) {
            //处理掉的html的标志
            sentence = sentence.replaceAll("(&rdquo;|&ldquo;|&mdash;|&lsquo;|&rsquo;|&middot;|&quot;|&darr;|&bull;)", "");
            sentences.add(sentence.trim());
        }
        return sentences;
    }

    /**
     * 这里使用IK进行分词
     * @param text 待处理句子
     * @return 句子分词列表
     */
    private List<String> IKSegment(String text) {
        List<String> wordList = new ArrayList<String>();
        Reader reader = new StringReader(text);
        IKSegmenter ik = new IKSegmenter(reader, true);
        Lexeme lex = null;
        try {
            while ((lex = ik.next()) != null) {
                String word = lex.getLexemeText();
                if (word.equals("&nbsp;") || stopWords.contains(word) || "\t".equals(word)) continue;
                if (word.length() > 1 ) wordList.add(word);
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }
        return wordList;
    }


    /**
     * 每个句子得分  (keywordsLen*keywordsLen/totalWordsLen)
     *
     * @param sentences 分句
     * @param topnWords keywords top-n关键词
     */
    private Map<Integer, Double> scoreSentences(List<String> sentences, List<String> topnWords) {
        Map<Integer, Double> scoresMap = new LinkedHashMap<Integer, Double>();//句子编号，得分
        sentSegmentWords = new HashMap<>();
        int sentence_idx = -1;//句子编号
        for (String sentence : sentences) {
            sentence_idx += 1;
            List<String> words = this.IKSegment(sentence);//对每个句子分词
            sentSegmentWords.put(sentence_idx, words);
            List<Integer> word_idx = new ArrayList<Integer>();//每个关词键在本句子中的位置
            for (String word : topnWords) {
                if (words.contains(word)) {
                    word_idx.add(words.indexOf(word));
                }
            }
            if (word_idx.size() == 0) continue;
            Collections.sort(word_idx);
            //对于两个连续的单词，利用单词位置索引，通过距离阀值计算一个族
            List<List<Integer>> clusters = new ArrayList<List<Integer>>();//根据本句中的关键词的距离存放多个词族
            List<Integer> cluster = new ArrayList<Integer>();
            cluster.add(word_idx.get(0));
            int i = 1;
            while (i < word_idx.size()) {
                if ((word_idx.get(i) - word_idx.get(i - 1)) < this.CLUSTER_THRESHOLD) {
                    cluster.add(word_idx.get(i));
                } else {
                    clusters.add(cluster);
                    cluster = new ArrayList<>();
                    cluster.add(word_idx.get(i));
                }
                i += 1;
            }
            clusters.add(cluster);
            //对每个词族打分，选择最高得分作为本句的得分
            double max_cluster_score = 0.0;
            for (List<Integer> clu : clusters) {
                int keywordsLen = clu.size();//关键词个数
                int totalWordsLen = clu.get(keywordsLen - 1) - clu.get(0) + 1;//总的词数
                double score = 1.0 * keywordsLen * keywordsLen / totalWordsLen;
                if (score > max_cluster_score) max_cluster_score = score;
            }
            scoresMap.put(sentence_idx, max_cluster_score);
        }
        return scoresMap;
    }

    /**
     * 利用最大边缘相关自动文摘
     */
    public String SummaryMMRNTxt(String text) {
        //将文本拆分成句子列表
        List<String> sentencesList = this.SplitSentences(text);

        //利用IK分词组件将文本分词，返回分词列表
        List<String> words = this.IKSegment(text);

        //统计分词频率
        Map<String, Integer> wordsMap = new HashMap<>();
        for (String word : words) {
            Integer val = wordsMap.get(word);
            wordsMap.put(word, val == null ? 1 : val + 1);
        }

        //使用优先队列自动排序
        Queue<Entry<String, Integer>> wordsQueue = new PriorityQueue<>(wordsMap.size(), (o1, o2) -> o2.getValue() - o1.getValue());
        wordsQueue.addAll(wordsMap.entrySet());

        if (N > wordsMap.size()) {
            N = wordsQueue.size();
        }

        //取前N个频次最高的词存在wordsList
        List<String> wordsList = new ArrayList<>(N);//top-n关键词
        for (int i = 0; i < N; i++) {
            Optional.ofNullable(wordsQueue.poll()).ifPresent(entry -> {
                wordsList.add(entry.getKey());
            });
        }
        //利用频次关键字，给句子打分，并对打分后句子列表依据得分大小降序排序
        Map<Integer, Double> scoresLinkedMap = scoreSentences(sentencesList, wordsList);//返回的得分,从第一句开始,句子编号的自然顺序
        List<Entry<Integer, Double>> sortedSentList = new ArrayList<>(scoresLinkedMap.entrySet());
        //按得分从高到底排序好的句子，句子编号与得分
        sortedSentList.sort((o1, o2) -> o2.getValue().compareTo(o1.getValue()));

        if (sentencesList.size() == 2) {
            return sentencesList.get(0) + sentencesList.get(1);
        } else if (sentencesList.size() == 1) {
            return sentencesList.get(0);
        }
        Map<Integer, String> keySentence = new TreeMap<Integer, String>();
        dealWithCommentWithMMR(sentencesList, sortedSentList, keySentence);

        StringBuilder sb = new StringBuilder();
        for (int index : keySentence.keySet())
            sb.append(keySentence.get(index));
        return sb.toString();
    }

    /**
     * 使用MMR算法处理句子
     *
     * @param sentencesList  句子列表
     * @param sortedSentList 排好序的句子(句子编号及其得分)
     * @param keySentence    处理结果
     */
    private void dealWithCommentWithMMR(List<String> sentencesList, List<Entry<Integer, Double>> sortedSentList, Map<Integer, String> keySentence) {
        int count = 0;
        Map<Integer, Double> MMR_SentScore = MMR(sortedSentList);
        for (Entry<Integer, Double> entry : MMR_SentScore.entrySet()) {
            count++;
            int sentIndex = entry.getKey();
            String sentence = sentencesList.get(sentIndex);
            keySentence.put(sentIndex, sentence);
            if (count == this.TOP_SENTENCES) break;
        }
    }


    /**
     * 最大边缘相关(Maximal Marginal Relevance)，根据λ调节准确性和多样性
     * max[λ*score(i) - (1-λ)*max[similarity(i,j)]]:score(i)句子的得分，similarity(i,j)句子i与j的相似度
     * User-tunable diversity through λ parameter
     * - High λ= Higher accuracy
     * - Low λ= Higher diversity
     *
     * @param sortedSentList 排好序的句子，编号及得分
     */
    private Map<Integer, Double> MMR(List<Entry<Integer, Double>> sortedSentList) {
        double[][] simSentArray = sentJSimilarity();//所有句子的相似度
        Map<Integer, Double> sortedLinkedSent = new LinkedHashMap<>();
        for (Entry<Integer, Double> entry : sortedSentList) {
            sortedLinkedSent.put(entry.getKey(), entry.getValue());
        }
        Map<Integer, Double> MMR_SentScore = new LinkedHashMap<>();//最终的得分（句子编号与得分）
        Entry<Integer, Double> Entry = sortedSentList.get(0);//第一步先将最高分的句子加入
        MMR_SentScore.put(Entry.getKey(), Entry.getValue());
        boolean flag = true;
        while (flag) {
            int index = 0;
            double maxScore = Double.NEGATIVE_INFINITY;//通过迭代计算获得最高分句子
            for (Map.Entry<Integer, Double> entry : sortedLinkedSent.entrySet()) {
                if (MMR_SentScore.containsKey(entry.getKey())) continue;
                double simSentence = 0.0;
                for (Map.Entry<Integer, Double> MMREntry : MMR_SentScore.entrySet()) {//这个是获得最相似的那个句子的最大相似值
                    double simSen = 0.0;
                    if (entry.getKey() > MMREntry.getKey()) simSen = simSentArray[MMREntry.getKey()][entry.getKey()];
                    else simSen = simSentArray[entry.getKey()][MMREntry.getKey()];
                    if (simSen > simSentence) {
                        simSentence = simSen;
                    }
                }
                simSentence = λ * entry.getValue() - (1 - λ) * simSentence;
                if (simSentence > maxScore) {
                    maxScore = simSentence;
                    index = entry.getKey();//句子编号
                }
            }
            MMR_SentScore.put(index, maxScore);
            if (MMR_SentScore.size() == sortedLinkedSent.size()) flag = false;
        }
        return MMR_SentScore;
    }

    /**
     * 每个句子的相似度，这里使用简单的jaccard方法，计算所有句子的两两相似度
     */
    private double[][] sentJSimilarity() {
        //System.out.println("sentJSimilarity in...");
        int size = sentSegmentWords.size();
        double[][] simSent = new double[size][size];
        for (Entry<Integer, List<String>> entry : sentSegmentWords.entrySet()) {
            for (Entry<Integer, List<String>> entry1 : sentSegmentWords.entrySet()) {
                if (entry.getKey() >= entry1.getKey()) continue;
                int commonWords = 0;
                double sim = 0.0;
                for (String entryStr : entry.getValue()) {
                    if (entry1.getValue().contains(entryStr)) commonWords++;
                }
                sim = 1.0 * commonWords / (entry.getValue().size() + entry1.getValue().size() - commonWords);
                simSent[entry.getKey()][entry1.getKey()] = sim;
            }
        }
        return simSent;
    }
}

3.2 文件读取工具

public class FileUtils {

    /**
     * 从网络地址读取文件
     *
     * @param path 网络地址
     * @return 读取后的文件
     */
    public File readFileFromNet(String path) throws IOException {
        File temporary = File.createTempFile("SensitiveWord", ".txt");
        URL url = new URL(path);
        InputStream inputStream = url.openStream();
        FileUtils.copyInputStreamToFile(inputStream, temporary);
        return temporary;
    }

    private static void copyInputStreamToFile(InputStream inputStream, File file) throws IOException {
        try (FileOutputStream outputStream = new FileOutputStream(file)) {
            int read;
            byte[] bytes = new byte[1024];

            while ((read = inputStream.read(bytes)) != -1) {
                outputStream.write(bytes, 0, read);
            }
        }

    }

}

3.3 相关依赖

 <dependency>
     <groupId>com.github.magese</groupId>
     <artifactId>ik-analyzer</artifactId>
     <version>8.5.0</version>
</dependency>

3.4 调用算法,生成自动摘要

   public static void main(String[] args) {

        SummaryUtil summary = new SummaryUtil();

        //停顿词我们一般放在OSS服务器上,而不是放在系统文件里面,方便灵活更换
        String[] paths = {"www.xxx.com/xxxxx(停顿词资源路径1)","www.xxx.com/xxxxx(停顿词资源路径2)"};
        //初始化停顿词
        initStopWords(paths);

        String text = "我国古代历史演义小说的代表作。明代小说家罗贯中依据有关三国的历史、杂记，在广泛吸取民间传说和民间艺人创作成果的基础上，加工、再创作了这部长篇章回小说。" +
                "作品写的是汉末到晋初这一历史时期魏、蜀、吴三个封建统治集团间政治、军事、外交等各方面的复杂斗争。通过这些描写，揭露了社会的黑暗与腐朽，谴责了统治阶级的残暴与奸诈," +
                "反映了人民在动乱时代的苦难和明君仁政的愿望。小说也反映了作者对农民起义的偏见，以及因果报应和宿命论等思想。战争描写是《三国演义》突出的艺术成就。这部小说通过惊心动魄的军事、政治斗争，运用夸张、对比、烘托、渲染等艺术手法，成功地塑造了诸葛亮、曹操、关羽、张飞等一批鲜明、生动的人物形象。《三国演义》结构宏伟而又严密精巧，语言简洁、明快、生动。有的评论认为这部作品在艺术上的不足之处是人物性格缺乏发展变化，有的人物渲染夸张过分导致失真。《三国演义》标志着历史演义小说的辉煌成就。在传播政治、军事斗争经验、推动历史演义创作的繁荣等方面都起过积极作用。《三国演义》的版本主要有明嘉靖刻本《三国志通俗演义》和清毛宗岗增删评点的《三国志演义》";
        String mmrSentences = summary.SummaryMMRNTxt(text);
        System.out.println("MMR算法获取到的摘要: " + mmrSentences);
    }

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

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

相关文章

python给word插入脚注

python给word插入脚注

1.需求 最近因为工作需要&#xff0c;需要给大量文本的脚注插入内容&#xff0c;我就写了个小程序。 2.实现 下面程序是我已经给所有脚注插入了两次文本“幸福”&#xff0c;给脚注2到4再插入文本“幸福” from win32com import clientdef add_text_to_specific_footnotes(…
阅读更多...
汽车销量可视化分析

汽车销量可视化分析

目录 一.分析的背景、目的、意义 1、背景 2、目的 3、意义 二.数据来源 三.图表分析 1、汽车品牌销量柱状图 2、中国汽车销量柱状图 3、汽车销量前10排行柱状图 4、汽车厂商销量折线图 ​编辑5、汽车销量词云图 6、汽车车型销量 7、汽车价格分布雷达图 8、汽车分…
阅读更多...
【FAS Survey】《Deep learning for face anti-spoofing: A Survey》

【FAS Survey】《Deep learning for face anti-spoofing: A Survey》

PAMI-2022 最新成果&#xff1a;https://github.com/ZitongYu/DeepFAS 文章目录 1 Introduction & Background1.1 Face Spoofing Attacks1.2 Datasets for Face Anti-Spoofing1.3 Evaluation Metrics1.4 Evaluation Protocols 2 Deep FAS with Commercial RGB Camera2.1 H…
阅读更多...
MFC 对话框架构

MFC 对话框架构

目录 Win32对话框回顾 对话框架构 无模式对话框架构程序执行过程 Win32对话框回顾 MFC框架中都是无模式对话框&#xff0c;不会阻塞&#xff0c;先回顾一下无模式对话框的创建&#xff1a; 添加对话框资源查找资源&#xff0c;FindResource加载资源&#xff0c;LoadResour…
阅读更多...
idea自动生成实体类

idea自动生成实体类

第一步&#xff1a;idea连接数据库 出现这个就连接成功 第二步&#xff1a;选择数据库 第三步&#xff1a;创建实体类 也可以点击数据库一下子全部创建 选择创建实体类所放位置 这样就完成了&#xff0c;点击看看对其做相应修改
阅读更多...
防火墙双向NAT配置

防火墙双向NAT配置

目录 拓扑需求 配置配置服务器映射配置NAT策略配置访问外网的NAT 配置安全策略 测试 拓扑 需求 分公司内部的客户端可以通过公网地址访问到内部的服务器 主要配置区域 配置 测试之前记得开启服务器的服务 配置服务器映射 配置NAT策略 源地址和目的地址同时转换 配置访问…
阅读更多...
高等数学：微分

高等数学：微分

本文主要参考视频&#xff1a; 【建议收藏】同济七版《高等数学》精讲视频 | 期末考试 | 考研零基础 | 高数小白_哔哩哔哩_bilibili 3.3.1.1 微分的定义_哔哩哔哩_bilibili 3.3.5.1 导数与微分区别_哔哩哔哩_bilibili 仅供本人学习使用。 什么是微分 相对于导数来说&#xff0c…
阅读更多...
简单实践 java spring cloud 负载均衡

简单实践 java spring cloud 负载均衡

1 概要 1.1 实现一个最简单的微服务。远程调用负载均衡&#xff0c;基本上完成了最核心的微服务框架。 远程调用&#xff1a;RestTemplate 注册中心&#xff1a;eureka 负载均衡&#xff1a;Ribbon 1.2 要点 1.2.1 依赖 1.2.1.1 主框架依赖 spring boot 依赖 <depe…
阅读更多...
【JavaScript 漫游】【004】数据类型 object

【JavaScript 漫游】【004】数据类型 object

文章简介 本文为【JavaScript 漫游】专栏的第 004 篇文章&#xff0c;记录 JS 数据类型 object 的重要知识点。 . 运算符和 [] 运算符Object.keys 方法delete 命令in 运算符for ... in ... 对象概述 JS 的对象是一组“键值对”&#xff08;key-value&#xff09;的集合&…
阅读更多...
基于ssm的法律咨询系统（有报告）。Javaee项目，ssm项目。

基于ssm的法律咨询系统（有报告）。Javaee项目，ssm项目。

演示视频&#xff1a; 基于ssm的法律咨询系统&#xff08;有报告&#xff09;。Javaee项目&#xff0c;ssm项目。 项目介绍&#xff1a; 采用M&#xff08;model&#xff09;V&#xff08;view&#xff09;C&#xff08;controller&#xff09;三层体系结构&#xff0c;通过Sp…
阅读更多...
【百度Apollo】自动驾驶规划技术：实现安全高效的智能驾驶

【百度Apollo】自动驾驶规划技术：实现安全高效的智能驾驶

&#x1f3ac; 鸽芷咕&#xff1a;个人主页 &#x1f525; 个人专栏:《linux深造日志》《粉丝福利》 ⛺️生活的理想&#xff0c;就是为了理想的生活! ⛳️ 推荐 前些天发现了一个巨牛的人工智能学习网站&#xff0c;通俗易懂&#xff0c;风趣幽默&#xff0c;忍不住分享一下…
阅读更多...
springboot-前后端分离——第二篇

springboot-前后端分离——第二篇

本篇主要介绍一个发送请求的工具—postman&#xff0c;然后对请求中的参数进行介绍&#xff0c;例如简单参数、实体参数、数组参数、集合参数、日期类型参数以及json类型参数&#xff0c;对这些参数接收进行总结。最后对响应数据进行介绍&#xff0c;使用统一响应结果返回浏览器…
阅读更多...
MIT6.5830 实验0

MIT6.5830 实验0

前置 本次实验使用 Golang 语言实现&#xff0c;在之前的年份中&#xff0c;都是像 cs186 那样使用 Java 实现。原因&#xff1a; Golang 语言作为现代化语言&#xff0c;简单易上手但功能强大。 使参加实验的同学有同一起跑线&#xff0c;而不是像Java那样&#xff0c;有些同…
阅读更多...
增加 CentOS 系统的交换空间/虚拟内存（swap）大小

增加 CentOS 系统的交换空间/虚拟内存（swap）大小

增加 CentOS 系统的交换空间/虚拟内存&#xff08;swap&#xff09;大小 文章目录 增加 CentOS 系统的交换空间/虚拟内存&#xff08;swap&#xff09;大小 检查当前交换空间&#xff1a; 在终端中执行以下命令来查看当前的交换空间情况&#xff1a; swapon --show这将显示当…
阅读更多...
二级域名分发全解密支持对接易支付

二级域名分发全解密支持对接易支付

二级域名分发全解密支持对接易支付 先改epay里面的config.php 你的支付域名 然后再改&#xff0c;二级域名分发网站 环境&#xff1a;php74 伪静态&#xff1a; location / { try_files $uri $uri/ /index.php?$query_string; } 源代码&#xff1a;百度网盘 密码&#xff1a;1…
阅读更多...
实现注册登录时数据的加密传输（含前后端具体代码）

实现注册登录时数据的加密传输（含前后端具体代码）

前言 http/https协议提交在被抓包时请求内容是明文的, 直接传输账号密码的风险非常大&#xff0c;故这里我们要对数据加密处理&#xff0c;并生成校验码&#xff0c;防止数据篡改 Http/https传输账户密码等数据时需要加密处理的原因主要有以下几点&#xff1a; 数据保密性&a…
阅读更多...
20240131在WIN10下配置whisper

20240131在WIN10下配置whisper

20240131在WIN10下配置whisper 2024/1/31 18:25 首先你要有一张NVIDIA的显卡&#xff0c;比如我用的PDD拼多多的二手GTX1080显卡。【并且极其可能是矿卡&#xff01;】800&#xffe5; 2、请正确安装好NVIDIA最新的545版本的驱动程序和CUDA。 2、安装Torch 3、配置whisper http…
阅读更多...
理解部署描述符的元素

理解部署描述符的元素

理解部署描述符的元素 部署描述符是文件名为web.xml的XML文件&#xff0c;其包含了Web应用程序的配置信息。每个Web应用程序都有一个web.xml文件。web.xml文件的元素可用于指定servlet的初始化参数、不同文件的MIME类型、侦听器类&#xff0c;以及将URL模式映射到servlet上。一…
阅读更多...
【SparkML系列3】特征提取器TF-IDF、Word2Vec和CountVectorizer

【SparkML系列3】特征提取器TF-IDF、Word2Vec和CountVectorizer

本节介绍了用于处理特征的算法&#xff0c;大致可以分为以下几组&#xff1a; 提取&#xff08;Extraction&#xff09;&#xff1a;从“原始”数据中提取特征。转换&#xff08;Transformation&#xff09;&#xff1a;缩放、转换或修改特征。选择&#xff08;Selection&…
阅读更多...
【 USRP 相控阵】X波段相控阵开发平台用户指南

【 USRP 相控阵】X波段相控阵开发平台用户指南

包装 一共三件。 1、AD9081-FMCA-EBZ AD9081 MxFE Evaluation Board, https://www.analog.com/eval-ad9081 AD9081 的全功能评估板使用 ACE 软件进行控制的 PC 软件HMC7044 的板载时钟用于管理套件和 FPGA 时钟选择切换到外部直接时钟 AD9081-FMCA-EBZ 评估板包括以各种模…
阅读更多...
最新文章

Copyright @ 2022~2023