def test_compute_class_weight_auto_negative():
# Test compute_class_weight when labels are negative
# Test with balanced class labels.
classes = np.array([-2, -1, 0])
y = np.asarray([-1, -1, 0, 0, -2, -2])
cw = assert_warns(DeprecationWarning, compute_class_weight, "auto",
classes, y)
assert_almost_equal(cw.sum(), classes.shape)
assert_equal(len(cw), len(classes))
assert_array_almost_equal(cw, np.array([1., 1., 1.]))
cw = compute_class_weight("balanced", classes, y)
assert_equal(len(cw), len(classes))
assert_array_almost_equal(cw, np.array([1., 1., 1.]))
# Test with unbalanced class labels.
y = np.asarray([-1, 0, 0, -2, -2, -2])
cw = assert_warns(DeprecationWarning, compute_class_weight, "auto",
classes, y)
assert_almost_equal(cw.sum(), classes.shape)
assert_equal(len(cw), len(classes))
assert_array_almost_equal(cw, np.array([0.545, 1.636, 0.818]), decimal=3)
cw = compute_class_weight("balanced", classes, y)
assert_equal(len(cw), len(classes))
class_counts = np.bincount(y + 2)
assert_almost_equal(np.dot(cw, class_counts), y.shape[0])
assert_array_almost_equal(cw, [2. / 3, 2., 1.])
def test_compute_class_weight():
# Test (and demo) compute_class_weight.
y = np.asarray([2, 2, 2, 3, 3, 4])
classes = np.unique(y)
cw = compute_class_weight("auto", classes, y)
assert_almost_equal(cw.sum(), classes.shape)
assert_true(cw[0] < cw[1] < cw[2])
def test_compute_class_weight_auto_negative():
# Test compute_class_weight when labels are negative
# Test with balanced class labels.
classes = np.array([-2, -1, 0])
y = np.asarray([-1, -1, 0, 0, -2, -2])
cw = compute_class_weight("auto", classes, y)
assert_almost_equal(cw.sum(), classes.shape)
assert_equal(len(cw), len(classes))
assert_array_almost_equal(cw, np.array([1., 1., 1.]))
# Test with unbalanced class labels.
y = np.asarray([-1, 0, 0, -2, -2, -2])
cw = compute_class_weight("auto", classes, y)
assert_almost_equal(cw.sum(), classes.shape)
assert_equal(len(cw), len(classes))
assert_array_almost_equal(cw, np.array([0.545, 1.636, 0.818]), decimal=3)
def test_compute_class_weight_auto_unordered():
# Test compute_class_weight when classes are unordered
classes = np.array([1, 0, 3])
y = np.asarray([1, 0, 0, 3, 3, 3])
cw = compute_class_weight("auto", classes, y)
assert_almost_equal(cw.sum(), classes.shape)
assert_equal(len(cw), len(classes))
assert_array_almost_equal(cw, np.array([1.636, 0.818, 0.545]), decimal=3)
def test_compute_class_weight_not_present():
"""Test compute_class_weight in case y doesn't contain all classes."""
classes = np.arange(4)
y = np.asarray([0, 0, 0, 1, 1, 2])
cw = compute_class_weight("auto", classes, y)
assert_almost_equal(cw.sum(), classes.shape)
assert_equal(len(cw), len(classes))
assert_true(cw[0] < cw[1] < cw[2] <= cw[3])
def test_compute_class_weight_balanced_negative():
# Test compute_class_weight when labels are negative
# Test with balanced class labels.
classes = np.array([-2, -1, 0])
y = np.asarray([-1, -1, 0, 0, -2, -2])
cw = compute_class_weight("balanced", classes, y)
assert_equal(len(cw), len(classes))
assert_array_almost_equal(cw, np.array([1., 1., 1.]))
# Test with unbalanced class labels.
y = np.asarray([-1, 0, 0, -2, -2, -2])
cw = compute_class_weight("balanced", classes, y)
assert_equal(len(cw), len(classes))
class_counts = np.bincount(y + 2)
assert_almost_equal(np.dot(cw, class_counts), y.shape[0])
assert_array_almost_equal(cw, [2. / 3, 2., 1.])
def test_compute_class_weight_balanced_unordered():
# Test compute_class_weight when classes are unordered
classes = np.array([1, 0, 3])
y = np.asarray([1, 0, 0, 3, 3, 3])
cw = compute_class_weight("balanced", classes, y)
class_counts = np.bincount(y)[classes]
assert_almost_equal(np.dot(cw, class_counts), y.shape[0])
assert_array_almost_equal(cw, [2., 1., 2. / 3])
def test_compute_class_weight():
# Test (and demo) compute_class_weight.
y = np.asarray([2, 2, 2, 3, 3, 4])
classes = np.unique(y)
cw = compute_class_weight("balanced", classes, y)
# total effect of samples is preserved
class_counts = np.bincount(y)[2:]
assert_almost_equal(np.dot(cw, class_counts), y.shape[0])
assert cw[0] < cw[1] < cw[2]
def test_compute_class_weight_default():
# Test for the case where no weight is given for a present class.
# Current behaviour is to assign the unweighted classes a weight of 1.
y = np.asarray([2, 2, 2, 3, 3, 4])
classes = np.unique(y)
classes_len = len(classes)
# Test for non specified weights
cw = compute_class_weight(None, classes, y)
assert_equal(len(cw), classes_len)
assert_array_almost_equal(cw, np.ones(3))
# Tests for partly specified weights
cw = compute_class_weight({2: 1.5}, classes, y)
assert_equal(len(cw), classes_len)
assert_array_almost_equal(cw, [1.5, 1., 1.])
cw = compute_class_weight({2: 1.5, 4: 0.5}, classes, y)
assert_equal(len(cw), classes_len)
assert_array_almost_equal(cw, [1.5, 1., 0.5])
def test_compute_class_weight_auto_unordered():
# Test compute_class_weight when classes are unordered
classes = np.array([1, 0, 3])
y = np.asarray([1, 0, 0, 3, 3, 3])
cw = assert_warns(DeprecationWarning, compute_class_weight, "auto", classes, y)
assert_almost_equal(cw.sum(), classes.shape)
assert_equal(len(cw), len(classes))
assert_array_almost_equal(cw, np.array([1.636, 0.818, 0.545]), decimal=3)
cw = compute_class_weight("balanced", classes, y)
class_counts = np.bincount(y)[classes]
assert_almost_equal(np.dot(cw, class_counts), y.shape[0])
assert_array_almost_equal(cw, [2.0, 1.0, 2.0 / 3])
def test_compute_class_weight():
# Test (and demo) compute_class_weight.
y = np.asarray([2, 2, 2, 3, 3, 4])
classes = np.unique(y)
cw = assert_warns(DeprecationWarning, compute_class_weight, "auto", classes, y)
assert_almost_equal(cw.sum(), classes.shape)
assert_true(cw[0] < cw[1] < cw[2])
cw = compute_class_weight("balanced", classes, y)
# total effect of samples is preserved
class_counts = np.bincount(y)[2:]
assert_almost_equal(np.dot(cw, class_counts), y.shape[0])
assert_true(cw[0] < cw[1] < cw[2])
def test_compute_class_weight_dict():
classes = np.arange(3)
class_weights = {0: 1.0, 1: 2.0, 2: 3.0}
y = np.asarray([0, 0, 1, 2])
cw = compute_class_weight(class_weights, classes, y)
# When the user specifies class weights, compute_class_weights should just
# return them.
assert_array_almost_equal(np.asarray([1.0, 2.0, 3.0]), cw)
# When a class weight is specified that isn't in classes, a ValueError
# should get raised
msg = "Class label 4 not present."
class_weights = {0: 1.0, 1: 2.0, 2: 3.0, 4: 1.5}
assert_raise_message(ValueError, msg, compute_class_weight, class_weights, classes, y)
msg = "Class label -1 not present."
class_weights = {-1: 5.0, 0: 1.0, 1: 2.0, 2: 3.0}
assert_raise_message(ValueError, msg, compute_class_weight, class_weights, classes, y)
new_shape = (416, 416)
re_train_images, re_train_masks = resize_images_masks(train_images,
train_masks, new_shape)
re_val_images, re_val_masks = resize_images_masks(val_images, val_masks,
new_shape)
train_images = re_train_images
train_masks = re_train_masks
val_images = re_val_images
val_masks = re_val_masks
# Compute the appropriate class weights
weights = class_weight.compute_class_weight('balanced',
np.unique(train_masks > 0.5),
(train_masks > 0.5).flatten())
# Callbacks
filepath = 'weights.hdf5'
checkpoint = ModelCheckpoint(filepath,
monitor='val_loss',
verbose=1,
save_best_only=True,
mode='min')
callbacks = [checkpoint]
# Define the model
BACKBONE = 'resnet101'
model = Unet(BACKBONE, classes=1, activation='sigmoid')
train_generator = datagen.flow_from_directory(train_data_dir,
target_size=(img_width,
img_height),
batch_size=batch_size,
class_mode="categorical",
shuffle=True)
validation_generator = test_datagen.flow_from_directory(
validation_data_dir,
target_size=(img_width, img_height),
batch_size=batch_size,
class_mode="categorical",
shuffle=True)
class_weight = class_weight.compute_class_weight(
'balanced', np.unique(train_generator.classes), train_generator.classes)
print(class_weight)
print("Downloading Base Model.....")
base_model = Xception(include_top=False, weights='imagenet')
for layer in base_model.layers:
layer.trainable = False
# get layers and add average pooling layer
## set model architechture
x = base_model.output
x = attach_attention_module(x, attention_module)
x = GlobalAveragePooling2D()(x)
def update_general(self, X, y, w, load_func, reset=False):
log = logging.getLogger(__name__)
data_size = y.shape[0]
#figure out the weights
if w is None and len(y.shape)==1:
y_unique = np.unique(y)
weights = class_weight.compute_class_weight(self.class_weight, y_unique, y)
self.class_actual_weight_ = {}
for i, y_val in enumerate(y_unique):
self.class_actual_weight_[y_val] = weights[i]
w = np.zeros(data_size)
for i,v in enumerate(y):
w[i] = self.class_actual_weight_[v]
elif w is None:
log.warn('Do not know how to make class weights for multidimensinal output. If neeed, specify weights directly. Assuming uniform weights.')
w = np.ones(data_size)
else:
assert w.shape[0]==data_size, 'Weight size should match data size.'
if self.background:
queue = multiprocessing.Queue()
else:
queue = Queue.Queue()
log.info('Starting to fit the NN model.')
if self.callbacks is not None:
for callback in self.callbacks:
if callback is not None:
callback.on_train_begin(self)
for epoch in xrange(self.nb_epoch):
last_update = time.time()-1000
start_time = time.time()
#generate the progress bar
if self.verbose>0:
progbar = Progbar(data_size, width=80, verbose=self.verbose)
#get random permutation
p = np.random.permutation(range(data_size))
#load the first batch
batch_idx = p[0:self.memory_batch_size];
self.matrix_load_into_queue(X, batch_idx, queue, load_func, y, w);
X_batch,y_batch,w_batch = queue.get()
if reset and epoch==0:
n_features = self.get_dimensions(X_batch)
log.info('Compiling the NN model with {} dimensions.'.format(n_features))
self.generate_and_compile_model_(n_features)
samples = 0
for batch, i in enumerate(xrange(0, len(p), self.memory_batch_size)):
#compute indicies for next batch
next_start = i+len(batch_idx)
next_end = min(len(p), next_start+self.memory_batch_size)
if next_end>next_start:
#spin the thread up
batch_idx_next = p[next_start:next_end];
#load data in background
thread = 0
if self.background:
thread = multiprocessing.Process(target=self.matrix_load_into_queue, args=(X,batch_idx_next,queue,load_func, y, w))
thread.start()
else:
batch_idx_next = None
thread = None
#perform update
loss = self.batch_update(X_batch, y_batch, w_batch)
#increment the counter
samples+= len(batch_idx)
curr_update = time.time()
if self.verbose>0 and (curr_update-last_update>=0.5 or (samples)>=len(p)):
progbar.update(samples, [('Loss', loss)])
last_update = curr_update
if self.callbacks is not None:
for callback in self.callbacks:
if callback is not None:
r = callback.on_batch_end(self, epoch+1, batch+1)
#wait for the next load to happen
if thread is not None:
#if no background, load the data now
if not self.background:
self.matrix_load_into_queue(X, batch_idx, queue, load_func, y, w)
X_batch,y_batch,w_batch = queue.get()
#if loading a background process, do a join
if self.background:
thread.join()
#now add the next batch
batch_idx = batch_idx_next
finish_time = time.time()-start_time
if self.verbose>0:
log.info('Finished epoch {}/{}. Time per epoch (s): {:0.2f}, Time per sample (s): {}.'.format(epoch+1, self.nb_epoch,finish_time,finish_time/len(p)))
#process the end of epoch, and see if need to quit out
quit_now = False
if self.callbacks is not None:
for callback in self.callbacks:
if callback is not None:
r = callback.on_epoch_end(self, epoch+1)
if r is not None and r is True:
quit_now = True
if quit_now:
break
return self
encoder = LabelEncoder()
y_train = encoder.fit_transform(train['sentiment'].values)
y_train = to_categorical(y_train)
y_test = encoder.fit_transform(test['sentiment'].values)
y_test = to_categorical(y_test)
# get an idea of the distribution of the text values
from collections import Counter
ctr = Counter(train['sentiment'].values)
print('Distribution of Classes:', ctr)
# get class weights for the training data, this will be used data
y_train_int = np.argmax(y_train, axis=1)
cws = class_weight.compute_class_weight('balanced', np.unique(y_train_int),
y_train_int)
print(cws)
print('Dominant Class: ', ctr.most_common(n=1)[0][0])
print('Baseline Accuracy Dominant Class',
(ctr.most_common(n=1)[0][0] == test['sentiment'].values).mean())
preds = np.zeros_like(y_test)
preds[:, 0] = 1
preds[0] = 1 #done to suppress warning from numpy for f1 score
print('F1 Score:', f1_score(y_test, preds, average='weighted'))
def threshold_search(y_true, y_proba, average=None):
best_threshold = 0
best_score = 0
model = create_lstm(len(X_train[0]))
model.summary()
# save checkpoint
filepath = checkpoint_dir + "/weightsRibo250-improvement-{epoch:02d}-{val_acc:.2f}.hdf5"
checkpoint = ModelCheckpoint(filepath,
monitor='val_acc',
verbose=0,
save_best_only=True,
mode='max')
callbacks_list = [checkpoint]
print('Fitting model...')
print(np.unique(y_train))
class_weight = class_weight.compute_class_weight(
'balanced', np.unique(y_train),
y_train) # y_ints = [y.argmax() for y in y_train]
print("Class Weights")
print(class_weight)
history = model.fit(X_train,
y_train,
batch_size=BATCH_SIZE,
class_weight=class_weight,
epochs=EPOCHS,
callbacks=callbacks_list,
validation_split=0.2,
verbose=1,
shuffle=True)
# history = model.fit(X_train, y_train, batch_size=BATCH_SIZE, class_weight="auto", epochs=EPOCHS, callbacks=callbacks_list, validation_split = 0.1, verbose = 1)
# serialize model to JSON
train = X_train/X_train.max() # centering the data
X_valid = X_valid/X_train.max()
# i. Building the model
model = Sequential()
model.add(InputLayer((7*7*512,))) # input layer
model.add(Dense(units=1024, activation='relu', input_dim=7*7*512)) # hidden layer
model.add(Dropout(0.5)) # adding dropout
model.add(Dense(units=512, activation='relu')) # hidden layer
model.add(Dropout(0.5)) # adding dropout
model.add(Dense(units=256, activation='relu')) # hidden layer
model.add(Dropout(0.5)) # adding dropout
model.add(Dense(3, activation='softmax')) # output layer
# ii. Compiling the model
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
# iii. Training the model
# model.fit(train, y_train, epochs=100, validation_data=(X_valid, y_valid))
class_weights = compute_class_weight('balanced',np.unique(data.Class), data.Class) # computing weights of different classes
filepath="weights.best.hdf5"
checkpoint = ModelCheckpoint(filepath, monitor='val_loss', verbose=1, save_best_only=True, mode='min')
callbacks_list = [checkpoint] # model check pointing based on validation loss
model.fit(train, y_train, epochs=100, validation_data=(X_valid, y_valid), class_weight=class_weights, callbacks=callbacks_list)
drop_last=True)
test_loader = torch.utils.data.DataLoader(MyDataset(test_set, test_label),
batch_size=BATCH_SIZE)
model = CapsuleNet()
model = nn.DataParallel(model).cuda()
optimizer = Adam(model.parameters())
capsule_loss = CapsuleLoss()
train_loss_curve = []
test_loss_curve = []
train_acc_curve = []
test_acc_curve = []
classes = [0, 1]
weight = compute_class_weight('balanced', classes, training_label)
# train(train_loader, test_loader)
for epoch in range(NUM_EPOCHS):
# TRAIN MODE
model.train()
train_loss = 0
train_acc = 0
for batch_id, (data, target) in tqdm(enumerate(train_loader, 0),
desc='Batch',
total=len(train_loader)):
target = torch.sparse.torch.eye(NUM_CLASSES).index_select(
dim=0, index=target)
weighted_target = [weight] * BATCH_SIZE
weighted_target = Variable(
torch.tensor(weighted_target).float() * target).cuda()
def mode
# Retrieve data from pickle file.
# From ubs_process.py, will be a 3-item tuple(X, y(categorical matrix), folds)
vec_type = 'mels'
data_path = os.path.join('pickles', 'urbansound_'+ vec_type + '.p')
with open(data_path, 'rb') as handle:
data = pickle.load(handle)
X, y, folds = data[0], data[1], data[2]
# Pre-specify global variables for model
# num_rows as specified by number of mfccs or mels.
# Columns expected to be same as <max_pad_len> in ubs_process
if vec_type == 'mfccs':
num_rows = 40
elif vec_type == 'mels':
num_rows = 60
num_columns = 174
num_channels = 1
X = X.reshape(X.shape[0], num_rows, num_columns, num_channels)
num_labels = y.shape[1]
filter_size = 2
### TRAINING
# user specified number of epochs
num_epochs = int(input('Enter number of epochs: '))
# num_epochs = 72
num_batch_size = 8
# start the timer before training. This will include all the fold durations
start = datetime.now()
# print a model summary
tmp = get_conv_model()
tmp.summary()
### Cross validation. Fold indices pre-specified for UrbanSound8k dataset
fold_accuracies = {}
logo = LeaveOneGroupOut()
for train_idx, test_idx in logo.split(X, y, folds):
## test_idx groups samples with the same fold, train_idx is all NOT in the test fold
X_train, X_test, y_train, y_test = X[train_idx], X[test_idx], y[train_idx], y[test_idx]
### compute class weights
y_flat = np.argmax(y_train, axis=1)
class_weights = compute_class_weight(class_weight='balanced' , classes=np.unique(y_flat), y=y_flat )
fold = folds[test_idx][0]
model = get_conv_model()
#create checkpoint to save best model
checkpoint = ModelCheckpoint(filepath=f'models/{vec_type}/cnn_fold{fold}.hdf5',
monitor='val_acc', verbose=1, save_best_only=True,
save_weights_only=False)
# add early stopping checkpoint
earlystop = EarlyStopping(monitor='val_acc', patience=50, mode='auto')
# put the different runs into a tensorboard log directory
log_dir = f"logs/fit/fold{fold}_" + datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard = TensorBoard(log_dir=log_dir, histogram_freq=2,
batch_size=num_batch_size, write_graph=True,
write_grads=True, write_images=True)
start_fold = datetime.now()
history = model.fit(X_train, y_train, batch_size=num_batch_size,
epochs=num_epochs, class_weight=class_weights, validation_data=(X_test, y_test),
callbacks=[checkpoint, earlystop, tensorboard], verbose=1)
duration_fold = datetime.now() - start_fold
print("Fold training completed in time: ", duration_fold)
score_test = history.history['val_acc'][-1]
print("Final Testing Accuracy: ", score_test)
best_score = max(history.history['val_acc'])
print("Best Testing Accuracy: ", best_score)
fold_accuracies[fold] = best_score
clear_session()
### Review results of total training
duration = datetime.now() - start
print("Training completed in time: ", duration)
# compute average accuracy
for k, v in sorted(fold_accuracies.items()):
print(f'Fold {k}: accuracy = {v}')
avg_score = np.mean([v for v in fold_accuracies.values()])
print('Average Accuracy: ', avg_score)
im = cv2.resize(cv2.imread(image_file), (wd, ht))
#im = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
X_train.append(im)
Y_train.append([0, 1])
print(image_file)
return X_train, Y_train
X_train, labels = datasetCreate(TR_0_folder, TR_1_folder)
X_train = np.array(X_train)
labels = np.array(labels)
tr_indices = np.argmax(labels, axis=1)
cw = class_weight.compute_class_weight(class_weight='balanced',
classes=np.unique(
np.argmax(labels, axis=1)),
y=np.argmax(labels, axis=1))
print(cw)
a = optimizers.Adam(lr=0.0005)
base_model = ResNet50(weights=None,
include_top=True,
input_shape=(wd, ht, 3),
classes=2)
for layer in base_model.layers:
layer.trainable = True
base_model.compile(optimizer=a,
loss='categorical_crossentropy',
totalLosses = all[:, 0].sum()
giniSum = all[:, 0].cumsum().sum() / totalLosses
giniSum -= (len(actual) + 1) / 2.
return giniSum / len(actual)
def gini_normalized(a, p):
return gini(a, p) / gini(a, a)
model.compile(loss='binary_crossentropy', optimizer=OPTIMIZER, metrics=['acc'])
# Adjust class weights
from sklearn.utils import class_weight
class_weight = class_weight.compute_class_weight('balanced', np.unique(y), y)
class_weight_dict = dict(enumerate(class_weight))
# Train
history = model.fit(x_train,
y_train,
batch_size=BATCH_SIZE,
epochs=NB_EPOCH,
verbose=VERBOSE,
validation_split=VALIDATION_SPLIT,
class_weight=class_weight_dict)
score = model.evaluate(x_test, y_test, verbose=0)
print("Test score:", score[0])
print('Test accuracy:', score[1])
# Calculate gini of test
def weight_categorical_crossentropy(weights):
weights = K.variable(weights)
def loss(y_true, y_pred):
y_pred /= K.sum(y_pred, axis=-1, keepdims=True)
y_pred = K.clip(y_pred, K.epsilon(), 1 - K.epsilon())
loss = y_true * K.log(y_pred) * weights
loss = -K.sum(loss, -1)
return loss
return loss
class_weights = class_weight.compute_class_weight('balanced',
np.unique(y_train.target),
y_train.target)
print(class_weights)
# Here is our playground for testing with weights
class_weights = [1.5, 0.5, 1, 1] # TODO use api result instead 05281347
def fit_hydra_head_model(fX_train, fy_train, fX_valid, fy_valid, n_model):
oy_train = to_categorical(
fy_train
) # https://www.tensorflow.org/api_docs/python/tf/keras/utils/to_categorical
oy_valid = to_categorical(fy_valid)
model = Sequential(head_nn_models[n_model])
def train_DNN(X_train, X_test, y_train, y_test, base_X_train):
# def focal_loss(y_true, y_pred):
# gamma = 2.0
# alpha = 0.25
# pt_1 = tf.where(tf.equal(y_true, 1), y_pred, tf.ones_like(y_pred))
# pt_0 = tf.where(tf.equal(y_true, 0), y_pred, tf.zeros_like(y_pred))
# # pt_1 = K.clip(pt_1, 1e-3, .999)
# # pt_0 = K.clip(pt_0, 1e-3, .999)
#
# return -K.sum(alpha * K.pow(1. - pt_1, gamma) * K.log( pt_1))-K.sum((1-alpha) * K.pow( pt_0, gamma) * K.log(1. - pt_0 ))
#bias for predictions
fl_pi = 0.01
final_bias = -np.log((1 - fl_pi) / fl_pi)
num_labels = len(set(y_test))
from sklearn.utils import class_weight
class_weights = class_weight.compute_class_weight('balanced',
np.unique(y_train),
y_train)
tf.keras.backend.clear_session()
fast_NN = Sequential(name='quick')
#fast_NN.add(GaussianNoise(.5))
fast_NN.add(Dense(512, activation='sigmoid', name='input'))
fast_NN.add(Dropout(0.5))
fast_NN.add(
Dense(128,
activation='relu',
name='first',
bias_initializer=tf.keras.initializers.Constant(value=0.1)))
#fast_NN.add(Dropout(0.5))
fast_NN.add(
Dense(64,
activation='relu',
name='second',
bias_initializer=tf.keras.initializers.Constant(value=0.1)))
#fast_NN.add(Dropout(0.5))
fast_NN.add(
Dense(16,
activation='relu',
name='third',
bias_initializer=tf.keras.initializers.Constant(value=0.1)))
#fast_NN.add(Dropout(0.25))
fast_NN.add(
Dense(
num_labels,
activation='softmax',
name='predict',
bias_initializer=tf.keras.initializers.Constant(value=final_bias)))
fast_NN.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=[
'categorical_accuracy',
tf.keras.metrics.Recall(),
tf.keras.metrics.Precision()
])
fast_NN_model = fast_NN.fit(X_train,
to_categorical(y_train),
validation_data=(X_test,
to_categorical(y_test)),
epochs=10,
batch_size=500,
class_weight=class_weights,
shuffle=True,
verbose=0)
test_NN_test_preds = fast_NN.predict(X_test)
train_NN_test_preds = fast_NN.predict(X_train)
base_train_NN_test_preds = fast_NN.predict(base_X_train)
return train_NN_test_preds[:,
1], test_NN_test_preds[:,
1], base_train_NN_test_preds[:,
1], fast_NN_model.history
labels_gt = labels_gt[labels_gt < 2]
#%%
batch_size = 128
num_classes = 2
epochs = 5
test_fraction = 0.25
augmentation = True
# input image dimensions
img_rows, img_cols = 50, 50
x_train, x_test, y_train, y_test = train_test_split(
all_masks_gt, labels_gt, test_size=test_fraction)
class_weight = cw.compute_class_weight('balanced', np.unique(y_train), y_train)
if K.image_data_format() == 'channels_first':
x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)
x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)
input_shape = (1, img_rows, img_cols)
else:
x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
#x_train /= 255
#x_test /= 255
print('x_train shape:', x_train.shape)
def fit(self,
x_train: List[List[str]],
y_train: Union[List[str], List[List[str]], List[Tuple[str]]],
x_validate: List[List[str]] = None,
y_validate: Union[List[str], List[List[str]],
List[Tuple[str]]] = None,
batch_size: int = 64,
epochs: int = 5,
class_weight: bool = False,
fit_kwargs: Dict = None,
**kwargs):
"""
:param x_train: list of training data.
:param y_train: list of training target label data.
:param x_validate: list of validation data.
:param y_validate: list of validation target label data.
:param batch_size: batch size for trainer model
:param epochs: Number of epochs to train the model.
:param class_weight: set class weights for imbalanced classes
:param fit_kwargs: additional kwargs to be passed to
:func:`~keras.models.Model.fit`
:param kwargs:
:return:
"""
assert len(x_train) == len(y_train)
self.build_token2id_label2id_dict(x_train, y_train, x_validate,
y_validate)
if len(x_train) < batch_size:
batch_size = len(x_train) // 2
if not self.model:
if self.embedding.sequence_length == 0:
self.embedding.sequence_length = sorted(
[len(x) for x in x_train])[int(0.95 * len(x_train))]
logging.info('sequence length set to {}'.format(
self.embedding.sequence_length))
self.build_model()
train_generator = self.get_data_generator(
x_train, y_train, batch_size, is_bert=self.embedding.is_bert)
if fit_kwargs is None:
fit_kwargs = {}
if x_validate:
validation_generator = self.get_data_generator(
x_validate,
y_validate,
batch_size,
is_bert=self.embedding.is_bert)
fit_kwargs['validation_data'] = validation_generator
fit_kwargs['validation_steps'] = max(
len(x_validate) // batch_size, 1)
if class_weight:
y_list = self.convert_label_to_idx(y_train)
class_weights = class_weight_calculte.compute_class_weight(
'balanced', np.unique(y_list), y_list)
else:
class_weights = None
self.model.fit_generator(train_generator,
steps_per_epoch=len(x_train) // batch_size,
epochs=epochs,
class_weight=class_weights,
**fit_kwargs)
loss = 'mse'
model_type = 'lstm_time'
base_path = '/scratch/sk7898/pedbike/window_256'
out_dir = '/scratch/sk7898/radar_counting/models/'
batch_size = 64
scaling = False
fileloc = os.path.join(base_path, 'downstream_time')
x_train, x_val, x_test, y_train, y_val, y_test, seqs_train, seqs_val, seqs_test = get_data(
fileloc)
n_bins = int(len(seqs_train) / batch_size)
assert x_train.shape[0] == y_train.shape[0] == seqs_train.shape[0]
class_weights = class_weight.compute_class_weight('balanced',
np.unique(list(y_train)),
y_train)
n_timesteps, n_features = None, window * 2
input_shape = (n_timesteps, n_features)
y_val = np.array(y_val).reshape(-1, 1)
train_gen = train_generator(n_bins,
x_train,
y_train,
seq_lengths=seqs_train,
padding=True,
padding_value=0.0)
val_gen = val_generator(x_val, y_val)
output_dir = os.path.join(out_dir + loss, model_type)
thio_X = X.iloc[24550:24650, :]
thio_y = y_.iloc[24550:24650]
X = X.drop(X.index[24550:24650])
y_ = y_.drop(y_.index[24550:24650])
y_w = y_w.drop(y_w.index[24550:24650])
X_test = pd.concat([metal_X, sulph_X, dis_X, thio_X], axis=0)
y_test = np.asarray(pd.concat([metal_y, sulph_y, dis_y, thio_y], axis=0))
y_train = np.asarray(y_)
X_train = X
y_w = list(y_w.values)
encoder = LabelEncoder()
encoder.fit(y_w)
y_w = encoder.transform(y_w)
class_weights = class_weight.compute_class_weight('balanced', np.unique(y_w),
y_w)
print(class_weights, np.unique(y_w))
X_train, y_train = shuffle(X_train, y_train, random_state=42)
y_ = pd.DataFrame(y_)
X_train = np.expand_dims(X_train, axis=2)
X_test = np.expand_dims(X_test, axis=2)
# NN (Skip Connections) Model
input_ = Input(shape=(
len(X.columns),
1,
))
x = Conv1D(128, (3),
padding='same',
def computeClassWeight_balanced(cls, lY):
Y = np.hstack(lY)
Y_unique = np.unique(Y)
class_weights = compute_class_weight("balanced", Y_unique, Y)
del Y, Y_unique
return class_weights
def get_weight(y):
class_weight_current = class_weight.compute_class_weight(
'balanced', np.unique(y), y)
return class_weight_current
'dim_x': MAX_QRY_LENGTH,
'dim_y': MAX_DOC_LENGTH,
'dim_x1': NUM_OF_FEATS,
'batch_size': batch_size,
'shuffle': True
}
'''
# Datasets
partition = # IDs
{'train': ['id-1', 'id-2', 'id-3'], 'validation': ['id-4']}
labels = # Labels
{'id-1': 0, 'id-2': 1, 'id-3': 2, 'id-4': 1}
'''
[partition, labels, partition_answer] = input_data_process.genTrainValidSet()
class_weight = class_weight.compute_class_weight(
'balanced', np.unique(partition_answer['train']),
partition_answer['train'])
class_weight = {0: class_weight[0], 1: class_weight[1]}
print "Training: ", len(partition['train'])
print "Validation: ", len(partition['validation'])
print "Class Weight:", class_weight
# Generators
training_generator = DataGenerator(**params).generate(labels,
partition['train'])
validation_generator = DataGenerator(**params).generate(
labels, partition['validation'])
# Model check point
checkpoint = ModelCheckpoint(exp_path,
def Conv2DClassifierIn1(x_train, y_train, x_test, y_test):
summary = True
verbose = 1
# setHyperParams------------------------------------------------------------------------------------------------
batch_size = {{choice([32, 64, 128, 256, 512])}}
epoch = {{choice([25, 50, 75, 100, 125, 150, 175, 200])}}
conv_block = {{choice(['two', 'three', 'four'])}}
conv1_num = {{choice([8, 16, 32, 64])}}
conv2_num = {{choice([16, 32, 64, 128])}}
conv3_num = {{choice([32, 64, 128])}}
conv4_num = {{choice([32, 64, 128, 256])}}
dense1_num = {{choice([128, 256, 512])}}
dense2_num = {{choice([64, 128, 256])}}
l1_regular_rate = {{uniform(0.00001, 1)}}
l2_regular_rate = {{uniform(0.000001, 1)}}
drop1_num = {{uniform(0.1, 1)}}
drop2_num = {{uniform(0.0001, 1)}}
activator = {{choice(['elu', 'relu', 'tanh'])}}
optimizer = {{choice(['adam', 'rmsprop', 'SGD'])}}
#---------------------------------------------------------------------------------------------------------------
kernel_size = (3, 3)
pool_size = (2, 2)
initializer = 'random_uniform'
padding_style = 'same'
loss_type = 'binary_crossentropy'
metrics = ['accuracy']
my_callback = None
# early_stopping = EarlyStopping(monitor='val_loss', patience=4)
# checkpointer = ModelCheckpoint(filepath='keras_weights.hdf5',
# verbose=1,
# save_best_only=True)
# my_callback = callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.2,
# patience=5, min_lr=0.0001)
# build --------------------------------------------------------------------------------------------------------
input_layer = Input(shape=x_train.shape[1:])
conv = layers.Conv2D(conv1_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(input_layer)
conv = layers.Conv2D(conv1_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(conv)
pool = layers.MaxPooling2D(pool_size, padding=padding_style)(conv)
if conv_block == 'two':
conv = layers.Conv2D(conv2_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(pool)
conv = layers.Conv2D(conv2_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(conv)
BatchNorm = layers.BatchNormalization(axis=-1)(conv)
pool = layers.MaxPooling2D(pool_size, padding=padding_style)(BatchNorm)
elif conv_block == 'three':
conv = layers.Conv2D(conv2_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(pool)
conv = layers.Conv2D(conv2_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(conv)
BatchNorm = layers.BatchNormalization(axis=-1)(conv)
pool = layers.MaxPooling2D(pool_size, padding=padding_style)(BatchNorm)
conv = layers.Conv2D(conv3_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(pool)
conv = layers.Conv2D(conv3_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(conv)
BatchNorm = layers.BatchNormalization(axis=-1)(conv)
pool = layers.MaxPooling2D(pool_size, padding=padding_style)(BatchNorm)
elif conv_block == 'four':
conv = layers.Conv2D(conv2_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(pool)
conv = layers.Conv2D(conv2_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(conv)
BatchNorm = layers.BatchNormalization(axis=-1)(conv)
pool = layers.MaxPooling2D(pool_size, padding=padding_style)(BatchNorm)
conv = layers.Conv2D(conv3_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(pool)
conv = layers.Conv2D(conv3_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(conv)
BatchNorm = layers.BatchNormalization(axis=-1)(conv)
pool = layers.MaxPooling2D(pool_size, padding=padding_style)(BatchNorm)
conv = layers.Conv2D(conv4_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(pool)
conv = layers.Conv2D(conv4_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(conv)
BatchNorm = layers.BatchNormalization(axis=-1)(conv)
pool = layers.MaxPooling2D(pool_size, padding=padding_style)(BatchNorm)
flat = layers.Flatten()(pool)
drop = layers.Dropout(drop1_num)(flat)
dense = layers.Dense(dense1_num,
activation=activator,
kernel_regularizer=regularizers.l1_l2(
l1=l1_regular_rate, l2=l2_regular_rate))(drop)
BatchNorm = layers.BatchNormalization(axis=-1)(dense)
drop = layers.Dropout(drop2_num)(BatchNorm)
dense = layers.Dense(dense2_num,
activation=activator,
kernel_regularizer=regularizers.l1_l2(
l1=l1_regular_rate, l2=l2_regular_rate))(drop)
output_layer = layers.Dense(len(np.unique(y_train)),
activation='softmax')(dense)
model = models.Model(inputs=input_layer, outputs=output_layer)
if summary:
model.summary()
# train(self):
class_weights = class_weight.compute_class_weight('balanced',
np.unique(y_train),
y_train.reshape(-1))
class_weights_dict = dict(enumerate(class_weights))
model.compile(
optimizer=optimizer,
loss=loss_type,
metrics=metrics # accuracy
)
result = model.fit(x=x_train,
y=y_train,
batch_size=batch_size,
epochs=epoch,
verbose=verbose,
callbacks=my_callback,
validation_data=(x_test, y_test),
shuffle=True,
class_weight=class_weights_dict)
validation_acc = np.amax(result.history['val_acc'])
print('Best validation acc of epoch:', validation_acc)
return {'loss': -validation_acc, 'status': STATUS_OK, 'model': model}
def train(self, train_params):
if self.training_data["loaded"]:
try:
x = self.training_data["x_data"]
y = self.model_data["y_labels"]
epochs = train_params["epochs"]
batch_size = train_params["batch_size"]
except Exception as e:
print("Incorrect training parameters! ", e)
return False
else:
print("Training data not loaded!")
return False
model = self.model
run_threaded = False
if train_params.get("threaded"):
model = train_params["model"].model
run_threaded = True
if "eval_data" in train_params:
eval_data = train_params["eval_data"]
if isinstance(eval_data, float):
x, xTest, y, yTest = train_test_split(x,
y,
test_size=eval_data)
eval_data = (xTest, yTest)
else:
eval_data = None
y_ints = [d.argmax() for d in y]
class_weights = class_weight.compute_class_weight(
'balanced', np.unique(y_ints), y_ints)
class_weights = dict(enumerate(class_weights))
cb = []
plot_cb = train_params.get("plot_cb", None)
stop_cb = train_params.get("stop_cb", None)
save_best = train_params.get("save_best", None)
steps = int(np.ceil(x.shape[0] / batch_size))
func = TrainCallback(plot_cb=plot_cb,
steps_per_epoch=steps,
stop_cb=stop_cb,
save_best=save_best,
parent=self)
cb.append(func)
if plot_cb is not None:
verbose = 0
else:
verbose = 1
if "dropout" in train_params:
dropout = train_params["dropout"]
if isinstance(dropout, dict):
if dropout["monitor"] in [
"acc", "val_acc", "loss", "val_loss"
]:
cb_early_stop = EarlyStopping(
monitor=dropout["monitor"],
min_delta=dropout["min_delta"],
patience=dropout["patience"],
verbose=verbose,
mode="auto")
cb.append(cb_early_stop)
# This will only save the model, nothing else!
'''
if train_params.get("save_best"):
cb_best = ModelCheckpoint(os.path.join(train_params["save_best"], "best_model.npy"),
monitor="val_loss",
verbose=0,
save_best_only=True,
save_weights_only=False,
mode="auto",
period=1
)
cb.append(cb_best)
'''
if run_threaded:
tf_session = train_params["session"].as_default()
tf_graph = train_params["graph"].as_default()
else:
tf_session = self.tf_session.as_default()
tf_graph = self.tf_graph.as_default()
optimizer = None
if train_params.get("optimizer"):
optimizer = train_params["optimizer"]
with tf_session:
with tf_graph:
if optimizer is not None:
self.set_optimizer(optimizer)
if "learning_rate" in train_params:
K.set_value(model.optimizer.lr,
train_params["learning_rate"])
history = model.fit(
x,
y,
epochs=epochs,
batch_size=batch_size,
callbacks=cb,
validation_data=eval_data,
verbose=verbose,
class_weight=class_weights,
)
if run_threaded:
return model, self.get_current_graph(), self.get_current_session()
else:
return history
validation_batches = ImageDataGenerator(
rescale=1 / 255.0,
rotation_range=30,
zoom_range=0.20,
fill_mode="nearest",
shear_range=0.20,
horizontal_flip=True,
width_shift_range=0.1,
height_shift_range=0.1).flow_from_dataframe(val_df,
x_col='image_name',
y_col='target',
target_size=(224, 224),
class_mode="categorical",
shuffle=True)
class_weights = class_weight.compute_class_weight(
'balanced', np.unique(train_batches.classes), train_batches.classes)
epochs = 100
batch_size = 32
#**********************************************************************************
#***********************************************************************************
from tensorflow.keras.callbacks import ReduceLROnPlateau
from tensorflow.keras.layers import GlobalAveragePooling2D
learning_rate_reduction = ReduceLROnPlateau(monitor='val_acc',
patience=5,
verbose=1,
factor=0.5,
min_lr=1e-7)
extra_train_ids = [os.path.join(EXTRA_TRAIN_FOLDER,line.rstrip('\n')) for line in open(os.path.join(EXTRA_TRAIN_FOLDER, 'good_jpgs'))]
extra_train_ids.sort()
ids_train.extend(extra_train_ids)
extra_val_ids = glob.glob(os.path.join(EXTRA_VAL_FOLDER,'*/*.jpg'))
extra_val_ids.sort()
ids_val.extend(extra_val_ids)
classes = [get_class(idx.split('/')[-2]) for idx in ids_train]
classes_count = np.bincount(classes)
for class_name, class_count in zip(CLASSES, classes_count):
print('{:>22}: {:5d} ({:04.1f}%)'.format(class_name, class_count, 100. * class_count / len(classes)))
class_weight = class_weight.compute_class_weight('balanced', np.unique(classes), classes)
ids_test = glob.glob(os.path.join(TEST_FOLDER,'*.tif'))
train_loader = gen(ids_train, args.batch_size)
val_loader = gen(ids_val, args.batch_size)
test_loader = gen(ids_test, args.batch_size)
#%%
print(args)
#original_model = models.resnet101(pretrained=True)
original_model = globals()[args.arch](pretrained=args.pretrained)
if args.finetune:
for param in original_model.parameters():
param.requires_grad = False
def train_wrapper(filename): # filename='measurements.mat'
global dataset
global seed
global model
global ss
global mX
global nX
global mY
global nY
data = loadmat(filename) # this is a dict.
keys = list(data.keys())[3:] # skip the first three columns
values = list(data.values())[3:]
dataset = pd.DataFrame()
dataset = dataset.reindex(columns=keys) # create an empty dataframe
for ii in np.arange(len(values)):
v_ = np.array(values[ii])
dataset[keys[ii]] = pd.Series(
v_.flatten()) # cannot add the data to this empty df.
dataset['y'] = 1 * (dataset['BLER'] <= 0.1) # H-ARQ target.
dataset = dataset[['RSRP', 'TBSINR_1', 'rank', 'y']]
dataset.dropna(inplace=True, axis=0)
if os.path.exists('dataset.csv'):
dataset.to_csv('dataset.csv', index=False, mode='a',
header=False) # append
else:
dataset.to_csv('dataset.csv', index=False)
#print(dataset.head())
# Perform a split 30-70
train, test = train_test_split(dataset, test_size=0.30, random_state=seed)
X_train = train.drop('y', axis=1)
X_test = test.drop('y', axis=1)
y_train = train['y'].values
y_test = test['y'].values
mX, nX = X_train.shape
mY = y_train.shape
nY = 1
ss = MinMaxScaler(feature_range=(0, 1))
# Scale the variables
X_train_sc = ss.fit_transform(X_train)
X_test_sc = ss.transform(X_test)
model = KerasClassifier(build_fn=create_mlp,
verbose=0,
epochs=10,
batch_size=8)
# The hyperparameters
width_dims = [3, 5, 10]
n_hiddens = [3, 5] # the depth of hidden layers
hyperparameters = dict(width=width_dims, depth=n_hiddens)
class_weights = class_weight.compute_class_weight('balanced',
np.unique(y_train),
y_train)
grid = GridSearchCV(estimator=model,
param_grid=hyperparameters,
n_jobs=1,
cv=3)
gpu_available = tf.test.is_gpu_available()
if (gpu_available == False):
print('WARNING: No GPU available. Will continue with CPU.')
with tf.device('/gpu:0'):
grid_result = grid.fit(X_train_sc, y_train, class_weight=class_weights)
# This is the best model
best_model_mlp = grid_result.best_params_
print(best_model_mlp)
model = grid_result.best_estimator_
mlp = model
y_pred = mlp.predict(X_test_sc)
y_score = mlp.predict_proba(X_test_sc)
mu = accuracy_score(y_test, y_pred)
# Compute ROC curve and ROC area
try:
roc_auc = roc_auc_score(y_test, y_score[:, 1])
except:
print('WARNING: ROC was not computed. Returning NaN')
roc_auc = np.nan
print('ROC for training is: {}'.format(roc_auc))
print('Misclassification error for training is: {:.3f}'.format(1 - mu))
return [roc_auc, 1 - mu] # model is valid
def calculating_class_weights(labels):
number_dim = np.shape(labels)[1]
weights = np.empty([number_dim, 2])
for i in range(number_dim):
weights[i] = compute_class_weight('balanced', [0., 1.], labels[:, i])
return weights
def test_compute_class_weight():
"""Test (and demo) compute_class_weight."""
classes, y = unique(np.asarray([2, 2, 2, 3, 3, 4]), return_inverse=True)
cw = compute_class_weight("auto", classes, y)
assert_almost_equal(cw.sum(), classes.shape)
assert_true(cw[0] < cw[1] < cw[2])
n_tag_2 = len(np.unique(tag_2))
n_tag_3 = len(np.unique(tag_3))
n_tag_4 = len(np.unique(tag_4))
print('Creating stratified train/validation/test splits (80%, 10%, 10%)..')
sss = StratifiedShuffleSplit(n_splits=1, test_size=0.2, random_state=555)
train_index, test_valid_index = next(sss.split(allpkts, meta.filename))
sss = StratifiedShuffleSplit(n_splits=1, test_size=0.5, random_state=555)
test_index, val_index = next(
sss.split(allpkts.iloc[test_valid_index],
meta.filename.iloc[test_valid_index]))
test_index = allpkts.iloc[test_valid_index].iloc[test_index].index
val_index = allpkts.iloc[test_valid_index].iloc[val_index].index
print('Calculating class weigths..')
tag_1_class_weights = class_weight.compute_class_weight(
'balanced', np.unique(tag_1), tag_1)
tag_2_class_weights = class_weight.compute_class_weight(
'balanced', np.unique(tag_2), tag_2)
tag_3_class_weights = class_weight.compute_class_weight(
'balanced', np.unique(tag_3), tag_3)
tag_4_class_weights = class_weight.compute_class_weight(
'balanced', np.unique(tag_4), tag_4)
losses = {
'tag_1': 'sparse_categorical_crossentropy',
'tag_2': 'sparse_categorical_crossentropy',
'tag_3': 'sparse_categorical_crossentropy',
'tag_4': 'sparse_categorical_crossentropy'
}
class_weights = {
idx_to_transfer = [idx for idx in ids_train \
if get_class(idx.split('/')[-2]) == class_idx][:max_classes_val_count-classes_val_count[class_idx]]
ids_train = list(set(ids_train).difference(set(idx_to_transfer)))
ids_val.extend(idx_to_transfer)
print("Training set distribution:")
print_distribution(ids_train)
print("Validation set distribution:")
print_distribution(ids_val)
classes_train = [get_class(idx.split('/')[-2]) for idx in ids_train]
class_weight = class_weight.compute_class_weight('balanced',
np.unique(classes_train),
classes_train)
classes_val = [get_class(idx.split('/')[-2]) for idx in ids_val]
weights = [class_weight[i_class] for i_class in classes_train]
weights = torch.DoubleTensor(weights)
train_sampler = sampler.WeightedRandomSampler(weights, len(weights))
weights = [class_weight[i_class] for i_class in classes_val]
weights = torch.DoubleTensor(weights)
val_sampler = sampler.WeightedRandomSampler(weights, len(weights))
train_dataset = IEEECameraDataset(ids_train,
crop_size=CROP_SIZE,
training=True)
val_dataset = IEEECameraDataset(ids_val,
cls_train = generator_train.classes
cls_test = generator_test.classes
# 获取数据集的类名称。
class_names = list(generator_train.class_indices.keys())
# class_names # ['forky', 'knifey', 'spoony']
# 获取数据集的类别总数。
num_classes = generator_train.num_class
# print(num_classes)
# 数据集相当不平衡,在这里，我们使用scikit-learn来计算将适当平衡数据集的权重。
# 在训练期间将这些权重应用于批次中的每个图像的梯度，以便缩放对批次的总体梯度的影响
from sklearn.utils.class_weight import compute_class_weight
class_weight = compute_class_weight(class_weight='balanced',
classes=np.unique(cls_train),
y=cls_train)
# print(class_weight)
# 迁移学习
'''
预先训练的VGG16模型无法分类来自Knifey-Spoony数据集的图像。
原因可能是VGG16模型是在所谓的ImageNet数据集上进行训练的，可能没有包含许多餐具图像。
卷积神经网络的较低层可以识别图像中的许多不同形状或特征。 它是将这些特征组合成整个图像分类的最后几个完全连通的图层。
因此，我们可以尝试将VGG16模型的最后一个卷积层的输出重新路由到一个新的完全连接的神经网络，我们创建这个网络是为了在Knifey-Spoony数据集上进行分类。
首先我们打印VGG16模型的摘要，以便我们可以看到它的图层的名称和类型，以及层之间流动张量的形状。
这是我们在本教程中使用VGG16模型的主要原因之一，因为Inception v3模型有很多图层，打印出来会令人困惑。
'''
# model.summary()
def get_class_weights(y_train):
labels = np.unique(y_train)
weights = compute_class_weight('balanced', labels, y_train)
class_weight_dict = {}
for i, w in enumerate(weights):
class_weight_dict[labels[i]] = weights[i]
############################################################################
opt_DRf = keras.optimizers.SGD(momentum=0.5, lr=0.01)
DRf = Model(input=[inputs], output=[model(inputs), advmodel(inputs)])
DRf.compile(loss=[make_loss_model(c=1.0),
make_loss_advmodel(c=-lam)],
optimizer=opt_DRf)
opt_DfR = keras.optimizers.SGD(momentum=0.5, lr=0.01)
DfR = Model(input=[inputs], output=[advmodel(inputs)])
DfR.compile(loss=[make_loss_advmodel(c=1.0)], optimizer=opt_DfR)
classWeight = class_weight.compute_class_weight('balanced', np.unique(train_y),
train_y[:])
# Pretraining of "model"
model.trainable = True
advmodel.trainable = False
numberOfEpochs = 100
batchSize = 256
earlystop1 = keras.callbacks.EarlyStopping(monitor='val_loss',
min_delta=0.0001,
patience=10)
#model.summary()
# With sample weights
model.fit(
train_x,
x_fc = Flatten()(x_fc)
x_fc = Dense(2, activation='softmax', name='fc2')(x_fc)
model = Model(img_input, x_fc)
# load weights
if weights_path:
model.load_weights(weights_path, by_name=True)
return model
##transfering learning resnet-152
map_characters1 = {0: 'No Pneumonia', 1: 'Yes Pneumonia'}
class_weight1 = class_weight.compute_class_weight('balanced',
np.unique(y_train), y_train)
# weight_path1 = '/home/patrik/jogos_mortais/vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5'
# weight_path2 = '/home/patrik/jogos_mortais/inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5'
# weight_path3 = '/home/patrik/jogos_mortais/resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5'
weight_path4 = '/home/patrik/jogos_mortais/resnet152_weights_tf.h5'
# Patrik = tambem pegar os pesos da ResNet para colocar aqui em outro pretreino
# tamanho padrao VGG: 224,224,3 variar
# pretrained_model_1 = VGG16(weights = weight_path1, include_top=False, input_shape=(img_width, img_height, 3))
# tamanho padrao inception 299,299,3
# pretrained_model_2 = InceptionV3(weights = weight_path2, include_top=False, input_shape=(img_width, img_height, 3))
# tamaho padrao resnet 224x224x3
# pretrained_model_3 = ResNet50(weights = weight_path3, include_top=False, input_shape=(img_width, img_height, 3))
# resnet-152
pretrained_model_4 = resnet152_model(weight_path4)
# %% pass the pre-trained BERT to our define architecture
model = BERT_Arch(bert)
# %% push the model to GPU
model = model.to(device)
# optimizer from hugging face transformers
# define the optimizer
optimizer = AdamW(model.parameters(), lr=1e-3)
# %% - Find Class Weights¶
# compute the class weights
class_wts = compute_class_weight('balanced', np.unique(train_labels),
train_labels)
print(class_wts)
# convert class weights to tensor
weights = torch.tensor(class_wts, dtype=torch.float)
weights = weights.to(device)
# loss function
cross_entropy = nn.NLLLoss(weight=weights)
# number of training epochs
epochs = 10
# %% - Fine-Tune BERT¶
all_masks_gt = all_masks_gt[labels_gt < 2]
labels_gt = labels_gt[labels_gt < 2]
#%%
batch_size = 128
num_classes = 2
epochs = 5
test_fraction = 0.25
augmentation = True
# input image dimensions
img_rows, img_cols = 48, 48
x_train, x_test, y_train, y_test = train_test_split(
all_masks_gt, labels_gt, test_size=test_fraction)
class_weight = cw.compute_class_weight('balanced', np.unique(y_train), y_train)
if K.image_data_format() == 'channels_first':
x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)
x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)
input_shape = (1, img_rows, img_cols)
else:
x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
#x_train /= 255
#x_test /= 255
print('x_train shape:', x_train.shape)
#PCA
#pca_model = PCA(n_components=10, svd_solver='full')
#X_train_test = pca_model.fit_transform(X_train_test, Y_labels)
#X_to_predict = pca_model.transform(X_to_predict)
#Select best features
#selecter = SelectKBest(chi2, k=6)
#X_train_test = selecter.fit_transform(X_train_test, Y_labels)
#X_to_predict = selecter.transform(X_to_predict)
gettingDistributionOfDatas()
#Getting class_weirght distribution
class_weight = class_weight.compute_class_weight('balanced', np.unique(Y_labels), Y_labels)
class_weight_dict = {1: class_weight[0], 0: class_weight[1]}
print(class_weight_dict)
print('')
#Percentage train
porcentagem_de_treino = 0.8
tamanho_de_treino = porcentagem_de_treino * len(Y_labels)
treino_dados = X_train_test[:int(tamanho_de_treino)]
treino_marcacoes = Y_labels[:int(tamanho_de_treino)]
#Percentage test
validacao_dados = X_train_test[int(tamanho_de_treino):]
validacao_marcacoes = Y_labels[int(tamanho_de_treino):]