def inference(model_object, model, loader, return_sequences=False): """ @param model_object: object contains all variables. Can be any class @param model: a tcn model @param return_sequences: whether to return a sequence or the prediction at the last step """ if model_object.device.lower() != 'cpu': model_object.device = 'cuda:0' model = model.to(model_object.device) model.eval() formatter = InferenceFormatter() for datum in loader: src, seq_len, meta = datum src = src.to(model_object.device) out = model(src) out = parse_pred(out, seq_len, return_sequences=return_sequences, min_length=model_object.min_length) meta = parse_meta(meta, seq_len, return_sequences=return_sequences, min_length=model_object.min_length) prob = sigmoid(out.cpu().detach().numpy()) formatter.collect(prob, meta) return formatter
def predict(ep, model_object, model, datum): src, tgt, seq_len, meta = datum # construct input sequence for decoder # pad inputs_rev on the left with zeros to enforce teacher forcing # assume the src and tgt has shape batch_size x seq_len x feature_dim # move all features to device src = src.to(model_object.device) tgt = tgt.to(model_object.device) seq_len = seq_len.to(model_object.device) # make prediction out = model(src) # normalized(out) = prob out = parse_pred(out, seq_len, return_sequences=True, min_length=model_object.min_length) tgt = parse_pred(tgt, seq_len, return_sequences=True, min_length=model_object.min_length).float() # bceloss meta = parse_meta(meta, seq_len, return_sequences=True, min_length=model_object.min_length) loss = model_object.criterion(out, tgt) prob = sigmoid(out.cpu().detach().numpy()) return loss, prob, tgt, meta
def __init__(self, fname, root): self.root = root self.fname = fname self.fpath = os.path.join(root, fname) self.dname = dn(self.fpath) self.ext = os.path.splitext(fname)[1] self.meta = dict(name=self.nice_name, sortkey="5", tags=set("data")) if not self.skip_file: self.meta.update(utils.parse_meta(self.fpath))
def __init__(self, fname, root): self.root = root self.fname = fname self.fpath = os.path.join(root, fname) self.dname = dn(self.fpath) self.ext = os.path.splitext(fname)[1] self.meta = dict(name=self.nice_name, sortkey="5", tags=set("data"), doctype="markdown") # large files should not be parsed if not self.skip_file: self.meta.update(utils.parse_meta(self.fpath))
def parse_zip(self, rawzip): zipfile = ZipFile(rawzip, 'r') all_files = zipfile.namelist() instances = [name for name in all_files if name.split('.')[-1] == 'csv'] for inum, name in enumerate(instances): base = '.'.join(name.split('.')[:-1]) img = base + '.png' vid = base + '.webm' meta = base + '.meta' idata = None vdata = None mdata = None if img in all_files: idata = zipfile.open(img).read() if vid in all_files: vdata = zipfile.open(vid).read() if meta in all_files: mdata = utils.parse_meta(zipfile.open(meta).read()) dframe = read_table(zipfile.open(name), sep=',') iclass = name.split('-')[0] yield inum, name, iclass, dframe, mdata, idata, vdata
print 'Classes : ', result['list_classes'] print 'Confusion Matrix for the dataset over 10 runs :' for i in data.keys(): print i, ' ', for j in data.keys(): print data[i][j], ' ', print '' print 'Accuracy for 10 runs: ', list_accuracy print 'Mean Accuracy : ', Stat.mean(list_accuracy) print 'Variance : ', Stat.variance(list_accuracy) print 'Standard Deviation : ', Stat.standard_deviation(list_accuracy) """ """ Specific to Iris Dataset """ column_list, column_map = utils.parse_meta("/home/arpit/Downloads/iris.meta") result = utils.knn_classify("/home/arpit/Downloads/iris.data", "/home/arpit/Downloads/iris.meta", ['sepal width in cm', 'petal width in cm'], 'class', Globals.euclidean) data = result['aggregated_confusion_matrix'] list_accuracy = list(result[i]['class_stat']['accuracy'] for i in range(10)) print 'Number of instances : ', result['number_instance'] print 'Number of Features : ', len(result['column_list']) - 1 print 'Classes : ', result['list_classes'] print 'Confusion Matrix for the dataset over 10 runs :' for i in data.keys(): print i, ' ', for j in data.keys(): print data[i][j], ' ',
print 'Accuracy for 10 runs: ', list_accuracy print 'Mean Accuracy : ', Stat.mean(list_accuracy) print 'Variance : ', Stat.variance(list_accuracy) print 'Standard Deviation : ', Stat.standard_deviation(list_accuracy) """ """ Specific to Iris Dataset """ column_list, column_map = utils.parse_meta("/home/arpit/Downloads/iris.meta") result = utils.knn_classify( "/home/arpit/Downloads/iris.data", "/home/arpit/Downloads/iris.meta", ['sepal width in cm', 'petal width in cm'], 'class', Globals.euclidean ) data = result['aggregated_confusion_matrix'] list_accuracy = list(result[i]['class_stat']['accuracy'] for i in range(10)) print 'Number of instances : ', result['number_instance'] print 'Number of Features : ', len(result['column_list']) - 1 print 'Classes : ', result['list_classes'] print 'Confusion Matrix for the dataset over 10 runs :'
__author__ = 'arpit' import Stat import utils import Globals import matplotlib.pyplot as plt from matplotlib.font_manager import FontProperties """ Specific to Iris Dataset """ column_list, column_map = utils.parse_meta("iris.meta.txt") result = utils.knn_classify("iris.data","iris.meta", ['sepal width in cm', 'petal width in cm'], 'class', Globals.euclidean ) data = result['aggregated_confusion_matrix'] list_accuracy = list(result[i]['class_stat']['accuracy'] for i in range(10)) print 'Number of instances : ', result['number_instance'] print 'Number of Features : ', len(result['column_list']) - 1 print 'Classes : ', result['list_classes'] print 'Confusion Matrix for the dataset over 10 runs :' for i in data.keys(): print i, ' ', for j in data.keys(): print data[i][j], ' ', print '' print 'Accuracy for 10 runs: ', list_accuracy print 'Mean Accuracy : ', Stat.mean(list_accuracy)