def pool(theta, size): w, h = theta.shape[0]//size, theta.shape[1]//size feat = np.zeros((w, h, theta.shape[-1])) for x, y in gv.multirange(w, h): feat[x,y] = np.apply_over_axes(np.sum, theta[x*size:(x+1)*size, y*size:(y+1)*size], [0, 1])[0,0] feat /= np.apply_over_axes(np.sum, feat, [-1]) + 1e-8 return feat
def find_bounding_box(im): first = True pixels = im.getdata() bounding_box = [np.inf, np.inf, -np.inf, -np.inf] for x, y in gv.multirange(*im.size): p = pixels[y * im.size[0] + x] if p[3] > 0: bounding_box[0] = min(x, bounding_box[0]) bounding_box[1] = min(y, bounding_box[1]) bounding_box[2] = max(x, bounding_box[2]) bounding_box[3] = max(y, bounding_box[3]) # Make a bit bigger bounding_box = (bounding_box[0]-1, bounding_box[1]-1, bounding_box[2]+1, bounding_box[3]+1) return tuple(bounding_box)
def find_bounding_box(im): first = True pixels = im.getdata() bounding_box = [np.inf, np.inf, -np.inf, -np.inf] for x, y in gv.multirange(*im.size): p = pixels[y * im.size[0] + x] if p[3] > 0: bounding_box[0] = min(x, bounding_box[0]) bounding_box[1] = min(y, bounding_box[1]) bounding_box[2] = max(x, bounding_box[2]) bounding_box[3] = max(y, bounding_box[3]) # Make a bit bigger bounding_box = (bounding_box[0] - 1, bounding_box[1] - 1, bounding_box[2] + 1, bounding_box[3] + 1) return tuple(bounding_box)
Gs_ok = Gs[:, burnin:].reshape((-1, F)) Zs_ok = np.exp(Gs_ok) # Now use samples to estimate G_mu = Gs_ok.mean(0) Z_mu = np.exp(G_mu) #g_mu = np.exp(G_mu) G_Sigma = np.cov(Gs_ok.T) + np.eye(F) * 0.0001 # Find w through a binary search #for f in xrange(10): if 0: for f in xrange(F): print 'Doing', f for l0, l1 in gv.multirange(*w.shape[:2]): def fun(w0): return gv.sigmoid(w0 + gv.logit(Zs_ok[..., f])).mean( ) - Xbar[l0, l1, f] w[l0, l1, f] = find_zero(fun, l=-6, u=6, depth=15) if 0: l0 = l1 = 4 f = 10 def fun(w0): return gv.sigmoid(w0 + gv.logit(Zs_ok[..., f])).mean() - Xbar[l0, l1, f]
import os import numpy as np from pylab import cm net = pnet.PartsNet.load('parts-net.npy') p = net._layers[1]._parts[...,0] shape = p.shape[-2:] grid = gv.plot.ImageGrid(10, 10, p.shape[1:]) for i in xrange(p.shape[0]): grid.set_image(p[i], i//10, i%10, vmin=0, vmax=1, cmap=cm.RdBu_r) if 0: print('shape', shape) print( np.asarray(list(gv.multirange(*[2]*np.prod(shape)))).shape) types = np.asarray(list(gv.multirange(*[2]*np.prod(shape)))).reshape((-1,) + shape) t = p[:,np.newaxis] x = types[np.newaxis] llh = x * np.log(t) + (1 - x) * np.log(1 - t) counts = np.bincount(np.argmax(llh.sum(-1).sum(-1), 0), minlength=p.shape[0]) print('counts', counts) #import pdb; pdb.set_trace() if args.output is None: plt.imshow(grid.image, interpolation='nearest')
def superimposed_model(settings, threading=True): num_mixtures = settings['detector']['num_mixtures'] # Train a mixture model to get a clustering of the angles of the object descriptor = gv.load_descriptor(settings) detector = gv.BernoulliDetector(num_mixtures, descriptor, settings['detector']) files = get_training_files(detector) neg_files = sorted(glob.glob(settings['detector']['neg_dir'])) ag.info("Checkpoint 1") testing_type = detector.settings.get('testing_type') # Extract clusters (manual or through EM) ############################################################################## detector, comps = cluster(detector, files) each_mix_N = np.bincount(comps, minlength=num_mixtures) ############################################################################## ag.info("Checkpoint 3") ag.info("Checkpoint 4") support = detector.support kernels = [] #ag.info("TODO, quitting") #return detector # Determine bounding boxes ############################################################################## psize = settings['detector']['subsample_size'] bbs = calc_bbs(detector) ag.info("Checkpoint 6") ag.info("Checkpoint 7") bkgs = [] orig_sizes = [] new_support = [] im_size = settings['detector']['image_size'] ag.info("Checkpoint 8") all_negs = [] ag.info("Checkpoint 9") # Retrieve features and support ############################################################################## ag.info('Fetching positives again...') all_pos_feats = [] all_neg_feats = [] alphas = [] all_alphas = [] all_binarized_alphas = [] if settings['detector'].get('superimpose'): detector.extra['concentrations'] = [] argses = [(m, settings, bbs[m], list(np.where(comps == m)[0]), files, neg_files, settings['detector'].get('stand_multiples', 1)) for m in range(detector.num_mixtures)] for mixcomp, neg_feats, pos_feats, alpha_maps, extra in itr.starmap(get_pos_and_neg, argses): alpha = np.mean(alpha_maps, axis=0) alpha_maps = np.asarray(alpha_maps) all_alphas.append(alpha_maps) all_binarized_alphas.append(alpha_maps > 0.05) alphas.append(alpha) all_neg_feats.append(neg_feats) all_pos_feats.append(pos_feats) detector.extra['concentrations'].append(extra.get('concentrations', {})) ag.info('Done.') # Setup some places to store things if 'weights' not in detector.extra: detector.extra['weights'] = [None] * detector.num_mixtures if 'sturf' not in detector.extra: detector.extra['sturf'] = [{} for _ in xrange(detector.num_mixtures)] for m in xrange(detector.num_mixtures): detector.extra['sturf'].append(dict()) obj = all_pos_feats[m].mean(axis=0) bkg = all_neg_feats[m].mean(axis=0) size = gv.bb.size(bbs[m]) kernels.append(obj) bkgs.append(bkg) orig_sizes.append(size) new_support.append(alphas[m]) if 0: for m in xrange(detector.num_mixtures): obj = all_pos_feats[m].mean(axis=0) bkg = all_neg_feats[m].mean(axis=0) size = gv.bb.size(bbs[m]) eps = 0.025 obj = np.clip(obj, eps, 1 - eps) avg = np.clip(avg, eps, 1 - eps) #lmb = obj / avg #w = np.clip(np.log(obj / avg), -1, 1) w = np.log(obj / (1 - obj) * ((1 - avg) / avg)) #w = np.log( #w_avg = np.apply_over_axes(np.sum, w * support[...,np.newaxis], [0, 1]) / support.sum() #w -= w_avg * support[...,np.newaxis] if 'weights' not in detector.extra: detector.extra['weights'] = [] detector.extra['weights'].append(w) if 'sturf' not in detector.extra: detector.extra['sturf'] = [] detector.extra['sturf'].append(dict()) kernels.append(obj) bkgs.append(bkg) orig_sizes.append(size) new_support.append(alphas[m]) detector.settings['per_mixcomp_bkg'] = True else: # Get a single background model for this one bkg = _get_background_model(settings, neg_files) crop_image = detector.settings.get('crop_image') import pdb; pdb.set_trace() argses = [(m, settings, list(np.where(comps == m)[0]), files, crop_image) for m in range(detector.num_mixtures)] for m, pos_feats in gv.parallel.starmap(get_positives, argses): obj = pos_feats.mean(axis=0) all_pos_feats.append(pos_feats) kernels.append(obj) bkgs.append(bkg) size = gv.bb.size(bbs[m]) orig_sizes.append(size) support = np.ones(settings['detector']['image_size']) new_support.append(support) detector.settings['per_mixcomp_bkg'] = True # False # Get weights and support for m in xrange(detector.num_mixtures): #kern = detector.kernel_templates[m] #bkg = detector.fixed_spread_bkg[m] obj = all_pos_feats[m].mean(axis=0) bkg = all_neg_feats[m].mean(axis=0) if detector.eps is None: detector.prepare_eps(bkg) weights = detector.build_clipped_weights(obj, bkg, detector.eps) detector.extra['weights'][m] = weights detector.extra['sturf'][m]['support'] = arrange_support(alphas[m], weights.shape, psize) # Modify weights if not detector.settings.get('plain'): for m in xrange(detector.num_mixtures): weights = detector.extra['weights'][m] F = detector.num_features indices = get_key_points(weights, suppress_radius=detector.settings.get('indices_suppress_radius', 4), even=True) L0 = indices.shape[0] // F kp_weights = np.zeros((L0, F)) M = np.zeros(weights.shape, dtype=np.uint8) counts = np.zeros(F) for index in indices: f = index[2] M[tuple(index)] = 1 kp_weights[counts[f],f] = weights[tuple(index)] counts[f] += 1 #theta = np.load('theta3.npy')[1:-1,1:-1] #th = theta #eth = np.load('empty_theta.npy') #support = 1-th[:,:,np.arange(1,F+1),np.arange(F)].mean(-1) #offset = gv.sub.subsample_offset_shape(alphas[m].shape, psize) support = detector.extra['sturf'][m]['support'] # def subsample_offset_shape(shape, size): pos, neg = all_pos_feats[m].astype(bool), all_neg_feats[m].astype(bool) #avg = np.apply_over_axes( diff = pos ^ neg appeared = pos & ~neg disappeared = ~pos & neg #bs = (support > 0.5)[np.newaxis,...,np.newaxis] A = appeared.mean(0) / (0.00001+((1-neg).mean(0))) D = disappeared.mean(0) / (0.00001+neg.mean(0)) #ss = D.mean(-1)[...,np.newaxis] ss = support[...,np.newaxis] B = (np.apply_over_axes(np.mean, A*ss, [0, 1])).squeeze() / ss.mean() def clogit(x): return gv.logit(gv.bclip(x, 0.025)) def find_zero(fun, l, u, depth=30): m = np.mean([l, u]) if depth == 0: return m v = fun(m) if v > 0: return find_zero(fun, l, m, depth-1) else: return find_zero(fun, m, u, depth-1) # Find zero-crossing #for f in xrange(F): # Now construct weights from these deltas #weights = ((clogit(ss * deltas + A) - clogit(B))) #weights = (ss * (clogit(deltas + pos.mean(0)) - clogit(neg.mean(0)))) avg = np.apply_over_axes(np.mean, pos * M * ss, [1, 2]) / (ss * M).mean() if 0: for l0, l1, f in gv.multirange(*weights.shape): def fun(w): return -(np.clip(pos[:,l0,l1,f].mean(), 0.005, 0.995) - np.mean(expit(w + logit(avg[...,f])))) weights[l0,l1,f] = find_zero(fun, -10, 10) if 1: # Print these to file from matplotlib.pylab import cm grid = gv.plot.ImageGrid(detector.num_features, 1, weights.shape[:2], border_color=(0.5, 0.5, 0.5)) mm = np.fabs(weights).max() for f in xrange(detector.num_features): grid.set_image(weights[...,f], f, 0, vmin=-mm, vmax=mm, cmap=cm.RdBu_r) fn = os.path.join(os.path.expandvars('$HOME'), 'html', 'plots', 'plot2.png') grid.save(fn, scale=10) os.chmod(fn, 0644) #A = appeared.mean(0) / (0.00001+((1-neg).mean(0))) #mm = (A * ss).mean() / ss.mean() #xx = (bs & pos) | (~bs & appeared) #avg = xx.mean(0) weights1 = ss*(weights - np.apply_over_axes(np.mean, weights * ss, [0, 1])/ss.mean()) detector.extra['sturf'][m]['weights1'] = weights1 eps = 0.025 avg_pos = (np.apply_over_axes(np.mean, pos * ss, [0, 1, 2]) / ss.mean()).squeeze().clip(eps, 1-eps) avg_neg = (np.apply_over_axes(np.mean, neg * ss, [0, 1, 2]) / ss.mean()).squeeze().clip(eps, 1-eps) #w_avg = np.apply_over_axes(np.sum, weights * support[...,np.newaxis], [0, 1]) / support.sum() # #w_avg = (logit(np.apply_over_axes(np.mean, pos, [0, 1, 2])) - \ # logit(np.apply_over_axes(np.mean, neg, [0, 1, 2]))).squeeze() w_avg = logit(avg_pos) - logit(avg_neg) detector.extra['sturf'][m]['wavg'] = w_avg detector.extra['sturf'][m]['reweighted'] = (w_avg * support[...,np.newaxis]).squeeze() #weights -= w_avg * support[...,np.newaxis] #weights *= support[...,np.newaxis] * M if 0: weights *= support[...,np.newaxis] avg_weights = np.apply_over_axes(np.mean, weights, [0, 1]) / M.mean(0).mean(0) avg_w = kp_weights.mean(0) weights -= avg_w - (-kp_weights.var(0) / 2) weights *= support[...,np.newaxis] print((weights * M).mean(0)) #weights = (weights - w_avg) * support[...,np.newaxis] #weights -= (w_avg + 0.0) * support[...,np.newaxis] weights -= w_avg * support[...,np.newaxis] F = detector.num_features if 0: for f in xrange(F): #zz = np.random.normal(-1.5, size=(1, 1, 50)) zz = np.random.normal(-1.5, size=(1, 1, 50)).ravel() betas = np.zeros(len(zz)) for i, z in enumerate(zz): def fun(beta): w = weights[...,f] - beta * support return np.log(1 - expit(w[...,np.newaxis] + z)).mean() - np.log(1 - expit(z)) betas[i] = find_zero(fun, -10, 10) if f == 0: np.save('betas.npy', betas) beta0 = betas.mean() print(f, beta0, betas.std()) weights[...,f] -= beta0 * support if 1: # Print these to file from matplotlib.pylab import cm grid = gv.plot.ImageGrid(detector.num_features, 2, weights.shape[:2], border_color=(0.5, 0.5, 0.5)) mm = np.fabs(weights).max() for f in xrange(detector.num_features): grid.set_image(weights[...,f], f, 0, vmin=-mm, vmax=mm, cmap=cm.RdBu_r) grid.set_image(M[...,f], f, 1, vmin=0, vmax=1, cmap=cm.RdBu_r) fn = os.path.join(os.path.expandvars('$HOME'), 'html', 'plots', 'plot.png') grid.save(fn, scale=10) os.chmod(fn, 0644) ag.info('sum', np.fabs(np.apply_over_axes(np.sum, weights, [0, 1])).sum()) # Instead, train model rigorously!! detector.extra['sturf'][m]['pos'] = all_pos_feats[m] detector.extra['sturf'][m]['neg'] = all_neg_feats[m] # Averags of all positives ff = all_pos_feats[m] posavg = np.apply_over_axes(np.sum, all_pos_feats[m] * support[...,np.newaxis], [1, 2]).squeeze() / support.sum() negavg = np.apply_over_axes(np.sum, all_neg_feats[m] * support[...,np.newaxis], [1, 2]).squeeze() / support.sum() S = np.cov(posavg.T) Sneg = np.cov(negavg.T) detector.extra['sturf'][m]['pavg'] = avg_pos detector.extra['sturf'][m]['pos-samples'] = posavg detector.extra['sturf'][m]['S'] = S detector.extra['sturf'][m]['Sneg'] = Sneg detector.extra['sturf'][m]['navg'] = avg_neg Spos = S rs = np.random.RandomState(0) detector.extra['sturf'][m]['Zs'] = rs.multivariate_normal(avg_neg, Sneg, size=1000).clip(min=0.005, max=0.995) detector.extra['sturf'][m]['Zs_pos'] = rs.multivariate_normal(avg_pos, Spos, size=1000).clip(min=0.005, max=0.995) detector.extra['sturf'][m]['Zs_pos2'] = rs.multivariate_normal(avg_pos, Spos * 2, size=1000).clip(min=0.005, max=0.995) detector.extra['sturf'][m]['Zs_pos10'] = rs.multivariate_normal(avg_pos, Spos * 10, size=1000).clip(min=0.005, max=0.995) detector.extra['sturf'][m]['Zs_pos50'] = rs.multivariate_normal(avg_pos, Spos * 50, size=1000).clip(min=0.005, max=0.995) #{{{ if 0: argses = [(m, settings, bbs[m], np.where(comps == m)[0], files, neg_files) for m in xrange(detector.num_mixtures)] for kern, bkg, orig_size, sup in gv.parallel.starmap(_create_kernel_for_mixcomp, argses): kernels.append(kern) bkgs.append(bkg) orig_sizes.append(orig_size) new_support.append(sup) ag.info("Checkpoint 10") detector.settings['per_mixcomp_bkg'] = True #}}} detector.kernel_templates = kernels detector.kernel_sizes = orig_sizes detector.settings['kernel_ready'] = True detector.use_alpha = False detector.support = new_support # Determine the background ag.info("Determining background") detector.fixed_bkg = None detector.fixed_spread_bkg = bkgs detector.settings['bkg_type'] = 'from-file' detector._preprocess() detector.prepare_eps(detector.fixed_spread_bkg[0]) # Determine the standardization values ag.info("Determining standardization values") #fixed_train_mean = np.zeros(detector.num_mixtures) #detector.fixed_train_mean = [] #fixed_train_std = np.ones(detector.num_mixtures) # Determine indices for coarse detection sweep if INDICES: detector.indices = [] for m in xrange(detector.num_mixtures): these_indices = [] weights = detector.extra['weights'][m] ag.info('Indices:', np.prod(weights.shape)) # If not plain, we need even keypoints even = not detector.settings.get('plain') indices = get_key_points(weights, suppress_radius=detector.settings.get('indices_suppress_radius', 4), even=even) if not detector.settings.get('plain'): detector.extra['weights'][m] = weights assert len(indices) > 0, "No indices were extracted when keypointing" detector.indices.append(indices) else: detector.indices = None if testing_type in ('fixed', 'non-parametric'): detector.standardization_info = [] if testing_type == 'fixed': if detector.settings.get('standardize_with_samples'): detector.standardization_info = [dict(mean=0, std=1)] * detector.num_mixtures info = [] source = detector.settings.get('standardize_negative_source', 'neg-dir') N = detector.settings.get('standardize_num_images', 50) if source.startswith('voc-train-non-'): obj_class = source.split('-')[-1] print('Taking negatives from voc train, without class', obj_class) gen = gv.voc.gen_negative_files(obj_class, 'train') #print('negatives', len([im for im in gen])) else: print('Taking negatives from neg_dir') gen = itr.cycle(gv.datasets.ImgFile(path=fn, img_id=os.path.basename(fn)) for fn in neg_files) gen = itr.cycle(gen) gen = itr.islice(gen, N) gens = itr.tee(gen, detector.num_mixtures) th = -np.inf for m in xrange(detector.num_mixtures): neg_files_segment = gens[m] argses = [(detector, i, fileobj, th, m) for i, fileobj in enumerate(neg_files_segment)] topsy = list(gv.parallel.starmap_unordered(get_strong_fps_single, argses)) confs = np.asarray([bbobj.confidence for topsy_m in topsy for bbobj in topsy_m]) info.append(dict(mean=confs.mean(), std=confs.std())) #for m in xrange(detector.num_mixtures): detector.standardization_info = info else: argses = [(m, settings, detector.eps, bbs[m], kernels[m], bkgs[m], None, None, None, detector.indices[m] if INDICES else None, 3) for m in xrange(detector.num_mixtures)] detector.standardization_info = list(gv.parallel.starmap(_calc_standardization_for_mixcomp, argses)) else: raise Exception("Unknown testing type") detector.settings['testing_type'] = testing_type #detector.settings['testing_type'] = 'NEW' #detector. # # Data mine stronger negatives # # TODO: Object class must be input if 1: contest = 'voc' obj_class = 'car' gen = gv.voc.gen_negative_files(obj_class, 'train') else: contest = 'custom-tmp-frontbacks' obj_class = 'bicycle' gen, tot = gv.datasets.load_files(contest, obj_class) import heapq top_bbs = [[] for k in xrange(detector.num_mixtures)] TOP_N = 10000 if detector.settings.get('cascade'): # New SVM attempt detector.extra['cascade_threshold'] = detector.settings.get('cascade_threshold', 8) COUNT = detector.settings.get('cascade_farming_count', 500) args = itr.izip( \ itr.repeat(detector), xrange(COUNT), itr.islice(gen, COUNT) ) for res in gv.parallel.starmap_unordered(get_strong_fps, args): for m in xrange(detector.num_mixtures): top_bbs[m].extend(res[m]) ag.info('- TOPS ------') ag.info(map(np.shape, top_bbs) ) detector.extra['top_bbs_shape'] = map(np.shape, top_bbs) # Save the strong negatives detector.extra['negs'] = top_bbs def phi(X, mixcomp): if SVM_INDICES and 0: indices = detector.indices2[mixcomp][0] return X.ravel()[np.ravel_multi_index(indices.T, X.shape)] else: #return gv.sub.subsample(X, (2, 2)).ravel() return X.ravel() all_neg_X0 = [] for k in xrange(detector.num_mixtures): all_neg_X0.append(np.asarray(map(lambda bbobj: phi(bbobj.X, k), top_bbs[k]))) del top_bbs all_pos_X0 = [] for mixcomp, pos_feats in enumerate(all_pos_feats): all_pos_X0.append(np.asarray(map(lambda X: phi(X, mixcomp), pos_feats))) ag.info('Done.') detector.extra['poss'] = all_pos_feats ag.info('Training SVMs...') # Train SVMs #from sklearn.svm import LinearSVC from sklearn.svm import LinearSVC, SVC clfs = [] detector.indices2 = None # not [] for now #all_neg_X0 = [[bbobj.X for bbobj in top_bbs[m]] for m in xrange(detector.num_mixtures)] detector.extra['svms'] = [] for m in xrange(detector.num_mixtures): X = np.concatenate([all_pos_X0[m], all_neg_X0[m]]) # Flatten ag.info(m, ':', X.shape) #X = phi(X, k) ag.info(m, '>', X.shape) y = np.concatenate([np.ones(len(all_pos_feats[m])), np.zeros(len(all_neg_X0[m]))]) #detector.extra['data_x'].append(X) #detector.extra['data_y'].append(y) from sklearn import cross_validation as cv #C = 5e-8 C = 1.0 #clf = LinearSVC(C=C) #clf = LinearSVC(C=C) clf = SVC(C=C, kernel='linear') clf.fit(X, y) svm_info = dict(intercept=float(clf.intercept_), weights=clf.coef_) detector.extra['svms'].append(svm_info) #sh = all_pos_feats[m][0].shape # Get most significant coefficients #th = smallest_th[k] #th = 0 #detector.extra['svms'].append(dict(svm=clf, th=th, uses_indices=SVM_INDICES)) ag.info('Done.') # Remove negatives and positives from extra, since it takes space if 1: del detector.extra['poss'] del detector.extra['negs'] ag.info('extra') ag.info(detector.extra.keys()) ag.info('eps', detector.eps) #ag.info("THIS IS SO TEMPORARY!!!!!") if 'weights' in detector.extra: #detector.indices = None ag.info(detector.standardization_info) #try: # detector.standardization_info[0]['std'] = 1.0 #except TypeError: # detector.standardization_info = [dict(std=1.0, mean=0.0)] ag.info('corner2', detector.extra['weights'][0][0,0,:5]) return detector
def train_from_samples(self, patches,patches_original): #from pnet.latent_bernoulli_mm import LatentBernoulliMM from pnet.bernoullimm import BernoulliMM min_prob = self._settings.get('min_prob', 0.01) flatpatches = patches.reshape((patches.shape[0], -1)) if 1: mm = BernoulliMM(n_components=self._num_parts, n_iter=20, tol=1e-15,n_init=2, random_state=self._settings.get('em_seed',0), min_prob=min_prob, verbose=False) mm.fit(flatpatches) print(mm.fit(flatpatches)) #print('AIC', mm.aic(flatpatches)) #print('BIC', mm.bic(flatpatches)) if 0: # Draw samples #size = (20, 20) import gv import os N = 10000 D = np.prod(self._part_shape) size = (20, 20) grid = gv.plot.ImageGrid(size[0], size[1], self._part_shape) samp = mm.sample(n_samples=np.prod(size)).reshape((-1,) + self._part_shape) samples = mm.sample(n_samples=N).reshape((-1,) + self._part_shape) print('samples', samples.shape) types = np.asarray(list(gv.multirange(*[2]*D))).reshape((-1,) + self._part_shape) th = np.clip(types, 0.01, 0.99) t = th[:,np.newaxis] x = samples[np.newaxis] llh0 = x * np.log(t) + (1 - x) * np.log(1 - t) counts0 = np.bincount(np.argmax(llh0.sum(-1).sum(-1), 0), minlength=th.shape[0]) x1 = patches[np.newaxis,...,0] llh1 = x1 * np.log(t) + (1 - x1) * np.log(1 - t) counts1 = np.bincount(np.argmax(llh1.sum(-1).sum(-1), 0), minlength=th.shape[0]) #import pdb; pdb.set_trace() w0 = counts0 / counts0.sum() w1 = counts1 / counts1.sum() print('w0', w0) print('w1', w1) #import pdb; pdb.set_trace() #import pdb; pdb.set_trace() self._parts = mm.means_.reshape((self._num_parts,)+patches.shape[1:]) self._weights = mm.weights_ else: #mm = ag.stats.BernoulliMixture(self._num_parts, flatpatches, max_iter=2000) #mm.run_EM(1e-6, min_probability=min_prob) #self._parts = mm.templates.reshape((self._num_parts,)+patches.shape[1:]) #self._weights = mm.weights from pnet.bernoulli import em ret = em(flatpatches, self._num_parts,20,numpy_rng=self._settings.get('em_seed',0),verbose=True) self._parts = ret[1].reshape((self._num_parts,) + patches.shape[1:]) self._weights = np.arange(self._num_parts) if 0: predictedGroups = mm.predict(flatpatches) # Calculate entropy of parts Hall = (self._parts * np.log(self._parts) + (1 - self._parts) * np.log(1 - self._parts)) H = -np.apply_over_axes(np.mean, Hall, [1, 2, 3])[:,0,0,0]
Gs_ok = Gs[:,burnin:].reshape((-1, F)) Zs_ok = np.exp(Gs_ok) # Now use samples to estimate G_mu = Gs_ok.mean(0) Z_mu = np.exp(G_mu) #g_mu = np.exp(G_mu) G_Sigma = np.cov(Gs_ok.T) + np.eye(F) * 0.0001 # Find w through a binary search #for f in xrange(10): if 0: for f in xrange(F): print 'Doing', f for l0, l1 in gv.multirange(*w.shape[:2]): def fun(w0): return gv.sigmoid(w0 + gv.logit(Zs_ok[...,f])).mean() - Xbar[l0,l1,f] w[l0,l1,f] = find_zero(fun, l=-6, u=6, depth=15) if 0: l0 = l1 = 4 f = 10 def fun(w0): return gv.sigmoid(w0 + gv.logit(Zs_ok[...,f])).mean() - Xbar[l0,l1,f] #import IPython #IPython.embed()