def createNxN( n ): # Create a 3x3 grid network network = networks.Network( (n*200, n*200) ) for x in range( 0, n*200, 200 ): for y in range( 0, n*200, 200 ): network.addNode( x, y ) return network
def test_updateWeights(self): loss = C.LossMSE() m = N.Network(loss) try: m.updateWeights(0.01) except: return 0 return 1
def test_resetGradients(self): loss = C.LossMSE() m = N.Network(loss) try: m.resetGradients(x, y) except: return 0 return 1
def test_backwardCall(self): loss = C.LossMSE() m = N.Network(loss) try: m.backwardCall() except: return 0 return 1
def test_iter(self): loss = C.LossMSE() m = N.Network(loss) try: m.__iter__() except: return 0 return 1
def test_forward(self): loss = C.LossMSE() m = N.Network(loss) try: m.forward() except: return 0 return 1
def main(args): # load model model = networks.Network() model.init_model() model.loading_model(args['model_path']) # load dataset dset = dataset.Dataset(args['dataset_path']) # predict scores = model.model.predict_classes(dset.features, batch_size=args['batch_size'])[:, 0] fig = plt.figure(figsize=(8, 8)) t0 = time() for slideName in dset.slides: # check if slide name matches slide path if slideName == args['slide_path'].split('/')[-1].split('.')[0]: # get dataset information for each slide slide_idx = dset.getSlideIdx(slideName) object_num = dset.getObjNum(slide_idx) data_idx = dset.getDataIdx(slide_idx) x_centroid_set = dset.getXcentroidSet(data_idx, object_num) y_centroid_set = dset.getYcentroidSet(data_idx, object_num) # get score for eadh slide score_set = scores[data_idx:data_idx + object_num] # get slide properties for each slide slide = openslide.open_slide(args['slide_path']) # compute downsample factor base_mag = find_mag(slide.level_count) downsample_factor = base_mag / args['target_mag'] level = find_level(downsample_factor) # read downsampled image downsampled_img = slide.read_region((0, 0), level, slide.level_dimensions[level]) # get centroids for the downsampled image [width, height] = slide.level_dimensions[level] patch_size_log_mag = int(args['patch_size'] / downsample_factor) half_patch_size_log_mag = int(patch_size_log_mag / 2) x_centroids = x_centroid_set / downsample_factor y_centroids = y_centroid_set / downsample_factor mask = np.zeros((height, width)) for i in range(len(x_centroids)): top, left = get_patch_bounds(x_centroids[i, 0], y_centroids[i, 0], half_patch_size_log_mag) if score_set[i] > 0: mask[top:top + patch_size_log_mag, left:left + patch_size_log_mag] = 255 elif score_set[i] == 0: mask[top:top + patch_size_log_mag, left:left + patch_size_log_mag] = 128 im_output = args['out_dir'] + slideName + '.png' plt.imsave(im_output, mask) t1 = time() print("Processing done ", t1 - t0)
def test_backward(self): x = FloatTensor([[1, 2, 3], [-4, 2, 3]]) y = FloatTensor([[3, 2, 0], [-1, 2, 3]]) loss = C.LossMSE() m = N.Network(loss) try: m.backward(x, y) except: return 0 return 1
def __init__(self, nspins, network=None, shape=None, seed=None): """Init method. Parameters ---------- nspins : int Number of spins. network : Network object Network object with the connection between spins. seed : int Random number generator seed. """ # Store parameters self.nspins = nspins # Create a flat array to store the spin configuration # (an structured array will be accesible through the # latt() method). self.spins = np.zeros(self.nspins, dtype="intc") # Set values randomly self.reset_random() # If a network is not given create an empty one if network == None: self.network = networks.Network(self.nspins) else: self.network = network # If the lattice has no shape attribute, create it if shape == None: self._shape = tuple((self.nspins, )) else: if np.prod(shape) == self.nspins: self._shape = tuple(shape) else: raise ValueError( "The given shape does not match the number of spins.") # Create neighbour lists self.update_neighbours() # Initialize the random number generators if seed == None: seed = random.SystemRandom().randint(0, 32767) self.seed = seed # Store seed cevolve.seed(seed) # dranxor number generator np.random.seed(seed) # Python random number generator
def __init__(self, shape, seed=None): """Init method. Parameters ---------- shape : int tuple Shape of the network (e.g. (2,3) or 2). It must satisfy np.prod(shape) = nnodes. This parameter needed to plot the network. If None, a 1D network (shape = (nnodes, )) is assumed. seed : int Seed for the pseudo-random number generator used in the network evolution. """ # Cast shape to tuple try: shape = tuple(shape) except TypeError: shape = tuple((shape, )) nnodes = np.prod(shape) # Initialize list of leanrt patterns self.patterns = list() # Create empty network network = networks.Network(nnodes, weighted=True) # Initialize Ising lattice isingmodel.IsingCoupling.__init__(self, nnodes, network=network, shape=shape, seed=seed)
def main(args): # load model model = networks.Network() model.init_model() model.loading_model(args['model_path']) # load dataset dset = dataset.Dataset(args['dataset_path']) # predict scores = model.model.predict_classes(dset.features, batch_size=args['batch_size'])[:, 0] fig = plt.figure(figsize=(8, 8)) t0 = time() for slideName in dset.slides: # check if slide name matches slide path if slideName == args['slide_path'].split('/')[-1].split('.')[0]: # get dataset information for each slide slide_idx = dset.getSlideIdx(slideName) object_num = dset.getObjNum(slide_idx) data_idx = dset.getDataIdx(slide_idx) x_centroid_set = dset.getXcentroidSet(data_idx, object_num) y_centroid_set = dset.getYcentroidSet(data_idx, object_num) # get score for eadh slide score_set = scores[data_idx:data_idx + object_num] # get slide properties for each slide slide = openslide.open_slide(args['slide_path']) # compute downsample factor base_mag = find_mag(slide.level_count) downsample_factor = base_mag / args['target_mag'] level = find_level(downsample_factor) # read downsampled image downsampled_img = slide.read_region((0, 0), level, slide.level_dimensions[level]) # get centroids for the downsampled image [width, height] = slide.level_dimensions[level] patch_size_log_mag = int(args['patch_size'] / downsample_factor) half_patch_size_log_mag = int(patch_size_log_mag / 2) x_centroids = x_centroid_set / downsample_factor y_centroids = y_centroid_set / downsample_factor mask = np.zeros((height, width)) for i in range(len(x_centroids)): top, left = get_patch_bounds(x_centroids[i, 0], y_centroids[i, 0], half_patch_size_log_mag) if score_set[i] > 0: mask[top:top + patch_size_log_mag, left:left + patch_size_log_mag] = 255 elif score_set[i] == 0: mask[top:top + patch_size_log_mag, left:left + patch_size_log_mag] = 128 im_output = args['out_dir'] + slideName + '.png' fig.add_subplot(1, 2, 1) plt.title('Predicted') plt.imshow(mask, cmap='jet') fig.add_subplot(1, 2, 2) points = np.hstack((x_centroids, y_centroids)) # get positive and negative points positive_index = np.where(score_set[score_set > 0]) positive_points = points[positive_index].astype(int) # random choice if the number of superpixels is over 1000 if len(positive_points) > args['random_choice']: indices = np.random.choice(positive_points.shape[0], args['random_choice'], replace=False) positive_points = positive_points[indices] # perform Affinity Propagation Clustering af = AffinityPropagation().fit(positive_points) cluster_centers_indices = af.cluster_centers_indices_ labels = af.labels_ n_clusters_ = len(cluster_centers_indices) im1 = plt.imshow(downsampled_img) colors = cycle('bgrcmykbgrcmykbgrcmykbgrcmyk') for k, col in zip(range(n_clusters_), colors): class_members = labels == k cluster_center = positive_points[cluster_centers_indices[k]] plt.plot(positive_points[class_members, 0], positive_points[class_members, 1], col + '.') plt.plot(cluster_center[0], cluster_center[1], 'o', markerfacecolor=col, markeredgecolor='k', markersize=5) for x in positive_points[class_members]: plt.plot([cluster_center[0], x[0]], [cluster_center[1], x[1]], col) plt.title('AffinityAnalyzed') plt.savefig(im_output) t1 = time() print("Training took ", t1 - t0)
# load dataset f = h5py.File(dataSet) features = f['features'][:] # load trainingset c = h5py.File(trainSet) object_num = len(c['slideIdx'][:]) sample_features = c['features'][:] train_features = np.vstack((sample_features, c['augments_features'][:])) sample_labels = c['labels'][:] train_labels = np.vstack((sample_labels, c['augments_labels'][:])) train_labels[train_labels < 0] = 0 train_labels = to_categorical(train_labels, num_classes=2) # initialize neural network model model = networks.Network() model.init_model() print('Training ... ', len(train_labels)) t0 = time() model.train_model(train_features, train_labels) t1 = time() print('Training took ', t1 - t0) print('Predict ... ', len(train_labels)) t0 = time() predicts = model.predict(features) t1 = time() print('Predict took ', t1 - t0)
def run_mlp_experiment(args, device): """ Runs the experiment with a 3-layers fully connected network. :param args: Namespace from utils.parse_arguments :param device: torch.device :return: np.array of float, np.array of float, np.array of float; train_acc, val_acc, test_acc (in percentage) """ validation_ratio, record_train_acc, record_val_acc, record_test_acc = utils.configure_training_mode( args) train_loader, validation_loader, test_loader = datasets.build_loaders_by_dataset( args.dataset, args.batch_size, validation_ratio=validation_ratio, train_validation_split_seed=0) local_loss_list = utils.get_loss(args) nonlinearity = utils.get_nonlinearity(args) optimizer_local, local_opt_arguments_dict, local_scheduler_arguments_dict, \ optimizer_final, final_opt_arguments_dict, final_scheduler_arguments_dict = \ utils.choose_optimizers_and_parameters(args) conv_sizes = [] do_pooling = [] kernel_sizes = [] fc_layers = [args.mlp_layer_size, args.mlp_layer_size, args.mlp_layer_size] if args.divisive_norm_fc: divisive_norm_list = [ networks.DivisiveNorm(args.divnorm_power, args.grouping_dim, args.grouped_var_delta) for i in range(len(fc_layers)) ] else: divisive_norm_list = None alt_feedback_type = None if args.feedback_alignment: alt_feedback_type = 'feedback_alignment' elif args.sign_symmetry: alt_feedback_type = 'sign_symmetry' net = networks.Network( nonlinearity, local_loss_list, optimizer_local, torch.optim.lr_scheduler.MultiStepLR, conv_sizes, kernel_sizes, do_pooling, fc_layers, 'max', args.dataset, bias=False, local_opt_arguments_dict=local_opt_arguments_dict, local_scheduler_arguments_dict=local_scheduler_arguments_dict, dropout_p=args.dropout_p, batch_norm=args.batch_norm, divisive_norm_list_conv=None, divisive_norm_list_fc=divisive_norm_list, spatial_dropout=args.spatial_dropout, alt_feedback_type=alt_feedback_type) net = net.to(device) print(net) final_loss = nn.CrossEntropyLoss() if args.backprop: final_opt = optimizer_final(net.parameters(), **final_opt_arguments_dict) compute_local_loss = False update_local_loss = False else: final_opt = optimizer_final(net.softmax_layer.parameters(), **final_opt_arguments_dict) compute_local_loss = True update_local_loss = True final_scheduler = torch.optim.lr_scheduler.MultiStepLR( final_opt, **final_scheduler_arguments_dict) train_acc, val_acc, test_acc = utils.train_network( net, device, final_loss, final_opt, final_scheduler, args.n_epochs, train_loader, validation_loader, test_loader, compute_local_loss=compute_local_loss, update_local_loss=update_local_loss, record_train_acc=record_train_acc, record_val_acc=record_val_acc, record_test_acc=record_test_acc, print_results=True, backprop_batch_manhattan=args.backprop_batch_manhattan) return train_acc, val_acc, test_acc
def run(): # initialize VGG Model and PCA iset = init.Init() # initialize neural network model model = networks.Network() model.init_model() # initialize global instance uset = users.Users() # store special features in memory # dset_special = dataset.Dataset(set.PATH_TO_SPECIAL) dset_special = None print "Dataset Loaded." # set normal features in memory to false is_normal_loaded = True tset_name = None is_reloaded = False m_checkpoints = 0 while True: queue = db.lrange(set.REQUEST_QUEUE, set.REQUEST_START, set.REQUEST_END) q_uid = None # initialize local instance select = selectonly.Select() finalize = save.Save() viewer = view.View() retrain_v = retrainView.retrainView() retrain_h = retrainHeatmap.retrainHeatmap() heat = heatmap.Heatmap() t_train = train.Train() report_label = label.label() report_count = count.count() report_map = mapping.map() for q in queue: q = json.loads(q.decode("utf-8")) q_uid = q["uid"] target = q["target"] session_uid = q["uid"] dataSetPath = set.DATASET_DIR + q["dataset"] pcaPath = set.DATASET_DIR + q["pca"] # if specific features then set m_loaded to true is_normal_loaded = False if dataSetPath == set.PATH_TO_SPECIAL else True if target == "label": report_label.setData(q) if target == "count": report_count.setData(q) if target == "map": report_map.setData(q) if target == 'selectonly': select.setData(q) if target == 'save': finalize.setData(q) if target == 'view': viewer.setData(q) if target == 'retrainView': retrain_v.setData(q) if target == 'retrainHeatmap': retrain_h.setData(q) if target == 'heatmapAll': heatmaps = q["viewJSONs"] if target == 'heatmap': heat.setData(q) if target == 'train': t_train.setData(q) if target == 'reload': t_path = set.TRAININGSET_DIR + q["trainingSetName"] is_reloaded = True if target == 'reviewSave': q_samples = json.loads(q["samples"]) if q_uid is not None: print target, " Session Start ....." no_uid = True uidx = 0 # find current user Index for i in range(len(uset.users)): if uset.users[i]['uid'] == session_uid: uidx = i no_uid = False if no_uid: # set users data uset.addUser(session_uid) if is_normal_loaded: dset = dataset.Dataset(dataSetPath) else: dset = dset_special PCA = joblib.load(pcaPath) if target == 'selectonly': uset.setIter(uidx, select.iter) print "Predict Start ... " t0 = time() scores = model.predict_prob(dset.features) t1 = time() print "Predict took ", t1 - t0 # Find uncertain samples data = select.getData(scores, dset.slideIdx, dset.slides, dset.x_centroid, dset.y_centroid) db.set(q_uid, json.dumps(data)) db.ltrim(set.REQUEST_QUEUE, len(q_uid), -1) if target == 'view': slide_idx = dset.getSlideIdx(viewer.slide) object_num = dset.getObjNum(slide_idx) data_idx = dset.getDataIdx(slide_idx) feature_set = dset.getFeatureSet(data_idx, object_num) x_centroid_set = dset.getXcentroidSet(data_idx, object_num) y_centroid_set = dset.getYcentroidSet(data_idx, object_num) print "Predict Start ... " t0 = time() predictions = model.predict(feature_set) t1 = time() print "Predict took ", t1 - t0 object_idx = load( viewer.left, viewer.right, viewer.top, viewer.bottom, x_centroid_set.astype(np.float), y_centroid_set.astype(np.float) ) data = {} for i in object_idx: data[str(x_centroid_set[i][0])+'_'+str(y_centroid_set[i][0])] = str(predictions[i]) db.set(q_uid, json.dumps(data)) db.ltrim(set.REQUEST_QUEUE, len(q_uid), -1) if target == 'heatmap': slide_idx = dset.getSlideIdx(heat.slide) object_num = dset.getObjNum(slide_idx) data_idx = dset.getDataIdx(slide_idx) feature_set = dset.getFeatureSet(data_idx, object_num) x_centroid_set = dset.getXcentroidSet(data_idx, object_num) y_centroid_set = dset.getYcentroidSet(data_idx, object_num) print "Predict Start ... " t0 = time() if set.IS_HEATMAP == False: scores = model.predict_prob(feature_set) t1 = time() print "Predict took ", t1 - t0 # set x and y maps heat.setXandYmap() # write heatmaps heat.setHeatMap(x_centroid_set, y_centroid_set, scores) # get heatmap data data = heat.getData(0) db.set(q_uid, json.dumps(data)) db.ltrim(set.REQUEST_QUEUE, len(q_uid), -1) if target == 'heatmapAll': data = [] index = 0 t0 = time() scores = model.predict_prob(dset.features) t1 = time() print "Predict took ", t1 - t0 for h in heatmaps: h['uid'] = session_uid heat.setData(h) slide_idx = dset.getSlideIdx(heat.slide) object_num = dset.getObjNum(slide_idx) data_idx = dset.getDataIdx(slide_idx) # feature_set = dset.getFeatureSet(data_idx, object_num) x_centroid_set = dset.getXcentroidSet(data_idx, object_num) y_centroid_set = dset.getYcentroidSet(data_idx, object_num) score_set = scores[data_idx: data_idx+object_num] # set x and y maps heat.setXandYmap() # write heatmaps heat.setHeatMap(x_centroid_set, y_centroid_set, score_set) # get heatmap data data_k = heat.getData(index) data.append(data_k) index += 1 # print data db.set(q_uid, json.dumps(data)) db.ltrim(set.REQUEST_QUEUE, len(q_uid), -1) if target == 'reload': # initialize augment agen = augments.Augments() # set user train samples # uset.setReloadedData(uidx, t_path, dset.slides) uset.setReloadedData(uidx, t_path) sample_size = len(uset.users[uidx]['samples']) m_checkpoints = uset.users[uidx]['samples'][sample_size-1]['checkpoints'] sample_batch_size = agen.AUG_BATCH_SIZE * sample_size train_size = sample_size + sample_batch_size train_features = np.zeros((train_size, set.FEATURE_DIM)) train_labels = np.zeros((train_size, )) for i in range(sample_size): train_features[i] = uset.users[uidx]['samples'][i]['feature'] train_labels[i] = uset.users[uidx]['samples'][i]['label'] train_features[i+sample_size:i+sample_size+agen.AUG_BATCH_SIZE] = uset.users[uidx]['augments'][i]['feature'] train_labels[i+sample_size:i+sample_size+agen.AUG_BATCH_SIZE] = uset.users[uidx]['augments'][i]['label'] tset_path = t_path.split('/')[-1] tset_name = tset_path.split('.')[0] print "Training ... ", len(train_labels) t0 = time() model.train_model(train_features, train_labels, tset_name) t1 = time() print "Training took ", t1 - t0 data = {"success": 'pass'} db.set(q_uid, json.dumps(data)) db.ltrim(set.REQUEST_QUEUE, len(q_uid), -1) if target == 'label': # initialize augment agen = augments.Augments() # set user train samples uset.setReloadedData(uidx, report_label.trainSet) sample_size = len(uset.users[uidx]['samples']) sample_batch_size = agen.AUG_BATCH_SIZE * sample_size train_size = sample_size + sample_batch_size train_features = np.zeros((train_size, set.FEATURE_DIM)) train_labels = np.zeros((train_size, )) for i in range(sample_size): train_features[i] = uset.users[uidx]['samples'][i]['feature'] train_labels[i] = uset.users[uidx]['samples'][i]['label'] train_features[i+sample_size:i+sample_size+agen.AUG_BATCH_SIZE] = uset.users[uidx]['augments'][i]['feature'] train_labels[i+sample_size:i+sample_size+agen.AUG_BATCH_SIZE] = uset.users[uidx]['augments'][i]['label'] print "Training ... ", len(train_labels) t0 = time() model.train_model(train_features, train_labels, report_label.classifier) t1 = time() print "Training took ", t1 - t0 slide_idx = dset.getSlideIdx(report_label.slide) object_num = dset.getObjNum(slide_idx) data_idx = dset.getDataIdx(slide_idx) test_features = dset.getFeatureSet(data_idx, object_num) x_centroid_set = dset.getXcentroidSet(data_idx, object_num) y_centroid_set = dset.getYcentroidSet(data_idx, object_num) print "Testing Start ... " t0 = time() predicts = model.predict(test_features) t1 = time() print "Predict took ", t1 - t0 inputImageFile = '/datasets/tif/'+ report_label.slide + '.svs.dzi.tif' bold = 512 bold_left = report_label.left - bold bold_top = report_label.top - bold bold_bottom = report_label.bottom + bold bold_right = report_label.right + bold bold_width = report_label.width + 2*bold bold_height = report_label.height + 2*bold ts = large_image.getTileSource(inputImageFile) region = dict( left=report_label.left, top=report_label.top, width=report_label.width, height=report_label.height, ) im_region = ts.getRegion( region=region, format=large_image.tilesource.TILE_FORMAT_NUMPY )[0] mydb = mysql.connector.connect( host=set.MYSQL_HOST, user="******", passwd="guest", database="nuclei", charset='utf8', use_unicode=True ) boundaryTablename = 'sregionboundaries' runcursor = mydb.cursor() query = 'SELECT centroid_x, centroid_y, boundary from ' + boundaryTablename + ' where slide="' + report_label.slide + \ '" AND centroid_x BETWEEN ' + str(report_label.left) + ' AND ' + str(report_label.right) + \ ' AND centroid_y BETWEEN ' + str(report_label.top) + ' AND ' + str(report_label.bottom) runcursor.execute(query) boundarySet = runcursor.fetchall() # find region index from hdf5 object_idx = load( report_label.left, report_label.right, report_label.top, report_label.bottom, x_centroid_set.astype(np.float), y_centroid_set.astype(np.float) ) # set an array for boundary points in a region to zero im_bold = np.zeros((bold_height, bold_width), dtype=np.uint8) for i in object_idx: for j in range(len(boundarySet)): x = int(boundarySet[j][0]) y = int(boundarySet[j][1]) boundaryPoints = [] if x == int(x_centroid_set[i, 0]) and y == int(y_centroid_set[i, 0]): object = boundarySet[j][2].encode('utf-8').split(' ') object_points = [] for p in range(len(object)-1): intP = map(int, object[p].split(',')) intP[0] = intP[0] - report_label.left + bold intP[1] = intP[1] - report_label.top + bold object_points.append(intP) boundaryPoints.append(np.asarray(object_points)) cv2.fillPoly(im_bold, boundaryPoints, 255 if predicts[i] > 0 else 128) im_out = im_bold[bold:bold+report_label.height, bold:bold+report_label.width] imsave(report_label.inFile, im_out) runcursor.close() mydb.close() print ("label success ", report_label.inFile) data = {"success": report_label.outFile} db.set(q_uid, json.dumps(data)) db.ltrim(set.REQUEST_QUEUE, len(q_uid), -1) uset.users = [] uset.u_size = 0 model = networks.Network() model.init_model() print ("label done") if target == 'count': # initialize augment agen = augments.Augments() # set user train samples uset.setReloadedData(uidx, report_count.trainSet) sample_size = len(uset.users[uidx]['samples']) sample_batch_size = agen.AUG_BATCH_SIZE * sample_size train_size = sample_size + sample_batch_size train_features = np.zeros((train_size, set.FEATURE_DIM)) train_labels = np.zeros((train_size, )) for i in range(sample_size): train_features[i] = uset.users[uidx]['samples'][i]['feature'] train_labels[i] = uset.users[uidx]['samples'][i]['label'] train_features[i+sample_size:i+sample_size+agen.AUG_BATCH_SIZE] = uset.users[uidx]['augments'][i]['feature'] train_labels[i+sample_size:i+sample_size+agen.AUG_BATCH_SIZE] = uset.users[uidx]['augments'][i]['label'] print "Training ... ", len(train_labels) t0 = time() model.train_model(train_features, train_labels, report_count.classifier) t1 = time() print "Training took ", t1 - t0 print "Testing Start ... " t0 = time() predicts = model.predict(dset.features) t1 = time() print "Predict took ", t1 - t0 # find positive and negative numbers for each slide pos_num = [] neg_num = [] for i in range(dset.n_slides): if i == len(dset.dataIdx) - 1: predict = predicts[dset.dataIdx[i, 0]:] else: predict = predicts[dset.dataIdx[i, 0]: dset.dataIdx[i+1, 0]] pos = len(predict[predict>0]) neg = len(predict) - pos pos_num.append(pos) neg_num.append(neg) print('>> Writing count file') out_file = open(report_count.inFile, 'w') out_file.write("Slide\t") out_file.write("Predicted positive (superpixels)\t") out_file.write("Predicted negative (superpixels)\t") out_file.write("\n") for i in range(len(dset.slides)): out_file.write("%s\t" % dset.slides[i]) out_file.write("%d\t" % pos_num[i]) out_file.write("%d\t" % neg_num[i]) out_file.write("\n") out_file.close() print ("count success ", report_count.inFile) data = {"success": report_count.outFile} db.set(q_uid, json.dumps(data)) db.ltrim(set.REQUEST_QUEUE, len(q_uid), -1) uset.users = [] uset.u_size = 0 model = networks.Network() model.init_model() print ("count done") if target == 'map': # initialize augment agen = augments.Augments() # set user train samples uset.setReloadedData(uidx, report_map.trainSet) sample_size = len(uset.users[uidx]['samples']) sample_batch_size = agen.AUG_BATCH_SIZE * sample_size train_size = sample_size + sample_batch_size train_features = np.zeros((train_size, set.FEATURE_DIM)) train_labels = np.zeros((train_size, )) for i in range(sample_size): train_features[i] = uset.users[uidx]['samples'][i]['feature'] train_labels[i] = uset.users[uidx]['samples'][i]['label'] train_features[i+sample_size:i+sample_size+agen.AUG_BATCH_SIZE] = uset.users[uidx]['augments'][i]['feature'] train_labels[i+sample_size:i+sample_size+agen.AUG_BATCH_SIZE] = uset.users[uidx]['augments'][i]['label'] print "Training ... ", len(train_labels) t0 = time() model.train_model(train_features, train_labels, report_map.classifier) t1 = time() print "Training took ", t1 - t0 slide_idx = dset.getSlideIdx(report_map.slide) object_num = dset.getObjNum(slide_idx) data_idx = dset.getDataIdx(slide_idx) test_features = dset.getFeatureSet(data_idx, object_num) x_centroid_set = dset.getXcentroidSet(data_idx, object_num) y_centroid_set = dset.getYcentroidSet(data_idx, object_num) print "Testing Start ... " t0 = time() predicts = model.predict(test_features) t1 = time() print "Predict took ", t1 - t0 output = h5py.File(report_map.inFile, 'w') output.create_dataset('features', data=test_features) output.create_dataset('predicts', data=predicts) output.create_dataset('x_centroid', data=x_centroid_set) output.create_dataset('y_centroid', data=y_centroid_set) output.create_dataset('slides', data=[report_map.slide]) output.close() print ("map success ", report_map.inFile) data = {"success": report_map.outFile} db.set(q_uid, json.dumps(data)) db.ltrim(set.REQUEST_QUEUE, len(q_uid), -1) uset.users = [] uset.u_size = 0 model = networks.Network() model.init_model() print ("map done") if target == 'save': data = finalize.getData(uset.users[uidx]) db.set(q_uid, json.dumps(data)) db.ltrim(set.REQUEST_QUEUE, len(q_uid), -1) if target == 'review': data = {} data['review'] = [] for sample in uset.users[uidx]['samples']: sample_data = {} sample_data['id'] = str(sample['id']) sample_data['label'] = 1 if sample['label'] == 1 else -1 sample_data['iteration'] = int(sample['iteration']) sample_data['slide'] = str(sample['slide']) sample_data['centX'] = str(sample['centX']) sample_data['centY'] = str(sample['centY']) sample_data['boundary'] = "" sample_data['maxX'] = 0 sample_data['maxY'] = 0 data['review'].append(sample_data) db.set(q_uid, json.dumps(data)) db.ltrim(set.REQUEST_QUEUE, len(q_uid), -1) if target == 'train': # increase checkpoint by 1 m_checkpoints += 1 # initialize augment agen = augments.Augments() uset.setIter(uidx, t_train.iter) for sample in t_train.samples: # init sample and augment init_sample = dict( id=0, f_idx=0, checkpoints=0, aurl=None, feature=None, label=0, iteration=0, centX=0, centY=0, slideIdx=0, slide=None ) init_augment = dict( id=[], checkpoints=[], feature=[], label=[] ) # check db_id in users samples remove_idx = [] for u in range(len(uset.users[uidx]['samples'])): if uset.users[uidx]['samples'][u]['id'] == sample['id']: remove_idx.append(u) for r in remove_idx: uset.users[uidx]['samples'].pop(r) uset.users[uidx]['augments'].pop(r) # add feature init_sample['id'] = sample['id'] init_sample['aurl'] = str(sample['aurl']) init_sample['slide'] = str(sample['slide']) slide_idx = dset.getSlideIdx(init_sample['slide']) object_num = dset.getObjNum(slide_idx) data_idx = dset.getDataIdx(slide_idx) feature_set = dset.getFeatureSet(data_idx, object_num) x_centroid_set = dset.getXcentroidSet(data_idx, object_num) y_centroid_set = dset.getYcentroidSet(data_idx, object_num) slideIdx_set = dset.getSlideIdxSet(data_idx, object_num) c_idx = getIdx( x_centroid_set.astype(np.float), y_centroid_set.astype(np.float), slideIdx_set.astype(np.int), np.float32(sample['centX']), np.float32(sample['centY']), slide_idx ) f_idx = data_idx + c_idx init_sample['f_idx'] = f_idx init_sample['feature'] = feature_set[c_idx] init_sample['label'] = 1 if sample['label'] == 1 else 0 init_sample['iteration'] = t_train.iter init_sample['centX'] = sample['centX'] init_sample['centY'] = sample['centY'] init_sample['checkpoints'] = m_checkpoints # add augment features slide_idx = dset.getSlideIdx(init_sample['slide']) slide_mean = dset.getWSI_Mean(slide_idx) slide_std = dset.getWSI_Std(slide_idx) a_imgs = agen.prepare_image(init_sample['aurl'], slide_mean, slide_std) a_featureSet = iset.FC1_MODEL.predict(a_imgs) a_featureSet = PCA.transform(a_featureSet) a_labelSet = np.zeros((agen.AUG_BATCH_SIZE, )).astype(np.uint8) a_idSet = [] a_checkpointSet = [] for i in range(agen.AUG_BATCH_SIZE): a_idSet.append(init_sample['id']) a_checkpointSet.append(init_sample['checkpoints']) if init_sample['label'] > 0: a_labelSet.fill(1) init_augment['id'] = a_idSet init_augment['feature'] = a_featureSet init_augment['label'] = a_labelSet init_augment['checkpoints'] = a_checkpointSet uset.setAugmentData(uidx, init_augment) uset.setTrainSampleData(uidx, init_sample) sample_size = len(uset.users[uidx]['samples']) sample_batch_size = agen.AUG_BATCH_SIZE * sample_size train_size = sample_size + sample_batch_size train_features = np.zeros((train_size, set.FEATURE_DIM)) train_labels = np.zeros((train_size, )) for i in range(sample_size): train_features[i] = uset.users[uidx]['samples'][i]['feature'] train_labels[i] = uset.users[uidx]['samples'][i]['label'] train_features[i+sample_size:i+sample_size+agen.AUG_BATCH_SIZE] = uset.users[uidx]['augments'][i]['feature'] train_labels[i+sample_size:i+sample_size+agen.AUG_BATCH_SIZE] = uset.users[uidx]['augments'][i]['label'] # train_labels = to_categorical(train_labels, num_classes=2) if tset_name is None: tset_name = t_train.classifier print "Training ... ", len(train_labels) t0 = time() model.train_model(train_features, train_labels, tset_name) t1 = time() print "Training took ", t1 - t0 data = {"success": 'pass'} db.set(q_uid, json.dumps(data)) db.ltrim(set.REQUEST_QUEUE, len(q_uid), -1) if target == 'retrainView': m_checkpoints += 1 # initialize augment agen = augments.Augments() uset.setIter(uidx, retrain_v.iter) print "Augment ... ", len(retrain_v.samples) t0 = time() for sample in retrain_v.samples: # init sample and augment init_sample = dict( id=0, f_idx=0, checkpoints=0, aurl=None, feature=None, label=0, iteration=0, centX=0, centY=0, slideIdx=0, slide=None ) init_augment = dict( id=[], checkpoints=[], feature=[], label=[] ) # remove samples stored if it already exists remove_idx = [] for u in range(len(uset.users[uidx]['samples'])): if uset.users[uidx]['samples'][u]['id'] == sample['id']: remove_idx.append(u) for r in remove_idx: uset.users[uidx]['samples'].pop(r) uset.users[uidx]['augments'].pop(r) # add feature init_sample['id'] = sample['id'] init_sample['aurl'] = str(sample['aurl']) init_sample['slide'] = str(sample['slide']) slide_idx = dset.getSlideIdx(init_sample['slide']) object_num = dset.getObjNum(slide_idx) data_idx = dset.getDataIdx(slide_idx) feature_set = dset.getFeatureSet(data_idx, object_num) x_centroid_set = dset.getXcentroidSet(data_idx, object_num) y_centroid_set = dset.getYcentroidSet(data_idx, object_num) slideIdx_set = dset.getSlideIdxSet(data_idx, object_num) c_idx = getIdx( x_centroid_set.astype(np.float), y_centroid_set.astype(np.float), slideIdx_set.astype(np.int), np.float32(sample['centX']), np.float32(sample['centY']), slide_idx ) f_idx = data_idx + c_idx init_sample['f_idx'] = f_idx init_sample['feature'] = feature_set[c_idx] init_sample['label'] = 1 if sample['label'] == 1 else 0 init_sample['iteration'] = retrain_v.iter init_sample['centX'] = sample['centX'] init_sample['centY'] = sample['centY'] init_sample['checkpoints'] = m_checkpoints # add augment features slide_idx = dset.getSlideIdx(init_sample['slide']) slide_mean = dset.getWSI_Mean(slide_idx) slide_std = dset.getWSI_Std(slide_idx) a_imgs = agen.prepare_image(init_sample['aurl'], slide_mean, slide_std) a_featureSet = iset.FC1_MODEL.predict(a_imgs) a_featureSet = PCA.transform(a_featureSet) a_labelSet = np.zeros((agen.AUG_BATCH_SIZE, )).astype(np.uint8) a_idSet = [] a_checkpointSet = [] for i in range(agen.AUG_BATCH_SIZE): a_idSet.append(init_sample['id']) a_checkpointSet.append(init_sample['checkpoints']) if init_sample['label'] > 0: a_labelSet.fill(1) init_augment['id'] = a_idSet init_augment['feature'] = a_featureSet init_augment['label'] = a_labelSet init_augment['checkpoints'] = a_checkpointSet uset.setAugmentData(uidx, init_augment) uset.setTrainSampleData(uidx, init_sample) t1 = time() print "Augmentation took ", t1 - t0 sample_size = len(uset.users[uidx]['samples']) sample_batch_size = agen.AUG_BATCH_SIZE * sample_size train_size = sample_size + sample_batch_size train_features = np.zeros((train_size, set.FEATURE_DIM)) train_labels = np.zeros((train_size, )) for i in range(sample_size): train_features[i] = uset.users[uidx]['samples'][i]['feature'] train_labels[i] = uset.users[uidx]['samples'][i]['label'] train_features[i+sample_size:i+sample_size+agen.AUG_BATCH_SIZE] = uset.users[uidx]['augments'][i]['feature'] train_labels[i+sample_size:i+sample_size+agen.AUG_BATCH_SIZE] = uset.users[uidx]['augments'][i]['label'] # train_labels = to_categorical(train_labels, num_classes=2) if tset_name is None: tset_name = retrain_v.classifier t0 = time() model.train_model(train_features, train_labels, tset_name) t1 = time() print "Training took ", t1 - t0, " ", len(train_labels), "Samples" slide_idx = dset.getSlideIdx(retrain_v.slide) object_num = dset.getObjNum(slide_idx) data_idx = dset.getDataIdx(slide_idx) feature_set = dset.getFeatureSet(data_idx, object_num) x_centroid_set = dset.getXcentroidSet(data_idx, object_num) y_centroid_set = dset.getYcentroidSet(data_idx, object_num) print "Testing Start ... " t0 = time() predictions = model.predict(feature_set) t1 = time() print "Predict took ", t1 - t0 object_idx = load( retrain_v.left, retrain_v.right, retrain_v.top, retrain_v.bottom, x_centroid_set.astype(np.float), y_centroid_set.astype(np.float) ) data = {} for i in object_idx: data[str(x_centroid_set[i][0])+'_'+str(y_centroid_set[i][0])] = str(predictions[i]) db.set(q_uid, json.dumps(data)) db.ltrim(set.REQUEST_QUEUE, len(q_uid), -1) if target == 'retrainHeatmap': m_checkpoints += 1 # initialize augment agen = augments.Augments() uset.setIter(uidx, retrain_h.iter) for sample in retrain_h.samples: # init sample and augment init_sample = dict( id=0, f_idx=0, checkpoints=0, aurl=None, feature=None, label=0, iteration=0, centX=0, centY=0, slideIdx=0, slide=None ) init_augment = dict( id=[], checkpoints=[], feature=[], label=[] ) # remove samples stored if it already exists remove_idx = [] for u in range(len(uset.users[uidx]['samples'])): if uset.users[uidx]['samples'][u]['id'] == sample['id']: remove_idx.append(u) for r in remove_idx: uset.users[uidx]['samples'].pop(r) uset.users[uidx]['augments'].pop(r) # add feature init_sample['id'] = sample['id'] init_sample['aurl'] = str(sample['aurl']) init_sample['slide'] = str(sample['slide']) slide_idx = dset.getSlideIdx(init_sample['slide']) object_num = dset.getObjNum(slide_idx) data_idx = dset.getDataIdx(slide_idx) feature_set = dset.getFeatureSet(data_idx, object_num) x_centroid_set = dset.getXcentroidSet(data_idx, object_num) y_centroid_set = dset.getYcentroidSet(data_idx, object_num) slideIdx_set = dset.getSlideIdxSet(data_idx, object_num) c_idx = getIdx( x_centroid_set.astype(np.float), y_centroid_set.astype(np.float), slideIdx_set.astype(np.int), np.float32(sample['centX']), np.float32(sample['centY']), slide_idx ) f_idx = data_idx + c_idx init_sample['f_idx'] = f_idx init_sample['feature'] = feature_set[c_idx] init_sample['label'] = 1 if sample['label'] == 1 else 0 init_sample['iteration'] = retrain_h.iter init_sample['centX'] = sample['centX'] init_sample['centY'] = sample['centY'] init_sample['checkpoints'] = m_checkpoints # add augment features slide_idx = dset.getSlideIdx(init_sample['slide']) slide_mean = dset.getWSI_Mean(slide_idx) slide_std = dset.getWSI_Std(slide_idx) a_imgs = agen.prepare_image(init_sample['aurl'], slide_mean, slide_std) a_featureSet = iset.FC1_MODEL.predict(a_imgs) a_featureSet = PCA.transform(a_featureSet) a_labelSet = np.zeros((agen.AUG_BATCH_SIZE, )).astype(np.uint8) a_idSet = [] a_checkpointSet = [] for i in range(agen.AUG_BATCH_SIZE): a_idSet.append(init_sample['id']) a_checkpointSet.append(init_sample['checkpoints']) if init_sample['label'] > 0: a_labelSet.fill(1) init_augment['id'] = a_idSet init_augment['feature'] = a_featureSet init_augment['label'] = a_labelSet init_augment['checkpoints'] = a_checkpointSet uset.setAugmentData(uidx, init_augment) uset.setTrainSampleData(uidx, init_sample) sample_size = len(uset.users[uidx]['samples']) sample_batch_size = agen.AUG_BATCH_SIZE * sample_size train_size = sample_size + sample_batch_size train_features = np.zeros((train_size, set.FEATURE_DIM)) train_labels = np.zeros((train_size, )) for i in range(sample_size): train_features[i] = uset.users[uidx]['samples'][i]['feature'] train_labels[i] = uset.users[uidx]['samples'][i]['label'] train_features[i+sample_size:i+sample_size+agen.AUG_BATCH_SIZE] = uset.users[uidx]['augments'][i]['feature'] train_labels[i+sample_size:i+sample_size+agen.AUG_BATCH_SIZE] = uset.users[uidx]['augments'][i]['label'] if tset_name is None: tset_name = retrain_h.classifier t0 = time() model.train_model(train_features, train_labels, tset_name) t1 = time() print "Training took ", t1 - t0, " ", len(train_labels), "Samples" slide_idx = dset.getSlideIdx(retrain_h.slide) object_num = dset.getObjNum(slide_idx) data_idx = dset.getDataIdx(slide_idx) feature_set = dset.getFeatureSet(data_idx, object_num) x_centroid_set = dset.getXcentroidSet(data_idx, object_num) y_centroid_set = dset.getYcentroidSet(data_idx, object_num) print "Testing Start ... " t0 = time() if set.IS_HEATMAP == False: scores = model.predict_prob(feature_set) t1 = time() print "Predict took ", t1 - t0 # set x and y maps retrain_h.setXandYmap() # write heatmaps retrain_h.setHeatMap(x_centroid_set, y_centroid_set, scores) # get heatmap data data = retrain_h.getData(0) db.set(q_uid, json.dumps(data)) db.ltrim(set.REQUEST_QUEUE, len(q_uid), -1) if target == 'cancel': uset.users = [] uset.u_size = 0 is_normal_loaded = True tset_name = None is_reloaded = False m_checkpoints = 0 del select del finalize del viewer del retrain_v del retrain_h del heat del t_train del report_label model = networks.Network() model.init_model() # dset = dataset.Dataset(set.PATH_TO_SPECIAL) data = {"success": 'pass'} db.set(q_uid, json.dumps(data)) db.ltrim(set.REQUEST_QUEUE, len(q_uid), -1) if target == 'reviewSave': # modify labels if they are changed on review tab for q_sample in q_samples: for sample in uset.users[uidx]['samples']: if sample['id'] == q_sample['id']: sample['label'] = 1 if q_sample['label'] == 1 else 0 for sample in uset.users[uidx]['augments']: if sample['id'][0] == q_sample['id']: sample['label'][:] = 1 if q_sample['label'] == 1 else 0 data = {"success": 'pass'} db.set(q_uid, json.dumps(data)) db.ltrim(set.REQUEST_QUEUE, len(q_uid), -1)
def main(): network = networks.Network().to(device) print(next(network.parameters()).is_cuda) game_data = [] value_data = [] policy_data = [] print(device) replaybuffer = data_generator.ReplayBuffer(parameters.replay_buffer_size, device) generator = data_generator.DataGenerator(network, parameters.rollouts, replaybuffer, device, displayer) policy_loss = nn.KLDivLoss(reduction='batchmean') value_loss = nn.MSELoss() optimizer = optim.Adam(network.parameters(), lr=parameters.learning_rate) policy_activation = nn.LogSoftmax() while True: generator.generate_games(parameters.games_generated_at_a_time) if len(replaybuffer.games) >= parameters.batch_size: for epoch in range(batches_per_train_loop): input, policy_target, value_target = replaybuffer.sample( parameters.batch_size) optimizer.zero_grad() policy_guess, value_guess = network(input) ''' print("policy_guess") print(policy_guess) print("policy_target") print(policy_target) print("value_guess") print(value_guess) print("value_target") print(value_target) print((policy_guess, value_guess)) ''' loss1 = policy_loss(policy_activation(policy_guess), policy_target) loss2 = value_loss(value_guess, value_target) loss = loss1 + loss2 ''' print("policy_loss") print(loss1) print("value loss") print(loss2) print("total loss") ''' print((loss1.item(), loss2.item())) loss.backward() optimizer.step() ''' processes = [] for i in range(4): print("hi") generator = data_generator.DataGenerator(network, rollouts, replaybuffer) process = mp.Process(target = generator.generate_games) process.start() processes.append(process) for process in processes: process.join() ''' #pool = mp.Pool(mp.cpu_count()) #queue = mp.Queue(4) #datagenerators = [data_generator.DataGenerator(network, rollouts, replaybuffer) for i in range(4)] #for datagenerator in datagenerators: #queue.put(datagenerator.generate_games()) #pool.map(datagenerator.generate_games(), range(6)) '''