nlpkit14 0.3.0__py3-none-any.whl

nlpkit14/__init__.py

@@ -0,0 +1,70 @@
+"""Run the fourteen supplied NLP practicals, with source available separately."""
+from importlib.resources import files
+import json
+import os
+
+__version__ = "0.3.0"
+
+def _resource(number):
+    if number not in range(1, 15):
+        raise ValueError("Choose a question from 1 to 14")
+    return files(__package__).joinpath("programs", f"q{number}.py")
+
+def _configure():
+    path = os.path.expanduser(os.environ.get("NLPKIT14_DATA", "~/.nlpkit14"))
+    data = os.path.join(path, "nltk_data")
+    os.environ.setdefault("HF_HOME", os.path.join(path, "huggingface"))
+    try:
+        import nltk
+    except ModuleNotFoundError:
+        return
+    if data not in nltk.data.path:
+        nltk.data.path.insert(0, data)
+
+def source(number):
+    """Print runnable source, including the commented question and expected output."""
+    print(_resource(number).read_text(encoding="utf-8"), end="")
+
+def questions():
+    for row in json.loads(files(__package__).joinpath("questions.json").read_text(encoding="utf-8")):
+        print(f"q{row['number']}(): {row['question']}")
+
+def _run(number):
+    _configure()
+    resource = _resource(number)
+    namespace = {"__name__": f"nlpkit14.question{number}"}
+    exec(compile(resource.read_text(encoding="utf-8"), str(resource), "exec"), namespace)
+
+def _make(number):
+    def question():
+        _run(number)
+    question.__name__ = f"q{number}"
+    question.__qualname__ = question.__name__
+    question.__doc__ = f"Execute question {number}. Use source({number}) to see code and comments."
+    return question
+
+for _number in range(1, 15):
+    globals()[f"q{_number}"] = _make(_number)
+
+def setup(models=False):
+    """Explicit online preparation. models=True also downloads large parsing/BERT models."""
+    _configure()
+    import nltk
+    import subprocess
+    import sys
+    directory = os.path.join(os.path.expanduser(os.environ.get("NLPKIT14_DATA", "~/.nlpkit14")), "nltk_data")
+    os.makedirs(directory, exist_ok=True)
+    for name in ("punkt_tab", "stopwords", "averaged_perceptron_tagger_eng", "wordnet", "omw-1.4"):
+        if not nltk.download(name, download_dir=directory, quiet=True):
+            raise RuntimeError(f"Could not download {name}; check internet connectivity")
+    subprocess.run([sys.executable, "-m", "spacy", "download", "en_core_web_sm"], check=True)
+    if models:
+        subprocess.run([sys.executable, "-m", "spacy", "download", "en_core_web_md"], check=True)
+        import benepar
+        if not benepar.download("benepar_en3", download_dir=directory):
+            raise RuntimeError("Could not download benepar_en3; check internet connectivity")
+        from transformers import BertTokenizer, BertModel
+        BertTokenizer.from_pretrained("bert-base-uncased")
+        BertModel.from_pretrained("bert-base-uncased")
+
+__all__ = ["questions", "source", "setup"] + [f"q{i}" for i in range(1, 15)]

nlpkit14/programs/q1.py

@@ -0,0 +1,30 @@
+# Question 1 (B1): Tokenization and Stop-word Removal using NLTK
+# Output below is the document example; actual model and website results may differ.
+# Expected output:
+# Sentences: ['This is a simple example demonstrating stopword removal in NLP.', 'NLP is interesting.']
+# Words: ['This', 'is', 'a', 'simple', 'example', 'demonstrating', 'stopword', 'removal', 'in', 'NLP', '.', 'NLP', 'is', 'interesting', '.']
+# Filtered Tokens: ['simple', 'example', 'demonstrating', 'stopword', 'removal', 'NLP', 'NLP', 'interesting']
+
+import nltk
+from nltk.tokenize import word_tokenize, sent_tokenize
+from nltk.corpus import stopwords
+
+# Download required resources
+# Resource download moved to n.setup().
+# Resource download moved to n.setup().
+# Input text
+text = "This is a simple example demonstrating stopword removal in NLP. NLP is interesting."
+
+# Sentence tokenization
+sentences = sent_tokenize(text)
+
+# Word tokenization
+words = word_tokenize(text)
+
+# Stop-word removal
+stop_words = set(stopwords.words('english'))
+filtered = [w for w in words if w.lower() not in stop_words and w.isalnum()]
+
+print("Sentences:", sentences)
+print("Words:", words)
+print("Filtered Tokens:", filtered)

nlpkit14/programs/q10.py

@@ -0,0 +1,41 @@
+# Question 10 (C3): Add-One (Laplace) Smoothing for an N-gram Model
+# Output below is the document example; actual model and website results may differ.
+# Expected output:
+# P(i|<s>) = 0.272727
+# P(like|i) = 0.300000
+# P(apples|like) = 0.200000
+# P(</s>|apples) = 0.300000
+# Vocabulary Size = 8
+# Add-One Sentence Probability = 0.00490909
+
+from collections import Counter
+
+corpus = [
+    ['i', 'like', 'apples'],
+    ['i', 'like', 'bananas'],
+    ['you', 'eat', 'apples']
+]
+
+unigrams = Counter()
+bigrams = Counter()
+
+for sentence in corpus:
+    tokens = ['<s>'] + sentence + ['</s>']
+    unigrams.update(tokens)
+    bigrams.update(zip(tokens[:-1], tokens[1:]))
+
+V = len(unigrams)   # vocabulary size including boundary tokens
+
+def add_one(w1, w2):
+    return (bigrams[(w1, w2)] + 1) / (unigrams[w1] + V)
+
+test = ['<s>', 'i', 'like', 'apples', '</s>']
+probability = 1.0
+
+for w1, w2 in zip(test[:-1], test[1:]):
+    p = add_one(w1, w2)
+    probability *= p
+    print(f"P({w2}|{w1}) = {p:.6f}")
+
+print("Vocabulary Size =", V)
+print("Add-One Sentence Probability =", round(probability, 8))

nlpkit14/programs/q11.py

@@ -0,0 +1,39 @@
+# Question 11 (C4): Calculate Good-Turing Frequency
+# Output below is the document example; actual model and website results may differ.
+# Raw Good-Turing adjusted frequencies only; this is not a normalized probability model.
+# Expected output:
+# r    C*(r)
+# -------------
+# 0    0.0
+# 1    1.3333
+# 2    1.5
+# 3    0.0
+
+from collections import Counter
+
+def good_turing(counts):
+    # counts contains observed frequencies of different events
+    freq_of_freq = Counter(counts)
+    max_r = max(freq_of_freq.keys())
+    adjusted_counts = {}
+
+    for r in range(0, max_r + 1):
+        Nr = freq_of_freq.get(r, 0)
+        Nr_plus_1 = freq_of_freq.get(r + 1, 0)
+
+        if Nr > 0:
+            c_star = (r + 1) * (Nr_plus_1 / Nr)
+            adjusted_counts[r] = round(c_star, 4)
+        else:
+            adjusted_counts[r] = 0.0
+
+    return adjusted_counts
+
+# 3 events occur once, 2 events occur twice, 1 event occurs 3 times
+sample_counts = [1, 1, 1, 2, 2, 3]
+result = good_turing(sample_counts)
+
+print(f"{'r':<5}{'C*(r)':<10}")
+print("-" * 13)
+for r in sorted(result):
+    print(f"{r:<5}{result[r]:<10}")

nlpkit14/programs/q12.py

@@ -0,0 +1,50 @@
+# Question 12 (C5): Text Classification
+# Output below is the document example; actual model and website results may differ.
+# Preserves the document example; fit the vectorizer on training data only for unbiased evaluation.
+# Expected output:
+# precision    recall  f1-score   support
+# 
+#       sports       0.00      0.00      0.00         2
+#   technology       0.33      1.00      0.50         1
+# 
+#     accuracy                           0.33         3
+#    macro avg       0.17      0.50      0.25         3
+# weighted avg       0.11      0.33      0.17         3
+
+from sklearn.feature_extraction.text import CountVectorizer
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import classification_report
+
+texts = [
+    "The CPU and memory are important in a computer",
+    "Basketball is a popular sport",
+    "Python and Java are programming languages",
+    "Football players need strength and speed",
+    "Hard disk and RAM are types of hardware",
+    "Tennis is played with a racket",
+    "Motherboard connects all components",
+    "He scored a goal in the last minute"
+]
+
+labels = [
+    "technology", "sports", "technology", "sports",
+    "technology", "sports", "technology", "sports"
+]
+
+# Convert text into Bag-of-Words vectors
+vectorizer = CountVectorizer()
+X = vectorizer.fit_transform(texts)
+
+# Train-test split
+X_train, X_test, y_train, y_test = train_test_split(
+    X, labels, test_size=0.3, random_state=42
+)
+
+# Train classifier
+clf = LogisticRegression()
+clf.fit(X_train, y_train)
+
+# Predict and evaluate
+y_pred = clf.predict(X_test)
+print(classification_report(y_test, y_pred, zero_division=0))

nlpkit14/programs/q13.py

@@ -0,0 +1,25 @@
+# Question 13 (C6): Calculate Vector Similarity in Semantic Space
+# Output below is the document example; actual model and website results may differ.
+# Expected output:
+# Semantic similarity between:
+# "Apples are tasty" and "Bananas are delicious" = 0.8661
+
+import spacy
+from sklearn.metrics.pairwise import cosine_similarity
+
+# Medium model contains pretrained vectors
+nlp = spacy.load("en_core_web_md")
+
+text1 = "Apples are tasty"
+text2 = "Bananas are delicious"
+
+doc1 = nlp(text1)
+doc2 = nlp(text2)
+
+vec1 = doc1.vector.reshape(1, -1)
+vec2 = doc2.vector.reshape(1, -1)
+
+similarity = cosine_similarity(vec1, vec2)[0][0]
+
+print(f'Semantic similarity between:')
+print(f'"{text1}" and "{text2}" = {similarity:.4f}')

nlpkit14/programs/q14.py

@@ -0,0 +1,40 @@
+# Question 14 (C7): Identify Context of Ambiguous Words using BERT
+# Output below is the document example; actual model and website results may differ.
+# Expected output:
+# Sentence 1: He sat on the river bank and watched the water flow.
+# Sentence 2: She went to the bank to deposit some money.
+# Contextual similarity of 'bank': 0.4972
+
+from transformers import BertTokenizer, BertModel
+import torch
+from sklearn.metrics.pairwise import cosine_similarity
+
+# Load pretrained BERT
+tokenizer = BertTokenizer.from_pretrained('bert-base-uncased', local_files_only=True)
+model = BertModel.from_pretrained('bert-base-uncased', local_files_only=True)
+model.eval()
+
+sent1 = "He sat on the river bank and watched the water flow."
+sent2 = "She went to the bank to deposit some money."
+
+def get_word_embedding(sentence, target_word):
+    inputs = tokenizer(sentence, return_tensors='pt')
+
+    with torch.no_grad():
+        outputs = model(**inputs)
+
+    tokens = tokenizer.convert_ids_to_tokens(inputs['input_ids'][0])
+    embeddings = outputs.last_hidden_state.squeeze(0)
+
+    # Find token position
+    idx = tokens.index(target_word)
+    return embeddings[idx].numpy()
+
+embedding1 = get_word_embedding(sent1, "bank")
+embedding2 = get_word_embedding(sent2, "bank")
+
+similarity = cosine_similarity([embedding1], [embedding2])[0][0]
+
+print("Sentence 1:", sent1)
+print("Sentence 2:", sent2)
+print("Contextual similarity of 'bank':", round(similarity, 4))

nlpkit14/programs/q2.py

@@ -0,0 +1,33 @@
+# Question 2 (B2): Tokenization and Stop-word Removal using spaCy
+# Output below is the document example; actual model and website results may differ.
+# Expected output:
+# Sentences: ['This is an example sentence, demonstrating tokenization and stop word removal.']
+# Tokens: ['This', 'is', 'an', 'example', 'sentence', ',', 'demonstrating', 'tokenization', 'and', 'stop', 'word', 'removal', '.']
+# Filtered Tokens: ['example', 'sentence', 'demonstrating', 'tokenization', 'stop', 'word', 'removal']
+
+import spacy
+
+# Load spaCy English model
+nlp = spacy.load("en_core_web_sm")
+
+# Sample text
+text = "This is an example sentence, demonstrating tokenization and stop word removal."
+
+# Process text
+Doc = nlp(text)
+
+# Sentence tokenization
+sentences = [sent.text for sent in Doc.sents]
+
+# Word tokenization
+tokens = [token.text for token in Doc]
+
+# Remove stop words and punctuation
+filtered_tokens = [
+    token.text for token in Doc
+    if not token.is_stop and not token.is_punct
+]
+
+print("Sentences:", sentences)
+print("Tokens:", tokens)
+print("Filtered Tokens:", filtered_tokens)

nlpkit14/programs/q3.py

@@ -0,0 +1,29 @@
+# Question 3 (B3): Stemming and Lemmatization using spaCy
+# Output below is the document example; actual model and website results may differ.
+# Expected output:
+# Original Words   : ['Studies', 'studying', 'cries', 'cried', 'flying', 'flies']
+# Lemmatized Words : ['study', 'study', 'cry', 'cry', 'fly', 'fly']
+# Stemmed Words    : ['studi', 'studi', 'cri', 'cri', 'fli', 'fli']
+
+import spacy
+from nltk.stem import PorterStemmer
+
+# Load spaCy model and create stemmer
+nlp = spacy.load("en_core_web_sm")
+stemmer = PorterStemmer()
+
+sentence = "Studies studying cries cried flying flies"
+doc = nlp(sentence)
+
+# Original tokens
+original_words = [token.text for token in doc]
+
+# Lemmatization using spaCy
+lemmatized_words = [token.lemma_ for token in doc]
+
+# Stemming on spaCy tokens
+stemmed_words = [stemmer.stem(token.text) for token in doc]
+
+print("Original Words   :", original_words)
+print("Lemmatized Words :", lemmatized_words)
+print("Stemmed Words    :", stemmed_words)

nlpkit14/programs/q4.py

@@ -0,0 +1,44 @@
+# Question 4 (B4): Stemming and Lemmatization using NLTK
+# Output below is the document example; actual model and website results may differ.
+# Expected output:
+# Original Words: ['Studies', 'studying', 'cries', 'cried', 'flying', 'flies']
+# Stemmed Words : ['studi', 'studi', 'cri', 'cri', 'fli', 'fli']
+# Lemmatized Words: ['Studies', 'study', 'cry', 'cry', 'fly', 'fly']
+
+import nltk
+from nltk.tokenize import word_tokenize
+from nltk.stem import PorterStemmer, WordNetLemmatizer
+from nltk.corpus import wordnet
+
+# Resource download moved to n.setup().
+# Resource download moved to n.setup().
+# Resource download moved to n.setup().
+# Resource download moved to n.setup().
+stemmer = PorterStemmer()
+lemmatizer = WordNetLemmatizer()
+
+# Map Treebank POS tag to WordNet POS
+def get_wordnet_pos(tag):
+    if tag.startswith('J'):
+        return wordnet.ADJ
+    elif tag.startswith('V'):
+        return wordnet.VERB
+    elif tag.startswith('N'):
+        return wordnet.NOUN
+    elif tag.startswith('R'):
+        return wordnet.ADV
+    return wordnet.NOUN
+
+text = "Studies studying cries cried flying flies"
+tokens = word_tokenize(text)
+tagged = nltk.pos_tag(tokens)
+
+stems = [stemmer.stem(word) for word in tokens]
+lemmas = [
+    lemmatizer.lemmatize(word, get_wordnet_pos(tag))
+    for word, tag in tagged
+]
+
+print("Original Words:", tokens)
+print("Stemmed Words :", stems)
+print("Lemmatized Words:", lemmas)

nlpkit14/programs/q5.py

@@ -0,0 +1,33 @@
+# Question 5 (B5): Design a Python Program to Illustrate Corpus
+# Output below is the document example; actual model and website results may differ.
+# Expected output:
+# --- Document 1 ---
+# Tokens: ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog', '.']
+# POS Tags: [('The', 'DET'), ('quick', 'ADJ'), ('brown', 'ADJ'), ('fox', 'NOUN'), ('jumps', 'VERB'), ('over', 'ADP'), ('the', 'DET'), ('lazy', 'ADJ'), ('dog', 'NOUN'), ('.', 'PUNCT')]
+# 
+# --- Document 2 ---
+# Tokens: ['SpaCy', 'is', 'a', 'popular', 'NLP', 'library', 'in', 'Python', '.']
+# 
+# --- Document 3 ---
+# Tokens: ['Natural', 'Language', 'Processing', 'enables', 'machines', 'to', 'understand', 'human', 'language', '.']
+
+import spacy
+
+nlp = spacy.load("en_core_web_sm")
+
+# A small corpus: collection of documents
+corpus = [
+    "The quick brown fox jumps over the lazy dog.",
+    "SpaCy is a popular NLP library in Python.",
+    "Natural Language Processing enables machines to understand human language."
+]
+
+for i, text in enumerate(corpus, start=1):
+    print(f"\n--- Document {i} ---")
+    doc = nlp(text)
+
+    tokens = [token.text for token in doc]
+    pos_tags = [(token.text, token.pos_) for token in doc]
+
+    print("Tokens:", tokens)
+    print("POS Tags:", pos_tags)

nlpkit14/programs/q6.py

@@ -0,0 +1,43 @@
+# Question 6 (B6): Generate a Constituency Parse Tree
+# Output below is the document example; actual model and website results may differ.
+# Expected output:
+# Parse String:
+# (S (NP (DT The) (JJ quick) (JJ brown) (NN fox))
+#    (VP (VBZ jumps)
+#        (PP (IN over) (NP (DT the) (JJ lazy) (NN dog))))
+#    (. .))
+# 
+# Pretty Tree:
+#                       S
+#        _______________|__________________________
+#       |                         VP               |
+#       |                _________|___             |
+#       NP              |             PP           |
+#   ____|__________     |     ________|___         |
+#  DT   JJ    JJ   NN  VBZ   IN   DT      JJ   NN  .
+#  The quick brown fox jumps over the     lazy dog  .
+
+# Run once if required:
+# !pip install spacy benepar
+# !python -m spacy download en_core_web_sm
+
+import spacy
+import benepar
+import nltk
+
+# Model download moved to n.setup(models=True).
+nlp = spacy.load("en_core_web_sm")
+
+if not nlp.has_pipe("benepar"):
+    nlp.add_pipe("benepar", config={"model": "benepar_en3"})
+
+sentence = "The quick brown fox jumps over the lazy dog."
+doc = nlp(sentence)
+
+for sent in doc.sents:
+    parse_string = sent._.parse_string
+    print("Parse String:\n", parse_string)
+
+    tree = nltk.Tree.fromstring(parse_string)
+    print("\nPretty Tree:")
+    tree.pretty_print()

nlpkit14/programs/q7.py

@@ -0,0 +1,31 @@
+# Question 7 (B7): Generate a Dependency Parse Tree
+# Output below is the document example; actual model and website results may differ.
+# Expected output:
+# Word: The      POS: DET    Head: team     Dep: det
+# Word: cricket  POS: NOUN   Head: team     Dep: compound
+# Word: team     POS: NOUN   Head: won      Dep: nsubj
+# Word: won      POS: VERB   Head: won      Dep: ROOT
+# Word: the      POS: DET    Head: match    Dep: det
+# Word: match    POS: NOUN   Head: won      Dep: dobj
+# Word: in       POS: ADP    Head: won      Dep: prep
+# Word: Mumbai   POS: PROPN  Head: in       Dep: pobj
+# Word: .        POS: PUNCT  Head: won      Dep: punct
+
+import spacy
+from spacy import displacy
+
+nlp = spacy.load("en_core_web_sm")
+sentence = "The cricket team won the match in Mumbai."
+doc = nlp(sentence)
+
+# Print dependency information
+for token in doc:
+    print(
+        f"Word: {token.text:8} "
+        f"POS: {token.pos_:6} "
+        f"Head: {token.head.text:8} "
+        f"Dep: {token.dep_}"
+    )
+
+# In Jupyter / Colab
+# displacy.render(doc, style="dep", jupyter=True)

nlpkit14/programs/q8.py

@@ -0,0 +1,39 @@
+# Question 8 (C1): POS Tagging on Text Scraped from a Website
+# Output below is the document example; actual model and website results may differ.
+# Expected output:
+# POS Tags (sample):
+# [('B.N.M', 'NNP'), ('Institute', 'NNP'), ('of', 'IN'),
+#  ('Technology', 'NNP'), ('is', 'VBZ'), ('one', 'CD'),
+#  ('of', 'IN'), ('the', 'DT'), ('top', 'JJ'),
+#  ('engineering', 'NN'), ('colleges', 'NNS'), ...]
+
+import requests
+from bs4 import BeautifulSoup
+import nltk
+
+# Resource download moved to n.setup().
+# Resource download moved to n.setup().
+def scrape_text(url):
+    response = requests.get(url, timeout=10)
+    response.raise_for_status()
+    soup = BeautifulSoup(response.content, 'html.parser')
+
+    # Remove scripts and styles
+    for item in soup(['script', 'style']):
+        item.extract()
+
+    return soup.get_text(separator=' ')
+
+def pos_tag_text(text):
+    tokens = nltk.word_tokenize(text)
+    return nltk.pos_tag(tokens)
+
+url = "https://www.bnmit.org/"
+scraped_text = scrape_text(url)
+pos_tags = pos_tag_text(scraped_text)
+
+print("Scraped Text (first 300 characters):")
+print(scraped_text[:300])
+
+print("\nPOS Tags (first 30 tokens):")
+print(pos_tags[:30])

nlpkit14/programs/q9.py

@@ -0,0 +1,36 @@
+# Question 9 (C2): Implement a Bigram Model and Calculate Test-Sentence Probability
+# Output below is the document example; actual model and website results may differ.
+# Expected output:
+# P(i|<s>) = 2/3 = 0.666667
+# P(like|i) = 2/2 = 1.000000
+# P(apples|like) = 1/2 = 0.500000
+# P(</s>|apples) = 2/2 = 1.000000
+# Sentence Probability = 0.33333333
+
+from collections import Counter
+
+# Training corpus
+corpus = [
+    ['i', 'like', 'apples'],
+    ['i', 'like', 'bananas'],
+    ['you', 'eat', 'apples']
+]
+
+unigrams = Counter()
+bigrams = Counter()
+
+for sentence in corpus:
+    tokens = ['<s>'] + sentence + ['</s>']
+    unigrams.update(tokens)
+    bigrams.update(zip(tokens[:-1], tokens[1:]))
+
+# Test sentence
+test = ['<s>', 'i', 'like', 'apples', '</s>']
+probability = 1.0
+
+for w1, w2 in zip(test[:-1], test[1:]):
+    p = bigrams[(w1, w2)] / unigrams[w1]
+    probability *= p
+    print(f"P({w2}|{w1}) = {bigrams[(w1,w2)]}/{unigrams[w1]} = {p:.6f}")
+
+print("Sentence Probability =", round(probability, 8))

nlpkit14/questions.json

@@ -0,0 +1,72 @@
+[
+  {
+    "number": 1,
+    "label": "B1",
+    "question": "Tokenization and Stop-word Removal using NLTK"
+  },
+  {
+    "number": 2,
+    "label": "B2",
+    "question": "Tokenization and Stop-word Removal using spaCy"
+  },
+  {
+    "number": 3,
+    "label": "B3",
+    "question": "Stemming and Lemmatization using spaCy"
+  },
+  {
+    "number": 4,
+    "label": "B4",
+    "question": "Stemming and Lemmatization using NLTK"
+  },
+  {
+    "number": 5,
+    "label": "B5",
+    "question": "Design a Python Program to Illustrate Corpus"
+  },
+  {
+    "number": 6,
+    "label": "B6",
+    "question": "Generate a Constituency Parse Tree"
+  },
+  {
+    "number": 7,
+    "label": "B7",
+    "question": "Generate a Dependency Parse Tree"
+  },
+  {
+    "number": 8,
+    "label": "C1",
+    "question": "POS Tagging on Text Scraped from a Website"
+  },
+  {
+    "number": 9,
+    "label": "C2",
+    "question": "Implement a Bigram Model and Calculate Test-Sentence Probability"
+  },
+  {
+    "number": 10,
+    "label": "C3",
+    "question": "Add-One (Laplace) Smoothing for an N-gram Model"
+  },
+  {
+    "number": 11,
+    "label": "C4",
+    "question": "Calculate Good-Turing Frequency"
+  },
+  {
+    "number": 12,
+    "label": "C5",
+    "question": "Text Classification"
+  },
+  {
+    "number": 13,
+    "label": "C6",
+    "question": "Calculate Vector Similarity in Semantic Space"
+  },
+  {
+    "number": 14,
+    "label": "C7",
+    "question": "Identify Context of Ambiguous Words using BERT"
+  }
+]

nlpkit14-0.3.0.dist-info/METADATA

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: nlpkit14
+Version: 0.3.0
+Summary: Execute fourteen NLP practical programs with commented source and expected outputs
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: nltk<4,>=3.9
+Requires-Dist: spacy<4,>=3.8
+Requires-Dist: scikit-learn<2,>=1.5
+Requires-Dist: requests<3,>=2.32
+Requires-Dist: beautifulsoup4<5,>=4.12
+Provides-Extra: models
+Requires-Dist: torch<3,>=2.4; extra == "models"
+Requires-Dist: transformers<5,>=4.45; extra == "models"
+Requires-Dist: benepar<0.3,>=0.2.0; extra == "models"
+Requires-Dist: sentencepiece<1,>=0.2; extra == "models"
+
+# nlpkit14 0.3.0
+
+Run the fourteen programs from the supplied IA1 question/code/output document.
+
+```python
+import nlpkit14 as n
+n.q1()       # Actually runs question 1 and prints computed output
+n.source(1)  # Shows the code, question and expected output as comments
+n.questions()
+```
+
+Question numbers 1–7 are B1–B7. Numbers 8–14 are C1–C7. The question, expected output, and extra notes are comments in each bundled standalone Python program. Exercise calls print only the program's output. No expected-output text is substituted for model computation.
+
+## Install and prepare online once
+
+Install the shared wheel, then prepare the basic data and spaCy model:
+
+```sh
+python -m pip install ./nlpkit14-0.3.0-py3-none-any.whl
+python -c "import nlpkit14 as n; n.setup()"
+```
+
+For all exercises, install the model extra and run the complete setup (large downloads):
+
+```sh
+python -m pip install './nlpkit14-0.3.0-py3-none-any.whl[models]'
+python -c "import nlpkit14 as n; n.setup(models=True)"
+```
+
+This is a local release of the new nlpkit14 project, not yet uploaded to PyPI. Do not use pip install nlpkit14 until publication succeeds.
+
+## Offline installation
+
+On an internet-connected machine with the SAME OS, architecture and Python version as the offline machine, download the wheel and dependencies:
+
+```sh
+python -m pip download --dest wheelhouse './nlpkit14-0.3.0-py3-none-any.whl[models]'
+```
+
+Install and run setup online on that matching machine. Copy the wheelhouse, both installed spaCy model packages (or their installation wheels), and the full data/cache folder to the offline machine. Model data defaults to ~/.nlpkit14; set NLPKIT14_DATA before setup/import to choose a portable folder. Copying the entire prepared Python environment is platform specific; do not copy a Mac environment to Windows.
+
+On the offline computer:
+
+```sh
+python -m pip install --no-index --find-links=wheelhouse nlpkit14==0.3.0
+```
+
+Install the spaCy model wheels from local storage too. Keep the copied data folder at ~/.nlpkit14 or point NLPKIT14_DATA to it. Model and dependency archives are not included in this small library wheel.
+
+q8 fetches https://www.bnmit.org/ and requires internet even after setup. Other exercises can run without internet after all their requirements are installed. No downloads run implicitly from q1–q14. Missing packages/data raise their real installation errors rather than producing fake results.
+
+## Output fidelity
+
+The original algorithms and sample input are preserved. Downloads are moved to explicit setup. HTTP errors are checked. BERT uses evaluation mode and local cached model files. The raw Good–Turing demonstration is not a normalized probability estimator. The document's classifier fits its vocabulary before splitting and is an educational example, not an unbiased evaluation pipeline. Model outputs, parse trees, POS tags and similarity values can differ from the commented reference output. The document's B5 reference omits POS lines that the code actually prints. Read TEST_RESULTS.md for exactly which programs were executed.

nlpkit14-0.3.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+nlpkit14/__init__.py,sha256=2EHXNbGUKxx4Ye2c9TZadt7fsOQarGe_GPX0gb5QToQ,2869
+nlpkit14/questions.json,sha256=CVPEhmk-O3BZHxDaaZrna7XHzea7R6RzknIH_7Guozk,1473
+nlpkit14/programs/q1.py,sha256=ahswJa7pL7JWeAqtc5RGZte_oZLlcZflAa-j_ieVHfA,1183
+nlpkit14/programs/q10.py,sha256=tWRjvc7hD0zLTFvLvjIHdVb5wXRqmttd_-3SWCElrWU,1086
+nlpkit14/programs/q11.py,sha256=BfLYiyaxQWRQo19vZ7PUJX5sLTonacctVH3noalhWC8,1105
+nlpkit14/programs/q12.py,sha256=RZws0e4PfZ7rtiLXTCX317ghaAEBcDpcuz6qHGlMHI4,1694
+nlpkit14/programs/q13.py,sha256=1ERbF9xHdwOfb37lBjwZhSfVR-ibNtMaqmbyseykGIo,716
+nlpkit14/programs/q14.py,sha256=vvkdMsJDpdfkenX1qNef_e7t53hy-1BDxvY8Chktx6c,1443
+nlpkit14/programs/q2.py,sha256=9bLonO1zS8TIeGCKxPy6eJ1mLY-wlResFXz2EjAAew8,1082
+nlpkit14/programs/q3.py,sha256=AH0krQLuUe0yI5y5YN7ps0qAJsC2nK3A8D47fCbS3ik,974
+nlpkit14/programs/q4.py,sha256=xu6Jow4Fqn7vpMSOTeJ3qOlaZQEkFzcuWQdUWr31mdM,1406
+nlpkit14/programs/q5.py,sha256=98wjuG9qh-zP2_9c8YuAHTrEFqA_aJJDk00v6bpMIs4,1261
+nlpkit14/programs/q6.py,sha256=we8-i04A-H48UGQE7TKdqPhLqwSSWbHmmnD2clC6H4s,1330
+nlpkit14/programs/q7.py,sha256=1f6olq4RaJmygdkpesVXMNRb6tFq0Kq4fQrO_ohXf_Y,1069
+nlpkit14/programs/q8.py,sha256=PZWqzAkHKx84PcLhx6zIRi50Xvk8_yCYqVQKPlKi0dw,1167
+nlpkit14/programs/q9.py,sha256=DjlgwamtvDwvfZzDSRy4vnJazY41-5r7b7wH4Nsjq_Y,1002
+nlpkit14-0.3.0.dist-info/METADATA,sha256=izsROo-CFlx30m35clCpACTZzEuE-HkClFg7AhpqvAQ,3701
+nlpkit14-0.3.0.dist-info/WHEEL,sha256=16fc_9Rp854SLcdhaDEjr0u65p0e3FhZxihNgcnCE98,91
+nlpkit14-0.3.0.dist-info/top_level.txt,sha256=DDWqq9h6vlXFiGvftng11Hx_I1Nfge5RFEqR2HfxNVE,9
+nlpkit14-0.3.0.dist-info/RECORD,,

nlpkit14-0.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

nlpkit14-0.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+nlpkit14