This question is the follow-up to this previous question.
Background
Using this simulation I investigate a system in which enzymes proliferate in cells. During the replications of enzymes, parasites can come to be due to mutation. They can drive the system into extinction. I'm interested in where in the parameter space coexistence is possible.
I have made the changes advised by HoboProber. Namely correction of style and implementing the model relying on Numpy. So now the system is a 2-dimensional array. Cells are the columns of the array. The values of the first row are the numbers of enzymes and the values of the second row are the numbers of parasites.
My request
The speed of this newer implementation is much better than that of the previous one. But as I would like to increase population_size and gen_max every bit of performance improvement counts.
So far I examined the system in more detail with population sizes ranging from 100 to 1000 cells and with the maximal number of generations being 10000. The amount of increase in population size depends on performance, a million cells would be a perfectly reasonable assumption concerning the modelled system. The maximal number of generations should be 20-30000.
- Primarily, does the code make use of vectorization and Numpy as effectively as it can?
- Which potential efficiency improvements I missed? For example calculating something multiple times instead of assigning it to a variable or making (explicit and/or implicit) array copies unnecessarily many times.
- Is there a better way performance-wise to write data to file?
The code
"""
Collect data on an enzyme-parasite system explicitly assuming compartmentalization.
Functions
---------
simulation()
Simulate mentioned system.
write_out_file()
Write data to csv output file.
"""
import csv
import time
import numpy as np
def simulation(population_size, cell_size, replication_rate_p, mutation_rate, gen_max):
"""
Simulate an enzyme-parasite system explicitly assuming compartmentalization.
Parameters
----------
population_size : int
The number of cells.
cell_size : int
The maximal number of replicators of cells at which cell division takes place.
replication_rate_p : float
The fitness (replication rate) of the parasites
relative to the fitness (replication rate) of the enzymes.
Example
-------
$ replication_rate_p = 2
This means that the parasites' fitness is twice as that of the enzymes.
mutation_rate : float
The probability of mutation during a replication event.
gen_max : int
The maximal number of generations.
A generation corresponds to one outer while cycle.
If the system extincts, the number of generations doesn't reach gen_max.
Yield
-------
generator object
Contains data on the simulated system.
"""
def population_stats(population):
"""
Calculate statistics of the system.
Parameter
---------
population : ndarray
The system itself.
Return
-------
tuple
Contains statistics of the simulated system.
"""
gyak_sums = population.sum(axis=1)
gyak_means = population.mean(axis=1)
gyak_variances = population.var(axis=1)
gyak_percentiles_25 = np.percentile(population, 25, axis=1)
gyak_medians = np.median(population, axis=1)
gyak_percentiles_75 = np.percentile(population, 75, axis=1)
fitness_list = population[0, :]/population.sum(axis=0)
return (
gyak_sums[0], gyak_sums[1], (population[0, :] > 1).sum(),
gyak_means[0], gyak_variances[0],
gyak_percentiles_25[0], gyak_medians[0], gyak_percentiles_75[0],
gyak_means[1], gyak_variances[1],
gyak_percentiles_25[1], gyak_medians[1], gyak_percentiles_75[1],
fitness_list.mean(), fitness_list.var(),
np.percentile(fitness_list, 25),
np.median(fitness_list),
np.percentile(fitness_list, 75)
)
# Creating the system with the starting state being
# half full cells containing only enzymes.
population = np.zeros((2, population_size), dtype=np.int32)
population[0, :] = cell_size//2
gen = 0
yield (gen, *population_stats(population), population_size,
cell_size, mutation_rate, replication_rate_p, "aft")
print(f"N = {population_size}, rMax = {cell_size}, "
f"aP = {replication_rate_p}, U = {mutation_rate}",
file=DEAD_OR_ALIVE)
while (population.size > 0) & (gen < gen_max):
gen += 1
# Replicator proliferation until cell_size in each cell.
mask = (population.sum(axis=0) < cell_size).nonzero()
while mask[0].size > 0:
# Calculating probabilites of choosing a parasite to replication.
repl_probs_p = population[:, mask].copy()
repl_probs_p.view(np.float32)[1, :] *= replication_rate_p
repl_probs_p = repl_probs_p[1, :]/repl_probs_p.sum(axis=0)
# Determining if an enzyme or a parasite replicates,
# and if an enzyme replicates, will it mutate to a parasite.
# (Outcome can differ among cells. Parasites don't mutate.)
repl_choices = np.random.random_sample(repl_probs_p.shape)
mut_choices = np.random.random_sample(repl_probs_p.shape)
lucky_replicators = np.zeros(repl_probs_p.shape, dtype=np.int32)
lucky_replicators[
(repl_choices < repl_probs_p) | (mut_choices < mutation_rate)
] = 1
population[lucky_replicators, mask] += 1
mask = (population.sum(axis=0) < cell_size).nonzero()
if gen % 100 == 0:
yield (gen, *population_stats(population), population_size,
cell_size, mutation_rate, replication_rate_p, "bef")
# Each cell divides.
new_population = np.random.binomial(population, 0.5)
population -= new_population
# Discarding dead cells.
population = np.concatenate((population[:, (population[0, :] > 1).nonzero()[0]],
new_population[:, (new_population[0, :] > 1).nonzero()[0]]),
axis=1)
# Choosing survivor cells according to their fitnesses
# if there are more viable cells than population_size.
# Hence population_size or less cells move on to the next generation.
if population.shape[1] > population_size:
fitness_list = population[0, :]/population.sum(axis=0)
fitness_list = fitness_list/fitness_list.sum()
population = population[:, np.random.choice(population.shape[1],
population_size,
replace=False,
p=fitness_list)]
elif population.size == 0:
for i in range(2):
yield (gen+i, *(0, 0)*9, population_size,
cell_size, mutation_rate, replication_rate_p, "aft")
print(f"{gen} generations are done.")
print("Cells are extinct.", file=DEAD_OR_ALIVE)
if (gen % 100 == 0) & (population.size > 0):
yield (gen, *population_stats(population), population_size,
cell_size, mutation_rate, replication_rate_p, "aft")
if (gen % 1000 == 0) & (population.size > 0):
print(f"{gen} generations are done.")
print("Simulation ended successfully.\n", file=DEAD_OR_ALIVE)
def write_out_file(result, local_time, n_run):
"""
Write data to csv output file.
Parameters
----------
result : list of generator object(s)
Contains data on the simulated system.
n_run : int
The number of consecutive runs.
"""
with open("output_data_" + local_time + ".csv", "w", newline="") as out_file:
out_file.write(
"gen;"
"eSzamSum;pSzamSum;alive;"
"eSzamAtl;eSzamVar;eSzamAKv;eSzamMed;eSzamFKv;"
"pSzamAtl;pSzamVar;pSzamAKv;pSzamMed;pSzamFKv;"
"fitAtl;fitVar;fitAKv;fitMed;fitFKv;"
"N;rMax;U;aP;boaSplit\n"
)
out_file = csv.writer(out_file, delimiter=";")
counter = 0
for i in result:
out_file.writerows(i)
counter += 1
print(counter, "/", n_run, "\n")
LOCAL_TIME = time.strftime("%m_%d_%H_%M_%S_%Y", time.localtime(time.time()))
DEAD_OR_ALIVE = open("output_data_" + LOCAL_TIME + ".txt", "w")
RESULT = [simulation(1000, 200, 1.5, 0.0, 10000)]
#RESULT.append(simulation(1000, 200, 1.5, 1.0, 10000))
N_RUN = 1
write_out_file(RESULT, LOCAL_TIME, N_RUN)
DEAD_OR_ALIVE.close()
# Normally I call the functions from another script,
# these last 4 lines are meant to be just an example.
line_profiling
Timer unit: 1e-07 s
Total time: 161.05 s
File: simulation.py
Function: simulation at line 16
Line # Hits Time Per Hit % Time Line Contents
==============================================================
16
17 def simulation(population_size, cell_size, replication_rate_p, mutation_rate, gen_max):
18 """
19 Simulate an enzyme-parasite system explicitly assuming compartmentalization.
20
21 Parameters
22 ----------
23 population_size : int
24 The number of cells.
25
26 cell_size : int
27 The maximal number of replicators of cells at which cell division takes place.
28
29 replication_rate_p : float
30 The fitness (replication rate) of the parasites
31 relative to the fitness (replication rate) of the enzymes.
32 Example
33 -------
34 $ replication_rate_p = 2
35 This means that the parasites' fitness is twice as that of the enzymes.
36
37 mutation_rate : float
38 The probability of mutation during a replication event.
39
40 gen_max : int
41 The maximal number of generations.
42 A generation corresponds to one outer while cycle.
43 If the system extincts, the number of generations doesn't reach gen_max.
44
45 Yield
46 -------
47 generator object
48 Contains data on the simulated system.
49 """
50
51 1 56.0 56.0 0.0 def population_stats(population):
52 """
53 Calculate statistics of the system.
54
55 Parameter
56 ---------
57 population : ndarray
58 The system itself.
59
60 Return
61 -------
62 tuple
63 Contains statistics of the simulated system.
64 """
65 gyak_sums = population.sum(axis=1)
66 gyak_means = population.mean(axis=1)
67 gyak_variances = population.var(axis=1)
68 gyak_percentiles_25 = np.percentile(population, 25, axis=1)
69 gyak_medians = np.median(population, axis=1)
70 gyak_percentiles_75 = np.percentile(population, 75, axis=1)
71 fitness_list = population[0, :]/population.sum(axis=0)
72 return (
73 gyak_sums[0], gyak_sums[1], (population[0, :] > 1).sum(),
74 gyak_means[0], gyak_variances[0],
75 gyak_percentiles_25[0], gyak_medians[0], gyak_percentiles_75[0],
76 gyak_means[1], gyak_variances[1],
77 gyak_percentiles_25[1], gyak_medians[1], gyak_percentiles_75[1],
78 fitness_list.mean(), fitness_list.var(),
79 np.percentile(fitness_list, 25),
80 np.median(fitness_list),
81 np.percentile(fitness_list, 75)
82 )
83
84 # Creating the system with the starting state being
85 # half full cells containing only enzymes.
86 1 68.0 68.0 0.0 population = np.zeros((2, population_size), dtype=np.int32)
87 1 53.0 53.0 0.0 population[0, :] = cell_size//2
88 1 9.0 9.0 0.0 gen = 0
89 1 14828.0 14828.0 0.0 yield (gen, *population_stats(population), population_size,
90 1 24.0 24.0 0.0 cell_size, mutation_rate, replication_rate_p, "aft")
91 1 49.0 49.0 0.0 print(f"N = {population_size}, rMax = {cell_size}, "
92 f"aP = {replication_rate_p}, U = {mutation_rate}",
93 1 113.0 113.0 0.0 file=DEAD_OR_ALIVE)
94
95 10001 140323.0 14.0 0.0 while (population.size > 0) & (gen < gen_max):
96 10000 123102.0 12.3 0.0 gen += 1
97
98 # Replicator proliferation until cell_size in each cell.
99 10000 3333616.0 333.4 0.2 mask = (population.sum(axis=0) < cell_size).nonzero()
100 1238245 20308315.0 16.4 1.3 while mask[0].size > 0:
101 # Calculating probabilites of choosing a parasite to replication.
102 1228245 239761224.0 195.2 14.9 repl_probs_p = population[:, mask].copy()
103 1228245 83589799.0 68.1 5.2 repl_probs_p.view(np.float32)[1, :] *= replication_rate_p
104 1228245 158300271.0 128.9 9.8 repl_probs_p = repl_probs_p[1, :]/repl_probs_p.sum(axis=0)
105 # Determining if an enzyme or a parasite replicates,
106 # and if an enzyme replicates, will it mutate to a parasite.
107 # (Outcome can differ among cells. Parasites don't mutate.)
108 1228245 132808465.0 108.1 8.2 repl_choices = np.random.random_sample(repl_probs_p.shape)
109 1228245 117430558.0 95.6 7.3 mut_choices = np.random.random_sample(repl_probs_p.shape)
110 1228245 35120008.0 28.6 2.2 lucky_replicators = np.zeros(repl_probs_p.shape, dtype=np.int32)
111 lucky_replicators[
112 (repl_choices < repl_probs_p) | (mut_choices < mutation_rate)
113 1228245 76236137.0 62.1 4.7 ] = 1
114 1228245 301823109.0 245.7 18.7 population[lucky_replicators, mask] += 1
115 1228245 357660422.0 291.2 22.2 mask = (population.sum(axis=0) < cell_size).nonzero()
116
117 10000 143547.0 14.4 0.0 if gen % 100 == 0:
118 100 1350075.0 13500.8 0.1 yield (gen, *population_stats(population), population_size,
119 100 2544.0 25.4 0.0 cell_size, mutation_rate, replication_rate_p, "bef")
120
121 # Each cell divides.
122 10000 17525435.0 1752.5 1.1 new_population = np.random.binomial(population, 0.5)
123 10000 1087713.0 108.8 0.1 population -= new_population
124
125 # Discarding dead cells.
126 10000 2526633.0 252.7 0.2 population = np.concatenate((population[:, (population[0, :] > 1).nonzero()[0]],
127 10000 1979199.0 197.9 0.1 new_population[:, (new_population[0, :] > 1).nonzero()[0]]),
128 10000 1003433.0 100.3 0.1 axis=1)
129
130 # Choosing survivor cells according to their fitnesses
131 # if there are more viable cells than population_size.
132 # Hence population_size or less cells move on to the next generation.
133 10000 184360.0 18.4 0.0 if population.shape[1] > population_size:
134 10000 5107803.0 510.8 0.3 fitness_list = population[0, :]/population.sum(axis=0)
135 10000 1244299.0 124.4 0.1 fitness_list = fitness_list/fitness_list.sum()
136 10000 213078.0 21.3 0.0 population = population[:, np.random.choice(population.shape[1],
137 10000 110896.0 11.1 0.0 population_size,
138 10000 111486.0 11.1 0.0 replace=False,
139 10000 49497963.0 4949.8 3.1 p=fitness_list)]
140 elif population.size == 0:
141 for i in range(2):
142 yield (gen+i, *(0, 0)*9, population_size,
143 cell_size, mutation_rate, replication_rate_p, "aft")
144 print(f"{gen} generations are done.")
145 print("Cells are extinct.", file=DEAD_OR_ALIVE)
146
147 10000 260742.0 26.1 0.0 if (gen % 100 == 0) & (population.size > 0):
148 100 1332898.0 13329.0 0.1 yield (gen, *population_stats(population), population_size,
149 100 2553.0 25.5 0.0 cell_size, mutation_rate, replication_rate_p, "aft")
150
151 10000 147525.0 14.8 0.0 if (gen % 1000 == 0) & (population.size > 0):
152 10 21265.0 2126.5 0.0 print(f"{gen} generations are done.")
153
154 1 226.0 226.0 0.0 print("Simulation ended successfully.\n", file=DEAD_OR_ALIVE)
cProfiling sample
Fri Nov 29 04:53:01 2019 cprofiling
16375164 function calls (16361694 primitive calls) in 135.937 seconds
Ordered by: internal time, cumulative time
ncalls tottime percall cumtime percall filename:lineno(function)
202 72.331 0.358 135.766 0.672 simulation.py:17(simulation)
2529183 27.246 0.000 27.246 0.000 {method 'reduce' of 'numpy.ufunc' objects}
2456168 20.346 0.000 20.346 0.000 {method 'random_sample' of 'numpy.random.mtrand.RandomState' objects}
10000 2.575 0.000 4.456 0.000 {method 'choice' of 'numpy.random.mtrand.RandomState' objects}
1258084 2.326 0.000 2.326 0.000 {method 'nonzero' of 'numpy.ndarray' objects}
1228747 2.139 0.000 2.139 0.000 {method 'copy' of 'numpy.ndarray' objects}
2486771 2.043 0.000 29.905 0.000 {method 'sum' of 'numpy.ndarray' objects}
1228085 1.420 0.000 1.420 0.000 {built-in method numpy.zeros}
10000 1.354 0.000 1.683 0.000 {method 'binomial' of 'numpy.random.mtrand.RandomState' objects}
1228088/1228087 0.899 0.000 0.899 0.000 {method 'view' of 'numpy.ndarray' objects}
2486771 0.783 0.000 27.862 0.000 _methods.py:36(_sum)
31404 0.585 0.000 0.585 0.000 {method 'argsort' of 'numpy.ndarray' objects}
31404 0.413 0.000 1.081 0.000 arraysetops.py:297(_unique1d)
31404 0.262 0.000 0.262 0.000 {method 'cumsum' of 'numpy.ndarray' objects}
134267/124016 0.162 0.000 2.224 0.000 {built-in method numpy.core._multiarray_umath.implement_array_function}
40804 0.103 0.000 0.334 0.000 fromnumeric.py:73(_wrapreduction)
31404 0.064 0.000 1.193 0.000 arraysetops.py:151(unique)
32007 0.039 0.000 0.039 0.000 {method 'flatten' of 'numpy.ndarray' objects}
31404 0.034 0.000 0.329 0.000 fromnumeric.py:2358(cumsum)
20000 0.032 0.000 0.092 0.000 {method 'all' of 'numpy.generic' objects}
31405 0.031 0.000 0.031 0.000 {built-in method numpy.empty}
804 0.027 0.000 0.111 0.000 function_base.py:3853(_quantile_ureduce_func)
31404 0.027 0.000 0.382 0.000 <__array_function__ internals>:2(cumsum)
31404 0.027 0.000 1.256 0.000 <__array_function__ internals>:2(unique)
68944 0.027 0.000 0.027 0.000 {built-in method numpy.array}
667 0.025 0.000 0.025 0.000 {built-in method nt.stat}
33012 0.025 0.000 0.303 0.000 fromnumeric.py:55(_wrapfunc)
67140 0.025 0.000 0.025 0.000 {built-in method builtins.getattr}
20000 0.024 0.000 0.029 0.000 getlimits.py:365(__new__)
40804 0.021 0.000 0.021 0.000 fromnumeric.py:74(<dictcomp>)
20000 0.021 0.000 0.189 0.000 fromnumeric.py:2277(all)
24824 0.020 0.000 0.030 0.000 numerictypes.py:293(issubclass_)
67230 0.020 0.000 0.045 0.000 _asarray.py:88(asanyarray)
20000 0.019 0.000 0.243 0.000 <__array_function__ internals>:2(all)
12412 0.019 0.000 0.050 0.000 numerictypes.py:365(issubdtype)
9045 0.017 0.000 0.025 0.000 numeric.py:1273(normalize_axis_tuple)
139 0.016 0.000 0.021 0.000 <frozen importlib._bootstrap_external>:914(get_data)
31404 0.016 0.000 0.021 0.000 arraysetops.py:138(_unpack_tuple)
10000 0.015 0.000 0.116 0.000 fromnumeric.py:2792(prod)
19 0.015 0.001 0.017 0.001 {built-in method _imp.create_dynamic}
317 0.014 0.000 0.014 0.000 {built-in method builtins.compile}
4221 0.014 0.000 0.043 0.000 numeric.py:1336(moveaxis)
139 0.014 0.000 0.014 0.000 {built-in method marshal.loads}
11207 0.012 0.000 0.064 0.000 <__array_function__ internals>:2(concatenate)
39330 0.011 0.000 0.011 0.000 {built-in method builtins.issubclass}
10000 0.011 0.000 0.139 0.000 <__array_function__ internals>:2(prod)
11608 0.011 0.000 0.011 0.000 {built-in method numpy.core._multiarray_umath.count_nonzero}
11608 0.010 0.000 0.037 0.000 <__array_function__ internals>:2(count_nonzero)
402 0.010 0.000 0.023 0.000 _methods.py:167(_var)
10804 0.010 0.000 0.093 0.000 <__array_function__ internals>:2(any)
1206 0.010 0.000 0.010 0.000 {method 'partition' of 'numpy.ndarray' objects}
10804 0.009 0.000 0.074 0.000 fromnumeric.py:2189(any)
62590/62386 0.008 0.000 0.008 0.000 {built-in method builtins.len}
40846 0.007 0.000 0.007 0.000 {method 'items' of 'dict' objects}
20000 0.007 0.000 0.059 0.000 _methods.py:47(_all)
804 0.006 0.000 0.017 0.000 _methods.py:134(_mean)
1608 0.006 0.000 0.006 0.000 {method 'take' of 'numpy.ndarray' objects}
11608 0.006 0.000 0.017 0.000 numeric.py:409(count_nonzero)
31404 0.006 0.000 0.006 0.000 fromnumeric.py:2354(_cumsum_dispatcher)
1206 0.006 0.000 0.145 0.000 function_base.py:3359(_ureduce)
21762 0.005 0.000 0.005 0.000 {method 'get' of 'dict' objects}
31404 0.005 0.000 0.005 0.000 arraysetops.py:146(_unique_dispatcher)
139 0.005 0.000 0.005 0.000 {method 'read' of '_io.FileIO' objects}
342/339 0.004 0.000 0.006 0.000 {built-in method builtins.__build_class__}
201 0.004 0.000 0.211 0.001 simulation.py:51(population_stats)
804 0.004 0.000 0.133 0.000 function_base.py:3569(percentile)
1 0.004 0.004 135.770 135.770 {method 'writerows' of '_csv.writer' objects}
20000 0.004 0.000 0.004 0.000 fromnumeric.py:2273(_all_dispatcher)
804 0.004 0.000 0.009 0.000 function_base.py:3840(_quantile_is_valid)
402 0.004 0.000 0.025 0.000 function_base.py:3508(_median)
13 0.003 0.000 0.003 0.000 {built-in method builtins.print}
642 0.003 0.000 0.003 0.000 {method 'sub' of 're.Pattern' objects}
9045 0.003 0.000 0.005 0.000 numeric.py:1323(<listcomp>)
4221 0.003 0.000 0.049 0.000 <__array_function__ internals>:2(moveaxis)
16 0.003 0.000 0.003 0.000 {built-in method nt.listdir}
322 0.002 0.000 0.029 0.000 <frozen importlib._bootstrap_external>:1356(find_spec)
11207 0.002 0.000 0.002 0.000 multiarray.py:145(concatenate)
10000 0.002 0.000 0.002 0.000 fromnumeric.py:2787(_prod_dispatcher)
4221 0.002 0.000 0.002 0.000 {method 'transpose' of 'numpy.ndarray' objects}
4222 0.002 0.000 0.002 0.000 {built-in method builtins.sorted}
9045 0.002 0.000 0.002 0.000 {built-in method numpy.core._multiarray_umath.normalize_axis_index}
11608 0.002 0.000 0.002 0.000 numeric.py:405(_count_nonzero_dispatcher)
1206 0.002 0.000 0.002 0.000 _methods.py:50(_count_reduce_items)
10804 0.002 0.000 0.002 0.000 fromnumeric.py:2185(_any_dispatcher)
101/33 0.002 0.000 0.004 0.000 sre_parse.py:469(_parse)
201 0.002 0.000 0.005 0.000 utils.py:1142(_median_nancheck)
321 0.002 0.000 0.002 0.000 {method 'findall' of 're.Pattern' objects}
9499 0.001 0.000 0.001 0.000 {built-in method builtins.isinstance}
19/14 0.001 0.000 0.011 0.001 {built-in method _imp.exec_dynamic}
469/1 0.001 0.000 135.938 135.938 {built-in method builtins.exec}
1608 0.001 0.000 0.009 0.000 fromnumeric.py:97(take)
614 0.001 0.000 0.002 0.000 _inspect.py:67(getargs)
1608 0.001 0.000 0.012 0.000 <__array_function__ internals>:2(take)
3189 0.001 0.000 0.001 0.000 {built-in method builtins.hasattr}
139 0.001 0.000 0.043 0.000 <frozen importlib._bootstrap_external>:793(get_code)
804 0.001 0.000 0.119 0.000 function_base.py:3828(_quantile_unchecked)
182/2 0.001 0.000 0.165 0.083 <frozen importlib._bootstrap>:978(_find_and_load)
4221 0.001 0.000 0.001 0.000 numeric.py:1399(<listcomp>)
4226 0.001 0.000 0.001 0.000 {method 'insert' of 'list' objects}
287 0.001 0.000 0.004 0.000 overrides.py:72(verify_matching_signatures)
317 0.001 0.000 0.029 0.000 overrides.py:154(decorator)
1555 0.001 0.000 0.003 0.000 <frozen importlib._bootstrap_external>:56(_path_join)
179 0.001 0.000 0.034 0.000 <frozen importlib._bootstrap>:882(_find_spec)
339 0.001 0.000 0.002 0.000 functools.py:37(update_wrapper)
190/31 0.001 0.000 0.003 0.000 sre_compile.py:71(_compile)
9045 0.001 0.000 0.001 0.000 {built-in method _operator.index}
77 0.001 0.000 0.001 0.000 sre_compile.py:276(_optimize_charset)
1555 0.001 0.000 0.001 0.000 <frozen importlib._bootstrap_external>:58(<listcomp>)
402 0.001 0.000 0.007 0.000 fromnumeric.py:3153(mean)
804 0.001 0.000 0.001 0.000 {method 'astype' of 'numpy.ndarray' objects}
278 0.001 0.000 0.002 0.000 <frozen importlib._bootstrap_external>:271(cache_from_source)
481 0.001 0.000 0.002 0.000 <frozen importlib._bootstrap>:157(_get_module_lock)
16 0.001 0.000 0.002 0.000 <frozen importlib._bootstrap_external>:1190(_path_hooks)
321 0.001 0.000 0.007 0.000 textwrap.py:414(dedent)
2 0.001 0.000 0.001 0.000 {built-in method _ctypes.LoadLibrary}
756 0.001 0.000 0.001 0.000 {method 'format' of 'str' objects}
481 0.001 0.000 0.001 0.000 <frozen importlib._bootstrap>:78(acquire)
804 0.001 0.000 0.135 0.000 <__array_function__ internals>:2(percentile)
366 0.001 0.000 0.001 0.000 {built-in method _thread.allocate_lock}
1608 0.001 0.000 0.001 0.000 {method 'squeeze' of 'numpy.ndarray' objects}
162 0.001 0.000 0.032 0.000 <frozen importlib._bootstrap_external>:1240(_get_spec)
175 0.001 0.000 0.003 0.000 <frozen importlib._bootstrap>:504(_init_module_attrs)
175/2 0.001 0.000 0.164 0.082 <frozen importlib._bootstrap>:663(_load_unlocked)
882/71 0.001 0.000 0.146 0.002 <frozen importlib._bootstrap>:1009(_handle_fromlist)
618 0.001 0.000 0.003 0.000 _inspect.py:98(getargspec)
481 0.001 0.000 0.001 0.000 <frozen importlib._bootstrap>:103(release)
17 0.001 0.000 0.001 0.000 {built-in method _imp.create_builtin}
634 0.001 0.000 0.001 0.000 {built-in method __new__ of type object at 0x00007FFFE42159A0}
455 0.001 0.000 0.010 0.000 re.py:271(_compile)
278 0.001 0.000 0.001 0.000 <frozen importlib._bootstrap_external>:62(_path_split)
402 0.001 0.000 0.006 0.000 fromnumeric.py:657(partition)
4221 0.001 0.000 0.001 0.000 numeric.py:1332(_moveaxis_dispatcher)
182/2 0.001 0.000 0.165 0.083 <frozen importlib._bootstrap>:948(_find_and_load_unlocked)
12 0.001 0.000 0.001 0.000 __init__.py:316(namedtuple)
2064 0.001 0.000 0.001 0.000 {method 'join' of 'str' objects}
Of course any advice is highly appreciated!=)
