def reducer(self, u, values): # initialize new Accumulators A_p, A_s, A_t = acc.Accumulator(), acc.Accumulator(), acc.Accumulator() S_m, T_m, S_u, T_u, E_u = [], [], [], [], [] for S_v, T_v, E_v in values: # master vertex if len(E_v) != 0: S_m = S_v T_m = T_v E_u = E_v # merge and filter S_v for se in S_v: if u == "t": A_p.accept(se) elif len(S_u) < MAX_PATHS: if A_s.accept(se): S_u.append(se) for te in T_v: if len(T_u) < MAX_PATHS: if A_t.accept(te): T_u.append(te) # initalize counter self.increment_counter("move", "source", 0) self.increment_counter("move", "source", 0) self.increment_counter("move", "source", len(S_u)) if (u == "t"): yield "A_p", A_p.edges yield (u, [S_u, T_u, E_u])
def mapper(self, u, node_info): saturated_edges = [] # dictionary containing edges that were augumented from previous # MapReduce job augmented_edges = node_info.pop() # update edges in S_u, T_u, and E_u with augmented_edges S_u, T_u, E_u = node_info # updates E_u, S_u, and T_u based on the augmented_edges # and addes saturated edges to saturated_edges for edge in E_u: update_edge(edge, augmented_edges, saturated_edges) for path in S_u: for edge in path: update_edge(edge, augmented_edges, saturated_edges) for path in T_u: for edge in path: update_edge(edge, augmented_edges, saturated_edges) # remove saturated excess paths for e_id in saturated_edges: for path in S_u: if path.count(e_id) > 0: S_u.remove(path) for path in T_u: if path.count(e_id) > 0: T_u.remove(path) # attempt to combine source and sink excess paths accumulator = acc.Accumulator() for source_path in S_u: for sink_path in T_u: augmenting_path = source_path + sink_path if accumulator.accept(augmenting_path): yield ("t", [[augmenting_path], [], []]) # reseed S's neighbors if u == "s": for e_v, e_id, e_f, e_c in E_u: new_path = [[e_v, e_id, e_f, e_c]] yield (e_v, [[new_path],[],[]]) # extends source excess paths if len(S_u) != 0: for edge in E_u: e_v, e_f, e_c = edge[0], edge[2], edge[3] if e_f < e_c: for source_path in S_u: if not edge_forms_cycle(edge, source_path): new_path = source_path[:] new_path.append(edge) yield(e_v, [[new_path], [], []]) yield(u, [S_u, T_u, E_u])
def __init__(self, countThreshold=2, dataset=None): self.counter = HierarchicalAccumulator( lambda: accumulator.Accumulator(AutoStats())) self.countThreshold = countThreshold self.features = [] self.featureTypes = [] self.itemCount = 0 self.newFeatureCount = 0 if dataset is not None: for d in dataset: self.add(d)
def __init__(self, _filepath, repeater=""): """Cmdfilebuilder(_filepath, repeater="") Instantiates a builder, reading the data from the _filepath as the master file. repeater can be used to specify the repeater controller """ filepath = os.path.abspath(_filepath) self.fileinfo = (filepath, os.path.dirname( filepath), os.path.basename(filepath)) self.line_dict = read_the_file(filepath) msg = 'File: {}, lines read: {}'.format( filepath, len(self.line_dict[INL])) LOGGER.debug(msg) self.md_dict = gen_xml(self.line_dict) # metadata dictionary self.repeater = repeater self.accum = accumulator.Accumulator(self.line_dict[CMT]) self.accum.add_file(_filepath) self._child_file_warning = True self.last_error = None
type=int, help='fft frame size') parser.add_argument('--fft_step', default=256, type=int, help='fft step') parser.add_argument('--phase_smooth', default=4, type=int, help='phase smoothing') args = parser.parse_args(''.split()) jack_to_accumulator = queue.Queue(maxsize=128) accumulator_to_delay_tracker = queue.Queue(maxsize=128) delay_tracker_to_fft = queue.Queue(maxsize=128) fft_to_graphics = queue.Queue(maxsize=128) jcli = jack_client.JackClient(jack_to_accumulator, args.num_channels, 'shark') acc = accumulator.Accumulator(jack_to_accumulator, accumulator_to_delay_tracker, args.accumulator) dtracker = delay_tracker.DelayTracker(accumulator_to_delay_tracker, delay_tracker_to_fft) fftop = fft.FFT(delay_tracker_to_fft, fft_to_graphics, fft_params=args) render = display.Display(fft_to_graphics, jcli.client.samplerate, fft_params=args) render.start() fftop.start() dtracker.start() acc.start() jcli.activate()
def second_virial_coefficient(beta=1., num_tune=int(1e6), freq_tune=int(1e4), num_prod=int(1e7), freq_print=int(1e6)): """ Return dictionary of meta data and pandas data frame with taylor series beta: inverse temperature num_tune: number of trials to tune max move freq_tune: number of trials between each tune num_prod: total number of trials freq_print: number of trials before printing status""" metadata = { "beta": beta, "num_tune": num_tune, "freq_tune": freq_tune, "num_prod": num_prod, "freq_print": freq_print } random.seed() pos_vec = [1.1, 0, 0] pe_old = ulj(origin_sq_distance(pos_vec)) beta = metadata["beta"] f12old = math.exp(-beta * pe_old) - 1 f12ref = math.exp(-beta * uhs(origin_sq_distance(pos_vec))) - 1 max_disp = 0.1 # maximum 1D distance of displacement num_disp_accept = 0 # number of accepted displacements num_disp_attempt = 0 # number of attempted displacements targ_accept = 0.25 # target acceptance for displacements num_order = 20 # maximum order of extrapolation taylor_coeffs = pandas.DataFrame(index=range(num_order + 1)) taylor_coeffs["b2"] = 0. mayer_moments = list() for order in range(num_order): mayer_moments.append(accumulator.Accumulator()) mayer = accumulator.Accumulator() mayer_ref = accumulator.Accumulator() # begin "num_prod" Mayer sampling Monte Carlo simulation trials for itrial in islice(count(1), metadata["num_prod"] - 1): # randomly displace the second particle pos_vec_old = copy.deepcopy(pos_vec) # store old position num_disp_attempt += 1 # count displacement attempts for index, dummy in enumerate(pos_vec): pos_vec[index] += max_disp * random.uniform(-1., 1.) # compute the energy and determine if move is accepted pe_attempted = ulj(origin_sq_distance(pos_vec)) f12 = math.exp(-beta * pe_attempted) - 1. if random.random() < math.fabs(f12) / math.fabs(f12old): # accept trial num_disp_accept += 1 f12old = f12 pe_old = pe_attempted pe_ref = uhs(origin_sq_distance(pos_vec)) f12ref = math.exp(-beta * pe_ref) - 1. else: # reject trial pos_vec = copy.deepcopy(pos_vec_old) # tune maximum trial displacement if (itrial < metadata["num_tune"]) and (itrial % metadata["freq_tune"] == 0): if float(num_disp_accept) > targ_accept * float(num_disp_attempt): max_disp *= 1. + 0.05 else: max_disp *= 1. - 0.05 num_disp_accept = num_disp_attempt = 0 if itrial == metadata["num_tune"]: print("# max_disp ", max_disp) # average mayer and derivatives only after tuning is complete if itrial > metadata["num_tune"]: if f12old < 0: mayer.accumulate(-1) else: mayer.accumulate(1) mayer_ref.accumulate(f12ref / math.fabs(f12old)) uebu = math.exp(-beta * pe_old) / math.fabs(f12old) for order in range(num_order): uebu *= -pe_old mayer_moments[order].accumulate(uebu) # store and print Taylor coefficients if ((itrial % metadata["freq_print"] == 0) or (itrial == metadata["num_prod"] - 1)): reffac = 2. * math.pi / 3. / mayer_ref.average() taylor_coeffs["b2"][0] = reffac * mayer.average() for order in range(num_order): taylor_coeffs["b2"][order + 1] = (reffac * mayer_moments[order].average() / math.factorial(order + 1)) print(taylor_coeffs) return metadata, taylor_coeffs
OUTPUT_FILE = "../output/img01.png" #################################### logger.info("read image") img = cv2.imread(INPUT_FILE, cv2.IMREAD_UNCHANGED) logger.info("keypoints") kpdetector = de.KeypointsDetector() keypoints = kpdetector.canny(img, N_KEYPOINTS) logger.info("descriptors") extractor = ex.DescriptorExtractor() descriptors = extractor.daisy(keypoints, img) logger.info("splashes") accumulator = ac.Accumulator(img) # https://github.com/mariusmuja/flann/issues/143 FLANN_INDEX_KDTREE = 0 flann = cv2.FlannBasedMatcher(dict(algorithm=FLANN_INDEX_KDTREE, trees=5), dict(checks=50)) matches = flann.knnMatch(descriptors, descriptors, k=K) for i, m_list in enumerate(matches): o = (int(keypoints[i].pt[1]), int(keypoints[i].pt[0])) points = [] rank = 1 for m in m_list: d = (int(keypoints[m.trainIdx].pt[1]),