EX.
NO:
SENTIMENT ANALYSIS FROM TEXT
DATE:
AIM:
To write a python program using a deep learning model to analyze and predict sentiment from
text data.
ALGORITHM:
Step 1: Start
Step 2: Load the IMDb dataset with a vocabulary size of 20,000 words.
Step 3: Preprocess the data by padding sequences to a fixed length of 200 and convert labels to
categorical format.
Step 4: Define a Sequential model with an Embedding layer, SpatialDropout1D, LSTM layer,
and Dense output layer.
Step 5: Compile the model using categorical cross-entropy loss, Adam optimizer, and accuracy
as the evaluation metric.
Step 6: Train the model on the training dataset for 5 epochs with a batch size of 64.
Step 7: Evaluate the model on the test dataset and print the accuracy.
Step 8: Define a function to predict sentiment for a given review and display the output. Stop
the program.
PROGRAM:
import numpy as np
import pandas as pd
from keras.datasets import imdb
from keras.models import Sequential
from keras.layers import Dense, LSTM, Embedding, SpatialDropout1D
from keras.preprocessing.sequence import pad_sequences
CSE/NM/NN&DL / 513322104001/PUNITHA U
from keras.utils import to_categorical
max_features = 20000 # Number of unique words to consider
max_length = 200 # Maximum length of each review
embedding_dim = 128 # Dimension of the embedding layer
(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=max_features)
X_train = pad_sequences(X_train, maxlen=max_length)
X_test = pad_sequences(X_test, maxlen=max_length)
y_train = to_categorical(y_train)
y_test = to_categorical(y_test)
model = Sequential()
model.add(Embedding(input_dim=max_feature,output_dim=embedding_dim,input_length=max_lengt
h))
model.add(SpatialDropout1D(0.2))
model.add(LSTM(100, dropout=0.2, recurrent_dropout=0.2))
model.add(Dense(2, activation='softmax')) # 2 classes: positive and negative
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
batch_size = 64
epochs = 5
model.fit(X_train, y_train, epochs=epochs, batch_size=batch_size, verbose=1)
loss, accuracy = model.evaluate(X_test, y_test, verbose=1)
print(f"Test Accuracy: {accuracy:.4f}")
def predict_sentiment(review):
word_index = imdb.get_word_index() # Get the word index
review = [word_index.get(word, 0) + 3 for word in review.split() if word in word_index] # Use get
to handle unknown words
review = pad_sequences([review], maxlen=max_length)
prediction = model.predict(review)
CSE/NM/NN&DL / 513322104001/PUNITHA U
sentiment = np.argmax(prediction, axis=1)
return "Positive" if sentiment[0] == 1 else "Negative"
sample_review = "The movie was fantastic! I loved it."
print(f"Review: {sample_review}")
print(f"Predicted Sentiment: {predict_sentiment(sample_review)}")
OUTPUT:
Test Accuracy: 0.8421
Review: The movie was fantastic! I loved it.
Downloading data from
https://storage.googleapis.com/tensorflow/tf-keras-datasets/imdb_word_index.json
1641221/1641221 ━━━━━━━━━━━━━━━━━━━━ 0s 0us/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 1s 674ms/step
Predicted Sentiment: Positive
RESULT:
Thus, the write a python program using a deep learning model to analyze and predict
sentiment from text data was executed successfully and output verified.
CSE/NM/NN&DL / 513322104001/PUNITHA U
EX.NO:
AUTOMATED EASY SCORING SYSTEM
DATE:
AIM:
To write a python program using gradient learning and backpropagation to score essays.
ALGORITHM:
Step 1: Start
Step 2: Create a dataset with essays and their corresponding scores.
Step 3: Split the dataset into training and testing sets.
Step 4: Convert the text data into numerical features using TF-IDF vectorization.
Step 5: Define and compile a neural network model for regression.
Step 6: Train the model on the training data and evaluate it on the test data.
Step 7: Define a function to predict the score of a given essay and display the result. Stop the
program.
PROGRAM:
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import Adam
data = {
'essay': [
"This is a great essay. It has a clear structure and good arguments.",
CSE/NM/NN&DL / 513322104001/PUNITHA U
"The essay is poorly written and lacks coherence.",
"An average essay with some good points but also many flaws.",
"Excellent work! Very insightful and well-organized.",
"This essay is not good. It needs a lot of improvement."
],
'score': [4, 1, 3, 5, 2] # Scores from 1 to 5
df = pd.DataFrame(data)
X_train, X_test, y_train, y_test = train_test_split(df['essay'], df['score'], test_size=0.2,
random_state=42)
vectorizer = TfidfVectorizer(max_features=1000)
X_train_tfidf = vectorizer.fit_transform(X_train).toarray()
X_test_tfidf = vectorizer.transform(X_test).toarray()
model = Sequential([
Dense(64, input_dim=X_train_tfidf.shape[1], activation='relu'),
Dense(32, activation='relu'),
Dense(1, activation='linear') # Regression output
])
model.compile(loss='mean_squared_error', optimizer=Adam(learning_rate=0.001))
model.fit(X_train_tfidf, y_train, epochs=100, batch_size=5, verbose=1)
loss = model.evaluate(X_test_tfidf, y_test, verbose=1)
print(f"Test Loss: {loss:.4f}")
def predict_score(essay):
essay_tfidf = vectorizer.transform([essay]).toarray()
return model.predict(essay_tfidf)[0][0]
sample_essay = "This essay is well-structured and presents strong arguments."
predicted_score = predict_score(sample_essay)
CSE/NM/NN&DL / 513322104001/PUNITHA U
print(f"Predicted Score: {predicted_score:.2f}")
OUTPUT:
Epoch 100/100
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 79ms/step - loss: 0.0012
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 155ms/step - loss: 1.6250
Test Loss: 1.6250
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 86ms/step
Predicted Score: 3.56
RESULT:
Thus, The write a python program using gradient learning and backpropagation to score essays
was executed successfully and output verified.
CSE/NM/NN&DL / 513322104001/PUNITHA U
EX.NO:
PREDICTIVE TEXT GENERATION
DATE:
AIM:
To write a python program using a system that generates predictive text using deep
feedforward networks.
ALGORITHM:
Step 1: Start
Step 2: Tokenize the input text data and create a word index.
Step 3: Generate input sequences for training by padding them to the same length.
Step 4: Split the sequences into input (X) and output (y) values and convert y to categorical
format.
Step 5: Define, compile, and train an LSTM-based neural network model.
Step 6: Create a function to predict the next word given a seed text.
Step 7: Use the trained model to predict and display the next word for a given input. Stop the
program.
PROGRAM:
import numpy as np
import tensorflow as tf
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, Dense, LSTM
data = ["hello world", "hello there", "how are you", "hello how are you"]
tokenizer = Tokenizer()
tokenizer.fit_on_texts(data)
CSE/NM/NN&DL / 513322104001/PUNITHA U
total_words = len(tokenizer.word_index) + 1
input_sequences = []
for line in data:
token_list = tokenizer.texts_to_sequences([line])[0]
for i in range(1, len(token_list)):
input_sequences.append(token_list[:i+1])
max_sequence_length = max(len(seq) for seq in input_sequences)
input_sequences = pad_sequences(input_sequences, maxlen=max_sequence_length, padding='pre')
X, y = input_sequences[:, :-1], input_sequences[:, -1]
y = tf.keras.utils.to_categorical(y, num_classes=total_words)
model = Sequential([
Embedding(total_words, 10, input_length=max_sequence_length-1),
LSTM(100),
Dense(total_words, activation='softmax')
])
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
model.fit(X, y, epochs=100, verbose=1)
def predict_next_word(seed_text, model, tokenizer, max_sequence_length):
token_list = tokenizer.texts_to_sequences([seed_text])[0]
token_list = pad_sequences([token_list], maxlen=max_sequence_length-1, padding='pre')
predicted_probs = model.predict(token_list, verbose=0)
predicted_index = np.argmax(predicted_probs)
for word, index in tokenizer.word_index.items():
if index == predicted_index:
return word
return ""
seed_text = "hello"
predicted_word = predict_next_word(seed_text, model, tokenizer, max_sequence_length)
print(f"Predicted next word: {predicted_word}")
CSE/NM/NN&DL / 513322104001/PUNITHA U
OUTPUT:
Predicted next word: how
RESULT:
Thus , The write a python program using a system that generates predictive text using deep
feed forward networks was executed successfully and output verified.
CSE/NM/NN&DL / 513322104001/PUNITHA U
EX.NO:
MEDICAL DIAGNOSIS ASSISTANT
DATE:
AIM:
To write a python program using a create a tool to assist in medical diagnosis using deep
learning techniques.
ALGORITHM:
Step 1: Start
Step 2: Load the diabetes dataset and assign column names.
Step 3: Preprocess the data by scaling the input features.
Step 4: Split the data into training and testing sets.
Step 5: Define, compile, and train a neural network model for binary classification.
Step 6: Evaluate the model on the test data and display the accuracy.
Step 7: Define a function to predict diabetes for a new patient and display the result. Stop the
program.
PROGRAM:
import numpy as np
import pandas as pd
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.optimizers import Adam
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
CSE/NM/NN&DL / 513322104001/PUNITHA U
columns = ['Pregnancies', 'Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI',
'DiabetesPedigreeFunction', 'Age', 'Outcome']
data = pd.read_csv(url, header=None, names=columns)
X, y = data.drop('Outcome', axis=1), data['Outcome']
X_scaled = StandardScaler().fit_transform(X)
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)
model = Sequential([
Dense(32, input_dim=X_train.shape[1], activation='relu'),
Dense(16, activation='relu'),
Dense(1, activation='sigmoid')
])
model.compile(loss='binary_crossentropy', optimizer=Adam(), metrics=['accuracy'])
model.fit(X_train, y_train, epochs=100, batch_size=10, validation_data=(X_test, y_test), verbose=0)
loss, accuracy = model.evaluate(X_test, y_test, verbose=0)
print(f"Model accuracy: {accuracy*100:.2f}%")
def predict_diabetes(patient_data):
patient_data_scaled = StandardScaler().fit(X).transform([patient_data])
return "Diabetic" if model.predict(patient_data_scaled)[0][0] > 0.5 else "Non-Diabetic"
new_patient = [2, 120, 70, 35, 0, 25, 0.4, 40]
print(predict_diabetes(new_patient))
CSE/NM/NN&DL / 513322104001/PUNITHA U
OUTPUT:
Model accuracy: 73.38%
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 72ms/step
Non-Diabetic
RESULT:
Thus, The write a python program using a create a tool to assist in medical diagnosis using
deep learning techniques was executed successfully and output verified.
CSE/NM/NN&DL / 513322104001/PUNITHA U
EX.NO: TIME SERIES FORECASTING USING RNN
DATE:
AIM:
To write a python program using RNNs for forecasting weather, stock prices, or other time-
series data.
ALGORITHM:
Step 1: Start the program.
Step 2: Generate a sine wave dataset with 100 data points using np.linspace() and
np.sin().
Step 3: Define a sequence length (window size) of 10 for input sequences.
Step 4: Prepare training data by splitting the dataset into input sequences (X) and
corresponding target values (Y).
Step 5: Reshape X into a format suitable for an RNN model using .reshape(-1,
seq_length, 1).
Step 6: Build a SimpleRNN model with one recurrent layer of 10 units and a dense output
layer.
Step 7: Compile the model using the Adam optimizer and mean squared error (MSE) loss
function.
Step 8: Train the model for 100 epochs using .fit() without displaying progress.
Step 9: Predict values using the trained model, plot actual vs. predicted data using
matplotlib, and display the graph.
Step 10: Stop the program.
PROGRAM:
import numpy as np
import tensorflow as tf
CSE/NM/NN&DL / 513322104001/PUNITHA U
import matplotlib.pyplot as plt
def generate_data(seq_length=100):
x = np.linspace(0, 50, seq_length)
y = np.sin(x)
return y
data = generate_data()
seq_length = 10 # Window size
X, Y = [], []
for i in range(len(data) - seq_length):
X.append(data[i:i + seq_length])
Y.append(data[i + seq_length])
X = np.array(X).reshape(-1, seq_length, 1) # Reshape for RNN
Y = np.array(Y)
model = tf.keras.Sequential([
tf.keras.layers.SimpleRNN(10, activation='relu', return_sequences=False),
tf.keras.layers.Dense(1)
])
model.compile(optimizer='adam', loss='mse')
model.fit(X, Y, epochs=100, verbose=0)
predicted = model.predict(X)
plt.figure(figsize=(10, 5))
plt.plot(data, label="Actual Data")
plt.plot(range(seq_length, len(predicted) + seq_length), predicted, label="Predicted Data")
plt.legend()
plt.show()
CSE/NM/NN&DL / 513322104001/PUNITHA U
OUTPUT:
RESULT:
Thus , The write a python program using RNNs for forecasting weather, stock prices, or other
time-series datawas executed successfully and output verified.
CSE/NM/NN&DL / 513322104001/PUNITHA U
EX.NO: MUSIC GENERATION USING RNN
DATE:
AIM:
To write a python program using a RNN to generate original music compositions.
ALGORITHM:
Step 1: Start the program.
Step 2: Generate a random melody sequence using predefined MIDI notes from the C Major
scale.
Step 3: Convert the melody into a numerical format using a mapping of notes to indexes.
Step 4: Prepare input-output training sequences for the RNN model with a sequence length of
5.
Step 5: Define and train a SimpleRNN model to predict the next note based on previous notes.
Step 6: Generate a new melody by predicting notes iteratively and mapping indexes back to
MIDI notes.
Step 7: Convert the generated melody into a MIDI file and save it as "generated_music.mid".
Step 8: Stop the program.
PROGRAM:
import numpy as np
import tensorflow as tf
from music21 import stream, note
def generate_melody_data(seq_length=50):
notes = [60, 62, 64, 65, 67, 69, 71, 72] # C Major Scale MIDI notes
data = np.random.choice(notes, seq_length)
return data
CSE/NM/NN&DL / 513322104001/PUNITHA U
data = generate_melody_data()
seq_length = 5 # Window size
X, Y = [], []
notes = [60, 62, 64, 65, 67, 69, 71, 72]
note_to_index = {note: i for i, note in enumerate(notes)}
index_to_note = {i: note for note, i in note_to_index.items()}
for i in range(len(data) - seq_length):
X.append([note_to_index[note] for note in data[i:i + seq_length]])
Y.append(note_to_index[data[i + seq_length]])
X = np.array(X).reshape(-1, seq_length, 1) # Reshape for RNN
Y = np.array(Y)
model = tf.keras.Sequential([
tf.keras.layers.SimpleRNN(64, activation='relu', return_sequences=False),
tf.keras.layers.Dense(8, activation='softmax') # 8 possible notes
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
model.fit(X, Y, epochs=2, verbose=0)
def generate_melody(seed, length=50):
result = list(seed)
for _ in range(length):
prediction = model.predict(np.array([result[-seq_length:]]).reshape(1, seq_length, 1))
next_note_index = np.argmax(prediction)
next_note = index_to_note[next_note_index]
result.append(next_note)
return result
seed_sequence = [note_to_index[n] for n in data[:seq_length]]
CSE/NM/NN&DL / 513322104001/PUNITHA U
melody = generate_melody(seed_sequence)
stream_obj = stream.Stream()
for midi_note in melody:
stream_obj.append(note.Note(midi_note))
stream_obj.write('midi', fp="generated_music.mid")
print("Music generated: 'generated_music.mid'")
OUTPUT:
RESULT:
Thus, The write a python program using a RNN to generate original music compositions was
executed successfully and output verified.
CSE/NM/NN&DL / 513322104001/PUNITHA U
EX.NO: CHATBOT FOR CUSTOMER SERVICE USING RNN
DATE:
AIM:
To write a python program using a chatbot using deep recurrent networks for handling
customer queries.
ALGORITHM:
Step 1: Start the program.
Step 2: Define sample queries and responses for the chatbot.
Step 3: Tokenize the queries and convert them into padded sequences.
Step 4: Build and train an LSTM-based neural network model to classify responses.
Step 5: Create a function to process user input and predict the most suitable response.
Step 6: Continuously take user input, predict a response, and display it.
Step 7: Stop the program when the user enters "exit" or "quit".
PROGRAM:
import numpy as np
import tensorflow as tf
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
queries = ["hi", "hello", "hey", "how are you", "what's up", "bye", "goodbye", "see you"]
responses = ["Hello!", "Hi there!", "Hey!", "I'm good!", "Not much, you?", "Goodbye!", "Take care!",
"See you soon!"]
tokenizer = Tokenizer()
tokenizer.fit_on_texts(queries)
X = pad_sequences(tokenizer.texts_to_sequences(queries), padding='post')
CSE/NM/NN&DL / 513322104001/PUNITHA U
Y = np.arange(len(responses))
model = tf.keras.Sequential([
tf.keras.layers.Embedding(input_dim=len(tokenizer.word_index) + 1, output_dim=8),
tf.keras.layers.LSTM(16),
tf.keras.layers.Dense(len(responses), activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
model.fit(X, Y, epochs=100, verbose=0) # Reduced epochs for better generalization
def chatbot_response(user_input):
tokens = pad_sequences(tokenizer.texts_to_sequences([user_input]), maxlen=X.shape[1])
prediction = np.argmax(model.predict(tokens))
return responses[prediction]
while True:
user = input("You: ")
if user.lower() in ["exit", "quit"]:
print("Chatbot: Goodbye!"); break
print("Chatbot:", chatbot_response(user))
CSE/NM/NN&DL / 513322104001/PUNITHA U
OUTPUT:
RESULT:
Thus, The write a python program using a chatbot using deep recurrent networks for
handling customer queries was executed successfully and output verified.
CSE/NM/NN&DL / 513322104001/PUNITHA U
EX.NO: LANGUAGE PROCESSING FOR SOCIAL MEDIA
USING RNN
DATE:
AIM:
To write a python program using a tool to process and analyze natural language from social
media posts using RNNs and autoencoders.
ALGORITHM:
Step 1: Start the program.
Step 2: Define sample social media posts and label them as positive or negative.
Step 3: Tokenize the posts and convert them into padded sequences.
Step 4: Build and train an LSTM-based neural network model for sentiment classification.
Step 5: Create a function to process new text input and predict its sentiment.
Step 6: Continuously take user input, analyze sentiment, and display the result.
Step 7: Stop the program when the user enters "exit" or "quit".
PROGRAM:
import numpy as np
import tensorflow as tf
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
posts = ["I love this!", "Worst experience ever!", "Feeling happy", "I hate waiting", "Great service!",
"Too expensive"]
labels = [1, 0, 1, 0, 1, 0]
tokenizer = Tokenizer()
tokenizer.fit_on_texts(posts)
X = pad_sequences(tokenizer.texts_to_sequences(posts), padding='post')
CSE/NM/NN&DL / 513322104001/PUNITHA U
model = tf.keras.Sequential([
tf.keras.layers.Embedding(len(tokenizer.word_index)+1, 8, input_length=X.shape[1]),
tf.keras.layers.LSTM(16),
tf.keras.layers.Dense(1, activation='sigmoid')
])
model.compile(optimizer='adam', loss='binary_crossentropy')
model.fit(X, np.array(labels), epochs=100, verbose=0)
def analyze_post(text):
tokens = pad_sequences(tokenizer.texts_to_sequences([text]), maxlen=X.shape[1])
return "Positive" if model.predict(tokens) > 0.5 else "Negative"
while True:
user = input("Enter post: ")
if user.lower() in ["exit", "quit"]:
break
print("Sentiment:", analyze_post(user))
OUTPUT:
RESULT:
Thus, The write a python program using a tool to process and analyze natural language from
social media posts using RNNs and auto encoders was executed successfully and output verified.
CSE/NM/NN&DL / 513322104001/PUNITHA U
