def update_r(cond, i, x, r): x_adv = x + (1 + over_shoot) * r logits = model(x_adv) prob = tf.nn.softmax(logits) log_prob = tf.nn.log_softmax(logits) prob_t = tf.reduce_sum(prob * targets_onehot, axis=1) log_prob_t = tf.reduce_sum(log_prob * targets_onehot, axis=1) f = tf.abs(log_prob_t - tf.log(confidence)) f = tf.reshape(f, (-1, ) + (1, ) * (ndims - 1)) w = tf.gradients(log_prob_t, x_adv)[0] w_norm = tf.sqrt(epsilon + tf.reduce_sum(w**2, axis=reduce_ind, keepdims=True)) r_upd = (epsilonsqrt + f / w_norm) * w / w_norm if clip_dist is not None: r_upd = tf.clip_by_norm(r_upd, clip_dist, axes=reduce_ind) # select and update is_high_confidence = tf.greater_equal(prob_t, confidence) is_target_hit = tf.equal(prediction(logits), targets) target_is_label = tf.equal(labels, targets) selector = tf.logical_or( tf.logical_and(is_target_hit, is_high_confidence), target_is_label) r_new = tf.where(selector, r, r + r_upd) cond = tf.logical_not(tf.reduce_all(selector)) if boxmin is not None and boxmax is not None: x_adv_new = x + (1 + over_shoot) * r_new r_new = (tf.clip_by_value(x_adv_new, boxmin, boxmax) - x) / (1 + over_shoot) return cond, i + 1, x, r_new
def test_epoch(model, test_loader, loss_fn): print('{} Validation Begins...'.format( datetime.now().strftime(_format)[:-3])) model.eval() counter = 0 total_loss = 0 post_acc = 0 pipe_acc = 0 for train_data, train_label in tqdm(test_loader): # train_data(?, 7, 80), train_label(?, 7) train_data = train_data[0] train_label = train_label[0] train_data = torch.as_tensor(train_data, dtype=torch.float32).to(DEVICE) train_label = torch.as_tensor(train_label, dtype=torch.float32).to(DEVICE) counter += 1 midnet_output, postnet_output, alpha = model(train_data) postnet_accuracy, pipenet_accuracy = prediction( train_label, midnet_output, postnet_output) post_acc += float(postnet_accuracy) pipe_acc += float(pipenet_accuracy) loss, _, _, _ = loss_fn(model, train_label, postnet_output, midnet_output, alpha) total_loss += loss.detach().item() # clear cache gc.collect() torch.cuda.empty_cache() print('{} Validation Finished...'.format( datetime.now().strftime(_format)[:-3])) print('Loss: {:.5f}, post acc: {:.4f}, pipe acc: {:.4f}'.format( total_loss / counter, post_acc / counter, pipe_acc / counter)) return total_loss / counter, post_acc / counter
def api_predict(): """ Renvoie un texte decrivant le résultat de la prédiction """ assert isinstance( request.json['title'], str), "The title of the article is not defined or not string" assert isinstance( request.json['text'], str), "The text of the article is not defined or not string" title = request.json['title'] date = request.json['date'] text = request.json['text'] subject = request.json['subject'] # Create dataframe data = formate_dataset( pd.DataFrame(data={ "title": [title], "date": [date], "text": [text], "subject": [subject] })) # Return prediction return jsonify(message(int(prediction(data))))
def predict(): """ Renvoie un template decrivant le résultat de la prédiction """ assert isinstance( request.form['title'], str), "The title of the article is not defined or not string" assert isinstance( request.form['text'], str), "The text of the article is not defined or not string" title = str(request.form["title"]) date = str(request.form["date"]) text = str(request.form["text"]) subject = str(request.form["subject"]) # Create dataframe data = formate_dataset( pd.DataFrame(data={ "title": [title], "date": [date], "text": [text], "subject": [subject] })) # Return prediction return render_template('result.html', prediction=prediction(data), title=title)
def handler(event, context): # Initialize Logger log = init_logger() log = add_handler(log) input_data = json.loads(event['body']) log.info(f"Input data: {input_data}") # Retrieve inputs input_url, n_predictions = input_data['input_url'], input_data[ 'n_predictions'] # Download image input_image = download_image(input_url) # Process input image log.info(f"INFO -- Processing Image") batch = preprocess_image(input_image) # Generate prediction log.info(f"INFO -- Generating Prediction") pred = prediction(input_batch=batch, mdl=mobilenet_v2) # Top n results log.info(f"INFO -- Generating Top n predictions") n_results = number_output(mdl_output=pred, mdl_labels=labels, top_n=n_predictions) # prediction = model.predict(url) response = {"statusCode": 200, "body": json.dumps(n_results)} return response
def predict(): if request.method == 'POST': message = request.form['message'] my_prediction = prediction(message) return render_template('home.html', prediction=my_prediction, question=message)
def test_prediction(): """ test prediction """ dataf = pd.DataFrame( data={"title": ["1st title"], "date": ["1st date"], "text": ["1st text"], "subject": ["1st subject"]}) assert utils.prediction(dataf) in (0, 1)
def autoLabel(self): if self.loadImage is not None: Utils.changeCursor(Qt.WaitCursor) image = load_image(self.loadImage.filePath) boundingBoxes = prediction(image, self.yolo) for box in boundingBoxes: oldH, oldW, _ = image.shape newH, newW = self.viewer.height(), self.viewer.width() box[:] = [ box[0] * newW / oldW, box[1] * newH / oldH, box[2] * newW / oldW, box[3] * newH / oldH ] self.viewer.autoLabeling(boundingBoxes) Utils.changeCursor(Qt.ArrowCursor)
def update_r(cond, i, x, r): x_adv = x + r logits = model(x_adv) x_adv_os = x + (1 + over_shoot) * r logits_os = model(x_adv_os) pred = prediction(logits_os) # closest boundary if targets is None: l = find_next_target(x, logits, labels, random=False) else: l = targets l_idx = batch_indices * num_classes + l logits_flt = tf.reshape(logits, (-1, )) logits_labels = tf.gather(logits_flt, labels_idx) logits_targets = tf.gather(logits_flt, l_idx) f = logits_targets - logits_labels w = tf.gradients(f, x_adv)[0] reduce_ind = list(range(1, ndims)) w2_norm = tf.sqrt(tf.reduce_sum(w**2, axis=reduce_ind)) if ord == 2: dist = tf.abs(f) / w2_norm else: dist = tf.abs(f) / tf.reduce_sum(tf.abs(w), axis=reduce_ind) # avoid numerical instability and clip max value if clip_dist is not None: dist = tf.clip_by_value(dist, 0, clip_dist) if ord == 2: r_upd = w * tf.reshape(((dist + epsilon) / w2_norm), (-1, ) + (1, ) * (ndims - 1)) else: r_upd = tf.sign(w) * tf.reshape(dist, (-1, ) + (1, ) * (ndims - 1)) # select and update is_mistake = tf.not_equal(labels, pred) # if targets is provides and it is equal to the class label target_is_label = tf.equal(labels, l) selector = tf.logical_or(is_mistake, target_is_label) r_new = tf.where(selector, r, r + r_upd) if boxmin is not None and boxmax is not None: x_adv_new = x + (1 + over_shoot) * r_new r_new = (tf.clip_by_value(x_adv_new, boxmin, boxmax) - x) / (1 + over_shoot) cond = tf.logical_not(tf.reduce_all(selector)) return cond, i + 1, x, r_new
def main(): args = vars(ap.parse_args()) image_path = args['image_path'] model = args['model'] top_k = args['top_k'] category_names = args['category_names'] with open(category_names, 'r') as f: class_names = json.load(f) reloaded_SavedModel = tf.keras.models.load_model( model, custom_objects={'KerasLayer': hub.KerasLayer}) image = preprocess(image_path) image = np.expand_dims(image, axis=0) ps = reloaded_SavedModel(image, training=False).numpy() if top_k > 1: preds, classes = prediction(ps, class_names, top_k) print("Top ", top_k, " Classes are:- ") for i in range(0, top_k): print(classes[i], " with probability of ", preds[i]) else: class_idx = np.argmax(ps[0]) Class_name = class_names[str(class_idx + 1)] print(" The given image is ", Class_name, " with probability of ", max(ps[0]))
import datetime import tensorflow as tf from sklearn.preprocessing import MinMaxScaler from sklearn.metrics import mean_squared_error from tensorflow.keras.models import Sequential, save_model, load_model from tensorflow.keras.layers import Dense, Dropout, LSTM, Activation import numpy as np import seaborn as sns import h5py import quandl from utils import create_dataset, preprocess, calcAccuracy, prediction from train import training app = Flask(__name__) nextDayPrice, price, lAcc, lPctAcc, gAcc, gPctAcc = prediction() @app.route('/') def hello_world(): # accuracy,pctChangeAccuracy,nextDayPrice,price = run_model() return render_template('index.html', tomorrow=nextDayPrice, today=price) @app.route('/results') def results(): return render_template('accuracy.html', lAcc=lAcc, lPctAcc=lPctAcc[0], gAcc=gAcc, gPctAcc=gPctAcc[0])
ts9 = 15 mask_ts_[mask_tiles == ts1] = 1 mask_ts_[mask_tiles == ts2] = 1 mask_ts_[mask_tiles == ts3] = 1 mask_ts_[mask_tiles == ts4] = 1 mask_ts_[mask_tiles == ts5] = 1 mask_ts_[mask_tiles == ts6] = 1 mask_ts_[mask_tiles == ts7] = 1 mask_ts_[mask_tiles == ts8] = 1 mask_ts_[mask_tiles == ts9] = 1 #% Load model model = load_model(filepath + 'unet_exp_' + str(exp) + '.h5', compile=False) area = 11 # Prediction ref_final, pre_final, prob_recontructed, ref_reconstructed, mask_no_considered_, mask_ts, time_ts = prediction( model, image_array, image_ref, final_mask, mask_ts_, patch_size, area) # Metrics cm = confusion_matrix(ref_final, pre_final) metrics = compute_metrics(ref_final, pre_final) print('Confusion matrix \n', cm) print('Accuracy: ', metrics[0]) print('F1score: ', metrics[1]) print('Recall: ', metrics[2]) print('Precision: ', metrics[3]) # Alarm area total = (cm[1, 1] + cm[0, 1]) / len(ref_final) * 100 print('Area to be analyzed', total) print('training time', end_training)
sess = tf.Session() images = tf.placeholder(tf.float32, [None, 400, 400, 3]) true_out = tf.placeholder(tf.float32, [None, 3]) train_mode = tf.placeholder(tf.bool) vgg = vgg19.Vgg19('./vgg19.npy') vgg.build(images, train_mode) # print number of variables used: 143667240 variables, i.e. ideal size = 548MB print(vgg.get_var_count()) sess.run(tf.global_variables_initializer()) # test classification prob = sess.run(vgg.prob, feed_dict={images: batch1, train_mode: False}) utils.prediction(prob[0]) # simple 1-step training cost = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits_v2(labels=true_out, logits=vgg.fc8)) train = tf.train.GradientDescentOptimizer(0.0001).minimize(cost) sess.run(train, feed_dict={ images: batch1, true_out: [img1_true_result], train_mode: True }) # test classification again, should have a higher probability about tiger prob = sess.run(vgg.prob, feed_dict={images: batch1, train_mode: False})
def train_epoch(model, train_loader, loss_fn, optimizer, scheduler, batch_size, epoch, start_stpe): model.train() count = 0 total_loss = 0 n = batch_size step = start_stpe examples = [] total_loss_window = ValueWindow(100) post_loss_window = ValueWindow(100) post_acc_window = ValueWindow(100) for x, y in train_loader: count += 1 examples.append([x[0], y[0]]) if count % 8 == 0: examples.sort(key=lambda x: len(x[-1])) examples = (np.vstack([ex[0] for ex in examples]), np.vstack([ex[1] for ex in examples])) batches = [(examples[0][i:i + n], examples[1][i:i + n]) for i in range(0, len(examples[-1]) + 1 - n, n)] if len(examples[-1]) % n != 0: batches.append( (np.vstack((examples[0][-(len(examples[-1]) % n):], examples[0][:n - (len(examples[0]) % n)])), np.vstack((examples[1][-(len(examples[-1]) % n):], examples[1][:n - (len(examples[-1]) % n)])))) for batch in batches: # mini batch # train_data(?, 7, 80), train_label(?, 7) step += 1 train_data = torch.as_tensor(batch[0], dtype=torch.float32).to(DEVICE) train_label = torch.as_tensor(batch[1], dtype=torch.float32).to(DEVICE) optimizer.zero_grad(True) midnet_output, postnet_output, alpha = model(train_data) postnet_accuracy, pipenet_accuracy = prediction( train_label, midnet_output, postnet_output) loss, postnet_loss, pipenet_loss, attention_loss = loss_fn( model, train_label, postnet_output, midnet_output, alpha) total_loss += loss.detach().item() loss.backward() nn.utils.clip_grad_norm_(model.parameters(), 5, norm_type=2) optimizer.step() scheduler.step() lr = scheduler._rate total_loss_window.append(loss.detach().item()) post_loss_window.append(postnet_loss.detach().item()) post_acc_window.append(postnet_accuracy) if step % 10 == 0: print( '{} Epoch: {}, Step: {}, overall loss: {:.5f}, postnet loss: {:.5f}, ' 'postnet acc: {:.4f}, lr :{:.5f}'.format( datetime.now().strftime(_format)[:-3], epoch, step, total_loss_window.average, post_loss_window.average, post_acc_window.average, lr)) if step % 50_000 == 0: print('{} save checkpoint.'.format( datetime.now().strftime(_format)[:-3])) checkpoint = { "model": model.state_dict(), 'optimizer': optimizer.state_dict(), "epoch": epoch, 'step': step, 'scheduler_lr': scheduler._rate, 'scheduler_step': scheduler._step } if not os.path.isdir("./checkpoint"): os.mkdir("./checkpoint") torch.save( checkpoint, './checkpoint/STAM_weights_%s_%s.pth' % (str(epoch), str(step / 1_000_000))) gc.collect() torch.cuda.empty_cache() del batches, examples examples = []
from config import MODEL, ALPHABET, N_HEADS, ENC_LAYERS, DEC_LAYERS, DEVICE, HIDDEN from utils import generate_data, process_data from dataset import TextCollate, TextLoader from utils import prediction char2idx = {char: idx for idx, char in enumerate(ALPHABET)} idx2char = {idx: char for idx, char in enumerate(ALPHABET)} if MODEL == 'model1': from models import model1 model = model1.TransformerModel(len(ALPHABET), hidden=HIDDEN, enc_layers=ENC_LAYERS, dec_layers=DEC_LAYERS, nhead=N_HEADS, dropout=0.0).to(DEVICE) if MODEL == 'model2': from models import model2 model = model2.TransformerModel(len(ALPHABET), hidden=HIDDEN, enc_layers=ENC_LAYERS, dec_layers=DEC_LAYERS, nhead=N_HEADS, dropout=0.0).to(DEVICE) if WEIGHTS_PATH != None: print(f'loading weights from {WEIGHTS_PATH}') model.load_state_dict(torch.load(WEIGHTS_PATH)) preds = prediction(model, PREDICT_PATH, char2idx, idx2char) f = open(DIR+'/predictions.tsv', 'w') f.write('filename\tprediction\n') for item in preds.items(): f.write(item[0]+'\t'+item[1]+'\n') f.close() print(f'predictions are saved in {DIR}predictions.tsv')
def model(X_train, Y_train, X_test, Y_test, learning_rate=0.009, num_epochs=100, minibatch_size=64, print_cost=True): """ Arguments: X_train -- training set, of shape (None, 64, 64, 3) Y_train -- test set, of shape (None, n_y = 6) X_test -- training set, of shape (None, 64, 64, 3) Y_test -- test set, of shape (None, n_y = 6) learning_rate -- learning rate of the optimization num_epochs -- number of epochs of the optimization loop minibatch_size -- size of a minibatch print_cost -- True to print the cost every 100 epochs Returns: train_accuracy -- real number, accuracy on the train set (X_train) test_accuracy -- real number, testing accuracy on the test set (X_test) parameters -- parameters learnt by the model. They can then be used to predict. """ ops.reset_default_graph( ) # to be able to rerun the model without overwriting tf variables (m, n_H0, n_W0, n_C0) = X_train.shape n_y = Y_train.shape[1] costs = [] # To keep track of the cost images = tf.placeholder(tf.float32, [1, 400, 400, 3]) true_out = tf.placeholder(tf.float32, [1, 64]) train_mode = tf.placeholder(tf.bool) vgg = vgg19.Vgg19('./vgg19.npy') vgg.build(images, train_mode) cost = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits_v2(labels=true_out, logits=vgg.fc8)) optimizer = tf.train.GradientDescentOptimizer(0.0001).minimize(cost) init = tf.global_variables_initializer() with tf.Session() as sess: # Run the initialization sess.run(init) # Do the training loop for epoch in range(num_epochs): minibatch_cost = 0. num_minibatches = int( m / minibatch_size ) # number of minibatches of size minibatch_size in the train set minibatches = random_mini_batches(X_train, Y_train, minibatch_size) for minibatch in minibatches: (minibatch_X, minibatch_Y) = minibatch _, temp_cost = sess.run([optimizer, cost], feed_dict={ images: minibatch_X, true_out: [minibatch_Y], train_mode: True }) minibatch_cost += temp_cost / num_minibatches # Print the cost every epoch if print_cost == True and epoch % 5 == 0: print("Cost after epoch %i: %f" % (epoch, minibatch_cost)) if print_cost == True and epoch % 1 == 0: costs.append(minibatch_cost) # Calculate the correct predictions prob = sess.run(vgg.prob, feed_dict={ images: images_test, train_mode: False }) predict_op = utils.prediction( vgg.prob ) #Attention recoder fonction predictions pour si plusieurs images correct_prediction = tf.equal(predict_op, tf.argmax(Y, 1)) # Calculate accuracy on the test set accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) print(accuracy) train_accuracy = accuracy.eval({X: X_train, Y: Y_train}) test_accuracy = accuracy.eval({X: X_test, Y: Y_test}) print("Train Accuracy:", train_accuracy) print("Test Accuracy:", test_accuracy) return train_accuracy, test_accuracy, parameters
def deepfool(model, x, labels=None, targets=None, ord=2, max_iter=25, clip_dist=None, over_shoot=0.02, boxmin=None, boxmax=None, epsilon=1e-4): """Tensorflow implementation of DeepFool https://arxiv.org/abs/1511.04599 """ ndims = x.get_shape().ndims batch_size = tf.shape(x)[0] batch_indices = tf.range(batch_size) num_classes = int(model(x).get_shape()[1]) if labels is None: labels = prediction(model(x)) labels_idx = batch_indices * num_classes + labels def should_continue(cond, i, x, r): return tf.logical_and(cond, tf.less(i, max_iter)) def update_r(cond, i, x, r): x_adv = x + r logits = model(x_adv) x_adv_os = x + (1 + over_shoot) * r logits_os = model(x_adv_os) pred = prediction(logits_os) # closest boundary if targets is None: l = find_next_target(x, logits, labels, random=False) else: l = targets l_idx = batch_indices * num_classes + l logits_flt = tf.reshape(logits, (-1, )) logits_labels = tf.gather(logits_flt, labels_idx) logits_targets = tf.gather(logits_flt, l_idx) f = logits_targets - logits_labels w = tf.gradients(f, x_adv)[0] reduce_ind = list(range(1, ndims)) w2_norm = tf.sqrt(tf.reduce_sum(w**2, axis=reduce_ind)) if ord == 2: dist = tf.abs(f) / w2_norm else: dist = tf.abs(f) / tf.reduce_sum(tf.abs(w), axis=reduce_ind) # avoid numerical instability and clip max value if clip_dist is not None: dist = tf.clip_by_value(dist, 0, clip_dist) if ord == 2: r_upd = w * tf.reshape(((dist + epsilon) / w2_norm), (-1, ) + (1, ) * (ndims - 1)) else: r_upd = tf.sign(w) * tf.reshape(dist, (-1, ) + (1, ) * (ndims - 1)) # select and update is_mistake = tf.not_equal(labels, pred) # if targets is provides and it is equal to the class label target_is_label = tf.equal(labels, l) selector = tf.logical_or(is_mistake, target_is_label) r_new = tf.where(selector, r, r + r_upd) if boxmin is not None and boxmax is not None: x_adv_new = x + (1 + over_shoot) * r_new r_new = (tf.clip_by_value(x_adv_new, boxmin, boxmax) - x) / (1 + over_shoot) cond = tf.logical_not(tf.reduce_all(selector)) return cond, i + 1, x, r_new cond = tf.constant(True, tf.bool) i = tf.constant(0) r0 = tf.zeros_like(x) r = tf.while_loop(should_continue, update_r, [cond, i, x, r0], back_prop=False)[-1] x_adv = tf.stop_gradient(x + (1 + over_shoot) * r) return x_adv