Update README.md

README.md

@@ -131,10 +131,10 @@ model-index:
   <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/>
 </a>
 
-Summarize long text and get a SparkNotes-esque summary of arbitrary topics!
+Summarize long text and get a SparkNotes-like summary of any topic!
 
--   Generalizes reasonably well to academic & narrative text.
--   This is the XL checkpoint, which **from a human-evaluation perspective, [produces even better summaries](https://long-t5-xl-book-summary-examples.netlify.app/)**.
+- Generalizes reasonably well to academic & narrative text.
+- This is the XL checkpoint, which **produces even better summaries [from a human evaluation perspective](https://long-t5-xl-book-summary-examples.netlify.app/)**.
 
 A simple example/use case with [the base model](https://huggingface.co/pszemraj/long-t5-tglobal-base-16384-book-summary) on ASR is [here](https://longt5-booksum-example.netlify.app/).
 
@@ -144,7 +144,7 @@ A summary of the [infamous navy seals copypasta](https://knowyourmeme.com/memes/
 
 > In this chapter, the monster explains how he intends to exact revenge on "the little b\*\*\*\*" who insulted him. He tells the kiddo that he is a highly trained and experienced killer who will use his arsenal of weapons--including his access to the internet--to exact justice on the little brat.
 
-While a somewhat crude example, try running this copypasta through other summarization models to see the difference in comprehension (_despite it not even being a "long" text!_)
+While this is a crude example, try running this copypasta through other summarization models to see the difference in comprehension (_even though it's not even a "long" text!_).
 
 * * *
 
@@ -152,21 +152,24 @@ While a somewhat crude example, try running this copypasta through other summari
 
 <!-- TOC -->
 
--   [Description](#description)
--   [How-To in Python](#how-to-in-python)
-    -   [Beyond the basics](#beyond-the-basics)
--   [About](#about)
-    -   [Intended uses & limitations](#intended-uses--limitations)
-    -   [Training and evaluation data](#training-and-evaluation-data)
-    -   [Eval results](#eval-results)
--   [FAQ](#faq)
-    -   [How can I run inference with this on CPU?](#how-can-i-run-inference-with-this-on-cpu)
-    -   [How to run inference over a very long (30k+ tokens) document in batches?](#how-to-run-inference-over-a-very-long-30k-tokens-document-in-batches)
-    -   [How to fine-tune further?](#how-to-fine-tune-further)
--   [Training procedure](#training-procedure)
-    -   [Updates](#updates)
-    -   [Training hyperparameters](#training-hyperparameters)
-    -   [Framework versions](#framework-versions)
+- [Description](#description)
+- [How-To in Python](#how-to-in-python)
+    - [Beyond the basics](#beyond-the-basics)
+        - [Adjusting parameters](#adjusting-parameters)
+        - [LLM.int8 Quantization](#llmint8-quantization)
+- [About](#about)
+    - [Intended uses & limitations](#intended-uses--limitations)
+    - [Training and evaluation data](#training-and-evaluation-data)
+    - [Eval results](#eval-results)
+- [FAQ](#faq)
+    - [How can I run inference with this on CPU?](#how-can-i-run-inference-with-this-on-cpu)
+    - [How to run inference over a very long (30k+ tokens) document in batches?](#how-to-run-inference-over-a-very-long-30k-tokens-document-in-batches)
+    - [How to fine-tune further?](#how-to-fine-tune-further)
+    - [Are there simpler ways to run this?](#are-there-simpler-ways-to-run-this)
+- [Training procedure](#training-procedure)
+    - [Updates](#updates)
+    - [Training hyperparameters](#training-hyperparameters)
+    - [Framework versions](#framework-versions)
 
 <!-- /TOC -->
 
@@ -201,7 +204,7 @@ print(result[0]["summary_text"])
 
 ### Beyond the basics
 
-There are two additional points to consider beyond simple inference: adjusting decoding parameters for improved performance, and quantization for decreased memory devouring.
+There are two additional points to consider beyond simple inference: adjusting decoding parameters for improved performance, and quantization for reduced memory consumption.
 
 #### Adjusting parameters
 
@@ -209,11 +212,11 @@ Pass [other parameters related to beam search textgen](https://huggingface.co/bl
 
 #### LLM.int8 Quantization
 
-> alternate section title: how to get this monster to run inference on free Colab runtimes
+> alternative section title: how to get this monster to run inference on free colab runtimes
 
-Per [this PR](https://github.com/huggingface/transformers/pull/20341) LLM.int8 is now supported for `long-t5` models. Per **initial testing** summarization quality appears to hold while requiring _significantly_ less memory! \*
+Per [this PR](https://github.com/huggingface/transformers/pull/20341) LLM.int8 is now supported for `long-t5` models. Per **initial tests** the summarization quality seems to hold while using _significantly_ less memory! \*
 
-How-to: essentially ensure you have pip installed from the **latest GitHub repo main** version of `transformers`, and `bitsandbytes`
+How-to: basically make sure you have pip-installed the **latest GitHub repo main** version of `transformers`, and also the `bitsandbytes` package.
 
 install the latest `main` branch:
 
@@ -238,11 +241,11 @@ model = AutoModelForSeq2SeqLM.from_pretrained(
 )
 ```
 
-The above is already present in the Colab demo linked at the top of the model card.
+The above is already present in the Colab demo linked at the top of the model map.
 
-Do you love to ask questions? Awesome. But first, check out the [how LLM.int8 works blog post](https://huggingface.co/blog/hf-bitsandbytes-integration) by huggingface.
+Do you like to ask questions? Great. But first, check out the [how LLM.int8 works blog post](https://huggingface.co/blog/hf-bitsandbytes-integration) by huggingface.
 
-\* More rigorous metric-based investigation into comparing beam-search summarization with and without LLM.int8 will take place over time.
+\* More rigorous metrics-based research comparing beam-search summarization with and without LLM.int8 will take place over time.
 
 * * *
 
@@ -250,25 +253,25 @@ Do you love to ask questions? Awesome. But first, check out the [how LLM.int8 wo
 
 ### Intended uses & limitations
 
-While this model seems to improve upon factual consistency, **do not take summaries to be foolproof and check things that seem odd**.
+While this model seems to improve factual consistency, **don't take summaries as foolproof and check things that seem odd**.
 
-Specifically: negation statements (i.e., model says: _This thing does not have [ATTRIBUTE]_ where instead it should have said _This thing has a lot of [ATTRIBUTE]_).
+Specifically: negation statements (i.e., the model says: _this thing does not have [ATTRIBUTE]_, when instead it should have said _this thing has lots of [ATTRIBUTE]_).
 
--   I'm sure someone will write a paper on this eventually (if there isn't one already), but you can usually fact-check this by comparing a specific claim to what the surrounding sentences imply.
+- I'm sure someone will write a paper on this eventually (if there isn't one already), but you can usually check this by comparing a particular statement with what the surrounding sentences imply.
 
 ### Training and evaluation data
 
 `kmfoda/booksum` dataset on HuggingFace - read [the original paper here](https://arxiv.org/abs/2105.08209).
 
--   **Initial fine-tuning** only used input text with 12288 tokens input or less and 1024 tokens output or less (_i.e. rows with longer were dropped before training_) for memory reasons. Per brief analysis, summaries in the 12288-16384 range in this dataset are in the **small** minority
-    -   In addition, this initial training combined the training and validation sets and trained on these in aggregate to increase the functional dataset size. **Therefore, take the validation set results with a grain of salt; primary metrics should be (always) the test set.**
--   **final phases of fine-tuning** used the standard conventions of 16384 input/1024 output keeping everything (truncating longer sequences). This did not appear to change the loss/performance much.
+- For **initial fine-tuning**, only input text with 12288 input tokens or less and 1024 output tokens or less was used (_i.e. lines longer than that were dropped before training_) for memory reasons. After a quick analysis, summaries in the 12288-16384 range are in the **small** minority in this dataset.
+    - In addition, this initial training combined the training and validation sets and trained on them in aggregate to increase the functional dataset size. **Therefore, take the validation set results with a grain of salt; primary metrics should (always) be the test set.**.
+- The **final stages of fine-tuning** used the standard 16384 input/1024 output conventions, preserving the standard in/out lengths (_and truncating longer sequences_). This did not seem to change the loss/performance much.
 
 ### Eval results
 
 Official results with the [model evaluator](https://huggingface.co/spaces/autoevaluate/model-evaluator) will be computed and posted here.
 
-**Please read the note above as due to training methods, validation set performance looks better than the test set results will be**. The model achieves the following results on the evaluation set:
+**Please read the note above, as due to the training methods, the performance on the validation set looks better than the results on the test set will be**. The model achieves the following results on the evaluation set:
 
 -   eval_loss: 1.2756
 -   eval_rouge1: 41.8013
@@ -307,15 +310,17 @@ lol
 
 See `summarize.py` in [the code for my hf space Document Summarization](https://huggingface.co/spaces/pszemraj/document-summarization/blob/main/summarize.py) :)
 
-You can also use the same code to split a document into batches of 4096, etc., and run over those with the model. This is useful in situations where CUDA memory is limited.
+You can also use the same code to split a document into batches of 4096, etc., and iterate over them with the model. This is useful in situations where CUDA memory is limited.
+
+**Update:** see the section on the `textsum` package below.
 
 ### How to fine-tune further?
 
 See [train with a script](https://huggingface.co/docs/transformers/run_scripts) and [the summarization scripts](https://github.com/huggingface/transformers/tree/main/examples/pytorch/summarization)
 
-### Is there an easier way to use this?
+### Are there simpler ways to run this?
 
-I have created a python package utility for this reason. It's called [textsum](https://github.com/pszemraj/textsum), and you can use it to load models and summarize things in a few lines of code.
+For this reason, I created a Python package utility. It's called [textsum](https://github.com/pszemraj/textsum), and you can use it to load models and summarize things in a few lines of code.
 
 ```sh
 pip install textsum
@@ -330,18 +335,14 @@ summarizer = Summarizer(
     model_name_or_path="pszemraj/long-t5-tglobal-xl-16384-book-summary"
 )
 
-# summarize a long string
-out_str = summarizer.summarize_string(
-    "This is a long string of text that will be summarized."
-)
+long_string = "This is a long string of text that will be summarized."
+out_str = summarizer.summarize_string(long_string)
 print(f"summary: {out_str}")
-
 ```
 
-This package provides easy-to-use interfaces for using summarization models on text documents of arbitrary length. Currently implemented interfaces include a python API, CLI, and a shareable demo app.
-
-For details, explanations, and docs, see the README (_linked above_) or the [wiki](https://github.com/pszemraj/textsum/wiki).
+This package provides easy-to-use interfaces for applying summarization models to text documents of arbitrary length. Currently implemented interfaces include a Python API, a CLI, and a shareable demo application.
 
+For details, explanations, and documentation, see the README (_linked above_) or the [wiki](https://github.com/pszemraj/textsum/wiki).
 
 * * *
 
@@ -349,7 +350,7 @@ For details, explanations, and docs, see the README (_linked above_) or the [wik
 
 ### Updates
 
-Updates to this model/model card will be posted here as relevant. The model seems fairly converged; if updates/improvements are possible using the `BookSum` dataset, this repo will be updated.
+Updates to this model/model card will be posted here when relevant. The model seems to be fairly converged; if updates/improvements are possible using the `BookSum` dataset, this repo will be updated.
 
 ### Training hyperparameters