def runClient(host, port, clients): """Runs the java ThreadClient with clients threads against server running on host:port. Returns the requests per second as a float.""" latency_out = tempfile.NamedTemporaryFile() child = subprocess.Popen(CLIENT + (host, str(port), str(clients), latency_out.name), stdout=subprocess.PIPE) output = "" for line in child.stdout: output += line error = child.wait() assert error == 0 latency_f = open(latency_out.name) latencies = [int(l) for l in latency_f] latency_f.close() latency_out.close() average_latency, median_latency, stddev, min, max, latency_confidence = statistics.stats(latencies) parts = output.split() assert parts[-1] == "us" assert parts[-5] == "msgs/s" throughput = float(parts[-6]) return throughput, average_latency, median_latency, latency_confidence
def run(self, wantpdf=False): self.enqueue(Arrival(self)) self.start_loop() sys.stdout.write("[%8s] %4d rate, %6d blocks, %6d arrivals [%.04f]\r" % ( self.methods[self.method], 1.0 / self.lambda_arr, self.blocks, self.arrivals, float(self.blocks) / float(self.arrivals) )) if wantpdf: sys.stdout.write('\n') sys.stdout.flush() while not wantpdf: avg, median, std, min, max, conf = stats(self.interferences) if conf >= 0.05: self.iterations *= 2 sys.stdout.write("Doubling iterations %d\r" % self.iterations) sys.stdout.flush() self.start_loop() else: sys.stdout.write("[%8s] %4d rate, %.6f interference, %6d blocks, %6d arrivals [%.04f]\r" % ( self.methods[self.method], 1.0 / self.lambda_arr, avg, self.blocks, self.arrivals, float(self.blocks) / float(self.arrivals) )) sys.stdout.write('\n') sys.stdout.flush() return (avg, median, std, min, max, conf) # If we are here we are just interested in the pdf # So just returns the results return (self.distances, self.interferences)
def mean_confidence_interval(data, confidence=0.95): mean, _, _, _, _, h = statistics.stats(data, 1-confidence) return mean, h
input = server_type + ".csv" data = open(input) reader = csv.reader(data) table = [] for row in reader: table.append(row) data.close() scatter = [('Simultaneous Clients', 'Messages/s')] average = [('Simultaneous Clients', server_type, '-95% confidence', '+95% confidence')] for row in table: x = row[0] for y in row[1:]: scatter.append((x, y)) stats = statistics.stats([float(f) for f in row[1:]]) average.append((x, stats[0], stats[0]-stats[-1], stats[0]+stats[-1])) options = { 'plottype': 'points', 'key': False, 'ylabel': scatter[0][1], } stupidplot.gnuplotTable(scatter, server_type + "-scatter.eps", options) averages.append(average) options = { #~ 'plottype': 'points', #~ 'key': False, 'ylabel': 'Messages/s',
def plot_stacked_bar2(index1,stats,alg,xlabel): out_label = [5, 10, 20, 40, 60, 80, 100, 120] n_groups = len(out_label) fig = plt.figure(index1) index = np.arange(n_groups) ax = fig.add_axes([0.15, 0.17, 0.8, 0.75]) plt.gca().yaxis.grid(True) plt.gca().xaxis.grid(False) plt.xlabel('Period of packet generation (sec)', fontsize=f_size - 6) CellType = ('Shared', 'TX', 'RX','Used TX','Used RX') CellTypeB = ('TX','RX') metrics=['Alloc_Cells','Used_Cells'] plt.ylabel("Avg Cells per SlotFrame", fontsize=f_size - 6) # x-axis configuration x=[] for i in range(0, len(xlabel)): if xlabel[i] in out_label: x.append(xlabel[i]) plt.xticks(x, out_label, fontsize=f_size - 8, rotation='vertical') plt.yticks(fontsize=f_size - 8) y_avg=[] y_conf = [] st = [] for i in range(0, 5): t1=[] t2=[] y_avg.append(t1) y_conf.append(t2) z=0 for j in range(0, len(xlabel)): if xlabel[j] in out_label: t3=[] st.append(t3) for l in range(0,5): t4=[] st[z].append(t4) for v in range(0,len(metrics)): for k in range(0, len(stats[alg][xlabel[j]][metrics[v]])): for cell_i in range(0, len(stats[alg][xlabel[j]][metrics[v]][k])): st[z][v*3+cell_i].append(stats[alg][xlabel[j]][metrics[v]][k][cell_i]) #print z,cell_i,st[z][cell_i] z += 1 for i in range(0, len(out_label)): for j in range(0,5): average, median, standard_deviation, minimum, maximum, confidence = statistics.stats(st[i][j], 0.05) # #print average, median, standard_deviation, minimum, maximum, confidence y_conf[j].append(confidence) y_avg[j].append(average) plt.grid(linestyle='dashed', linewidth=0.5, axis='y') error_config = {'elinewidth': '0.1'} # 'ecolor': '0.3', dataset1 = np.array(y_avg[0]) dataset2 = np.array(y_avg[1]) dataset3 = np.array(y_avg[2]) # Used Cells dataset4 = np.array(y_avg[3]) dataset5 = np.array(y_avg[4]) p1 = plt.bar(index + 0.32 + bar_width, y_avg[0], bar_width, alpha=opacity, color=my_color[0], error_kw=dict(lw=0.5, capsize=3, capthick=0.5, color=0.3), label=CellType[0], linewidth=1, edgecolor='grey',yerr=y_conf[0])#, p2 = plt.bar(index + 0.32 + bar_width, y_avg[1], bar_width, alpha=opacity, color=my_color[1],bottom = dataset1, error_kw=dict(lw=0.5, capsize=3, capthick=0.5, color=0.3), label=CellType[1], linewidth=1,edgecolor='grey',yerr=y_conf[1])#, p3 = plt.bar(index + 0.32 + bar_width, y_avg[2], bar_width, alpha=opacity, color=my_color[2], bottom=dataset1+dataset2, error_kw=dict(lw=0.5, capsize=3, capthick=0.5, color=0.3), label=CellType[2], linewidth=1, edgecolor='grey',yerr=y_conf[2]) # , # --- Used Cells --- p4 = plt.bar(index +0.32 +2*bar_width+0.05, y_avg[3], bar_width, alpha=opacity, color=my_color[1], error_kw=dict(lw=0.5, capsize=3, capthick=0.5, color=0.3), label=CellType[3], linewidth=1, edgecolor='grey',yerr=y_conf[3],hatch="//")#, p5 = plt.bar(index +0.32+ 2*bar_width+0.05, y_avg[4], bar_width, alpha=opacity, color=my_color[2],bottom = dataset4, error_kw=dict(lw=0.5, capsize=3, capthick=0.5, color=0.3), label=CellType[4], linewidth=1,edgecolor='grey',yerr=y_conf[4],hatch="//")#, plt.tick_params(axis='y', which='major', labelsize=13) plt.tick_params(axis='x', which='major', labelsize=11) plt.yticks(fontsize=f_size - 6) plt.xticks(fontsize=f_size - 6) plt.title(alg) plt.legend(loc='upper right', prop={'size': 10}) plt.xticks(index + 0.32 + bar_width, out_label, fontsize=f_size-6)#,2.5 locs, labels = plt.xticks() plt.savefig(path +"Stacked_bar" +"_"+str(alg)+str(index1) +'.png', format='png')
def read_values( file ): print "Reading file %s..."%file f=open(file,"r") xvalues = [] yvalues = [] errvalues = [] values = {} # mapping "x" values to a set of "y" values { x : { y : [...] , y: [...] },... } header = None try: for line in f.readlines(): line = line.strip() # see if needs a header line if options.header and header is None: header=line.split(options.delimiter) # map the name of the header to the index in the array header = dict(itertools.izip(header,xrange(len(header)))) print header continue # skip comments if line.startswith("#"): continue l = line.split(",") # first, read the x-value if header and options.x_pos in header: x = float(l[ header[options.x_pos] ] ) else: x = float(l[ int(options.x_pos)] ) if options.normx: x=x/float(l[options.normx]) if x not in values: values[x] = {} print "x:",x # now, match the x-value to the needed y-values if options.y_pos: cols = options.y_pos.split(",") # for each y-value we expect two values - the location and the action..for now, we do not really care about the action for i in xrange( 0,len(cols),2 ): if header and cols[i] in header: pos = header[cols[i]] else: pos = int(cols[i]) y = float(l[ pos ] ) if not options.miny or y>=options.miny: if options.normy: y=y/float(l[options.normy]) # ok, now we have the y value - let's add it to the right place if cols[i] not in values[x]: values[x][cols[i]] = [] # add the value to the right place values[x][cols[i]].append( y ) except: print "bad line." print "done." # now, let's see what we can do with the oprations. For each y operation we need to perform that on the list of matching values # overall, each "y" element should have a single number so we can plot them cols = options.y_pos.split(",") for i in xrange( 0,len(cols),2 ): if header and cols[i] in header: pos = header[cols[i]] else: pos = int(cols[i]) op = cols[i+1] for x in sorted(values.keys()): old_values = values[x][cols[i]] average, median, standard_deviation, minimum, maximum, confidence = statistics.stats( numpy.array(old_values) ) if op=="avg": new_value = average values[x][cols[i]+"_std"] = standard_deviation values[x][cols[i]+"_ci"] = confidence elif op=="normal": new_value = old_values[0] elif op=="max": new_value = maximum elif op=="min": new_value = minimum # set the new (single) value for that given x and y_pos values[x][cols[i]] = new_value return values
def learn(env, policy_func, reward_giver, expert_dataset, rank, pretrained, pretrained_weight, *, g_step, d_step, entcoeff, save_per_iter, ckpt_dir, log_dir, timesteps_per_batch, task_name, gamma, lam, max_kl, cg_iters, cg_damping=1e-2, vf_stepsize=3e-4, d_stepsize=3e-4, vf_iters=3, max_timesteps=0, max_episodes=0, max_iters=0, callback=None): nworkers = MPI.COMM_WORLD.Get_size() rank = MPI.COMM_WORLD.Get_rank() np.set_printoptions(precision=3) # Setup losses and stuff # ---------------------------------------- ob_space = env.observation_space ac_space = env.action_space pi = policy_func("pi", ob_space, ac_space, reuse=(pretrained_weight != None)) oldpi = policy_func("oldpi", ob_space, ac_space) atarg = tf.placeholder( dtype=tf.float32, shape=[None]) # Target advantage function (if applicable) ret = tf.placeholder(dtype=tf.float32, shape=[None]) # Empirical return ob = U.get_placeholder_cached(name="ob") ac = pi.pdtype.sample_placeholder([None]) kloldnew = oldpi.pd.kl(pi.pd) ent = pi.pd.entropy() meankl = tf.reduce_mean(kloldnew) meanent = tf.reduce_mean(ent) entbonus = entcoeff * meanent vferr = tf.reduce_mean(tf.square(pi.vpred - ret)) ratio = tf.exp(pi.pd.logp(ac) - oldpi.pd.logp(ac)) # advantage * pnew / pold surrgain = tf.reduce_mean(ratio * atarg) optimgain = surrgain + entbonus losses = [optimgain, meankl, entbonus, surrgain, meanent] loss_names = ["optimgain", "meankl", "entloss", "surrgain", "entropy"] dist = meankl all_var_list = pi.get_trainable_variables() var_list = [ v for v in all_var_list if v.name.startswith("pi/pol") or v.name.startswith("pi/logstd") ] vf_var_list = [v for v in all_var_list if v.name.startswith("pi/vff")] assert len(var_list) == len(vf_var_list) + 1 d_adam = MpiAdam(reward_giver.get_trainable_variables()) vfadam = MpiAdam(vf_var_list) get_flat = U.GetFlat(var_list) set_from_flat = U.SetFromFlat(var_list) klgrads = tf.gradients(dist, var_list) flat_tangent = tf.placeholder(dtype=tf.float32, shape=[None], name="flat_tan") shapes = [var.get_shape().as_list() for var in var_list] start = 0 tangents = [] for shape in shapes: sz = U.intprod(shape) tangents.append(tf.reshape(flat_tangent[start:start + sz], shape)) start += sz gvp = tf.add_n([ tf.reduce_sum(g * tangent) for (g, tangent) in zipsame(klgrads, tangents) ]) # pylint: disable=E1111 fvp = U.flatgrad(gvp, var_list) assign_old_eq_new = U.function( [], [], updates=[ tf.assign(oldv, newv) for (oldv, newv) in zipsame(oldpi.get_variables(), pi.get_variables()) ]) compute_losses = U.function([ob, ac, atarg], losses) compute_lossandgrad = U.function([ob, ac, atarg], losses + [U.flatgrad(optimgain, var_list)]) compute_fvp = U.function([flat_tangent, ob, ac, atarg], fvp) compute_vflossandgrad = U.function([ob, ret], U.flatgrad(vferr, vf_var_list)) @contextmanager def timed(msg): if rank == 0: print(colorize(msg, color='magenta')) tstart = time.time() yield print( colorize("done in %.3f seconds" % (time.time() - tstart), color='magenta')) else: yield def allmean(x): assert isinstance(x, np.ndarray) out = np.empty_like(x) MPI.COMM_WORLD.Allreduce(x, out, op=MPI.SUM) out /= nworkers return out U.initialize() th_init = get_flat() MPI.COMM_WORLD.Bcast(th_init, root=0) set_from_flat(th_init) d_adam.sync() vfadam.sync() if rank == 0: print("Init param sum", th_init.sum(), flush=True) # Prepare for rollouts # ---------------------------------------- seg_gen = traj_segment_generator(pi, env, reward_giver, timesteps_per_batch, stochastic=True) episodes_so_far = 0 timesteps_so_far = 0 iters_so_far = 0 tstart = time.time() lenbuffer = deque(maxlen=40) # rolling buffer for episode lengths rewbuffer = deque(maxlen=40) # rolling buffer for episode rewards true_rewbuffer = deque(maxlen=40) assert sum([max_iters > 0, max_timesteps > 0, max_episodes > 0]) == 1 g_loss_stats = stats(loss_names) d_loss_stats = stats(reward_giver.loss_name) ep_stats = stats(["True_rewards", "Rewards", "Episode_length"]) # if provide pretrained weight if pretrained_weight is not None: U.load_state(pretrained_weight, var_list=pi.get_variables()) while True: if callback: callback(locals(), globals()) if max_timesteps and timesteps_so_far >= max_timesteps: break elif max_episodes and episodes_so_far >= max_episodes: break elif max_iters and iters_so_far >= max_iters: break # Save model if rank == 0 and iters_so_far % save_per_iter == 0 and ckpt_dir is not None: fname = os.path.join(ckpt_dir, task_name) os.makedirs(os.path.dirname(fname), exist_ok=True) saver = tf.train.Saver() saver.save(tf.get_default_session(), fname) logger.log("********** Iteration %i ************" % iters_so_far) # global flag_render # if iters_so_far > 0 and iters_so_far % 10 ==0: # flag_render = True # else: # flag_render = False def fisher_vector_product(p): return allmean(compute_fvp(p, *fvpargs)) + cg_damping * p # ------------------ Update G ------------------ logger.log("Optimizing Policy...") for _ in range(g_step): with timed("sampling"): seg = seg_gen.__next__() print('rewards', seg['rew']) add_vtarg_and_adv(seg, gamma, lam) # ob, ac, atarg, ret, td1ret = map(np.concatenate, (obs, acs, atargs, rets, td1rets)) ob, ac, atarg, tdlamret = seg["ob"], seg["ac"], seg["adv"], seg[ "tdlamret"] vpredbefore = seg[ "vpred"] # predicted value function before udpate atarg = (atarg - atarg.mean()) / atarg.std( ) # standardized advantage function estimate if hasattr(pi, "ob_rms"): pi.ob_rms.update(ob) # update running mean/std for policy args = seg["ob"], seg["ac"], atarg fvpargs = [arr[::5] for arr in args] assign_old_eq_new( ) # set old parameter values to new parameter values with timed("computegrad"): *lossbefore, g = compute_lossandgrad(*args) lossbefore = allmean(np.array(lossbefore)) g = allmean(g) if np.allclose(g, 0): logger.log("Got zero gradient. not updating") else: with timed("cg"): stepdir = cg(fisher_vector_product, g, cg_iters=cg_iters, verbose=rank == 0) assert np.isfinite(stepdir).all() shs = .5 * stepdir.dot(fisher_vector_product(stepdir)) lm = np.sqrt(shs / max_kl) # logger.log("lagrange multiplier:", lm, "gnorm:", np.linalg.norm(g)) fullstep = stepdir / lm expectedimprove = g.dot(fullstep) surrbefore = lossbefore[0] stepsize = 1.0 thbefore = get_flat() for _ in range(10): thnew = thbefore + fullstep * stepsize set_from_flat(thnew) meanlosses = surr, kl, *_ = allmean( np.array(compute_losses(*args))) improve = surr - surrbefore logger.log("Expected: %.3f Actual: %.3f" % (expectedimprove, improve)) if not np.isfinite(meanlosses).all(): logger.log("Got non-finite value of losses -- bad!") elif kl > max_kl * 1.5: logger.log("violated KL constraint. shrinking step.") elif improve < 0: logger.log("surrogate didn't improve. shrinking step.") else: logger.log("Stepsize OK!") break stepsize *= .5 else: logger.log("couldn't compute a good step") set_from_flat(thbefore) if nworkers > 1 and iters_so_far % 20 == 0: paramsums = MPI.COMM_WORLD.allgather( (thnew.sum(), vfadam.getflat().sum())) # list of tuples assert all( np.allclose(ps, paramsums[0]) for ps in paramsums[1:]) with timed("vf"): for _ in range(vf_iters): for (mbob, mbret) in dataset.iterbatches( (seg["ob"], seg["tdlamret"]), include_final_partial_batch=False, batch_size=128): if hasattr(pi, "ob_rms"): pi.ob_rms.update( mbob) # update running mean/std for policy g = allmean(compute_vflossandgrad(mbob, mbret)) vfadam.update(g, vf_stepsize) g_losses = meanlosses for (lossname, lossval) in zip(loss_names, meanlosses): logger.record_tabular(lossname, lossval) logger.record_tabular("ev_tdlam_before", explained_variance(vpredbefore, tdlamret)) # ------------------ Update D ------------------ logger.log("Optimizing Discriminator...") logger.log(fmt_row(13, reward_giver.loss_name)) ob_expert, ac_expert = expert_dataset.get_next_batch(len(ob)) batch_size = len(ob) // d_step d_losses = [ ] # list of tuples, each of which gives the loss for a minibatch for ob_batch, ac_batch in dataset.iterbatches( (ob, ac), include_final_partial_batch=False, batch_size=batch_size): ob_expert, ac_expert = expert_dataset.get_next_batch(len(ob_batch)) # update running mean/std for reward_giver if hasattr(reward_giver, "obs_rms"): reward_giver.obs_rms.update( np.concatenate((ob_batch, ob_expert), 0)) *newlosses, g = reward_giver.lossandgrad(ob_batch, ac_batch, ob_expert, ac_expert) d_adam.update(allmean(g), d_stepsize) d_losses.append(newlosses) logger.log(fmt_row(13, np.mean(d_losses, axis=0))) lrlocal = (seg["ep_lens"], seg["ep_rets"], seg["ep_true_rets"] ) # local values listoflrpairs = MPI.COMM_WORLD.allgather(lrlocal) # list of tuples lens, rews, true_rets = map(flatten_lists, zip(*listoflrpairs)) true_rewbuffer.extend(true_rets) lenbuffer.extend(lens) rewbuffer.extend(rews) logger.record_tabular("EpLenMean", np.mean(lenbuffer)) logger.record_tabular("EpRewMean", np.mean(rewbuffer)) logger.record_tabular("EpTrueRewMean", np.mean(true_rewbuffer)) logger.record_tabular("EpThisIter", len(lens)) episodes_so_far += len(lens) timesteps_so_far += sum(lens) iters_so_far += 1 logger.record_tabular("EpisodesSoFar", episodes_so_far) logger.record_tabular("TimestepsSoFar", timesteps_so_far) logger.record_tabular("TimeElapsed", time.time() - tstart) if rank == 0: logger.dump_tabular()
def calc_student_ttest_result(a, b, confidence): result = {} # a = [1,3,5,17,9] # b = [12,4,6,8,10,41] result['group_1_N'] = len(a) result['group_2_N'] = len(b) if len(a) < 2 or len(b) < 2: result['group_1_mean'] = "-1" result['group_1_std'] = "-1" result['group_1_std_error'] = '-1' result['group_2_mean'] = "-1" result['group_2_std'] = "-1" result['group_2_std_error'] = '-1' result['group_unequal_low'] = "-1" result['group_unequal_up'] = "-1" result['group_equal_low'] = "-1" result['group_equal_up'] = "-1" result['group_equal_t'] = "-1" result['group_equal_p'] = "-1" result['group_equal_free_degree'] = "-1" result['group_unequal_t'] = "-1" result['group_unequal_p'] = "-1" result['group_unequal_free_degree'] = "-1" result['group_equal_mean_error'] = "-1" result['group_unequal_mean_error'] = "-1" result['F'] = "-1" result['sig'] = "-1" result['group_unequal_std_error'] = "-1" result['group_equal_std_error'] = "-1" return result mean1, _, stddev1, _, _, _ = statistics.stats(a, confidence) result['group_1_mean'] = utils.get_Decimal_float(mean1) result['group_1_std'] = utils.get_Decimal_float(stddev1) result['group_1_std_error'] = utils.get_Decimal_float(stddev1 / math.sqrt(len(a))) mean2, _, stddev2, _, _, _ = statistics.stats(b, confidence) result['group_2_mean'] = utils.get_Decimal_float(mean2) result['group_2_std'] = utils.get_Decimal_float(stddev2) result['group_2_std_error'] = utils.get_Decimal_float(stddev2 / math.sqrt(len(b))) import statsmodels.stats.api as sms cm = sms.CompareMeans(sms.DescrStatsW(a), sms.DescrStatsW(b)) tconfint_diff = cm.tconfint_diff(alpha=1.0 - confidence, usevar='unequal') result['group_unequal_low'] = utils.get_Decimal_float(tconfint_diff[0]) result['group_unequal_up'] = utils.get_Decimal_float(tconfint_diff[1]) tconfint_diff = cm.tconfint_diff(alpha=1.0 - confidence, usevar='pooled') result['group_equal_low'] = utils.get_Decimal_float(tconfint_diff[0]) result['group_equal_up'] = utils.get_Decimal_float(tconfint_diff[1]) import statsmodels.api as sm ttest_int_result = sm.stats.ttest_ind(a, b, usevar='pooled') result['group_equal_t'] = utils.get_Decimal_float(ttest_int_result[0]) result['group_equal_p'] = utils.get_Decimal_float(ttest_int_result[1]) result['group_equal_free_degree'] = Decimal(ttest_int_result[2]) ttest_int_result = sm.stats.ttest_ind(a, b, usevar='unequal') result['group_unequal_t'] = utils.get_Decimal_float(ttest_int_result[0]) result['group_unequal_p'] = utils.get_Decimal_float(ttest_int_result[1]) result['group_unequal_free_degree'] = utils.get_Decimal_float( ttest_int_result[2]) result['group_equal_mean_error'] = result['group_1_mean'] - result[ 'group_2_mean'] result['group_unequal_mean_error'] = result['group_1_mean'] - result[ 'group_2_mean'] from scipy.stats import levene ttest_levene = levene(a, b, center='trimmed') result['F'] = utils.get_Decimal_float(ttest_levene[0]) result['sig'] = utils.get_Decimal_float(ttest_levene[1]) result['group_unequal_std_error'] = utils.get_Decimal_float( math.sqrt(stddev1 * stddev1 / len(a) + stddev2 * stddev2 / len(b))) #error result['group_equal_std_error'] = utils.get_Decimal_float( math.sqrt(stddev1 * stddev1 / len(a) + stddev2 * stddev2 / len(b))) return result
ad_sc = [x.split(",")[0] for x in open("./method3/csv/adherent_sc_pwl.csv").readlines()] ad_not_net = [x.strip().split(",")[0] for x in open("./method3/csv/adherent_not_networked_pwl.csv").readlines()] nonad = [x.split(",")[0] for x in open("./master_nonadherent.csv").readlines()[1:]] nonad_giant = [x.split(",")[0] for x in open("./method3/csv/nonadherent_giant_pwl.csv").readlines()] nonad_sc = [x.split(",")[0] for x in open("./method3/csv/nonadherent_sc_pwl.csv").readlines()] nonad_not_net = [x.strip().split(",")[0] for x in open("./method3/csv/nonadherent_not_networked_pwl.csv").readlines()] #check sizes sections print "ad_giant, ad_sc, ad_not_net", len(ad_giant), len(ad_sc), len(ad_not_net) print "nonad_giant, nonad_sc, nonad_not_net", len(nonad_giant), len(nonad_sc), len(nonad_not_net) mean0, median0, stddev0, min0, max0, confidence0 = statistics.stats(values(data, nonad_not_net)) mean1, median1, stddev1, min1, max1, confidence1 = statistics.stats(values(data, nonad_sc)) mean2, median2, stddev2, min2, max2, confidence2 = statistics.stats(values(data, nonad_giant)) mean3, median3, stddev3, min3, max3, confidence3 = statistics.stats(values(data, ad_not_net)) mean4, median4, stddev4, min4, max4, confidence4 = statistics.stats(values(data, ad_sc)) mean5, median5, stddev5, min5, max5, confidence5 = statistics.stats(values(data, ad_giant)) print "means and 95% CIs for (a) and (b) panels" print 1*-mean0, confidence0, len(nonad_not_net) print 1*-mean1, confidence1, len(nonad_sc) print 1*-mean2, confidence2, len(nonad_giant) print 1*-mean3, confidence3, len(ad_not_net) print 1*-mean4, confidence4, len(ad_sc) print 1*-mean5, confidence5, len(ad_giant) non_ad_not_net_frac = frac(list(nonad_not_net))
obj = bootstrapmeans([ list(not_networked_overweight), list(overweight_sc), list(overweight_giant) ]) d = obj.hypo() obj = bootstrapmeans( [list(not_networked_obese), list(obese_sc), list(obese_giant)]) d = obj.hypo() #calculate stats for each set of values mean0, median0, stddev0, min0, max0, confidence0 = statistics.stats( values(data, not_networked_overweight)) mean1, median1, stddev1, min1, max1, confidence1 = statistics.stats( values(data, overweight_sc)) mean2, median2, stddev2, min2, max2, confidence2 = statistics.stats( values(data, overweight_giant)) mean3, median3, stddev3, min3, max3, confidence3 = statistics.stats( values(data, not_networked_obese)) mean4, median4, stddev4, min4, max4, confidence4 = statistics.stats( values(data, obese_sc)) mean5, median5, stddev5, min5, max5, confidence5 = statistics.stats( values(data, obese_giant)) not_networked_overweight_frac = frac(not_networked_overweight) overweight_sc_frac = frac(overweight_sc) overweight_giant_frac = frac(overweight_giant)
print ab print 'std: %.5f'% numpy.std(dataset) cd = numpy.std(dataset)/math.sqrt(len(dataset)) print 'error : %.5f'% cd std = dataset.std() print std mean = dataset.mean() print "std:%.5f"% std print "mean:%.5f"% mean interval=stats.t.interval(0.95,len(dataset)-1,5,std) print interval ci = stats.norm.interval(0.95, loc=mean, scale=std) #print ['%f' % mean, '%f' % std, '(%.3f,%.3f)' % (ci[0], ci[1])] mean, median, stddev, min, max, confidence = statistics.stats(dataset, 0.05) print mean, stddev, min, max, confidence print mean-5 print mean + confidence - 5 print mean - confidence - 5 # # def t_test_interval(dataset, percent, expectedVal): # std = dataset.std() # interval=stats.t.interval(percent, len(dataset)-1, expectedVal, std) # return interval # # def t_test_sample(dataset, percent): # mean, median, stddev, min, max, confidence = statistics.stats(dataset, percent)