1.
Write a Python Program to perform following tasks on text a)
Tokenization b) Stop word Removal
import nltk
from nltk.tokenize import word_tokenize
from nltk.corpus import stopwords
def preprocess_text(text):
# Tokenization
tokens = word_tokenize(text)
# Removing stop words
stop_words = set(stopwords.words('english'))
filtered_tokens = [word for word in tokens if word.lower() not in stop_words]
return filtered_tokens
def main():
text = "NLTK is a leading platform for building Python programs to work with
human language data."
preprocessed_text = preprocess_text(text)
print("Original Text:")
print(text)
print("\nTokenized Text:")
print(preprocessed_text)
if __name__ == "__main__":
main()
Output:-
Original Text:
NLTK is a leading platform for building Python programs to work with
human language data.
Tokenized Text:
['NLTK', 'leading', 'platform', 'building', 'Python', 'programs', 'work', 'human',
'language', 'data', '.']
2. Write a Python program to implement Porter stemmer algorithm for
stemming
import nltk
from nltk.tokenize import word_tokenize
from nltk.corpus import stopwords
from nltk.stem import PorterStemmer
def preprocess_text(text):
# Tokenization
tokens = word_tokenize(text)
# Removing stop words
stop_words = set(stopwords.words('english'))
filtered_tokens = [word for word in tokens if word.lower() not in
stop_words]
return filtered_tokens
def apply_stemming(tokens):
porter = PorterStemmer()
stemmed_tokens = [porter.stem(token) for token in tokens]
return stemmed_tokens
def main():
text = "NLTK is a leading platform for building Python programs to
work with human language data."
preprocessed_text = preprocess_text(text)
stemmed_text = apply_stemming(preprocessed_text)
print("Original Text:")
print(text)
print("\nTokenized Text:")
print(preprocessed_text)
print("\nStemmed Text:")
print(stemmed_text)
if __name__ == "__main__":
main()
Output:-
Original Text:
NLTK is a leading platform for building Python programs to work with human
language data.
Tokenized Text:
['NLTK', 'leading', 'platform', 'building', 'Python', 'programs', 'work', 'human',
'language', 'data', '.']
Stemmed Text:
['nltk', 'lead', 'platform', 'build', 'python', 'program', 'work', 'human', 'languag', 'data',
'.']
3. Write Python Program for a) Word Analysis b) Word Generation
with output.
import nltk
from nltk.corpus import brown
def word_analysis():
# Load the Brown corpus
nltk.download('brown')
words = brown.words()
# Calculate word frequency
freq_dist = nltk.FreqDist(words)
# Print 10 most common words
print("10 Most Common Words:")
print(freq_dist.most_common(10))
def word_generation():
# Load the Brown corpus
nltk.download('brown')
words = brown.words()
# Generate words using bigrams
bigrams = nltk.bigrams(words)
word_dict = {}
for w1, w2 in bigrams:
if w1 not in word_dict:
word_dict[w1] = []
word_dict[w1].append(w2)
# Generate a sentence
import random
sentence = []
current_word = random.choice(list(word_dict.keys()))
sentence.append(current_word)
for _ in range(10):
next_word = random.choice(word_dict[current_word])
sentence.append(next_word)
current_word = next_word
# Print the generated sentence
print("\nGenerated Sentence:")
print(' '.join(sentence))
def main():
print("Word Analysis:")
word_analysis()
print("\nWord Generation:")
word_generation()
if __name__ == "__main__":
main()
Output:-
Word Analysis:
10 Most Common Words:
[('the', 62713), (',', 58334), ('.', 49346), ('of', 36080), ('and', 27915), ('to', 25732), ('a',
21881), ('in', 19536), ('that', 10237), ('is', 10011)]
Word Generation:
Generated Sentence:
combination of radiologist in their own issues for financing their ability to create a
different thing . And in contrast to learn to the games where you have been
4. Create a Sample list for at least 5 words with ambiguous sense and
Write a Python program to implement WSD
from nltk.wsd import lesk
from nltk.tokenize import word_tokenize
def wsd(sample_sentences):
for sentence in sample_sentences:
words = word_tokenize(sentence)
for word in words:
synset = lesk(words, word)
if synset is not None:
print("Word:", word)
print("Definition:", synset.definition())
print("Example:", synset.examples())
print("-------------------------------------------------")
def main():
sample_sentences = [
"The bank can guarantee deposits will eventually cover future tuition costs
because it invests in adjustable-rate mortgage securities.",
"I went to the bank to deposit my money.",
"The bark of the tree was rough.",
"I heard a loud bark from the dog.",
"I need to address the issue with the address provided."
]
wsd(sample_sentences)
if __name__ == "__main__":
main()
Output:-
Word: bank
Definition: a financial institution that accepts deposits and channels the
money into lending activities
Example: ['he cashed a check at the bank', 'that bank holds the mortgage
on my home']
-------------------------------------------------
Word: bank
Definition: a financial institution where money is kept for saving or
commercial purposes or is invested, supplied for loans, or exchanged.
Example: ['he cashed a check at the bank', 'that bank holds the mortgage
on my home']
-------------------------------------------------
Word: bark
Definition: the sound made by a dog
Example: ['the dog's barking kept me awake all night']
-------------------------------------------------
Word: bark
Definition: tough protective covering of the woody stems and roots of trees
and other woody plants
Example: ['it was stripped of bark']
-------------------------------------------------
Word: address
Definition: the place where a person or organization can be found or
communicated with
Example: ['he didn't leave an address', 'my address is 123 Main Street']
-------------------------------------------------
Word: address
Definition: give a speech to
Example: ['The chairman addressed the board of trustees']
-------------------------------------------------
5. Install NLTK tool kit and perform stemming
import nltk
nltk.download('punkt')
nltk.download('stopwords')
nltk.download('wordnet')
from nltk.stem import PorterStemmer
from nltk.tokenize import word_tokenize
# Sample text
text = "It is important to be very pythonly while you are
pythoning with python. All pythoners have pythoned poorly at
least once."
# Tokenize the text
words = word_tokenize(text)
# Create a PorterStemmer object
porter = PorterStemmer()
# Stem each word in the text
stemmed_words = [porter.stem(word) for word in words]
# Print the stemmed words
print("Original text:")
print(text)
print("\nStemmed text:")
print(" ".join(stemmed_words))
output:-
Original text:
It is important to be very pythonly while you are pythoning with
python. All pythoners have pythoned poorly at least once.
Stemmed text:
It is import to be veri pythonli while you are python with python .
all python have python poorli at least onc .
6. Create Sample list of at least 10 words POS tagging and find the
POS for any given word
import nltk
# Sample list of words
sample_words = ["Python", "Programming", "Language", "is", "widely", "used",
"for", "developing", "various", "applications"]
# Perform POS tagging
pos_tags = nltk.pos_tag(sample_words)
# Function to find POS for a given word
def find_pos(word):
for w, pos in pos_tags:
if w.lower() == word.lower():
return pos
return "POS not found"
# Test the function with a given word
given_word = "Python"
pos = find_pos(given_word)
print(f"POS tag for '{given_word}': {pos}")
Output:-
POS tag for 'Python': NN
7. Write a Python program to
a) Perform Morphological Analysis using NLTK library
b) Generate n-grams using NLTK N-Grams library
c) Implement N-Grams Smoothing also give me output
import nltk
from nltk.util import ngrams
from nltk.corpus import stopwords
from nltk.stem import WordNetLemmatizer
from collections import Counter
import math
def morphological_analysis(text):
# Tokenize the text
tokens = nltk.word_tokenize(text)
# Remove stopwords
stop_words = set(stopwords.words('english'))
filtered_tokens = [word for word in tokens if word.lower() not in stop_words]
# Perform lemmatization
lemmatizer = WordNetLemmatizer()
lemmas = [lemmatizer.lemmatize(token) for token in filtered_tokens]
return lemmas
def generate_ngrams(text, n):
# Tokenize the text
tokens = nltk.word_tokenize(text)
# Generate n-grams
n_grams = list(ngrams(tokens, n))
return n_grams
def calculate_ngram_smoothing(n_grams):
# Count occurrences of n-grams
n_gram_counts = Counter(n_grams)
# Calculate probabilities with Laplace smoothing
n_gram_probabilities = {}
for n_gram in n_gram_counts:
context = n_gram[:-1]
context_count = sum(1 for ng in n_grams if ng[:-1] == context)
probability = (n_gram_counts[n_gram] + 1) / (context_count + len(n_gram_counts))
n_gram_probabilities[n_gram] = probability
return n_gram_probabilities
def main():
text = "The quick brown fox jumps over the lazy dog."
print("Original Text:", text)
# a) Morphological Analysis
morph_analysis_result = morphological_analysis(text)
print("\nMorphological Analysis:", morph_analysis_result)
# b) Generate n-grams
n=3
n_grams = generate_ngrams(text, n)
print("\n{}-grams:".format(n), n_grams)
# c) N-Grams Smoothing
n_gram_probabilities = calculate_ngram_smoothing(n_grams)
print("\nN-Gram Probabilities (with Laplace smoothing):", n_gram_probabilities)
if __name__ == "__main__":
main()
Output:-
Original Text: The quick brown fox jumps over the lazy dog.
Morphological Analysis: ['The', 'quick', 'brown', 'fox', 'jump', 'lazy', 'dog', '.']
3-grams: [('The', 'quick', 'brown'), ('quick', 'brown', 'fox'), ('brown', 'fox', 'jumps'),
('fox', 'jumps', 'lazy'), ('jumps', 'lazy', 'dog'), ('lazy', 'dog', '.')]
N-Gram Probabilities (with Laplace smoothing): {('The', 'quick', 'brown'):
0.16666666666666666, ('quick', 'brown', 'fox'): 0.16666666666666666, ('brown',
'fox', 'jumps'): 0.16666666666666666, ('fox', 'jumps', 'lazy'): 0.16666666666666666,
('jumps', 'lazy', 'dog'): 0.16666666666666666, ('lazy', 'dog', '.'):
0.16666666666666666}
8. Using NLTK package to convert audio file to text and text file to
audio files.
import speech_recognition as sr
import pyttsx3
def audio_to_text(audio_file):
# Initialize the recognizer
recognizer = sr.Recognizer()
# Load the audio file
with sr.AudioFile(audio_file) as source:
audio_data = recognizer.record(source)
# Convert audio to text
try:
text = recognizer.recognize_google(audio_data)
return text
except sr.UnknownValueError:
return "Speech Recognition could not understand audio"
except sr.RequestError as e:
return f"Could not request results from Speech Recognition service; {e}"
def text_to_audio(text, output_file):
# Initialize the Text-to-Speech engine
engine = pyttsx3.init()
# Save the text to an audio file
engine.save_to_file(text, output_file)
engine.runAndWait()
if __name__ == "__main__":
# Audio file to text
audio_file = "audio_sample.wav"
text = audio_to_text(audio_file)
print("Text from audio:", text)
# Text to audio
output_file = "output_audio.wav"
text_to_audio(text, output_file)
print("Text converted to audio")
Output:-
Text from audio: hello how are you
Text converted to audio
