4

#1.load the IMDB dataset:

import numpy as np

from tensorflow.keras.datasets import imdb

from tensorflow.keras.preprocessing.sequence import pad_sequences

#load dataset

(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=10000)


#pad sequences to ensure equal length inputs

x_train = pad_sequences(x_train, maxlen=200)

x_test = pad_sequences(x_test, maxlen=200)


#2.define the LSTM model with an embedding layer:

model = tf.keras.Sequential([

  tf.keras.layers.Embedding(input_dim=10000, output_dim=128, input_length=200),

  tf.keras.layers.LSTM(128, return_sequences=False),

  tf.keras.layers.Dense(1, activation='sigmoid')

])


model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

#3.train the model on the IMDB dataset:

history = model.fit(x_train, y_train, epochs=10, batch_size=64, validation_data=(x_test, y_test))


#4.visualize training progress:

import matplotlib.pyplot as plt

#plot accuracy

plt.plot(history.history['accuracy'], label='Training Accuracy')

plt.plot(history.history['val_accuracy'], label='Validation Accuracy')

plt.xlabel('Epochs')

plt.ylabel('Accuracy')

plt.legend()

plt.show()


#5.evalate the model using precision,recall,and f1 score:

from sklearn.metrics import precision_score, recall_score, f1_score


# get preictions and round them to nearest integer

y_pred = (model.predict(x_test) > 0.5).astype("int32")


#evaluate performance

precision = precision_score(y_test, y_pred)

recall = recall_score(y_test, y_pred)

f1 = f1_score(y_test, y_pred)

print(f"'Precision:', {precision}, 'Recall:', {recall}, 'F1 Score:', {f1}")


#6.analyze model perfaormance on sequential data:

def preprocess_input(text):

  tokenizer = Tokenizer(num_words=max_features)

  tokenizer.fit_on_texts([text])

  sequence = tokenizer.texts_to_sequences([text])

  padded_sequence = pad_sequences(sequence, maxlen=maxlen)

  return padded_sequence

#get user input

user_input = input("Enter a movie review: ")

#preprocess input

preprocessed_input = preprocess_input(user_input)

#make prediction

prediction = model.predict(preprocessed_input)

sentiment = "positive" if prediction > 0.5 else "negative"

#output

print(f"The predicted sentiment is: {sentiment} (probability: {prediction[0][0]:.2f})") 

Comments

Post a Comment

Popular posts from this blog

2

#1 from tensorflow.keras.datasets import fashion_mnist (x_train, y_train), (x_test, y_test) = fashion_mnist.load_data() x_train,x_test=x_train/255.0,x_test/255.0 #2 import tensorflow as tf model = tf.keras.Sequential([   tf.keras.layers.Flatten(input_shape=(28, 28)),   tf.keras.layers.Dense(128, activation='relu'),   tf.keras.layers.BatchNormalization(),   tf.keras.layers.Dropout(0.5),   tf.keras.layers.Dense(64, activation='relu'),   tf.keras.layers.Dense(10, activation='softmax') ]) model.compile(optimizer='adam',               loss='sparse_categorical_crossentropy',               metrics=['accuracy']) #3 lr_schedule = tf.keras.callbacks.LearningRateScheduler(     lambda epoch: 1e-3 * 10**(epoch / 20)) history = model.fit(x_train, y_train, epochs=10,                     validation_data=(x_test, y_test),       ...
Read more

1

#Steps: #1. Set up the environment: !pip install tensorflow import numpy as np #2. Define the OR and XOR gate datasets: # Define OR and XOR datasets X_OR = np.array([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=np.float32) y_OR = np.array([[0], [1], [1], [1]], dtype=np.float32) X_XOR = np.array([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=np.float32) y_XOR = np.array([[0], [1], [1], [0]], dtype=np.float32) #3. Create a single-layer perceptron model: import tensorflow as tf # Function to create and train a single-layer perceptron with improved #accuracy def train_perceptron(X, y, epochs=100, learning_rate=0.1):  model = tf.keras.Sequential([  tf.keras.layers.Dense(1, activation='sigmoid', input_shape=(2,))  ])  model.compile(optimizer=tf.keras.optimizers.SGD(learning_rate=  learning_rate),loss='binary_crossentropy',  metrics=['accuracy'])  model.fit(X, y, epochs=epochs, verbose=0)  return model #4. Train the model on OR and XOR datasets: # Train on OR gate wi...
Read more

3

#1.load amd preprocess the CIFAR-10 dataset import numpy as np import tensorflow as tf from tensorflow.keras.datasets import cifar10 from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense from sklearn.metrics import accuracy_score, precision_score, recall_score # Load the CIFAR-10 dataset (x_train, y_train), (x_test, y_test) = cifar10.load_data() # Normalize pixel values to be between 0 and 1 x_train = x_train.astype('float32') / 255.0 x_test = x_test.astype('float32') / 255.0 # convert class vectors to binary class matrices(one-hot encoding) y_train = tf.keras.utils.to_categorical(y_train,num_classes=10) y_test = tf.keras.utils.to_categorical(y_test,num_classes=10) #2.define a deeper cnn model #define the cnn model model = Sequential() model.add(Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3))) model.add(Conv2D(32, (3, 3), activation='relu', padding=...
Read more