def probablity_result(): tra_Name,tra_Label,val_Name,val_Label = readcsv(args.tra_path,args.val_path) test(val_Name,args.dataset_path) print(val_Label.shape) model = load_model('/Volumes/MyPassport/duke/test_chk1_model/ede/cross1/weights.20-0.22-0.94-Dukelungedema_.hdf5') result = model.predict_generator(get_train_batch(val_Name, val_Label, 8, True, 224, 224, 1, False, args.dataset_path,3),steps=math.ceil(val_Label.shape[0]/8.0),verbose=1) print(result.shape) AUC = roc_auc_score(val_Label,result) print('************') print(AUC) print(result) np.save("test_edema.hdf5",result)
def test(): logging.debug('Running system tests.') try: data.test(config.NEO4J_SERVER) nlp.test() scraping.test(config.SEC_SERVER) logging.debug('Tests cleared.') print('\n\n\nTests returned positive. All systems ready to go.\n\n\n') except: logging.error('System tests returned negative.') logging.debug(type(sys.exc_type)) logging.debug(str(sys.exc_type)) logging.error('%s:%s' % (sys.exc_type, sys.exc_value)) sys.exit('Tests returned negative. Check logs for more details.')
def main(): paddle.init(use_gpu=True, trainer_count=1) img = paddle.layer.data(name='img', type=paddle.data_type.dense_vector(784)) label = paddle.layer.data(name='label', type=paddle.data_type.integer_value(10)) predict = letnet_5(img) cost = paddle.layer.classification_cost(input=predict, label=label) if os.path.exists(PARAMETERS_TAR): with open(PARAMETERS_TAR, 'r') as f: parameters = paddle.parameters.Parameters.from_tar(f) else: parameters = paddle.parameters.create(cost) optimizer = paddle.optimizer.Momentum( learning_rate=0.1 / 128, momentum=0.9, regularization=paddle.optimizer.L2Regularization(rate=0.0001)) trainer = paddle.trainer.SGD(cost=cost, parameters=parameters, update_equation=optimizer) def event_handler(evt): if isinstance(evt, paddle.event.EndPass): print 'Pass id: %d, %s' % (evt.pass_id, evt.metrics) trainer.train(reader=paddle.batch(paddle.reader.shuffle(dataset.train(), buf_size=8192), batch_size=64), event_handler=event_handler, num_passes=30) with open(PARAMETERS_TAR, 'w') as f: trainer.save_parameter_to_tar(f) test_reader = dataset.test()() test_list = [] for img in test_reader: test_list.append(img) labels = paddle.infer(output_layer=predict, parameters=parameters, input=test_list) labels = np.argmax(labels, axis=1) dataset.save_result2csv('./result.csv', labels) print 'training end'
def beam_search(FLAGS): paddle.enable_static() if FLAGS.static else None device = paddle.set_device("gpu" if FLAGS.use_gpu else "cpu") # yapf: disable inputs = [ Input([None, 1, 48, 384], "float32", name="pixel"), Input([None, None], "int64", name="label_in") ] labels = [ Input([None, None], "int64", name="label_out"), Input([None, None], "float32", name="mask") ] # yapf: enable model = paddle.Model(Seq2SeqAttInferModel(encoder_size=FLAGS.encoder_size, decoder_size=FLAGS.decoder_size, emb_dim=FLAGS.embedding_dim, num_classes=FLAGS.num_classes, beam_size=FLAGS.beam_size), inputs=inputs, labels=labels) model.prepare(metrics=SeqBeamAccuracy()) model.load(FLAGS.init_model) test_dataset = data.test() test_collate_fn = BatchCompose( [data.Resize(), data.Normalize(), data.PadTarget()]) test_sampler = data.BatchSampler(test_dataset, batch_size=FLAGS.batch_size, drop_last=False, shuffle=False) test_loader = paddle.io.DataLoader(test_dataset, batch_sampler=test_sampler, places=device, num_workers=0, return_list=True, collate_fn=test_collate_fn) model.evaluate(eval_data=test_loader, callbacks=[LoggerCallBack(10, 2, FLAGS.batch_size)])
def main(FLAGS): device = set_device("gpu" if FLAGS.use_gpu else "cpu") fluid.enable_dygraph(device) if FLAGS.dynamic else None model = Seq2SeqAttModel(encoder_size=FLAGS.encoder_size, decoder_size=FLAGS.decoder_size, emb_dim=FLAGS.embedding_dim, num_classes=FLAGS.num_classes) # yapf: disable inputs = [ Input([None, 1, 48, 384], "float32", name="pixel"), Input([None, None], "int64", name="label_in") ] labels = [ Input([None, None], "int64", name="label_out"), Input([None, None], "float32", name="mask") ] # yapf: enable model.prepare(loss_function=WeightCrossEntropy(), metrics=SeqAccuracy(), inputs=inputs, labels=labels, device=device) model.load(FLAGS.init_model) test_dataset = data.test() test_collate_fn = BatchCompose( [data.Resize(), data.Normalize(), data.PadTarget()]) test_sampler = data.BatchSampler(test_dataset, batch_size=FLAGS.batch_size, drop_last=False, shuffle=False) test_loader = fluid.io.DataLoader(test_dataset, batch_sampler=test_sampler, places=device, num_workers=0, return_list=True, collate_fn=test_collate_fn) model.evaluate(eval_data=test_loader, callbacks=[LoggerCallBack(10, 2, FLAGS.batch_size)])
def main(FLAGS): paddle.enable_static() if FLAGS.static else None device = paddle.set_device("gpu" if FLAGS.use_gpu else "cpu") # yapf: disable inputs = [ Input([None,1,48,384], "float32", name="pixel"), Input([None, None], "int64", name="label_in"), ] labels = [ Input([None, None], "int64", name="label_out"), Input([None, None], "float32", name="mask"), ] # yapf: enable model = paddle.Model( Seq2SeqAttModel( encoder_size=FLAGS.encoder_size, decoder_size=FLAGS.decoder_size, emb_dim=FLAGS.embedding_dim, num_classes=FLAGS.num_classes), inputs, labels) lr = FLAGS.lr if FLAGS.lr_decay_strategy == "piecewise_decay": learning_rate = fluid.layers.piecewise_decay( [200000, 250000], [lr, lr * 0.1, lr * 0.01]) else: learning_rate = lr grad_clip = fluid.clip.GradientClipByGlobalNorm(FLAGS.gradient_clip) optimizer = fluid.optimizer.Adam( learning_rate=learning_rate, parameter_list=model.parameters(), grad_clip=grad_clip) model.prepare(optimizer, WeightCrossEntropy(), SeqAccuracy()) train_dataset = data.train() train_collate_fn = BatchCompose( [data.Resize(), data.Normalize(), data.PadTarget()]) train_sampler = data.BatchSampler( train_dataset, batch_size=FLAGS.batch_size, shuffle=True) train_loader = paddle.io.DataLoader( train_dataset, batch_sampler=train_sampler, places=device, num_workers=FLAGS.num_workers, return_list=True, collate_fn=train_collate_fn) test_dataset = data.test() test_collate_fn = BatchCompose( [data.Resize(), data.Normalize(), data.PadTarget()]) test_sampler = data.BatchSampler( test_dataset, batch_size=FLAGS.batch_size, drop_last=False, shuffle=False) test_loader = paddle.io.DataLoader( test_dataset, batch_sampler=test_sampler, places=device, num_workers=0, return_list=True, collate_fn=test_collate_fn) model.fit(train_data=train_loader, eval_data=test_loader, epochs=FLAGS.epoch, save_dir=FLAGS.checkpoint_path, callbacks=[LoggerCallBack(10, 2, FLAGS.batch_size)])
# -*- coding: utf-8 -*- import dash import dash_core_components as dcc import dash_html_components as html import pandas as pd import matplotlib.pyplot as plt import plotly.graph_objects as go import plotly.express as px import plotly.graph_objects as go import numpy as np import data as DATA DATA.test() external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css'] app = dash.Dash(__name__, external_stylesheets=external_stylesheets) data = pd.read_csv('complete.csv') ##############################Pie Chart - Percentage of States Affected################################### state = 28 UT = 8 total_states_UT = state + UT No_afftected_states = len(pd.unique(data['Name of State / UT'])) States_not_affected = total_states_UT - No_afftected_states labels = ['Number of afftected States', 'Number of Unafftected States'] values = [No_afftected_states, States_not_affected] ##############################Pie Chart - Percentage of States Affected###################################
''' Run all data cleaning and create example.osm.json ''' if __name__ == "__main__": import mapparser import tags import users import audit import data mapparser.test() tags.test() users.test() audit.test() data.test()
from skimage.io import imread, imshow from skimage.transform import resize import matplotlib.pyplot as plt from tqdm import tqdm np.random.seed = 42 IMG_WIDTH = 128 IMG_HEIGHT = 128 IMG_CHANNELS = 3 ################################# X_train, Y_train = data.train(IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS) X_test = data.test(IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS) ################################# model = arch.architecture(IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS) print(model.summary()) ################################ #Modelcheckpoint checkpointer = tf.keras.callbacks.ModelCheckpoint('model_for_nuclei.h5', verbose=1, save_best_only=True) callbacks = [ tf.keras.callbacks.EarlyStopping(patience=2, monitor='val_loss'),