Issue 1:
I've written a code that uses flow_from_directory method to import augmented images and their masks into a generator.

Then I want to 'reshape' these masks and create 'sample_weight' vector and build my own custom generator that yields (image, mask, sample_weights).

This is my implementation:

data_trn_gen_args_mask = dict(preprocessing_function = preprocess_mask,
horizontal_flip=True,
zoom_range=0.2)
data_trn_gen_args_image = dict(preprocessing_function = preprocess_input,
horizontal_flip=True,
zoom_range=0.2)

mask_datagen = ImageDataGenerator(**data_gen_args_mask)
image_datagen = ImageDataGenerator(**data_gen_args_image)

image_generator = image_datagen.flow_from_directory(PATH,
classes = ['train'],
class_mode=None,
batch_size=16,
shuffle=True,
seed=29)

mask_generator = mask_datagen.flow_from_directory(PATH, color_mode = 'grayscale'
classes = ['SegmentationClassAug'],
class_mode=None,
batch_size=16,
shuffle=True,
seed=29)

def segmentation_generator(image_gen, mask_gen):
while True:
X = image_gen.next()
y = mask_gen.next()
y = np.reshape(y, (mask_gen.batch_size, -1, 1))
y = y.astype('int32')
sample_weights = np.ones(y.shape)
sample_weights[y==0] = .1
sample_weights[y==255] = 0
yield X, y, sample_weights[...,0]

train_gen = segmentation_generator(image_generator, mask_generator)

model.fit_generator(train_gen, ...)

It works, but I'm concerned since this implementation doesn't avoid duplicate data when using multiprocessing, as I'm not using keras.utils.Sequence object.

How should I modify segmentation_generator then?

Thanks in advance

Issue 2:
I am learning python and started working with existing codes in google, but this code is not providing proper output , always giving wrong value.

import nltk

nltk.download('punkt')

nltk.download('wordnet')

from nltk.stem import WordNetLemmatizer

lemmatizer = WordNetLemmatizer()

import json

import pickle

import numpy as np

from keras.models import Sequential

from keras.layers import Dense, Activation, Dropout

from keras.optimizers import SGD

import random

import tensorflow as tf

import tensorflow_hub as hub

import tensorflow_datasets as tfds

intents_file = open('intents.json').read()

intents = json.loads(intents_file)

words=[]

classes = []

documents = []

ignore_letters = []

for intent in intents['intents']:

for pattern in intent['patterns']:

#tokenize each word

w = nltk.word_tokenize(pattern)

words.extend(w)

#add documents in the corpus

documents.append((w, intent['tag']))

# add to our classes list

if intent['tag'] not in classes:

classes.append(intent['tag'])

print(documents)

# lemmatize, lower each word and remove duplicates
words = [lemmatizer.lemmatize(w.lower()) for w in words if w not in ignore_letters]
words = sorted(list(set(words)))
# sort classes
classes = sorted(list(set(classes)))
# documents = combination between patterns and intents
print(len(documents), "documents")
# classes = intents
print(len(classes), "classes", classes)
# words = all words, vocabulary
print(len(words), "unique lemmatized words", words)
pickle.dump(words, open('words.pkl', 'wb'))
pickle.dump(classes, open('classes.pkl', 'wb'))
# create our training data
training = []
# create an empty array for our output
output_empty = [0] * len(classes)
# training set, bag of words for each sentence
for doc in documents:
# initialize our bag of words
bag = []
# list of tokenized words for the pattern
pattern_words = doc[0]
# lemmatize each word - create base word, in attempt to represent related words
pattern_words = [lemmatizer.lemmatize(word.lower()) for word in pattern_words]
# create our bag of words array with 1, if word match found in current pattern
for w in words:
bag.append(1) if w in pattern_words else bag.append(0)
# output is a '0' for each tag and '1' for current tag (for each pattern)
output_row = list(output_empty)
output_row[classes.index(doc[1])] = 1
training.append([bag, output_row])
# shuffle our features and turn into np.array
random.shuffle(training)
training = np.array(training)
# create train and test lists. X - patterns, Y - intents
train_x = list(training[:, 0])
train_y = list(training[:, 1])
print("Training data created")

# Create model - 3 layers. First layer 128 neurons, second layer 64 neurons and 3rd output layer contains number of neurons
# equal to number of intents to predict output intent with softmax
model = Sequential()
model.add(Dense(128, input_shape=(len(train_x[0]),), activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(len(train_y[0]), activation='softmax'))
# Compile model. Stochastic gradient descent with Nesterov accelerated gradient gives good results for this model
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])
# fitting and saving the model
hist = model.fit(np.array(train_x), np.array(train_y), epochs=8, batch_size=8, verbose=8)
model.save('chatbot_model.h5', hist)
print("model created")

# fitting and saving the model

hist = model.fit(np.array(train_x), np.array(train_y), epochs=1, batch_size=1, verbose=8,shuffle=True)

model.save('chatbot_model.h5', hist)

print("model created")

model.summary()

cvscores = []

scores = model.evaluate(train_x, train_y, verbose=0)

print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))

cvscores.append(scores[1] * 100)

print("%.2f%% (+/- %.2f%%)" % (numpy.mean(cvscores), numpy.std(cvscores)))