def main(top_k):
flower_arc = FlowerArc()
saliency = SaliencyDetection()
classifier = Classifier()
st.title("Flower retrieval")
train_img_fps, train_embs, train_labels = load_prec_embs()
uploaded_file = st.file_uploader("Choose an image...")
if uploaded_file is not None:
st.image(uploaded_file,
caption='Uploaded Image.',
use_column_width=True)
image = Image.open(uploaded_file)
img_arr = np.array(image)
flower_classifier = classifier.classification_predict(
img_arr, consts.CLASSIFICATION_THRESHHOLD)
if (flower_classifier == 0):
st.subheader('Flower Detected')
#saliency
map_img = saliency.saliency_predict(img_arr)
bounding_box_img = saliency.bounding_box(img_arr, map_img)
st.image(bounding_box_img,
use_column_width=True,
caption='Flower Detection')
# query emb
test_emb = flower_arc.predict(img_arr)
dists = cdist(test_emb, train_embs, metric='euclidean')[0]
min_dist_indexes = dists.argsort()[:top_k]
label_indexes = [
train_labels[index] + 1 for index in min_dist_indexes
]
img_fps = [train_img_fps[index] for index in min_dist_indexes]
indices_on_page, images_on_page = \
map(list, zip(*itertools.islice(zip(label_indexes, img_fps), 0, top_k))) # noqa
st.image(images_on_page, width=200, caption=indices_on_page)
else:
st.subheader(
'Your image doesn\'t contain flowers or flowers are not clear enough to be detected, please try another image'
)
def index():
if request.method == 'POST':
file = request.files['file']
if file:
filename = secure_filename(file.filename)
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
print(filename)
# return url_for(filename)
classifier = Classifier()
result = classifier.classify(filename)
print(result)
return render_template('index.html',
result=result,
file=filename,
form=False)
return render_template('index.html', form=True)
class Main:
dataset_dir = "dataset/" # path to corpus
print("Enter the number of frequent words to use:")
N = int(input())
print("Remove stopwords? [y/n]")
flag_stopwords = str(input())
classifier = Classifier(dataset_dir, int(N), flag_stopwords)
classifier.most_frequent_words()
classifier.compute_features()
classifier.generate_arff()
def train():
notcars = glob.glob('data/non-vehicles/*/*.png')
cars = glob.glob('data/vehicles/*/*.png')
print_stats(cars, notcars)
features_car = []
for car in cars:
img = read_image(car)
img_processed = process_image(img)
features_car.append(extract_features(img_processed, parameters))
features_notcar = []
for notcar in notcars:
img = read_image(notcar)
img_processed = process_image(img) # png
features_notcar.append(extract_features(img_processed, parameters))
features = np.vstack((features_car, features_notcar))
# Fit a per-column scaler
scaler = StandardScaler().fit(features)
# Apply the scaler to X
features_scaled = scaler.transform(features)
# Define the labels vector
labels = np.hstack(
(np.ones(len(features_car)), np.zeros(len(features_notcar))))
# Split up data into randomized training and test sets
rand_state = np.random.randint(0, 100)
out = train_test_split(features_scaled,
labels,
test_size=0.2,
random_state=rand_state)
features_train, features_test, labels_train, labels_test = out
# Initialize support vector machine object
clf = SVC(kernel='linear', C=0.00001)
# Check the training time for the SVC
t = time.time()
clf.fit(features_train, labels_train)
print('{0:2.2f} seconds to train SVC...'.format(time.time() - t))
# Accuracy score
accuracy = clf.score(features_test, labels_test)
print('Test Accuracy of SVC = {0:2.4f}'.format(accuracy))
classifier = Classifier(clf, scaler)
joblib.dump(classifier, 'classifier.pkl')
return classifier
if args.task_type == 'binary':
if args.average:
merged_preds[i] = avg_probs(prediction_dict[i])
else:
merged_preds[i] = merge_probs(prediction_dict[i], c)
elif args.task_type == 'regression':
merged_preds[i] = merge_regression(prediction_dict[i])
elif args.task_type == 'multiclass':
merged_preds[i] = avg_probs_multiclass(
np.array(prediction_dict[i]))
return merged_preds
for predictor_params in grid:
print(predictor_params, flush=True)
predictor = Classifier(**predictor_params).to(device)
if n_gpu > 1:
predictor = torch.nn.DataParallel(predictor)
if not(args.freeze_bert) and not(args.use_adversary):
param_optimizer = list(model.named_parameters()) + \
list(predictor.named_parameters())
elif args.freeze_bert and not(args.use_adversary):
param_optimizer = list(predictor.named_parameters())
elif args.freeze_bert and args.use_adversary:
raise Exception(
'No purpose in using an adversary if BERT layers are frozen')
else:
param_optimizer = list(model.named_parameters(
)) + list(predictor.named_parameters()) + list(discriminator.named_parameters())
import sys
import time
import os
from practice import Load
from utils import Classifier
from utils import Data2Vec
from utils import Save
from utils.GlobalParam import *
if __name__ == "__main__":
start_time = time.time()
CLUSTER_STRUCTURE_NAME = CLUSTER_STRUCTURE_NAME + '_' + str(VEC_DIMENSION) + '_vec.bin'
file_path = os.path.join(os.getcwd(), RESULT_DIRECTORY, CLUSTER_STRUCTURE_NAME)
cluster_structure = Load.unpickling(file_path)
print cluster_structure
clf = Classifier.train_clf(cluster_structure)
print clf.predict(Data2Vec.trim_data(sys.argv[1]))
Save.bin2graph(sys.argv[1])
end_time = time.time()
print '*** TOATL TIME: ' + str(end_time - start_time) + ' ***'
frame = imutils.rotate_bound(frame, 90)
if ret:
# Return a boolean success flag and the current frame converted to BGR
return (ret, cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
else:
return (ret, None)
else:
return (ret, None)
# Release the video source when the object is destroyed
def __del__(self):
if self.vid.isOpened():
self.vid.release()
#When open the app, load retina model first
global retina_model, classicifer_model, EAST
print("[INFO] Loading the retina_model ...")
retina_model = Retina()
print("[INFO] Loading the retina_model completed")
print("[INFO] Loading the classifier_model ...")
classicifer_model = Classifier()
print("[INFO] Loading the classifier_model completed")
layerNames = ["feature_fusion/Conv_7/Sigmoid", "feature_fusion/concat_3"]
EASTPATH = os.path.join("model", "EAST.pb")
print("[INFO] Loading the pre-trained EAST text detector ...")
EAST = cv2.dnn.readNet(EASTPATH)
print("[INFO] Loading the pre-trained EAST text completed")
# Create a window and pass it to the Application object
App(tkinter.Tk(), "Invoice lottery (Tkinter and OpenCV support)")
def manual_classes_classifier(data_path, column, language, lemmatize,
manual_mappings, manual_classes,
predicted_classes_filename, should_upload_db,
account_key_path):
print("Build classifier...")
with open(manual_classes, encoding="utf8") as json_data:
manual_classes_dict = json.load(json_data)
classifier = Classifier(manual_classes_dict, language)
print("Classifier built")
print()
print("Loading data...")
data_df = load_data(data_path, column)
print("Loaded data sample")
print(data_df.head())
print()
print("Cleaning data...")
data_df[column] = clean_data(data_df[column])
print("Clean data sample")
print(data_df.head())
print()
print("Removing stopwors...")
data_df[column] = remove_stopwords(data_df[column], language)
print("Data sample")
print(data_df.head())
print()
if lemmatize:
print("Lemmatizing data...")
data_df[column] = lemmatize_text(data_df[column], language)
print("Lemmatized data sample")
print(data_df.head())
print()
if manual_mappings:
print("Applying manual mappings...")
data_df[column] = apply_manual_mappings(data_df[column],
manual_mappings)
print("Manually mapped data sample")
print(data_df.head())
print()
print("Predict classes...")
predicted_classes = predict(classifier, data_df[column])
save_classes(predicted_classes, predicted_classes_filename)
print("Predicted classes saved to:", predicted_classes_filename)
print()
if should_upload_db:
db_client = connect_db(account_key_path)
print("Uploading predicted classes to db...")
upload_db(
db_client, 'predicted_classes', {
column:
json.loads(
pd.DataFrame(predicted_classes).to_json(orient='index',
force_ascii=False))
})
print('Done')
print()
# make iterator
train_iter = chainer.iterators.SerialIterator(
train_datasets, batch_size)
val_iter = chainer.iterators.SerialIterator(
val_datasets, batch_size, repeat=False, shuffle=False
)
test_iter = chainer.iterators.SerialIterator(
test_datasets, batch_size, repeat=False, shuffle=False)
# build model
model = chainer.links.VGG16Layers()
num_ftrs = model.fc8.out_size
# model.fc8 = L.Linear(in_size=None, out_size=101,
# initialW=initializers.Normal(scale=0.02),
# initial_bias=initializers.Normal(scale=0.02))
model = Classifier(model)
# model = L.Classifier(model)
if gpu >= 0:
# Make a specified GPU current
chainer.backends.cuda.get_device_from_id(gpu).use()
model.to_gpu() # Copy the model to the GPU
# make optimizer
optimizer = optimizers.MomentumSGD(lr=0.001, momentum=0.9)
optimizer.setup(model)
# make updater & set up trainer
updater = updaters.StandardUpdater(
train_iter, optimizer, device=gpu)
trainer = training.Trainer(
parser.add_argument("--num_lstm_layers", type=int, default=2)
parser.add_argument("--dropout_prob", type=float, default=0.1)
if __name__ == '__main__':
args = parser.parse_args()
device = torch.device("cpu")
if torch.cuda.is_available():
device = torch.device("cuda")
dl = DataLoader(batch_size=32)
test_data = dl.setup(return_only_test_data=True)
test_data = dl.test_dataloader(test_data)
wts = torch.load(args.weights_path, map_location=torch.device("cpu"))
model = Classifier(dl.vocab_size, args.embedding_size,
args.num_lstm_layers, args.dropout_prob)
model.load_state_dict(wts)
model.to(device)
preds, labels = model.predict(test_data, device)
cm = confusion_matrix(labels, preds)
names = [
"negative", "somewhat negative", "neutral", "somewhat positive",
"positive"
]
cm = pd.DataFrame(cm, columns=names, index=names)
print(cm)
#Pre-trainned network load
if arch == 'alexnet':
model = models.alexnet(pretrained=True)
input_size = 9216 #Based on pretrained model alexnet in_features value
elif arch == 'vgg19':
model = models.vgg19(pretrained=True)
input_size = 25088 #Based on pretrained model vgg19 in_features value
else:
model = models.densenet121(pretrained=True)
input_size = 1024 #Based on pretrained model desenet121 in_features value
#Classifier creation
output_size = 102 # According with the 102 flower classes
classifier = Classifier(input_size, hidden_layers, output_size, drop_p)
print('\n')
print('---'*20)
print(' Trainning CNN Parameters ')
print('---'*20)
print(' Data directory: {:12} Checkpoint: {:12}'.format(color(data_dir), color(save_dir)))
print(' CNN Pretrained: {:12} Learning rate: {:12} Epochs: {:12}'.format(color(arch), color(lr), color(epochs)))
print(' Hidden Units: {:12} Dropout: {:12} GPU: {:12}'.format(color(hidden_layers), color(drop_p), color(gpu)))
print('---'*20)
print(color(' Classifier'), classifier)
print('---'*20)
#Freeze params for the pretrainned model and avoid back propagation
for param in model.parameters():
def main():
m = Mask()
c = Classifier()
device = torch.device('cuda')
# IR_50
model_ir50 = IR_50([112, 112])
model_ir50.load_state_dict(
torch.load('./ckpt/backbone_ir50_ms1m_epoch120.pth',
map_location='cuda'))
model_ir50.eval().to(device).zero_grad()
# IR_152
model_ir152 = IR_152([112, 112])
model_ir152.load_state_dict(
torch.load('./ckpt/Backbone_IR_152_Epoch_112_Batch.pth',
map_location='cuda'))
model_ir152.eval().to(device).zero_grad()
# IR_SE_50
model_irse50 = Backbone(50, mode='ir_se')
model_irse50.load_state_dict(
torch.load('./ckpt/model_ir_se50.pth', map_location='cuda'))
model_irse50.eval().to(device).zero_grad()
eps = (args.max_epsilon / 255.0)
alpha = eps / args.iterations
momentum = args.momentum
kernel = gkern(args.kernlen, args.sig).astype(np.float32)
stack_kernel = np.stack([kernel, kernel, kernel])
stack_kernel = np.expand_dims(stack_kernel, 1)
stack_kernel = torch.Tensor(stack_kernel).to(device)
counter = 0
total_distance = 0
num = 1
for raw_images, filenames, _ in load_images_with_names(
args.input_dir, args.batch_size):
if num * args.batch_size > 712:
batch_size = 712 - (num - 1) * args.batch_size
else:
batch_size = args.batch_size
num += 1
in_tensor = process(raw_images)
raw_variable = in_tensor.detach().to(device)
# raw embedding
raw_ir50 = model_ir50(raw_variable)
raw_ir152 = model_ir152(raw_variable)
raw_irse50 = model_irse50(raw_variable)
true_labels = c.classifier(raw_ir50.data.cpu().detach().numpy())
bias_ir50, bias_ir152, bias_irse50 = found_bias_v2(
raw_ir50.data.cpu().detach().numpy(),
raw_ir152.data.cpu().detach().numpy(),
raw_irse50.data.cpu().detach().numpy(), batch_size)
perturbation = torch.Tensor(batch_size, 3, 112,
112).uniform_(-0.01, 0.01).to(device)
in_variable = raw_variable + perturbation
in_variable.data.clamp_(-1.0, 1.0)
in_variable.requires_grad = True
last_grad = 0.0
momentum_sum = 0.0
for step in range(args.iterations):
new_ir50 = model_ir50(in_variable)
new_ir152 = model_ir152(in_variable)
new_irse50 = model_irse50(in_variable)
loss1 = -torch.mean(
torch.cosine_similarity(x1=raw_ir50, x2=new_ir50, dim=1) * 1.7
+ torch.cosine_similarity(x1=raw_ir152, x2=new_ir152, dim=1) *
0.35 +
torch.cosine_similarity(x1=raw_irse50, x2=new_irse50, dim=1) *
0.65) / 2.7
loss2 = torch.mean(
torch.cosine_similarity(
x1=torch.from_numpy(bias_ir50).detach().to(device),
x2=new_ir50,
dim=1) * 1.7 + torch.cosine_similarity(x1=torch.from_numpy(
bias_ir152).detach().to(device),
x2=new_ir152,
dim=1) * 0.35 +
torch.cosine_similarity(x1=torch.from_numpy(
bias_irse50).detach().to(device),
x2=new_irse50,
dim=1) * 0.65) / 2.7
loss = loss1 + loss2
print('loss :', loss)
loss.backward(retain_graph=True)
data_grad = in_variable.grad.data
data_grad = F.conv2d(data_grad,
stack_kernel,
padding=(args.kernlen - 1) // 2,
groups=3)
for i in range(data_grad.shape[0]):
data_grad[i] = data_grad[i] / torch.mean(
data_grad[i].norm(2, 0) / 1.713)
if iter == 0:
noise = data_grad
else:
noise = last_grad * momentum + data_grad * 0.9
last_grad = noise.detach()
norm = noise.norm(dim=1).unsqueeze(1)
index = norm.mean()
momentum_sum = momentum_sum * momentum + 1.0
d_img = noise * norm * alpha / (momentum_sum * index)
d_img = d_img / d_img.norm(dim=1).mean() * alpha
perturb_mask = m.get_perturb_mask(
new_ir50.data.detach().cpu().numpy(),
new_ir152.data.detach().cpu().numpy(),
new_irse50.data.detach().cpu().numpy(), true_labels,
args.cos_margin)
in_variable.data = in_variable.data + \
d_img * torch.from_numpy(perturb_mask.reshape([batch_size, 1, 1, 1])).to(device).float()
raw_variable.data = torch.clamp(in_variable.data, -1.0, 1.0)
in_variable.grad.data.zero_()
advs = raw_variable.data.cpu().detach().numpy()
advs = advs.swapaxes(1, 2).swapaxes(2, 3)
total_distance_ = save_images(raw_images, advs, filenames,
args.output_dir)
total_distance += total_distance_
counter += batch_size
print('attack images num : [%d / 712]' % counter)
print('mean_dist:', total_distance / 712.0)