Breaking News: Grepper is joining You.com. Read the official announcement!

cnn in keras

Innocent Iguana answered on April 17, 2024 Popularity 4/10 Helpfulness 7/10

answer cnn in keras

cnn in keras

Comment

from keras.models import Sequential
model = Sequential()
from keras.layers import Dense
train_data.shape
# If you consider pixels are Independent, then use Dense Layer
model.add(Dense(10, activation='relu', input_shape=(784,)))
model.add(Dense(10, activation='relu'))
model.add(Dense(3, activation='softmax'))
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
df = df.reshape((100, 784)) # (1 row = one sample image, 1 column = one pixel, total width*height for total pixels for total columns)
X= df.iloc[:, :-1]
y= df.iloc[:,-1]
from tensorflow.keras.utils import to_categorical # For categorical target variable, you need something like one-hot-encoding
y = to_categorical(data['target']) # Use this for one-hot-encoding if target is a class and it is a classification problem
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split( X,y , random_state=104,test_size=0.25, shuffle=True)
model.fit(X_train, y_train, validation_split=0.2, epochs=3)
model.evaluate(X_test, y_test)

# If you consider pixels are not Independent, then use Convolution Layer
from keras.models import Sequential
from keras.layers import Dense, Conv2D, Flatten
model = Sequential()
# Start with convolution layer that will create 10 feature maps
model.add(Conv2D(10, kernel_size=3, activation='relu', input_shape=(img_rows, img_cols, 1)), padding='same', strides=1, dilation_rate=2) # padding default is 'valid', and dilation helps aggregate information across multiple scales (2,2) pixels skips
model.add(BatchNormalization()) # Regularization for re-scaling outputs with 0 mean and std of 1 in every batch of training (helps prevent producing totally different wildly different distribution of outputs in each batch )
model.add(MaxPool2D(pool_size=2)) # Pooling layer to reduce pixel parameters with a 2X2 window size pulling
model.add(Conv2D(15, kernel_size=3, activation='relu'))
model.add(Dropout(0.25)) # Regularization to reduce noise and overly correlated data by turning of 25% of previous layer neurons
model.add(MaxPool2D(2))
model.add(Flatten()) # Converts multi-dimensional neurons to single dimensional neurons
model.add(Dense(3, activation='softmax')) # The final output layer 
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

from keras.callbacks import ModelCheckpoint
# This will store the best model parameters in "weights.hdf5" file
checkpoint = ModelCheckpoint('weights.hdf5', monitor='val_loss', save_best_only=True) 
callbacks_list = [checkpoint] # Store in a list to be used during training
training = model.fit(train_data, train_labels, validation_split=0.2, epochs=3, batch_size=10, callbacks=callbacks_list)
# Load the best weights
model.load_weights('weights.hdf5')
model.predict_classes(test_data)
model.evaluate(test_data, test_labels, epochs=3)

# Visualize if  overfitting occurs
import matplotlib.pyplot as plt
plt.plot(training.history['loss'])
plt.plot(training.history['val_loss'])
plt.show()

# NOTE: Which batch-normalization fasten the process of learning, dropout layers slows down this process. be careful while using both as they may be counter-productive while using together (disharmony of batch normalization and dropout)

model.layers # See layers
conv1 = model.layers[0] # extract a layer
weights1 = conv1.get_weights() # get weights 
kernels1 = weights1[0] # Get the kernels
kernels1.shape # (3, 3, 1, 10) denotes (3X3 kernel window, this is a 1 channel kernel, there are 10 kernels )
kernel1_1 = kernels1[:, :,0, 0] # Extract the first kernel 
plt.imshow(kernel1_1) # Visualize kernel

def convolution(image, kernel):
    kernel = kernel - kernel.mean() # Normalization
    result = np.zeros(image.shape)
    for ii in range(image.shape[0]-2):
        for jj in range(image.shape[1]-2):
            result[ii, jj] = np.sum(image[ii:ii+2, jj:jj+2] * kernel)
    return result

filtered_image = convolution(test_image, kernel1_1) # convolution is a function that does test_image * kernel1_1
plt.imshow(filtered_image)

# NOTE: Also see CONVOLUTION IN PYTHON

Popularity 4/10 Helpfulness 7/10 Language python

Source: Grepper

Tags: keras python

Link to this answer
Share Copy Link

Contributed on Apr 17 2024

Innocent Iguana

0 Answers Avg Quality 2/10

cnn in keras

Contents

More Related Answers

cnn in keras

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.