Mt5 Base Summary

🚀 Summarization Model

A summarization model based on T5 architecture, capable of efficiently summarizing long - form text.

🚀 Quick Start

This model is designed for text summarization tasks. Here is a simple example of how to use it:

import torch
from transformers import T5ForConditionalGeneration, T5Tokenizer

model_path = "twwch/mt5-base-summary"
model = T5ForConditionalGeneration.from_pretrained(model_path)
tokenizer = T5Tokenizer.from_pretrained(model_path)

device = torch.device('cuda:0') if torch.cuda.is_available() else torch.device('cpu')
model.to(device)
model.eval()

text = """
What is Nginx
Nginx is an open - source high - performance HTTP and reverse proxy server. It can be used for tasks such as handling static resources, load balancing, reverse proxying, and caching. Nginx is widely used to build highly available and high - performance web applications and websites. It has low memory consumption, high concurrency capabilities, and good stability, so it is very popular in the Internet field.
Why use Nginx

High performance: Nginx uses an event - driven asynchronous architecture, which can handle a large number of concurrent connections without consuming excessive system resources. Its processing capacity is higher than that of traditional web servers and performs well under high - concurrency loads.
High reliability: Nginx has strong fault - tolerance and stability, and can maintain reliable operation in the face of abnormal situations such as high traffic and DDoS attacks. It can ensure service availability through health checks and automatic failover.
Load balancing: Nginx can act as a reverse proxy server to achieve load balancing, distributing requests evenly to multiple backend servers. This can improve the overall performance and availability of the system.
Static file service: Nginx is very efficient in handling static resources (such as HTML, CSS, JavaScript, images, etc.). It can directly cache static files, reducing the load on the backend server.
Scalability: Nginx supports rich modular extensions and can provide additional functions by adding third - party modules, such as gzip compression, SSL/TLS encryption, cache control, etc.

How to handle requests
The basic process of Nginx handling requests is as follows:


Receive requests: Nginx, as server software, listens on specified ports and receives requests sent by clients.


Parse requests: Nginx parses the content of requests, including the request method (GET, POST, etc.), URL, header information, etc.


Configuration matching: Nginx decides how to handle the request according to the rules and matching conditions in the configuration file. The configuration file defines specific processing methods such as virtual hosts, reverse proxies, load balancing, and caching.


Handle requests: Depending on the configured processing method, Nginx may perform the following operations:

Static file service: If the request is for a static resource file, such as HTML, CSS, JavaScript, images, etc., Nginx can directly return the file content without going through the backend application.
Reverse proxy: If a reverse proxy is configured, Nginx forwards the request to the backend application server and then returns its response to the client. This can provide functions such as load balancing, high availability, and caching.
Cache: If caching is enabled, Nginx can cache the responses of some static or dynamic content and directly return the cached response for subsequent identical requests, reducing the backend load and improving the response speed.
URL rewriting: Nginx can rewrite URLs according to the configured rules, redirecting requests from one URL to another or performing conversions.
SSL/TLS encryption: If SSL/TLS is enabled, Nginx can be responsible for encrypting and decrypting HTTPS requests and responses.
Access control: Nginx can perform access control on requests according to the configured rules, such as restricting IP access and performing identity authentication.

Response results: Nginx generates a response message based on the processing results, including the status code, header information, and response content. Then it sends the response to the client.
"""


def _split_text(text, length):
    chunks = []
    start = 0
    while start < len(text):
        if len(text) - start > length:
            pos_forward = start + length
            pos_backward = start + length
            pos = start + length
            while (pos_forward < len(text)) and (pos_backward >= 0) and (pos_forward < 20 + pos) and (
                    pos_backward + 20 > pos) and text[pos_forward] not in {'.', '。', '，', ','} and text[
                pos_backward] not in {'.', '。', '，', ','}:
                pos_forward += 1
                pos_backward -= 1
            if pos_forward - pos >= 20 and pos_backward <= pos - 20:
                pos = start + length
            elif text[pos_backward] in {'.', '。', '，', ','}:
                pos = pos_backward
            else:
                pos = pos_forward
            chunks.append(text[start:pos + 1])
            start = pos + 1
        else:
            chunks.append(text[start:])
            break
    # Combine last chunk with previous one if it's too short
    if len(chunks) > 1 and len(chunks[-1]) < 100:
        chunks[-2] += chunks[-1]
        chunks.pop()
    return chunks


def summary(text):
    chunks = _split_text(text, 300)
    chunks = [
        "summarize: " + chunk
        for chunk in chunks
    ]
    input_ids = tokenizer(chunks, return_tensors="pt",
                          max_length=512,
                          padding=True,
                          truncation=True).input_ids.to(device)
    outputs = model.generate(input_ids, max_length=250, num_beams=4, no_repeat_ngram_size=2)
    tokens = outputs.tolist()
    output_text = [
        tokenizer.decode(tokens[i], skip_special_tokens=True)
        for i in range(len(tokens))
    ]
    for i in range(len(output_text)):
        print(output_text[i])


summary(text)

📄 License

This project is licensed under the Apache 2.0 license.