Im trying to run CNNs on GPU and I was wondering if you know what I should change to make it happen.
I have already installed cudnn in anaconda, and I see already that my GPU is being recognized successfully(in anaconda prompt and also on Jupyter Notebook)
(base) C:\Users\USER>python
Python 3.9.13 (main, Aug 25 2022, 23:51:50) [MSC v.1916 64 bit (AMD64)] :: Anaconda, Inc. on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import tensorflow as tf
>>> tf.__version__
'2.10.1'
>>> len(tf.config.list_physical_devices('GPU'))>0
True
So my code on CPU for CNN to classify dogs and cats is this:
#Importing the libraries
import tensorflow as tf
from keras.preprocessing.image import ImageDataGenerator
##Data Preprocessing
train_datagen = ImageDataGenerator(rescale = 1./255,
shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True)
training_set = train_datagen.flow_from_directory('dataset/training_set',
target_size = (64, 64),
batch_size = 32,
class_mode = 'binary')
test_datagen = ImageDataGenerator(rescale = 1./255)
test_set = test_datagen.flow_from_directory('dataset/test_set',
target_size = (64, 64),
batch_size = 32,
class_mode = 'binary')
#Building the CNN
cnn = tf.keras.models.Sequential()
cnn.add(tf.keras.layers.Conv2D(filters=32, kernel_size=3, activation='relu', input_shape=[64, 64, 3]))
cnn.add(tf.keras.layers.MaxPool2D(pool_size=2, strides=2))
cnn.add(tf.keras.layers.Conv2D(filters=32, kernel_size=3, activation='relu'))
cnn.add(tf.keras.layers.MaxPool2D(pool_size=2, strides=2))
cnn.add(tf.keras.layers.Flatten())
cnn.add(tf.keras.layers.Dense(units=128, activation='relu'))
cnn.add(tf.keras.layers.Dense(units=1, activation='sigmoid'))
#Training the CNN
cnn.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
cnn.fit(x = training_set, validation_data = test_set, epochs = 25)
#Testing/making predictions
import numpy as np
from tensorflow.keras.preprocessing import image
test_image = image.load_img('dataset/single_predictions/cat_or_dog_2.jpg', target_size = (64, 64))
test_image = image.img_to_array(test_image)
test_image = np.expand_dims(test_image, axis = 0)
result = cnn.predict(test_image)
training_set.class_indices
if result[0][0] == 1:
prediction = 'dog'
else:
prediction = 'cat'
What should I add or change in my code to execute it on GPU?
Im using Jupiter Notebook!
Related
i tried following code for facial emotion recognition using deep learning based model LSTM but its not work.using python 3.7 anaconda3. this code works on CNN model.
from keras.preprocessing.image import ImageDataGenerator
train_datagen = ImageDataGenerator(rescale = 1./255, shear_range = 0.2, zoom_range = 0.2, horizontal_flip = True)
test_datagen = ImageDataGenerator(rescale = 1./255)
training_set = train_datagen.flow_from_directory('D:\\Datasets\\gender CK+\\training_set',
target_size = (64, 64), batch_size = 32, class_mode = 'categorical')
test_set = test_datagen.flow_from_directory('D:\\Datasets\\gender CK+\\test_set',
target_size = (64, 64), batch_size = 32, class_mode = 'categorical')
seq = Sequential()
seq.add(ConvLSTM2D(filters=32, kernel_size=(3, 3),input_shape=(None, 64, 64, 40),
padding='same', return_sequences=True))seq.add(Batch Normalization())
seq.add(Dense(2,activation="sigmoid"))
seq.compile(loss='binary_crossentropy', optimizer='rmsprop',metrics=['accuracy'])
seq.summary()
seq.fit_generator(training_set, steps_per_epoch = 100, epochs = 4, validation_data = test_set, validation_steps = 200)
following error occurs
ValueError: Error when checking input: expected conv_lst_m2d_4_input
to have 5 dimensions, but got array with shape (5, 64, 64, 3)
I am new to ML and I am trying to play a little with this tutorial:
https://medium.com/#ferhat00/deep-learning-with-keras-classifying-cats-and-dogs-part-2-21b3b25bbe5c . Anyway, the CNN seems to work only in the case I don't save it in an h5 file after the training. More precisely:
from keras.models import Sequential
from keras.layers import Conv2D
from keras.layers import MaxPooling2D
from keras.layers import Flatten
from keras.layers import Dense
from keras.layers import Dropout
from keras import optimizers
classifier = Sequential()
classifier.add(Conv2D(32, (3, 3), input_shape = (128, 128, 3), activation = 'relu'))
classifier.add(MaxPooling2D(pool_size = (2, 2)))
classifier.add(Conv2D(32, (3, 3), activation = 'relu'))
classifier.add(MaxPooling2D(pool_size = (2, 2)))
classifier.add(Conv2D(64, (3, 3), activation = 'relu'))
classifier.add(MaxPooling2D(pool_size = (2, 2)))
classifier.add(Flatten())
classifier.add(Dense(units = 64, activation = 'relu'))
classifier.add(Dropout(0.5))
classifier.add(Dense(units = 1, activation = 'sigmoid'))
classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
from keras.preprocessing.image import ImageDataGenerator
train_datagen = ImageDataGenerator(rescale = 1./255,
shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True)
test_datagen = ImageDataGenerator(rescale = 1./255)
training_set = train_datagen.flow_from_directory('PetImages/training_set',
target_size = (128, 128),
batch_size = 32,
class_mode = 'binary')
test_set = test_datagen.flow_from_directory('PetImages/test_set',
target_size = (128, 128),
batch_size = 32,
class_mode = 'binary')
history = classifier.fit_generator(training_set,
steps_per_epoch = 8000/32,
epochs = 30,
validation_data = test_set,
validation_steps = 2000/32, workers=12, max_q_size=100)
///////////////////////////////////////
classifier.save("cnnPetsModel.h5")
print("saved model to disk")
///////////////////////////////////////
from keras.preprocessing import image
from keras.applications.vgg16 import preprocess_input
import numpy as np
img_path = 'PetImages/test_set/Dog/5000.jpg'
img = image.load_img(img_path, target_size=(128, 128))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
preds = classifier.predict(x)
training_set.class_indices
print(preds)
if preds[0][0] == 1:
prediction = 'dog'
else:
prediction = 'cat'
print(prediction)
img_path = 'PetImages/test_set/Cat/5000.jpg'
img = image.load_img(img_path, target_size=(128, 128))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
preds = classifier.predict(x)
training_set.class_indices
print(preds)
if preds[0][0] == 1:
prediction = 'dog'
else:
prediction = 'cat'
print(prediction)
If I remove the code between "////////", the two images are predicted correctly, while it becomes always "cat" in the case I save the model. Why this happens? I am only saving parameters, structure etc. in a file, at all...
Thanks in advance!
EDIT:
I moved the saving at the end of the code and the model predicts correctly. Anyway, if such a model is loaded from another python file and then used for predict(x) like above, it results in an untrained one which always returns "cat".
I am training a Keras model for multi-label image classification, i.e. 3 classes namely flood, wildfire, storm.
But I am getting only [[1.]] instead of something like [0 0 1]. So if third bit is one, its a storm. But I don't know why it's returning just a single value [[1.]].
# # Importing the Keras libraries and packages
from keras.models import Sequential
from keras.layers import Conv2D
from keras.layers import MaxPooling2D
from keras.layers import Flatten
from keras.layers import Dense
import numpy as np
from keras.preprocessing import image
from keras.preprocessing.image import ImageDataGenerator
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
def create_model() :
# Initialising the CNN
classifier = Sequential()
# Step 1 - Convolution
classifier.add(Conv2D(32, (3, 3), input_shape = (64, 64, 3), activation = 'relu'))
# Step 2 - Pooling
classifier.add(MaxPooling2D(pool_size = (2, 2)))
# Adding a second convolutional layer
classifier.add(Conv2D(32, (3, 3), activation = 'relu'))
classifier.add(MaxPooling2D(pool_size = (2, 2)))
# Step 3 - Flattening
classifier.add(Flatten())
# Step 4 - Full connection
classifier.add(Dense(units = 128, activation = 'relu'))
classifier.add(Dense(units = 1, activation = 'sigmoid'))
return classifier
def train_save_model():
classifier = create_model()
classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
# Part 2 - Fitting the CNN to the images
train_datagen = ImageDataGenerator(rescale = 1./255,
shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True)
test_datagen = ImageDataGenerator(rescale = 1./255)
training_set = train_datagen.flow_from_directory('training_set',
target_size = (64, 64),
batch_size = 32,
class_mode = 'binary')
test_set = test_datagen.flow_from_directory('validation_set',
target_size = (64, 64),
batch_size = 32,
class_mode = 'binary')
classifier.fit_generator(training_set,
steps_per_epoch = 1407,
epochs = 1,
validation_data = test_set,
validation_steps = 100)
classifier.save_weights("model.h5")
# Part 3 - Making new predictions
def test_model():
classifier = create_model()
classifier.load_weights("model.h5")
test_image = image.load_img('validation_set/tornado/110.jpg', target_size = (64, 64))
test_image = image.img_to_array(test_image)
test_image = np.expand_dims(test_image, axis = 0)
# print(test_image)
result = classifier.predict(test_image)
train_datagen = ImageDataGenerator(rescale = 1./255,
shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True,
)
training_set = train_datagen.flow_from_directory('training_set',
target_size = (64, 64),
batch_size = 32,
class_mode = 'binary')
training_set.class_indices
# print(training_set.class_indices)
print(result)
train_save_model()
test_model()
result = classifier.predict(test_image)
I tried printing this result variable and I get [[1.]]. I cannot understand at all how's that happening.
If you have N labels, then the last layer (i.e. the sigmoid classifier layer) must also have N neurons, one for each of the classes:
classifier.add(Dense(units=3, activation='sigmoid'))
Then the output of the model, for each input sample, would be 3 numbers corresponding to three labels.
Update: Remove the class_mode = 'binary' from all flow_from_directory calls. That's because you are doing classification among multiple classes and therefore the generated labels should be either categorical (default behavior) or sparse (i.e. class_mode='sparse'). Further, after reading the relevant parts of your code, it seems that you are doing multi-class classification, and not multi-label classification. Read this answer to make sure and also to find out which activation and loss function you should use.
As loss function use categorical_crossentropy instead of binary_crossentropy.
I am trying to combine this two examples and create the tflite file for my android app.
https://medium.com/nybles/create-your-first-image-recognition-classifier-using-cnn-keras-and-tensorflow-backend-6eaab98d14dd
https://medium.com/#xianbao.qian/convert-keras-model-to-tflite-e2bdf28ee2d2
This is my code:
# Part 1 - Building the CNN
# Importing the Keras libraries and packages
from keras.models import Sequential
from keras.layers import Convolution2D
from keras.layers import MaxPooling2D
from keras.layers import Flatten
from keras.layers import Dense
import tensorflow as tf
from keras.models import load_model
# Initialising the CNN
classifier = Sequential()
# Step 1 - Convolution
classifier.add(Convolution2D(32, 3, 3, input_shape = (64, 64, 3), activation = 'relu'))
# Step 2 - Pooling
classifier.add(MaxPooling2D(pool_size = (2, 2)))
# Adding a second convolutional layer
classifier.add(Convolution2D(32, 3, 3, activation = 'relu'))
classifier.add(MaxPooling2D(pool_size = (2, 2)))
# Step 3 - Flattening
classifier.add(Flatten())
# Step 4 - Full connection
classifier.add(Dense(output_dim = 128, activation = 'relu'))
classifier.add(Dense(output_dim = 1, activation = 'sigmoid'))
# Compiling the CNN
classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
# Part 2 - Fitting the CNN to the images
from keras.preprocessing.image import ImageDataGenerator
train_datagen = ImageDataGenerator(rescale = 1./255,
shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True)
test_datagen = ImageDataGenerator(rescale = 1./255)
training_set = train_datagen.flow_from_directory('dataset/training_set',
target_size = (64, 64),
batch_size = 32,
class_mode = 'binary')
test_set = test_datagen.flow_from_directory('dataset/test_set',
target_size = (64, 64),
batch_size = 32,
class_mode = 'binary')
classifier.fit_generator(training_set,
samples_per_epoch = 80,
nb_epoch = 1,
validation_data = test_set,
nb_val_samples = 20)
output_names = [node.op.name for node in classifier.outputs]
sess = tf.keras.backend.get_session()
frozen_def = tf.graph_util.convert_variables_to_constants(sess, sess.graph_def, output_names)
tflite_model = tf.contrib.lite.toco_convert(frozen_def, [inputs], output_names)
with tf.gfile.GFile(tflite_graph, 'wb') as f:
f.write(tflite_model)
And at this line:
frozen_def = tf.graph_util.convert_variables_to_constants(sess, sess.graph_def, output_names)
I got an exception:
tensorflow.python.framework.errors_impl.FailedPreconditionError: Attempting to use uninitialized value conv2d_1/bias
[[Node: _retval_conv2d_1/bias_0_0 = _Retval[T=DT_FLOAT, index=0, _device="/job:localhost/replica:0/task:0/device:CPU:0"](conv2d_1/bias)]]
I am a beginner in the machine learning and absolutely have no idea what is this error about :-(
Can somebody explain to me what is wrong?
All that I need is processed several folders with many pics and make it possible to predict the relations of the new coming pictures to the certain folder.
Thank you.
It is possible to directly convert a keras-model to .tflite using the tf.lite.TFLiteConverter.from_session function. Place the following code after fit_generator to export it (tested with tensorflow 1.3.1)
with tf.keras.backend.get_session() as sess:
sess.run(tf.global_variables_initializer())
converter = tf.lite.TFLiteConverter.from_session(sess, model.inputs, model.outputs)
tflite_model = converter.convert()
with open("model.tflite", "wb") as f:
f.write(tflite_model)
A bit late to the party but here's how you do it:
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()
Source: https://www.tensorflow.org/lite/convert/python_api
I have trained an image classifier using keras and it gave a very good accuracy. I've saved the model using the save()and saved it using the h5 format. How can I make a prediction using the model?
The code is:
from keras.models import Sequential
from keras.layers import Conv2D
from keras.layers import MaxPooling2D
from keras.layers import Flatten
from keras.layers import Dense
classifier = Sequential()
classifier.add(Conv2D(32, (3, 3), input_shape = (64, 64, 3), activation = 'relu'))
classifier.add(MaxPooling2D(pool_size = (2, 2)))
classifier.add(Conv2D(32, (3, 3), activation = 'relu'))
classifier.add(MaxPooling2D(pool_size = (2, 2)))
classifier.add(Flatten())
classifier.add(Dense(units = 128, activation = 'relu'))
classifier.add(Dense(units = 1, activation = 'sigmoid'))
classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
from keras.preprocessing.image import ImageDataGenerator
train_datagen = ImageDataGenerator(rescale = 1./255,
shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True)
test_datagen = ImageDataGenerator(rescale = 1./255)
training_set = train_datagen.flow_from_directory('training_set',
target_size = (64, 64),
batch_size = 32,
class_mode = 'binary')
test_set = test_datagen.flow_from_directory('test_set',
target_size = (64, 64),
batch_size = 32,
class_mode = 'binary')
classifier.fit_generator(training_set,
steps_per_epoch = 8000,
epochs = 5,
validation_data = test_set,
validation_steps = 2000)
classifier.save('classifier.h5')
Thanks in Advance..!!
The first step is to import your model using load_model method.
from keras.models import load_model
model = load_model('my_model.h5')
Then you have to compile the model in order to make predictions.
model.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
Now you can predict results for a new entry image.
from keras.preprocessing import image
test_image = image.load_img(imagePath, target_size = (64, 64))
test_image = image.img_to_array(test_image)
test_image = np.expand_dims(test_image, axis = 0)
#predict the result
result = model.predict(test_image)