NLP

PROGRAM 1

import nltk

from nltk.tokenize import sent_tokenize, word_tokenize

text = " If you drive to the sun at 55 mph, it would take you about 193 years"

print(sent_tokenize(text))

print(word_tokenize(text))

OUTPUT :

PROGRAM 2

from nltk.corpus import stopwords

from nltk.tokenize import word_tokenize

example_sent = """This is a sample sentence,

showing off the stop words filtration."""

stop_words = set(stopwords.words('english'))

word_tokens = word_tokenize(example_sent)

filtered_sentence = [w for w in word_tokens if not w.lower() in stop_words]

filtered_sentence = []

for w in word_tokens:

if w not in stop_words:

filtered_sentence.append(w)

print(word_tokens)

print(filtered_sentence)

OUTPUT :
PROGRAM 3

from nltk.stem import WordNetLemmatizer

lemmatizer = WordNetLemmatizer()

print("rocks :", lemmatizer.lemmatize("rocks"))

print("corpora :", lemmatizer.lemmatize("corpora"))

print("better :", lemmatizer.lemmatize("better", pos="a"))

OUTPUT :

PROGRAM 4

from nltk.stem import PorterStemmer

from nltk.tokenize import word_tokenize

ps = PorterStemmer()

words = ["likes","liked","likely","liking"]

for w in words:

print(w,":",ps.stem(w))

OUTPUT :

PROGRAM 5

from nltk.corpus import wordnet

list1 = ['Compare', 'require']

list2 = ['choose', 'copy']

list = []

for word1 in list1:

for word2 in list2:

wordFromList2 = wordnet.synsets(word2)[0]

s = wordFromList1.wup_similarity(wordFromList2)

list.append(s)

print(max(list))

OUTPUT :

PROGRAM 6

import nltk

from nltk import word_tokenize, pos_tag, ne_chunk

def extract_named_entities(text):

words = word_tokenize(text)

pos_tags = pos_tag(words)

named_entities = ne_chunk(pos_tags)

return named_entities

text ="Albert Einsten was born in Germany. He was awareded the nobel prize in physics in 1921"

named_entities = extract_named_entities(text)

named_entities.draw()

OUTPUT :
PROGRAM 7

import nltk

from nltk.sentiment.vader import SentimentIntensityAnalyzer

def analyse_sentiment(text):

sid = SentimentIntensityAnalyzer()

sentiment_score = sid.polarity_scores(text)

return sentiment_score

text = "I love this product! it is a"

sentiment_scores = analyse_sentiment(text)

print(f"Sentiment scores : {sentiment_scores}")

OUTPUT :

PROGRAM 8

from gtts import gTTS

import os

def text_to_speech(text, lang='en'):

tts = gTTS(text=text, lang=lang)

tts.save("output.mp3")

os.system("start output.mp3")

if __name__ == "__main__":

text = "Hello, this is a text-to-speech conversion example."

text_to_speech(text)

OUTPUT :
PROGRAM 9

import speech_recognition as sr

recognizer = sr.Recognizer()

def audio_file_to_text (file_path):

with sr.AudioFile(file_path) as source:

audio_data = recognizer.record(source)

try:

text = recognizer.recognize_google(audio_data)

print('transcription:{}'.format(text))

except sr.UnknownValueError:

print("Sorry, I couldn't understand")

except sr.RequestError:

print("couldn't request results from google speech recognition service")

audio_file_path ="Y:/ttsMP3.com_VoiceText_2025-1-29_11-40-18.wav"

audio_file_to_text(audio_file_path)

OUTPUT :

PROGRAM 10

import nltk

from nltk.chat.util import Chat, reflections

pairs = [

r"my name is (.*)",

["Hello %1, how can I help you today?",]

],

r"hi|hello|hey",

["Hello!", "Hi there!", "Hey!"]

],
 [

r"what is your name?",

["I am a chatbot created using NLTK.",]

],

r"how are you?",

["I'm doing well, thank you!", "I'm great, how about you?"]

],

r"sorry (.*)",

["It's okay, no worries.", "No problem at all."]

],

r"quit",

["Goodbye! Have a great day!"]

],

chatbot = Chat(pairs, reflections)

print("Hi! I'm a chatbot. Type 'quit' to exit.")

chatbot.converse()

OUTPUT :
PROGRAM 12

import re

emails = [

"1.Congratulation you've won a free iPhone click here to claim now",

"2.Dear customer, your bank account needs verification",

"3.Meeting at 5pm, please be on time",

"4.Win $10,000 easily! just sign up now"

spam_keywords = ["click here", "win", "verification"]

def filter_spam(emails, keywords):

return [email for email in emails if any(re.search(keyword, email, re.IGNORECASE) for keyword in
keywords)]

spam_emails = filter_spam(emails, spam_keywords)

print("Spam Emails:")

for email in spam_emails:

print(email)

OUTPUT :

PROGRAM 13

import nltk

from nltk.corpus import stopwords

from nltk.tokenize import word_tokenize

from nltk.stem import PorterStemmer, WordNetLemmatizer

import re

# Sample text

text = "This is a Sample Sentence.!!"

print(text)

# Lowercase
text = text.lower()

# Remove punctuation

removepun_text = re.sub(r'[^\w\s]', '', text)

# Tokenize

tokenize_text = word_tokenize(text)

# Remove stopwords

stop_words = set(stopwords.words('english'))

words = [word for word in tokenize_text if word not in stop_words]

# Stemming

ps = PorterStemmer()

word = ["Likes","Liking","Liked"]

stemmed_words = [ps.stem(word) for word in word]

# Lemmatization

lemmatizer = WordNetLemmatizer()

word1 = ["rocks","corpora"]

lemmatized_words = [lemmatizer.lemmatize(word) for word in word1]

print("Lower Text:",text)

print("Tokenization:",tokenize_text)

print("Stop Word Removal:",words)

print("Remove Punctuation:",removepun_text)

print("Stemmed Words:",stemmed_words)

print("Lemmatized Words:",lemmatized_words)

OUTPUT :
PROGRAM 14

import nltk

from nltk.tokenize import word_tokenize

from nltk.tag import pos_tag

def pos_tagging(sentence):

words = word_tokenize(sentence)

tagged_words = pos_tag(words)

return tagged_words

sentence = "The quick brown fox jumps over the lazy dog."

tagged_sentence = pos_tagging(sentence)

print("Tagged Sentence:", tagged_sentence)

OUTPUT :

PROGRAM 15

import nltk

import re

from nltk import word_tokenize, pos_tag, ne_chunk

from nltk.tree import Tree

def extract_entities(sent):

chunked = ne_chunk(pos_tag(word_tokenize(sent)))

entities = []

current_entity = []

for subtree in chunked:

if type(subtree) == Tree:

entity_name = " ".join([token for token, pos in subtree.leaves()])

entity_type = subtree.label()

entities.append((entity_name, entity_type))

return entities
def extract_relations(text):

sentences = nltk.sent_tokenize(text)

relations = []

for sent in sentences:

entities = extract_entities(sent)

if len(entities) >= 2:

for i, ent1 in enumerate(entities):

for ent2 in entities[i + 1:]:

relation = (ent1[0], ent1[1], ent2[0], ent2[1])

relations.append(relation)

return relations

# Sample text

text = "Barack Obama was born in Hawaii. He was elected president of the United States in 2008."

relations = extract_relations(text)

for relation in relations:

print(f"Entity 1: {relation[0]} (Type: {relation[1]}) - Entity 2: {relation[2]} (Type: {relation[3]})")

OUTPUT :

PROGRAM 16

import nltk

import gensim

from gensim import corpora

from nltk.corpus import stopwords

from nltk.tokenize import word_tokenize

# Download necessary NLTK data files

nltk.download('stopwords')
nltk.download('punkt')

# Sample text data

documents = [

"Artificial intelligence and machine learning are revolutionizing various industries.",

"Natural language processing techniques are used to analyze and generate human language.",

"Deep learning models have significantly improved the accuracy of speech recognition systems.",

"Computer vision enables machines to interpret and understand visual information.",

"Neural networks are a key component of many modern AI systems."

# Preprocess the text data

stop_words = set(stopwords.words('english'))

def preprocess(doc):

tokens = word_tokenize(doc.lower())

tokens = [word for word in tokens if word.isalnum()]

tokens = [word for word in tokens if word not in stop_words]

return tokens

processed_docs = [preprocess(doc) for doc in documents]

# Create a dictionary and corpus

dictionary = corpora.Dictionary(processed_docs)

corpus = [dictionary.doc2bow(doc) for doc in processed_docs]

# Train the LDA model

lda_model = gensim.models.ldamodel.LdaModel(corpus, num_topics=2, id2word=dictionary,

# Print the topics

print(f"Topic {idx}: {topic}")

OUTPUT :