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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

from collections import Counter
from typing import List, Tuple
 
def analyze_case_impact(texts: List[str]) -> dict:
    """
    Analyze the impact of case on vocabulary size.
    """
    # Tokenize simply (split on whitespace and punctuation)
    import re
    all_tokens = []
    for text in texts:
        tokens = re.findall(r'\b\w+\b', text)
        all_tokens.extend(tokens)
    
    # Original vocabulary
    original_vocab = set(all_tokens)
    original_counts = Counter(all_tokens)
    
    # Lowercased vocabulary
    lowered_tokens = [t.lower() for t in all_tokens]
    lowered_vocab = set(lowered_tokens)
    lowered_counts = Counter(lowered_tokens)
    
    # Find case variants
    case_groups = {}
    for token in original_vocab:
        lower = token.lower()
        if lower not in case_groups:
            case_groups[lower] = []
        case_groups[lower].append(token)
    
    # Tokens with multiple case variants
    multi_case = {k: v for k, v in case_groups.items() if len(v) > 1}
    
    return {
        "original_vocab_size": len(original_vocab),
        "lowered_vocab_size": len(lowered_vocab),
        "reduction_percent": (1 - len(lowered_vocab) / len(original_vocab)) * 100,
        "tokens_with_variants": len(multi_case),
        "sample_variants": dict(list(multi_case.items())[:10]),
    }
 
# Sample corpus
corpus = [
    "The Machine Learning course covers machine learning fundamentals.",
    "MACHINE LEARNING is transforming industries.",
    "Apple released a new product. I ate an apple today.",
    "The United States of America is often called the US or USA.",
    "Python and python are both important in programming.",
    "NASA announced a new mission. nasa is trending on Twitter.",
]
 
results = analyze_case_impact(corpus)
 
print("=== Case Impact Analysis ===\n")
print(f"Original vocabulary size: {results['original_vocab_size']}")
print(f"Lowercased vocabulary size: {results['lowered_vocab_size']}")
print(f"Vocabulary reduction: {results['reduction_percent']:.1f}%")
print(f"Tokens with case variants: {results['tokens_with_variants']}")
 
print("\nSample case variants:")
for lower, variants in results['sample_variants'].items():
    if len(variants) > 1:
        print(f"  '{lower}' appears as: {variants}")

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
49
50
51
52
53
54

"""
Examples where case normalization causes semantic loss.
"""
 
semantic_case_examples = [
    # (lowercase, uppercase, explanation)
    ("apple", "Apple", "Fruit vs. technology company"),
    ("china", "China", "Porcelain vs. country"),
    ("it", "IT", "Pronoun vs. Information Technology"),
    ("us", "US", "Pronoun vs. United States"),
    ("polish", "Polish", "To clean vs. from Poland"),
    ("march", "March", "To walk vs. month"),
    ("may", "May", "Possibility vs. month/name"),
    ("will", "Will", "Future tense vs. name/legal document"),
    ("job", "Job", "Employment vs. biblical figure"),
    ("mercury", "Mercury", "Element vs. planet/god"),
    ("nice", "Nice", "Pleasant vs. French city"),
    ("turkey", "Turkey", "Bird vs. country"),
]
 
print("=== Case-Sensitive Semantic Distinctions ===\n")
print(f"{'Lowercase':<12} {'Uppercase':<12} {'Distinction'}")
print("-" * 60)
for lower, upper, distinction in semantic_case_examples:
    print(f"{lower:<12} {upper:<12} {distinction}")
 
# Demonstrate impact on NER
print("\n=== Impact on Named Entity Recognition ===\n")
 
import spacy
nlp = spacy.load("en_core_web_sm")
 
test_sentences = [
    "I ate an apple at the Apple store.",
    "The march will happen in March.",
    "Nice is a nice city in France.",
    "Turkey exports turkey meat worldwide.",
]
 
for sentence in test_sentences:
    print(f"Original: {sentence}")
    
    # NER on original
    doc_orig = nlp(sentence)
    orig_ents = [(ent.text, ent.label_) for ent in doc_orig.ents]
    
    # NER on lowercased
    doc_lower = nlp(sentence.lower())
    lower_ents = [(ent.text, ent.label_) for ent in doc_lower.ents]
    
    print(f"  Original entities: {orig_ents}")
    print(f"  Lowercased entities: {lower_ents}")
    print(f"  Information lost: {len(orig_ents) - len(lower_ents)} entities")
    print()

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

"""
Case normalization implementation strategies.
"""
from typing import Optional
import re
import unicodedata
 
# === Basic Case Conversion ===
 
text = "Hello WORLD München Straße"
 
print("=== Basic Python Case Methods ===\n")
print(f"Original: {text}")
print(f"lower():    {text.lower()}")
print(f"upper():    {text.upper()}")
print(f"casefold(): {text.casefold()}")
 
# The difference matters for German ß
german_text = "Straße"  # Street
print(f"\nGerman 'Straße' (street):")
print(f"  lower():    '{german_text.lower()}'")  # straße
print(f"  casefold(): '{german_text.casefold()}'")  # strasse (double s)
 
# === Unicode Case Folding ===
 
print("\n=== Unicode Considerations ===\n")
 
unicode_examples = [
    ("İstanbul", "Turkish capital I with dot"),
    ("ΣΩΚΡΑΤΗΣ", "Greek uppercase sigma"),
    ("Σ vs ς", "Greek sigma: different lowercase forms"),
    ("fi", "Latin small ligature fi"),
]
 
for text, desc in unicode_examples:
    print(f"{desc}:")
    print(f"  Original:  '{text}'")
    print(f"  lower():   '{text.lower()}'")
    print(f"  casefold(): '{text.casefold()}'")
    print()
 
# === The Turkish I Problem ===
 
print("=== The Turkish I Problem ===\n")
 
# In Turkish:
# - I (dotless I) lowercases to ı (dotless i)
# - İ (dotted I) lowercases to i (dotted i)
# Standard Python lower() doesn't handle this!
 
turkish_examples = [
    ("ISTANBUL", "Standard lowercase"),
    ("İSTANBUL", "Turkish dotted İ"),
]
 
print("In Turkish, 'I' and 'İ' are different letters:")
print("  I (dotless) ↔ ı (dotless)")
print("  İ (dotted)  ↔ i (dotted)")
print()
 
for text, desc in turkish_examples:
    print(f"{desc}: {text}")
    print(f"  Python lower(): {text.lower()}")
    print(f"  Python casefold(): {text.casefold()}")
    print()
 
# Proper Turkish lowercasing requires locale-aware functions
# import locale
# locale.setlocale(locale.LC_ALL, 'tr_TR.UTF-8')
 
# === Comprehensive Case Normalizer ===
 
class CaseNormalizer:
    """
    Production-ready case normalizer with configurable behavior.
    """
    
    def __init__(
        self,
        method: str = "lower",
        preserve_acronyms: bool = False,
        preserve_all_caps: bool = False,
        min_acronym_length: int = 2,
        max_acronym_length: int = 6
    ):
        """
        Initialize case normalizer.
        
        Args:
            method: 'lower', 'upper', or 'casefold'
            preserve_acronyms: Keep likely acronyms (2-6 uppercase letters)
            preserve_all_caps: Keep ALL CAPS words (potential emphasis)
            min_acronym_length: Minimum length to consider as acronym
            max_acronym_length: Maximum length to consider as acronym
        """
        self.method = method
        self.preserve_acronyms = preserve_acronyms
        self.preserve_all_caps = preserve_all_caps
        self.min_len = min_acronym_length
        self.max_len = max_acronym_length
        
        # Regex for detecting acronyms
        self.acronym_pattern = re.compile(
            rf'\b[A-Z]{{{min_acronym_length},{max_acronym_length}}}\b'
        )
    
    def _is_acronym(self, word: str) -> bool:
        """Check if word is likely an acronym."""
        return bool(self.acronym_pattern.fullmatch(word))
    
    def _is_all_caps(self, word: str) -> bool:
        """Check if word is all caps (length > max_acronym_length)."""
        return word.isupper() and len(word) > self.max_len
    
    def normalize_word(self, word: str) -> str:
        """Normalize case of a single word."""
        # Preserve acronyms if requested
        if self.preserve_acronyms and self._is_acronym(word):
            return word
        
        # Preserve all-caps emphasis if requested
        if self.preserve_all_caps and self._is_all_caps(word):
            return word
        
        # Apply normalization
        if self.method == "lower":
            return word.lower()
        elif self.method == "upper":
            return word.upper()
        elif self.method == "casefold":
            return word.casefold()
        else:
            return word
    
    def normalize_text(self, text: str) -> str:
        """Normalize case of entire text, preserving structure."""
        words = text.split()
        normalized = [self.normalize_word(w) for w in words]
        return " ".join(normalized)
 
# Demonstration
print("=== Configurable Case Normalizer ===\n")
 
text = "I work at NASA and IBM. The AMAZING results were published in Nature."
 
# Basic lowercase
basic = CaseNormalizer(method="lower")
print(f"Original: {text}")
print(f"Basic lower: {basic.normalize_text(text)}")
 
# Preserve acronyms
acronym_preserving = CaseNormalizer(method="lower", preserve_acronyms=True)
print(f"Preserve acronyms: {acronym_preserving.normalize_text(text)}")
 
# Preserve all-caps emphasis
emphasis_preserving = CaseNormalizer(
    method="lower", 
    preserve_acronyms=True, 
    preserve_all_caps=True
)
print(f"Preserve emphasis: {emphasis_preserving.normalize_text(text)}")

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

"""
Language-specific case normalization examples.
"""
import re
from typing import Optional
 
# === Turkish Case Conversion ===
 
def turkish_lower(text: str) -> str:
    """
    Locale-correct lowercase for Turkish.
    
    Turkish has:
    - I (dotless capital) → ı (dotless small)
    - İ (dotted capital) → i (dotted small)
    
    Standard Python lower() treats I → i, which is incorrect for Turkish.
    """
    # Direct character mapping for Turkish
    tr_map = str.maketrans({
        'I': 'ı',  # Dotless I to dotless i
        'İ': 'i',  # Dotted İ to dotted i
    })
    return text.translate(tr_map).lower()
 
def turkish_upper(text: str) -> str:
    """Locale-correct uppercase for Turkish."""
    tr_map = str.maketrans({
        'i': 'İ',  # Dotted i to dotted İ
        'ı': 'I',  # Dotless i to dotless I
    })
    return text.translate(tr_map).upper()
 
print("=== Turkish Case Handling ===\n")
 
turkish_words = ["ISTANBUL", "İSTANBUL", "SIK", "SİK"]
 
for word in turkish_words:
    print(f"{word}:")
    print(f"  Python lower(): {word.lower()}")
    print(f"  Turkish lower(): {turkish_lower(word)}")
    print()
 
# === German ß Handling ===
 
print("=== German ß Handling ===\n")
 
german_words = ["Straße", "Grüße", "STRASSE", "GRUESSE"]
 
for word in german_words:
    print(f"{word}:")
    print(f"  lower():    {word.lower()}")
    print(f"  casefold(): {word.casefold()}")
    print(f"  upper():    {word.upper()}")
    print()
 
# Note: Python 3.8+ has ẞ (capital ß), but it's not universally used
print("Capital ß (ẞ) introduced in 2017 German orthography:")
print(f"  'ß'.upper() = '{'ß'.upper()}'")
print(f"  'ẞ'.lower() = '{'ẞ'.lower()}'")
 
# === Greek Final Sigma ===
 
print("\n=== Greek Sigma Handling ===\n")
 
greek_text = "ΣΩΚΡΑΤΗΣ"  # Socrates in Greek
 
print(f"Greek 'Socrates': {greek_text}")
print(f"  lower(): {greek_text.lower()}")
# Note: The final sigma Σ becomes ς (not σ) when it's the last letter
 
# Python handles this correctly
print(f"  Last char is ς (final sigma): {greek_text.lower()[-1] == 'ς'}")
 
# === Language-Aware Normalizer ===
 
class MultilingualCaseNormalizer:
    """
    Language-aware case normalization.
    """
    
    def __init__(self, language: str = "en"):
        self.language = language
    
    def lower(self, text: str) -> str:
        """Language-appropriate lowercase."""
        if self.language == "tr":  # Turkish
            return turkish_lower(text)
        else:
            return text.lower()
    
    def upper(self, text: str) -> str:
        """Language-appropriate uppercase."""
        if self.language == "tr":  # Turkish
            return turkish_upper(text)
        else:
            return text.upper()
    
    def normalize(self, text: str) -> str:
        """Normalize to lowercase for the target language."""
        return self.lower(text)
 
# Test multilingual normalizer
print("\n=== Multilingual Normalizer ===\n")
 
en_norm = MultilingualCaseNormalizer("en")
tr_norm = MultilingualCaseNormalizer("tr")
 
test_text = "ISTANBUL"
print(f"'{test_text}':")
print(f"  English normalizer: {en_norm.normalize(test_text)}")
print(f"  Turkish normalizer: {tr_norm.normalize(test_text)}")

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

"""
Integrating case normalization into ML preprocessing pipelines.
"""
from sklearn.base import BaseEstimator, TransformerMixin
from sklearn.pipeline import Pipeline
from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer
from typing import List, Optional
import re
 
class CaseNormalizationTransformer(BaseEstimator, TransformerMixin):
    """
    Scikit-learn compatible case normalization transformer.
    """
    
    def __init__(
        self, 
        method: str = "lower",
        preserve_pattern: Optional[str] = None
    ):
        """
        Args:
            method: 'lower', 'upper', 'casefold', or 'none'
            preserve_pattern: Regex pattern for tokens to preserve (e.g., acronyms)
        """
        self.method = method
        self.preserve_pattern = preserve_pattern
        self._preserve_regex = None
    
    def fit(self, X, y=None):
        if self.preserve_pattern:
            self._preserve_regex = re.compile(self.preserve_pattern)
        return self
    
    def transform(self, X: List[str]) -> List[str]:
        return [self._normalize(text) for text in X]
    
    def _normalize(self, text: str) -> str:
        if self.method == "none":
            return text
        
        if self._preserve_regex:
            # Find tokens to preserve
            preserved = {}
            for match in self._preserve_regex.finditer(text):
                placeholder = f"__PRESERVED_{len(preserved)}__"
                preserved[placeholder] = match.group()
                text = text[:match.start()] + placeholder + text[match.end():]
            
            # Normalize
            if self.method == "lower":
                text = text.lower()
            elif self.method == "upper":
                text = text.upper()
            elif self.method == "casefold":
                text = text.casefold()
            
            # Restore preserved tokens
            for placeholder, original in preserved.items():
                text = text.replace(placeholder.lower(), original)
            
            return text
        
        # Simple normalization
        if self.method == "lower":
            return text.lower()
        elif self.method == "upper":
            return text.upper()
        elif self.method == "casefold":
            return text.casefold()
        
        return text
 
# === Build preprocessing pipeline ===
 
# Simple pipeline with case normalization
simple_pipeline = Pipeline([
    ('case_norm', CaseNormalizationTransformer(method='lower')),
    ('vectorizer', TfidfVectorizer(max_features=1000)),
])
 
# Advanced pipeline preserving acronyms
acronym_pattern = r'\b[A-Z]{2,6}\b'  # Match 2-6 letter acronyms
 
advanced_pipeline = Pipeline([
    ('case_norm', CaseNormalizationTransformer(
        method='lower', 
        preserve_pattern=acronym_pattern
    )),
    ('vectorizer', TfidfVectorizer(max_features=1000)),
])
 
# Test data
texts = [
    "I work at NASA and study machine learning.",
    "The FBI investigates cyber crimes.",
    "IBM and Google are tech giants.",
    "AMAZING breakthrough in AI research!",
]
 
print("=== Pipeline Comparison ===\n")
 
for i, text in enumerate(texts):
    simple_result = simple_pipeline.named_steps['case_norm'].fit_transform([text])[0]
    advanced_result = advanced_pipeline.named_steps['case_norm'].fit_transform([text])[0]
    
    print(f"Original: {text}")
    print(f"Simple:   {simple_result}")
    print(f"Advanced: {advanced_result}")
    print()
 
# === Interaction with BERT models ===
 
print("=== Case Handling for Transformer Models ===\n")
 
from transformers import AutoTokenizer
 
# BERT uncased (lowercases input automatically)
bert_uncased = AutoTokenizer.from_pretrained("bert-base-uncased")
 
# BERT cased (preserves case)
bert_cased = AutoTokenizer.from_pretrained("bert-base-cased")
 
test = "Apple announced iPhone in California"
 
print(f"Input: {test}\n")
 
uncased_tokens = bert_uncased.tokenize(test)
cased_tokens = bert_cased.tokenize(test)
 
print(f"BERT uncased tokens: {uncased_tokens}")
print(f"BERT cased tokens:   {cased_tokens}")
print(f"\nNote: Uncased model lowercases 'Apple' and 'iPhone' automatically")
print("      This may lose useful information for NER tasks")

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169

"""
True casing: restoring proper capitalization to lowercased text.
"""
from typing import List, Set, Dict
import re
from collections import Counter
 
class RuleBasedTrueCaser:
    """
    Simple rule-based true caser for common patterns.
    """
    
    def __init__(self, proper_nouns: Set[str] = None, acronyms: Set[str] = None):
        """
        Args:
            proper_nouns: Set of proper nouns to capitalize
            acronyms: Set of acronyms to uppercase
        """
        self.proper_nouns = proper_nouns or {
            'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 
            'saturday', 'sunday', 'january', 'february', 'march', 
            'april', 'may', 'june', 'july', 'august', 'september', 
            'october', 'november', 'december', 'english', 'french',
            'german', 'spanish', 'chinese', 'japanese', 'american',
            'european', 'african', 'asian'
        }
        
        self.acronyms = acronyms or {
            'usa', 'uk', 'eu', 'un', 'nato', 'nasa', 'fbi', 'cia',
            'ceo', 'cto', 'cfo', 'phd', 'mba', 'ai', 'ml', 'nlp',
            'api', 'url', 'html', 'css', 'js', 'sql', 'aws', 'gcp'
        }
        
        # Sentence-ending punctuation
        self.sentence_end = re.compile(r'[.!?]\s*$')
    
    def truecase_word(self, word: str, is_sentence_start: bool = False) -> str:
        """Apply true casing rules to a single word."""
        word_lower = word.lower()
        
        # Check acronyms first
        if word_lower in self.acronyms:
            return word.upper()
        
        # Check proper nouns
        if word_lower in self.proper_nouns:
            return word.capitalize()
        
        # Capitalize sentence starts
        if is_sentence_start:
            return word.capitalize()
        
        # Default to lowercase
        return word_lower
    
    def truecase(self, text: str) -> str:
        """Apply true casing to entire text."""
        sentences = re.split(r'([.!?]\s*)', text)
        result = []
        
        for i, segment in enumerate(sentences):
            if i % 2 == 0:  # Actual sentence content
                words = segment.split()
                if words:
                    # First word is sentence start
                    truecased = [self.truecase_word(words[0], is_sentence_start=True)]
                    # Rest of words
                    truecased.extend([self.truecase_word(w) for w in words[1:]])
                    result.append(' '.join(truecased))
            else:  # Punctuation
                result.append(segment)
        
        return ''.join(result)
 
class StatisticalTrueCaser:
    """
    Statistical true caser trained on a corpus.
    """
    
    def __init__(self):
        self.word_cases: Dict[str, Counter] = {}
        self.sentence_start_probs: Dict[str, float] = {}
    
    def fit(self, texts: List[str]):
        """Learn case patterns from a corpus."""
        # Count case occurrences for each lowercased word
        for text in texts:
            sentences = re.split(r'[.!?]\s*', text)
            
            for sentence in sentences:
                words = sentence.split()
                for i, word in enumerate(words):
                    lower = word.lower()
                    
                    if lower not in self.word_cases:
                        self.word_cases[lower] = Counter()
                    
                    # Record the observed case
                    self.word_cases[lower][word] += 1
        
        return self
    
    def truecase_word(self, word: str) -> str:
        """Get most likely casing for a word."""
        lower = word.lower()
        
        if lower in self.word_cases:
            # Return most common casing
            return self.word_cases[lower].most_common(1)[0][0]
        
        return lower
    
    def truecase(self, text: str, capitalize_starts: bool = True) -> str:
        """Apply learned true casing to text."""
        sentences = re.split(r'([.!?]\s*)', text)
        result = []
        
        for i, segment in enumerate(sentences):
            if i % 2 == 0:
                words = segment.split()
                truecased = [self.truecase_word(w) for w in words]
                
                # Capitalize sentence starts
                if capitalize_starts and truecased:
                    truecased[0] = truecased[0].capitalize()
                
                result.append(' '.join(truecased))
            else:
                result.append(segment)
        
        return ''.join(result)
 
# Demonstration
print("=== Rule-Based True Casing ===\n")
 
truecaser = RuleBasedTrueCaser()
 
test_texts = [
    "i went to paris on monday.",
    "the fbi and cia work together. nasa launches rockets.",
    "he speaks english and japanese fluently.",
    "we visited the usa and the uk last summer.",
]
 
for text in test_texts:
    truecased = truecaser.truecase(text)
    print(f"Input:  {text}")
    print(f"Output: {truecased}")
    print()
 
# Statistical true casing
print("=== Statistical True Casing ===\n")
 
# Training corpus (properly cased)
training_texts = [
    "Apple released a new iPhone at their headquarters in California.",
    "Google and Microsoft compete in the AI space.",
    "The United States and European Union signed a trade deal.",
    "NASA's Mars mission is progressing well.",
    "The CEO announced record profits at Apple.",
]
 
stat_truecaser = StatisticalTrueCaser()
stat_truecaser.fit(training_texts)
 
# Test on lowercased input
test = "apple released iphone and google announced ai updates"
print(f"Input:  {test}")
print(f"Output: {stat_truecaser.truecase(test)}")