DataBloom

Imagine we have a neural network, or any network that can be trained iteratively with epochs and consider the two training cases below;

1. We have x amount of data and we train until we reach 0.1 loss. Let us say this took 100 epochs.
2. We have greatly increased the size of our data to 100x and we have trained for a greatly reduced number of epochs (let us say 1 epoch) to reach 0.1 loss.

In terms of testing performance and realtime predictions, will there be any significant difference between these two cases even though the loss (let us assume the validation and training accuracies are the same as well.) is the same?

I am feeling the contradiction between training for large epochs with small data and training with small data for lower epochs.

As far as I am concerned, I could not get a transformer network to converge to acceptable metrics without data augmentation, while training for a low number of epochs. I have tried training it for thousands of epochs with limited data, no luck.

In order to keep the argument easily arguable, I assumed every other thing I did not change between two cases did not actually change. Quite obviously increasing the data size to 100x will not result in 0.1 loss with 1 epochs, models do not work linearly like that.

I am using keras Functional API for multiple stream of inputs.

I want to use pretrained Resnet50 inbetween my layers. I would like to freeze the layers of Resnet to train i.e, Transfer learning.

How can I do it

“` CNN_Input = Input(shape=INPUT_SHAPE)

resnet = tf.keras.applications.ResNet50( include_top=False, input_shape=None, pooling=’avg’,

classes=NUM_CLASSES,

 weights='imagenet')(CNN_Input) 

————–BELOW TWO LINES ARE CAUSING ERRORS—————– I assumed we do the same way we did for Sequential Model

for layer in resnet.layers: layer.trainable=False

CNN=Flatten()(resnet) CNN=BatchNormalization()(CNN) CNN=Dropout(0.2)(CNN) CNN=Dense(1024, activation=’relu’)(CNN) CNN=Dense(512, activation=’relu’)(CNN) CNN=Dense(256, activation=’relu’)(CNN) CNN=BatchNormalization()(CNN) CNN=Dropout(0.2)(CNN) CNN=Dense(64,activation=’relu’)(CNN)

CAT_Input = Input(shape=(3,))

CAT=Dense(32, activation=’relu’)(CAT_Input) CAT=Dropout(0.2)(CAT) CAT=Dense(64, activation=’relu’)(CAT)

merge=concatenate([CNN,CAT]) hidden=Dense(64, activation=’relu’)(merge) hidden=Dense(64, activation=’relu’)(hidden) hidden=Dense(32,activation=’relu’)(hidden) output=Dense(NUM_CLASSES,activation=’softmax’)(hidden)

model = Model(inputs=[CNN_Input, CAT_Input], outputs=output) print(model.summary())

“`

Let say I have an object detector from TF object detection API. Not much of customization can be done to the detector itself, but I want to add a branch on the detected images with LSTM to generate a description. Is there a way to do it in a single architecture? Or the only way is to train the detector and then train seperately the LSTM on detected images (2 stage)?

If I don’t have a need to define custom layers, is it still a common practice to use tensorflow (2.0) without the keras API, or is everyone just using keras now? Is there a scenario that makes sense to just use TF without keras if I’m not defining custom layers or anything.

EDIT: I don’t even see any tutorials on tensorflow.org docs that use defining custom layers without keras. Is it even possible to build a simple model with TF 2.0 without using keras?

Hey, I have trained an image classification problem to classify plant diseases, the training went well when testing the model with evaluate it gives 90% accuracy, it’s all rainbows, and till I started predicting single image.

I have 38 classes problem is if I tested it on an image from class 1 it will predict the image is class 10,

test it on an image from class 2 it will predict the image is class 11, class 3 will be class 12 class 4 will be class 13 and so on, like the labels are shifted linearly.

most images from any class will have their labels shifted to another class. I don’t know what’s going on here, any help would be appreciated.

code for reading the image and loading it to the model

img=np.resize(img,(256,256,3)) # Preprocessing the image img = image.img_to_array(img) # x = np.true_divide(x, 255) img = np.expand_dims(img, axis=0) img = img/255 prediction = model.predict(img) 

Im trying to import a lot of images into tensorflow, to traing a Keras AI, to do some image enhancement for me.

When disabling my gpu with:

import os
os.environ[“CUDA_VISIBLE_DEVICES”] = “-1”

The code runs absolutely fine, but the training takes ages. But when i enable my RTX 3060, with Cuda v11.7 installed proberly, i get the error:’

TypeError: Input ‘filename’ of ‘ReadFile’ Op has type float32 that does not match expected type of string.

Why? how can it change the datatype, that i switch from CPU to GPU?

​

The failing code is this:

def read_image(image_path):
image = tf.io.read_file(image_path) This Line
image = tf.image.decode_png(image, channels=3)
image.set_shape([None, None, 3])
image = tf.cast(image, dtype=tf.float32) / 255.0
return image

def random_crop(low_image, enhanced_image):
low_image_shape = tf.shape(low_image)[:2]
low_w = tf.random.uniform(
shape=(), maxval=low_image_shape[1] – IMAGE_SIZE + 1, dtype=tf.int32
)
low_h = tf.random.uniform(
shape=(), maxval=low_image_shape[0] – IMAGE_SIZE + 1, dtype=tf.int32
)
enhanced_w = low_w
enhanced_h = low_h
low_image_cropped = low_image[
low_h : low_h + IMAGE_SIZE, low_w : low_w + IMAGE_SIZE
]
enhanced_image_cropped = enhanced_image[
enhanced_h : enhanced_h + IMAGE_SIZE, enhanced_w : enhanced_w + IMAGE_SIZE
]
return low_image_cropped, enhanced_image_cropped

def load_data(low_light_image_path, enhanced_image_path):
low_light_image = read_image(low_light_image_path) And this line
enhanced_image = read_image(enhanced_image_path)
low_light_image, enhanced_image = random_crop(low_light_image, enhanced_image)
return low_light_image, enhanced_image

def get_dataset(low_light_images, enhanced_images):
dataset = tf.data.Dataset.from_tensor_slices((low_light_images, enhanced_images))
dataset = dataset.map(load_data, num_parallel_calls=tf.data.AUTOTUNE)
dataset = dataset.batch(BATCH_SIZE, drop_remainder=True)
return dataset

train_low_light_images = sorted(glob(“./lol_dataset/our485/low/*”))[:MAX_TRAIN_IMAGES]
train_enhanced_images = sorted(glob(“./lol_dataset/our485/high/*”))[:MAX_TRAIN_IMAGES]

And no, this is not my code, but grapped from a github repository. It’s a prove of concept, to see if i can do, what i want it to do. I’ll rewrite it, if i decide to go forward with Keras