Acrolinx fixes

Author: GraemeMalcolm

learn-pr/wwl-data-ai/introduction-language/includes/1-introduction.md

@@ -8,12 +8,12 @@
 
 Within artificial intelligence (AI), text analysis is a subset of natural language processing (NLP) that enables machines to extract meaning, structure, and insights from unstructured text. Organizations use text analysis to transform customer feedback, support tickets, contracts, and social media posts into actionable intelligence.
 
-Techniques to process and analyze text have evolved over many years, from simple statistical calculations based on term-frequency to vector-based language models that encapsulate semantic meaning. Along the way, some common use cases for text analysis have emerged; including:
+Techniques to process and analyze text evolved over many years, from simple statistical calculations based on term-frequency to vector-based language models that encapsulate semantic meaning. Some common use cases for text analysis include:
 
 - **Key term extraction**: Identifying important words and phrases in text, to help determine the topics and themes it discusses.
 - **Entity detection**: Identifying named entities mentioned in text; for example, places, people, dates, and organizations.
-- **Text classification**: Categorizing text documents based on their contents. For example, filtering email as "spam" or "not spam".
-- **Sentiment analysis**: A particular form of text classification that predicts the *sentiment* of text - for example, categorizing social media posts as "positive", "neutral", or "negative".
+- **Text classification**: Categorizing text documents based on their contents. For example, filtering email as *spam* or *not spam*.
+- **Sentiment analysis**: A particular form of text classification that predicts the *sentiment* of text - for example, categorizing social media posts as *positive*, *neutral*, or *negative*.
 - **Text summarization**: Reducing the volume of text while retaining its salient points. For example, generating a short one-paragraph summary from a multi-page document.
 
 Text analysis is challenging because language is complex, and computers find it hard to understand. Ultimately, all text analysis techniques are based on the requirement to extract *meaning* from natural language text.

learn-pr/wwl-data-ai/introduction-language/includes/2-how-it-works.md

@@ -11,29 +11,29 @@
 
 The first step in analyzing a body of text (referred to as a *corpus*) is to break it down into *tokens*. For the sake of simplicity, you can think of each distinct word in the text as a token. In reality, tokens can be generated for partial words or combinations of words and punctuation.
 
-For example, consider this phrase from a famous US presidential speech: :::no-loc text=""We choose to go to the moon"":::. The phrase can be broken down into the following tokens, with numeric identifiers:
+For example, consider this phrase from a famous US presidential speech: `"We choose to go to the moon"`. The phrase can be broken down into the following tokens, with numeric identifiers:
 
-1. :::no-loc text="We"::: 
-2. :::no-loc text="choose":::
-3. :::no-loc text="to":::
-4. :::no-loc text="go":::
-3. :::no-loc text="to":::
-5. :::no-loc text="the":::
-6. :::no-loc text="moon":::
+1. `We` 
+2. `choose`
+3. `to`
+4. `go`
+3. `to`
+5. `the`
+6. `moon`
 
-Notice that :::no-loc text=""to""::: (token number 3) is used twice in the corpus. The phrase :::no-loc text=""We choose to go to the moon""::: can be represented by the tokens.
+Notice that `"to"` (token number 3) is used twice in the corpus. The phrase `"We choose to go to the moon"` can be represented by the tokens.
 
 With each token assigned a discrete value, we can easily count their frequency in the text and use that to determine the most commonly used terms; which might help identify the main subject of the text.
 
 We've used a simple example in which tokens are identified for each distinct word in the text. However, consider the following pre-processing techniques that might apply to tokenization depending on the specific text analysis problem you're trying to solve:
 
 |**Technique**|**Description**|
 |-|-|
-|**Text normalization**| Before generating tokens, you might choose to *normalize* the text by removing punctuation and changing all words to lower case. For analysis that relies purely on word frequency, this approach improves overall performance. However, some semantic meaning could be lost - for example, consider the sentence :::no-loc text=""Mr Banks has worked in many banks."":::. You may want your analysis to differentiate between the person :::no-loc text=""Mr Banks""::: and the :::no-loc text=""banks""::: in which he's worked. You might also want to consider :::no-loc text=""banks.""::: as a separate token to :::no-loc text=""banks""::: because the inclusion of a period provides the information that the word comes at the end of a sentence|
-|**Stop word removal**| Stop words are words that should be excluded from the analysis. For example, :::no-loc text=""the", "a"":::, or :::no-loc text=""it""::: make text easier for people to read but add little semantic meaning. By excluding these words, a text analysis solution might be better able to identify the important words.|
-|**N-gram extraction**| Finding multi-term phrases such as :::no-loc text=""artificial intelligence""::: or :::no-loc text=""natural language processing"":::. A single word phrase is a *unigram*, a two-word phrase is a *bigram*, a three-word phrase is a *trigram*, and so on. In many cases, by considering frequently appearing sequences of words as groups, a text analysis algorithm can make better sense of the text.|
-| **Stemming**| A technique used to consolidate words by stripping endings like "s", "ing", "ed", and so on, before counting them; so that words with the same etymological root, like :::no-loc text=""powering"":::, :::no-loc text=""powered"":::, and :::no-loc text=""powerful"":::, are interpreted as being the same token (:::no-loc text=""power"":::).|
-| **Lemmatization** | Another approach to reducing words to their base or dictionary form (called a *lemma*). Unlike stemming, which simply chops off word endings, lemmatization uses linguistic rules and vocabulary to ensure the resulting form is a valid word (for example, :::no-loc text=""running"":::: → :::no-loc text=""run"":::, :::no-loc text=""global""::: → :::no-loc text=""globe"":::).|
+|**Text normalization**| Before generating tokens, you might choose to *normalize* the text by removing punctuation and changing all words to lower case. For analysis that relies purely on word frequency, this approach improves overall performance. However, some semantic meaning could be lost - for example, consider the sentence `"Mr Banks has worked in many banks."`. You may want your analysis to differentiate between the person `"Mr Banks"` and the `"banks"` in which he's worked. You might also want to consider `"banks."` as a separate token to `"banks"` because the inclusion of a period provides the information that the word comes at the end of a sentence|
+|**Stop word removal**| Stop words are words that should be excluded from the analysis. For example, `"the", "a"`, or `"it"` make text easier for people to read but add little semantic meaning. By excluding these words, a text analysis solution might be better able to identify the important words.|
+|**N-gram extraction**| Finding multi-term phrases such as `"artificial intelligence"` or `"natural language processing"`. A single word phrase is a *unigram*, a two-word phrase is a *bigram*, a three-word phrase is a *trigram*, and so on. In many cases, by considering frequently appearing sequences of words as groups, a text analysis algorithm can make better sense of the text.|
+| **Stemming**| A technique used to consolidate words by stripping endings like "s", "ing", "ed", and so on, before counting them; so that words with the same etymological root, like `"powering"`, `"powered"`, and `"powerful"`, are interpreted as being the same token (`"power"`).|
+| **Lemmatization** | Another approach to reducing words to their base or dictionary form (called a *lemma*). Unlike stemming, which simply chops off word endings, lemmatization uses linguistic rules and vocabulary to ensure the resulting form is a valid word (for example, `"running"`: → `"run"`, `"global"` → `"globe"`).|
 | **Parts of speech (POS) tagging** | Labeling each token with its grammatical category, such as noun, verb, adjective, or adverb. This technique uses linguistic rules and often statistical models to determine the correct tag based on both the token itself and its context within the sentence. |
 
 ::: zone-end

learn-pr/wwl-data-ai/introduction-language/includes/4-semantic-models.md

@@ -21,84 +21,84 @@ For example, consider the following three-dimensional embeddings for some common
 
 |Word|Vector|
 |-|-|
-|:::no-loc text="dog":::|[0.8, 0.6, 0.1]|
-|:::no-loc text="puppy":::|[0.9, 0.7, 0.4]|
-|:::no-loc text="cat":::|[0.7, 0.5, 0.2]|
-|:::no-loc text="kitten":::|[0.8, 0.6, 0.5]|
-|:::no-loc text="young":::|[0.1, 0.1, 0.3]|
-|:::no-loc text="ball":::|[0.3, 0.9, 0.1]|
-|:::no-loc text="tree":::|[0.2, 0.1, 0.9]|
+|`dog`|[0.8, 0.6, 0.1]|
+|`puppy`|[0.9, 0.7, 0.4]|
+|`cat`|[0.7, 0.5, 0.2]|
+|`kitten`|[0.8, 0.6, 0.5]|
+|`young`|[0.1, 0.1, 0.3]|
+|`ball`|[0.3, 0.9, 0.1]|
+|`tree`|[0.2, 0.1, 0.9]|
 
 We can visualize these vectors in three-dimensional space as shown here:
 
-![Diagram of a 3D visualization of word vectors.](../media/word-vectors-3d.png)
+![Diagram of a 3D visualization of word vectors.](../media/vectors.png)
 
-The vectors for :::no-loc text=""dog""::: and :::no-loc text=""cat""::: are similar (both domestic animals), as are :::no-loc text=""puppy""::: and :::no-loc text=""kitten""::: (both young animals). The words :::no-loc text=""tree"":::, :::no-loc text=""young"":::, and :::no-loc text="ball""::: have distinctly different vector orientations, reflecting their different semantic meanings.
+The vectors for `"dog"` and `"cat"` are similar (both domestic animals), as are `"puppy"` and `"kitten"` (both young animals). The words `"tree"`, `"young"`, and `ball"` have distinctly different vector orientations, reflecting their different semantic meanings.
 
 The semantic characteristic encoded in the vectors makes it possible to use vector-based operations that compare words and enable analytical comparisons.
 
 ### Finding related terms
 
 Since the orientation of vectors is determined by their dimension values, words with similar semantic meanings tend to have similar orientations. This means you can use calculations such as the *cosine similarity* between vectors to make meaningful comparisons.
 
-For example, to determine the "odd one out" between :::no-loc text=""dog"":::, :::no-loc text=""cat"":::, and :::no-loc text=""tree"":::, you can calculate the cosine similarity between pairs of vectors. The cosine similarity is calculated as:
+For example, to determine the "odd one out" between `"dog"`, `"cat"`, and `"tree"`, you can calculate the cosine similarity between pairs of vectors. The cosine similarity is calculated as:
 
 `cosine_similarity(A, B) = (A · B) / (||A|| * ||B||)`
 
 Where `A · B` is the dot product and `||A||` is the magnitude of vector A.
 
 Calculating similarities between the three words:
 
-- **:::no-loc text="dog":::** [0.8, 0.6, 0.1] and **:::no-loc text="cat":::** [0.7, 0.5, 0.2]:
+- **`dog`** [0.8, 0.6, 0.1] and **`cat`** [0.7, 0.5, 0.2]:
   - Dot product: (0.8 × 0.7) + (0.6 × 0.5) + (0.1 × 0.2) = 0.56 + 0.30 + 0.02 = 0.88
-  - Magnitude of :::no-loc text="dog":::: √(0.8² + 0.6² + 0.1²) = √(0.64 + 0.36 + 0.01) = √1.01 ≈ 1.005
-  - Magnitude of :::no-loc text="cat":::: √(0.7² + 0.5² + 0.2²) = √(0.49 + 0.25 + 0.04) = √0.78 ≈ 0.883
+  - Magnitude of `dog`: √(0.8² + 0.6² + 0.1²) = √(0.64 + 0.36 + 0.01) = √1.01 ≈ 1.005
+  - Magnitude of `cat`: √(0.7² + 0.5² + 0.2²) = √(0.49 + 0.25 + 0.04) = √0.78 ≈ 0.883
   - Cosine similarity: 0.88 / (1.005 × 0.883) ≈ **0.992** (high similarity)
 
-- **:::no-loc text="dog":::** [0.8, 0.6, 0.1] and **:::no-loc text="tree":::** [0.2, 0.1, 0.9]:
+- **`dog`** [0.8, 0.6, 0.1] and **`tree`** [0.2, 0.1, 0.9]:
   - Dot product: (0.8 × 0.2) + (0.6 × 0.1) + (0.1 × 0.9) = 0.16 + 0.06 + 0.09 = 0.31
-  - Magnitude of :::no-loc text="tree":::: √(0.2² + 0.1² + 0.9²) = √(0.04 + 0.01 + 0.81) = √0.86 ≈ 0.927
+  - Magnitude of `tree`: √(0.2² + 0.1² + 0.9²) = √(0.04 + 0.01 + 0.81) = √0.86 ≈ 0.927
   - Cosine similarity: 0.31 / (1.005 × 0.927) ≈ **0.333** (low similarity)
 
-- **:::no-loc text="cat":::** [0.7, 0.5, 0.2] and **:::no-loc text="tree":::** [0.2, 0.1, 0.9]:
+- **`cat`** [0.7, 0.5, 0.2] and **`tree`** [0.2, 0.1, 0.9]:
   - Dot product: (0.7 × 0.2) + (0.5 × 0.1) + (0.2 × 0.9) = 0.14 + 0.05 + 0.18 = 0.37
   - Cosine similarity: 0.37 / (0.883 × 0.927) ≈ **0.452** (low similarity)
 
 ![Diagram of cosine similarity visualization showing dog, cat, and tree vectors.](../media/cosine-similarity.png)
 
-The results show that :::no-loc text=""dog""::: and :::no-loc text=""cat""::: are highly similar (0.992), while :::no-loc text=""tree""::: has lower similarity to both :::no-loc text=""dog""::: (0.333) and :::no-loc text=""cat""::: (0.452). Therefore, **:::no-loc text="tree":::** is clearly the odd one out.
+The results show that `"dog"` and `"cat"` are highly similar (0.992), while `"tree"` has lower similarity to both `"dog"` (0.333) and `"cat"` (0.452). Therefore, **`tree`** is clearly the odd one out.
 
 ### Vector translation through addition and subtraction
 
 You can add or subtract vectors to produce new vector-based results; which can then be used to find tokens with matching vectors. This technique enables intuitive arithmetic-based logic to determine appropriate terms based on linguistic relationships.
 
 For example, using the vectors from earlier:
 
-- **:::no-loc text="dog":::** + **:::no-loc text="young":::** = [0.8, 0.6, 0.1] + [0.1, 0.1, 0.3] = [0.9, 0.7, 0.4] = **:::no-loc text="puppy":::**
-- **:::no-loc text="cat":::** + **:::no-loc text="young":::** = [0.7, 0.5, 0.2] + [0.1, 0.1, 0.3] = [0.8, 0.6, 0.5] = **:::no-loc text="kitten":::**
+- **`dog`** + **`young`** = [0.8, 0.6, 0.1] + [0.1, 0.1, 0.3] = [0.9, 0.7, 0.4] = **`puppy`**
+- **`cat`** + **`young`** = [0.7, 0.5, 0.2] + [0.1, 0.1, 0.3] = [0.8, 0.6, 0.5] = **`kitten`**
 
 ![Diagram of vector addition showing dog + young = puppy and cat + young = kitten.](../media/vector-addition.png)
 
-These operations work because the vector for :::no-loc text=""young""::: encodes the semantic transformation from an adult animal to its young counterpart.
+These operations work because the vector for `"young"` encodes the semantic transformation from an adult animal to its young counterpart.
 
 > [!NOTE]
 > In practice, vector arithmetic rarely produces exact matches; instead, you would search for the word whose vector is *closest* (most similar) to the result.
 
 The arithmetic works in reverse as well:
 
-- **:::no-loc text="puppy":::** - **:::no-loc text="young":::** = [0.9, 0.7, 0.4] - [0.1, 0.1, 0.3] = [0.8, 0.6, 0.1] = **:::no-loc text="dog":::**
-- **:::no-loc text="kitten":::** - **:::no-loc text="young":::** = [0.8, 0.6, 0.5] - [0.1, 0.1, 0.3] = [0.7, 0.5, 0.2] = **:::no-loc text="cat":::**
+- **`puppy`** - **`young`** = [0.9, 0.7, 0.4] - [0.1, 0.1, 0.3] = [0.8, 0.6, 0.1] = **`dog`**
+- **`kitten`** - **`young`** = [0.8, 0.6, 0.5] - [0.1, 0.1, 0.3] = [0.7, 0.5, 0.2] = **`cat`**
 
 ### Analogical reasoning
 
-Vector arithmetic can also answer analogy questions like "*:::no-loc text="puppy":::* is to *:::no-loc text="dog":::* as *:::no-loc text="kitten":::* is to *?*"
+Vector arithmetic can also answer analogy questions like "*`puppy`* is to *`dog`* as *`kitten`* is to *?*"
 
-To solve this, calculate: **:::no-loc text="kitten":::** - **:::no-loc text="puppy":::** + **:::no-loc text="dog":::**
+To solve this, calculate: **`kitten`** - **`puppy`** + **`dog`**
 
 - [0.8, 0.6, 0.5] - [0.9, 0.7, 0.4] + [0.8, 0.6, 0.1]
 - = [-0.1, -0.1, 0.1] + [0.8, 0.6, 0.1]
 - = [0.7, 0.5, 0.2]
-- = **:::no-loc text="cat":::**
+- = **`cat`**
 
 ![Diagram of vector arithmetic showing kitten - puppy + dog = cat.](../media/vector-analogy.png)