Scribd
Upload
8 views

keras

It is a Deep Learning program

Uploaded by

Vaishnavi
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
8 views

keras

It is a Deep Learning program

Uploaded by

Vaishnavi
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 4

Ex.No.2.

Installing Keras, Tensorflow and Pytorch libraries and making use of them

Aim:
To install Keras, Tensorflow and Pytorch libraries and making use of them.

Installation:

Installing Keras Library:


To install Keras, type the below command in terminal
pip install Keras

Installing Tensorflow Library:


To install tensorflow, type the below command in terminal
pip install tensorflow

Installing PyTorch Library:


To install PyTorch, type the below command in terminal
pip install torch

Tensorflow & Keras Program:

Aim:
To write a python program in Tensorflow & Keras.

Algorithm
1. Import numpy for data manipulation.
2. Import necessary classes from tensorflow.kerasm for building and training the neural
network.
3. Create a dataset with 100 samples, each having 8 features. The features are generated as
random numbers between 0 and 1.
4. Create binary target values (0 or 1) corresponding to each sample.
5. Create an empty neural network model using the Sequential API.
6. Add a Dense layer with 12 neurons, using the ReLU (Rectified Linear Unit) activation
function. This layer will take input with 8 features.
7. Add another Dense layer with 8 neurons, using the ReLU activation function.
8. Add an output Dense layer with 1 neuron, using the Sigmoid activation function to
produce a probability value for binary classification.
9. Set the optimizer to Adam, which adjusts the learning rate during training.
10. Use binary cross-entropy as the loss function, appropriate for binary classification tasks.
11. Specify accuracy as the evaluation metric to monitor the model's performance.
12. Fit the model on the generated data for 10 epochs with a batch size of 10.
13. During training, the model will learn to map features to the binary target values.
14. Generate 10 new samples with 8 features each for which predictions will be made.
15. Use the trained model to predict the probabilities of the new samples belonging to the
positive class (1).
16. Print the predicted probabilities for the new data.

Program:

import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
# Generate random data (replace with your own data)
X = np.random.rand(100, 8)
y = np.random.randint(2, size=100)

# Create a sequential model


model = Sequential()
model.add(Dense(units=12, input_dim=8, activation='relu'))
model.add(Dense(units=8, activation='relu'))
model.add(Dense(units=1, activation='sigmoid'))

# Compile the model


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

# Train the model


model.fit(X, y, epochs=10, batch_size=10)

# Make predictions (replace with your own data)


new_data = np.random.rand(10, 8)
predictions = model.predict(new_data)
print(predictions)

Output:
Epoch 1/5
1875/1875 ━━━━━━━━━━━━━━━━━━━━ 14s 6ms/step - accuracy: 0.8588 - loss: 0.4773
Epoch 2/5
1875/1875 ━━━━━━━━━━━━━━━━━━━━ 20s 6ms/step - accuracy: 0.9564 - loss: 0.1512
Epoch 3/5
1875/1875 ━━━━━━━━━━━━━━━━━━━━ 19s 5ms/step - accuracy: 0.9672 - loss: 0.1078
Epoch 4/5
1875/1875 ━━━━━━━━━━━━━━━━━━━━ 9s 5ms/step - accuracy: 0.9728 - loss: 0.0886
Epoch 5/5
1875/1875 ━━━━━━━━━━━━━━━━━━━━ 8s 4ms/step - accuracy: 0.9766 - loss: 0.0740
313/313 - 1s - 3ms/step - accuracy: 0.9768 - loss: 0.0797

[0.07969701290130615, 0.9768000245094299]

PyTorch Program:

Aim:
To write a python program in PyTorch.

Algorithm:

1.Load the training and test datasets.


2.Apply appropriate transformations (e.g., converting to tensors).
3.Create a feedforward neural network with two fully connected layers (28x28 -> 128, 128 -> 10).
4.Create an instance of the SimpleNet model.
5.Define a loss function (e.g., CrossEntropyLoss).
6.Choose an optimization algorithm (e.g., Adam).
7.Iterate through a specified number of epochs.
8.For each epoch, iterate through each batch in the training data.
9.Calculate the model's output for the batch.
10.Compute the loss between the model's output and the true labels.
11.Backpropagate the loss to update the model's parameters.
12.Disable gradient calculation (with torch.no_grad()).
13.Iterate through each batch in the test data.
14.Calculate the model's output for the batch.
15.Calculate the accuracy by comparing the model's predictions to the true labels.

Program:

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.datasets as datasets
import torchvision.transforms as transforms

# Define the neural network architecture


class SimpleNet(nn.Module):
def __init__(self):
super(SimpleNet, self).__init__()
self.fc1 = nn.Linear(28*28, 128)
self.fc2 = nn.Linear(128, 10)

def forward(self, x):


x = torch.flatten(x, 1)
x = torch.relu(self.fc1(x))
x = self.fc2(x)
return x

# Load the MNIST dataset


train_dataset = datasets.MNIST(root='./data', train=True, download=True,
transform=transforms.ToTensor())
test_dataset = datasets.MNIST(root='./data', train=False, download=True,
transform=transforms.ToTensor())

train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)


test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=64, shuffle=False)

# Initialize the model, loss function, and optimizer


model = SimpleNet()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Train the model


num_epochs = 5
for epoch in range(num_epochs):
for batch_idx, (data, target) in enumerate(train_loader):
optimizer.zero_grad()
output = model(data)
loss = criterion(output, target)
loss.backward()
optimizer.step()

# Evaluate the model


correct = 0
total = 0
with torch.no_grad():
for data, target in test_loader:
output = model(data)
_, predicted = torch.max(output.data, 1)
total += target.size(0)
correct += (predicted == target).sum().item()

accuracy = 100 * correct / total


print('Accuracy on test set: {}%'.format(accuracy))

Output:

Accuracy on test set: 97.27%

Result:

Thus the installation of the Keras, TensorFlow, and PyTorch libraries was completed, and they were
put to use.

You might also like