def display_images():
"""
This function obtains results from generators and plot image and image intensity
"""
vc = setup_camera_and_plot()
ims = stream_frames(vc) # Get the generator
fig, ax = plt.subplots(1, 2, figsize=(10, 5))
im = setup_plotting(imagestream=ims, imageaxis=ax[0], traceaxis=ax[1])
x_width = 50
starttime = time.time() # Time this
try:
pipeline = tz.pipe(ims,
c.map(lambda x: cv2.cvtColor(x, cv2.COLOR_BGR2RGB)),
c.map(c.do(im.set_array)),
c.map(lambda x: np.mean(x)),
c.sliding_window(x_width))
for n, i in enumerate(pipeline):
xdata = np.linspace(n, n + x_width, x_width)
plot_intensity(axis=ax[1], xdata=xdata, imageintensity=i)
plt.show(block=False)
plt.pause(0.001)
except KeyboardInterrupt:
elapsedtime = time.time() - starttime
print('The collection FPS was {:0.2f}'.format(n / elapsedtime))
vc.release()
def __init__(
self,
frame: pd.DataFrame,
window: int = 10,
window_two: int = 3,
is_fold: bool = False,
x_label: List[str] = ["state"],
y_label: List[str] = ["reward"]
):
self.n = 0
self.is_fold = is_fold
local_frame = frame.copy()
np_conv = lambda x: x.to_numpy()
swindows = sliding_window(window)
func = lambda x: pipe(x, np_conv, swindows)
stay = stack_array(window_two)
_slice_target = slice_target(window, window_two)
self.x_axis = pipe(
local_frame[x_label], np_conv, map(compress_row), swindows,
map(compose(concat_tuple)), map(stay)
)
self.y_axis = pipe(
frame[y_label], func, map(lambda x: torch.tensor(x).view(-1)),
map(log_el), map(_slice_target)
)
self.count = toolz.count(self.copy()[0])
self.zip_list = None
def _word_skip_grams(self, tokens, stop_words=None):
# handle stop words
if stop_words is not None:
tokens = [w for w in tokens if w not in stop_words]
return compose(cmap(' '.join), pluck([0, 2]),
sliding_window(3))(tokens)
def inner(avg_window_size, df_source_seq):
"""
Arguments:
- avg_window_size: Number of periods (of target resolution) to average over
"""
def to_sample(ohlc_data):
if any(
map(
lambda p: len(p) == 0 or p is None or np.isnan(p).any(
), ohlc_data)):
return None
v200davg = np.average(
[np.average(t[:, 3], axis=0) for t in ohlc_data],
axis=0) # Average the close
# Pick out high rew: (left, middle, right) OHLC, and build the low res ohlc (low_res_ohlc)
left, middle, right = [k[:5] / v200davg for k in ohlc_data[-3:]]
x = list(map(analysis.ohlc_collapse, [left, middle, right]))
y = [x[0], middle, x[2]]
return v200davg, x, y
return tz.pipe(tz.sliding_window(avg_window_size, df_source_seq),
tz.map(to_sample))
def split_at_breaks(array, breaks, axis=0):
""" Split an array into a list of arrays (using slices) at the given breaks
>>> split_at_breaks(np.arange(6), [3, 5])
[array([0, 1, 2]), array([3, 4]), array([5])]
"""
padded_breaks = concat([[None], breaks, [None]])
slices = [slice(i, j) for i, j in sliding_window(2, padded_breaks)]
preslice = (slice(None),) * axis
split_array = [array[preslice + (s,)] for s in slices]
return split_array
def split_at_breaks(array, breaks, axis=0):
""" Split an array into a list of arrays (using slices) at the given breaks
>>> split_at_breaks(np.arange(6), [3, 5])
[array([0, 1, 2]), array([3, 4]), array([5])]
"""
padded_breaks = concat([[None], breaks, [None]])
slices = [slice(i, j) for i, j in sliding_window(2, padded_breaks)]
preslice = (slice(None), ) * axis
split_array = [array[preslice + (s, )] for s in slices]
return split_array
def markov(seq):
'''
@Description:
get a 1st-order Markov model from a sequence of nucleotides
'''
model = np.zeros((8, 8))
tz.last(
tz.pipe(seq, c.sliding_window(2), c.map(PDICT.__getitem__),
c.map(increment_model(model))))
# 将计数矩阵转为概率矩阵
model /= np.sum(model, axis=1)[:, np.newaxis]
return model
def markov(seq):
"""Get a 1st-order Markov model from a sequence of nucleotides."""
model = np.zeros((4, 4))
tz.last(
tz.pipe(
seq,
cur.sliding_window(2),
# each successive tuple
cur.map(PDICT.__getitem__),
# location in matrix of tuple
cur.map(increment_model(model)))) # increment matrix
# convert counts to transition probability matrix
model /= np.sum(model, axis=1)[:, np.newaxis]
return model
def get_history(name):
booking_logs = frappe.get_all(
"Booking Log",
filters={"booking_order": name},
fields=[
"'Booking Log' as doctype",
"posting_datetime",
"booking_order",
"shipping_order",
"station",
"activity",
"loading_operation",
"loading_unit",
"sum(no_of_packages) as no_of_packages",
"sum(weight_actual) as weight_actual",
],
order_by="posting_datetime",
group_by="posting_datetime,activity",
)
get_shipping_logs = compose(
concat,
map(lambda x: frappe.get_all(
"Shipping Log",
filters={
"shipping_order":
x[0].get("shipping_order"),
"activity": ("in", ["Stopped", "Moving"]),
"posting_datetime": (
"between",
[
x[0].get("posting_datetime"), x[1].get(
"posting_datetime")
],
),
},
fields=[
"'Shipping Log' as doctype",
"posting_datetime",
"shipping_order",
"station",
"activity",
],
order_by="posting_datetime",
) if x[0].get("shipping_order") else []),
sliding_window(2),
)
shipping_logs = get_shipping_logs(
booking_logs + [{
"posting_datetime": frappe.utils.now()
}])
def get_message(log):
if log.get("doctype") == "Booking Log":
if log.get("loading_unit") == "Weight":
return "{} {} units by weight at {}".format(
log.get("activity"),
abs(log.get("weight_actual")),
log.get("station"),
)
return "{} {} packages at {}".format(
log.get("activity"), abs(log.get("no_of_packages")),
log.get("station"))
if log.get("doctype") == "Shipping Log":
prepo = "to" if log.get("activity") == "Moving" else "at"
return "{} {} {}".format(log.get("activity"), prepo,
log.get("station"))
return ""
def get_link(log):
if log.get("doctype") == "Shipping Log":
return "#Form/Shipping Order/{}".format(log.get("shipping_order"))
if log.get("doctype") == "Booking Log" and log.get(
"loading_operation"):
return "#Form/Loading Operation/{}".format(
log.get("loading_operation"))
return ""
def get_event(log):
return {
"datetime": log.get("posting_datetime"),
"status": log.get("activity"),
"message": get_message(log),
"link": get_link(log),
}
return sorted(
[get_event(x) for x in concat([booking_logs, shipping_logs])],
key=lambda x: frappe.utils.get_datetime(x.get("datetime")),
)
batch_size=batch_size)
_ = list(tz.pipe(samples, curried.partition(batch_size),
curried.map(np.array),
curried.map(ipca.partial_fit)))
return ipca
def array_from_txt(line):
return np.array(line.rstrip().split(','), dtype=np.float)
with open('iris.csv') as fin:
pca_obj = tz.pipe(fin, curried.map(array_from_txt), streaming_pca)
with open('iris.csv') as fin:
components = np.squeeze(list(tz.pipe(fin,
curried.map(array_from_txt),
curried.map(pca_obj.transform))))
from matplotlib import pyplot as plt
plt.scatter(*components.T)
type(open('iris.csv').readlines())
import glob
counts = tz.pipe(glob.glob('sample.fasta'), curried.map(open),
tz.concat, curried.filter(lambda x: not x.startswith('>')),
curried.interpose('$'), tz.concat,
curried.sliding_window(6), curried.map(''.join),
curried.filter(lambda x: '$' not in x),
tz.frequencies)
for k in counts:
print(k, counts[k])
break
counts_list = list(counts.values())
plt.hist(counts_list, bins=25)
def outer_edges_from_cycle(c: Cycle) -> Complex:
return pipe(c, sliding_window(2), map(pset), pset)
def edges_from_cycle(c: Cycle) -> Complex:
return pipe(c, cycle, sliding_window(2), take(len(c)), map(pset), pset)
def random_window(window_range, window):
return sliding_window(random.randint(*window_range), window)
def stack_array(size, x):
if size <= 0: return stack_process(x)
slide_size = sliding_window((size + 1))
slide_stack = map(stack_process, slide_size(x))
tuple_stack = tuple(slide_stack)
return (torch.stack(tuple_stack, dim=1)).squeeze(0)
