def _data_update(artists, workspace): # errorbar with workspaces can only return a single container container_orig = artists[0] # It is not possible to simply reset the error bars so # we have to plot new lines but ensure we don't reorder them on the plot! orig_idx = self.containers.index(container_orig) container_orig.remove() # The container does not remove itself from the containers list # but protect this just in case matplotlib starts doing this try: self.containers.remove(container_orig) except ValueError: pass # this gets pushed back onto the containers list container_new = plotfunctions.errorbar(self, workspace, **kwargs) self.containers.insert(orig_idx, container_new) self.containers.pop() # update line properties to match original orig_flat, new_flat = cbook.flatten( container_orig), cbook.flatten(container_new) for artist_orig, artist_new in zip(orig_flat, new_flat): artist_new.update_from(artist_orig) # ax.relim does not support collections... self._update_line_limits(container_new[0]) self.autoscale() return container_new
def get_subset(df, settings, dd_name, quiet=False): """ Select only those columns specified under settings. Optionaly Parameters ---------- df : DataFrame settings : dictionary with "dd_to_vars" column dd_name : str. for the lookup. quiet: Bool. If True will print, but not raise, on some columns from settings not being in the df's columns. Returns ------- subset : DataFrame. """ cols = {x for x in flatten(settings["dd_to_vars"][dd_name].values())} good_cols = { x for x in flatten(settings["dd_to_vars"]["jan2013"].values()) } all_cols = cols.union(good_cols) subset = df.columns.intersection(all_cols) if not quiet: print("Implicitly dropping {}".format( cols.symmetric_difference(subset))) return df[subset]
def get_subset(df, settings, dd_name, quiet=False): """ Select only those columns specified under settings. Optionaly Parameters ---------- df : DataFrame settings : dictionary with "dd_to_vars" column dd_name : str. for the lookup. quiet: Bool. If True will print, but not raise, on some columns from settings not being in the df's columns. Returns ------- subset : DataFrame. """ cols = {x for x in flatten(settings["dd_to_vars"][dd_name].values())} good_cols = {x for x in flatten(settings["dd_to_vars"]["jan2013"].values())} all_cols = cols.union(good_cols) subset = df.columns.intersection(all_cols) if not quiet: print("Implicitly dropping {}".format(cols.symmetric_difference(subset))) return df[subset]
def handle_returning_base_goals(self, data=None): # If input is received, use it. Otherwise, use data from above. if data != None: score_sheet = copy.copy(data) else: score_sheet = copy.copy(self.score_sheet) # I only want to output the configuration with the best score, so first I grab it from the score sheet. best_score_cfg = score_sheet[0, 0] best_score_score = score_sheet[0, 1] pr2_base_output = [] configuration_output = [] # Outputs the best location for the pr2 # base and the best "other" configurations in two separate lists. # Format of output is: # [x (m), y (m), theta (radians)], [pr2_z_axis (cm), autobed_height (cm), autobed_headrest_angle (radians)] # The current output for the robot base location is the transformation from the goal position for the robot base # to the AR tag. # For a task with a solution of multiple configurations, each configuration will be appended to the previous list. # E.g. [x1, y1, th1, x2, y2, th2] where the first three entries correspond to the first configuration. for i in xrange(len(best_score_cfg[0])): origin_B_goal = np.matrix([[m.cos(best_score_cfg[2][i]), -m.sin(best_score_cfg[2][i]), 0., best_score_cfg[0][i]], [m.sin(best_score_cfg[2][i]), m.cos(best_score_cfg[2][i]), 0., best_score_cfg[1][i]], [0., 0., 1., 0.], [0., 0., 0., 1.]]) pr2_B_goal = self.origin_B_pr2.I * origin_B_goal goal_B_ar = pr2_B_goal.I * self.pr2_B_ar pos_goal, ori_goal = Bmat_to_pos_quat(goal_B_ar) pr2_base_output.append([pos_goal[0], pos_goal[1], m.acos(pr2_B_goal[0, 0])]) configuration_output.append([best_score_cfg[3][i], 100*best_score_cfg[4][i], np.degrees(best_score_cfg[5][i])]) print 'Base selection service is done and has completed preparing its result.' return list(flatten(pr2_base_output)), list(flatten(configuration_output))
def get_gorod_sheremetevo(message): global gorod gorod = message.text marshrut = sorted(set(flatten(list(Sharik(0)['Маршрут'])))) spisok = [] sl = {} for i in marshrut: spisok.append(i.split('-')[1].strip()) for i in range(len(marshrut)): sl[spisok[i]] = marshrut[i] marshrut_1 = sorted(set(flatten(list(Sharik(1)['Маршрут'])))) spisok_1 = [] sl_1 = {} for i in marshrut_1: spisok_1.append(i.split('-')[0].strip()) for i in range(len(marshrut_1)): sl_1[spisok_1[i]] = marshrut_1[i] if action == 0 and gorod in spisok: data = Sharik(0)[Sharik(0)['Маршрут'] == sl[gorod]][[ 'Номер рейса' ]].to_dict('records') for element in data: for key, value in element.items(): if value != '': bot.send_message(message.chat.id, '{}: {}'.format(key, value)) dbworker.set_state(message.chat.id, config.States.S_REIS_NUMBER.value) bot.send_message( message.chat.id, 'Теперь введите номер вашего рейса\n' "Или нажмите /reset для отмены поиска") elif action == 1 and gorod in spisok_1: data = Sharik(1)[Sharik(1)['Маршрут'] == sl_1[gorod]][[ 'Номер рейса' ]].to_dict('records') for element in data: for key, value in element.items(): if value != '': bot.send_message(message.chat.id, '{}: {}'.format(key, value)) dbworker.set_state(message.chat.id, config.States.S_REIS_NUMBER.value) bot.send_message( message.chat.id, 'Теперь введите номер вашего рейса\n' "Или нажмите /reset для отмены поиска") elif (action == 0 and gorod not in spisok) or (action == 1 and gorod not in spisok_1): bot.send_message(message.chat.id, "Таких рейсов на сегодня не запланировано.") keyboard = types.InlineKeyboardMarkup() url_button = types.InlineKeyboardButton( text="Посмотреть онлайн табло", url= 'https://www.svo.aero/ru/timetable/departure?date=today&period=00:00-02:00&terminal=all' ) keyboard.add(url_button) bot.send_message(message.chat.id, "Предлагаю посмотреть онлайн табло.", reply_markup=keyboard) dbworker.set_state(message.chat.id, config.States.S_AIRPORT.value)
def enter_reis_num_sheremetevo(message): global reis reis = message.text bot.send_message(message.chat.id, 'Спасибо. Сейчас я обработаю вашу информацию') x = Sharik(action)['Номер рейса'] if reis in (sorted(list(flatten(list(x))))): for_sending = Sharik(action)[x == reis] py = for_sending.to_dict('records')[0] for key, value in py.items(): if value != '': bot.send_message(message.chat.id, '{}: {}'.format(key, value)) dbworker.set_state(message.chat.id, config.States.S_AIRPORT.value) elif reis not in (sorted(list(flatten(list(x))))): bot.send_message(message.chat.id, 'К сожалению указанного рейса не существует') if action == 1: bot.send_message( message.chat.id, 'Введите название города откуда должен вылететь самолёт по вашему рейсу. Например: Ларнака' ) dbworker.set_state(message.chat.id, config.States.S_GOROD.value) elif action == 0: bot.send_message( message.chat.id, 'Введите название города, в который ожидается выполнение рейса. Например: Краснодар' ) dbworker.set_state(message.chat.id, config.States.S_GOROD.value)
def _data_update(artists, workspace): # errorbar with workspaces can only return a single container container_orig = artists[0] # It is not possible to simply reset the error bars so # we have to plot new lines but ensure we don't reorder them on the plot! orig_idx = self.containers.index(container_orig) container_orig.remove() # The container does not remove itself from the containers list # but protect this just in case matplotlib starts doing this try: self.containers.remove(container_orig) except ValueError: pass # this gets pushed back onto the containers list container_new = plotfunctions.errorbar(self, workspace, **kwargs) self.containers.insert(orig_idx, container_new) self.containers.pop() # update line properties to match original orig_flat, new_flat = cbook.flatten(container_orig), cbook.flatten(container_new) for artist_orig, artist_new in zip(orig_flat, new_flat): artist_new.update_from(artist_orig) # ax.relim does not support collections... self._update_line_limits(container_new[0]) self.autoscale() return container_new
def handle_returning_base_goals(self, data=None): if data != None: score_sheet = copy.copy(data) else: score_sheet = copy.copy(self.score_sheet) # now = rospy.Time.now() + rospy.Duration(1.0) # self.listener.waitForTransform('/odom_combined', '/base_link', now, rospy.Duration(10)) # (trans, rot) = self.listener.lookupTransform('/odom_combined', '/base_link', now) # odom_B_pr2 = createBMatrix(trans, rot) best_score_cfg = score_sheet[0, 0] best_score_score = score_sheet[0, 1] pr2_base_output = [] configuration_output = [] # The output is a list of floats that are the position and quaternions for the transform from the goal location # to the ar tag. It also outputs a list of floats that is [robot z axis, bed height, head rest angle (degrees)]. for i in xrange(len(best_score_cfg[0])): origin_B_goal = np.matrix([[ m.cos(best_score_cfg[2][i]), -m.sin(best_score_cfg[2][i]), 0., best_score_cfg[0][i] ], [ m.sin(best_score_cfg[2][i]), m.cos(best_score_cfg[2][i]), 0., best_score_cfg[1][i] ], [0., 0., 1., 0.], [0., 0., 0., 1.]]) pr2_B_goal = self.origin_B_pr2.I * origin_B_goal goal_B_ar = pr2_B_goal.I * self.pr2_B_ar pos_goal, ori_goal = Bmat_to_pos_quat(goal_B_ar) # odom_B_goal = odom_B_pr2 * self.origin_B_pr2.I * origin_B_goal # pos_goal, ori_goal = Bmat_to_pos_quat(odom_B_goal) pr2_base_output.append( [pos_goal[0], pos_goal[1], m.acos(pr2_B_goal[0, 0])]) configuration_output.append([ best_score_cfg[3][i], 100 * best_score_cfg[4][i], np.degrees(best_score_cfg[5][i]) ]) ## I no longer return posestamped messages. Now I return a list of floats. # psm = PoseStamped() # psm.header.frame_id = '/odom_combined' # psm.pose.position.x=pos_goal[0] # psm.pose.position.y=pos_goal[1] # psm.pose.position.z=pos_goal[2] # psm.pose.orientation.x=ori_goal[0] # psm.pose.orientation.y=ori_goal[1] # psm.pose.orientation.z=ori_goal[2] # psm.pose.orientation.w=ori_goal[3] # #print 'The quaternion to the goal location #',i,' is: \n',psm # output.append(psm) print 'Base selection service is done and has output a result.' ## Format of output is a list. Output is position [x,y,z] then quaternion [x,y,z,w] for each base location # (could output multiple base locations). So each set of 7 values is for one base location. return list(flatten(pr2_base_output)), list( flatten(configuration_output))
def _makeplot( self, ax, fig, data, ymin=None, ymax=None, height=6, width=6, dos=None, color=None, ): """Utility method to tidy phonon band structure diagrams.""" # Define colours if color is None: color = "C0" # Default to first colour in matplotlib series # set x and y limits tymax = ymax if (ymax is not None) else max(flatten(data["frequency"])) tymin = ymin if (ymin is not None) else min(flatten(data["frequency"])) pad = (tymax - tymin) * 0.05 if ymin is None: ymin = 0 if tymin >= self.imag_tol else tymin - pad ymax = ymax if ymax else tymax + pad ax.set_ylim(ymin, ymax) ax.set_xlim(0, data["distances"][-1][-1]) if ymin < 0: dashline = True ax.axhline( 0, color=rcParams["grid.color"], linestyle="--", dashes=dashes, zorder=0, linewidth=rcParams["ytick.major.width"], ) else: dashline = False if dos is not None: self._plot_phonon_dos(dos, ax=fig.axes[1], color=color, dashline=dashline) else: # keep correct aspect ratio; match axis to canvas x0, x1 = ax.get_xlim() y0, y1 = ax.get_ylim() if width is None: width = rcParams["figure.figsize"][0] if height is None: height = rcParams["figure.figsize"][1] ax.set_aspect((height / width) * ((x1 - x0) / (y1 - y0)))
def setp(h, *args, **kwargs): """ matplotlib supports the use of :func:`setp` ("set property") and :func:`getp` to set and get object properties, as well as to do introspection on the object. For example, to set the linestyle of a line to be dashed, you can do:: >>> line, = plot([1,2,3]) >>> setp(line, linestyle='--') If you want to know the valid types of arguments, you can provide the name of the property you want to set without a value:: >>> setp(line, 'linestyle') linestyle: [ '-' | '--' | '-.' | ':' | 'steps' | 'None' ] If you want to see all the properties that can be set, and their possible values, you can do:: >>> setp(line) ... long output listing omitted :func:`setp` operates on a single instance or a list of instances. If you are in query mode introspecting the possible values, only the first instance in the sequence is used. When actually setting values, all the instances will be set. E.g., suppose you have a list of two lines, the following will make both lines thicker and red:: >>> x = arange(0,1.0,0.01) >>> y1 = sin(2*pi*x) >>> y2 = sin(4*pi*x) >>> lines = plot(x, y1, x, y2) >>> setp(lines, linewidth=2, color='r') :func:`setp` works with the matlab(TM) style string/value pairs or with python kwargs. For example, the following are equivalent:: >>> setp(lines, 'linewidth', 2, 'color', r') # matlab style >>> setp(lines, linewidth=2, color='r') # python style """ insp = ArtistInspector(h) if len(kwargs) == 0 and len(args) == 0: print "\n".join(insp.pprint_setters()) return if len(kwargs) == 0 and len(args) == 1: print insp.pprint_setters(prop=args[0]) return if not cbook.iterable(h): h = [h] else: h = cbook.flatten(h) if len(args) % 2: raise ValueError("The set args must be string, value pairs") funcvals = [] for i in range(0, len(args) - 1, 2): funcvals.append((args[i], args[i + 1])) funcvals.extend(kwargs.items()) ret = [] for o in h: for s, val in funcvals: s = s.lower() funcName = "set_%s" % s func = getattr(o, funcName) ret.extend([func(val)]) return [x for x in cbook.flatten(ret)]
def recurse(s, l, w): for ww, ll in zip(w, l): if type(ww) is list: for e in flatten(ll): s.Add((ww[0] == 0) <= (e == 0)) recurse(s, ll[1:], ww[1:]) else: for e in flatten(ll): s.Add((ww == 0) <= (e == 0))
def get_gorod_vnukovo(message): global gorod gorod = message.text all_cities = sorted( set(flatten(list(vnukovo(pri)['Город отправления (аэропорт)'])))) new = [] for i in all_cities: new.append(i.split()[0]) slovar = {} for i in range(len(new)): slovar[new[i]] = all_cities[i] all_cities_1 = sorted( set(flatten(list(vnukovo(vil)['Город назначения (аэропорт)'])))) new_1 = [] for i in all_cities_1: new_1.append(i.split()[0]) slovar_1 = {} for i in range(len(new_1)): slovar_1[new_1[i]] = all_cities_1[i] if action == pri and gorod in new: data = vnukovo(pri)[vnukovo(pri)['Город отправления (аэропорт)'] == slovar[gorod]][['Рейс']].to_dict('records') for element in data: for key, value in element.items(): if value != '': bot.send_message(message.chat.id, '{}: {}'.format(key, value)) dbworker.set_state(message.chat.id, config.States.S_REIS_NUMBER.value) bot.send_message( message.chat.id, 'Теперь введите номер вашего рейса\n' "Или нажмите /reset для отмены поиска") elif action == vil and gorod in new_1: data = vnukovo(vil)[vnukovo(vil)['Город назначения (аэропорт)'] == slovar_1[gorod]][['Рейс']].to_dict('records') for element in data: for key, value in element.items(): if value != '': bot.send_message(message.chat.id, '{}: {}'.format(key, value)) dbworker.set_state(message.chat.id, config.States.S_REIS_NUMBER.value) bot.send_message( message.chat.id, 'Теперь введите номер вашего рейса\n' "Или нажмите /reset для отмены поиска") elif (action == vil and gorod not in new_1) or (action == pri and gorod not in new): bot.send_message(message.chat.id, "Таких рейсов на сегодня не запланировано.") keyboard = types.InlineKeyboardMarkup() url_button = types.InlineKeyboardButton( text="Посмотреть онлайн табло", url='http://www.vnukovo.ru/flights/online-timetable/#tab-sortie') keyboard.add(url_button) bot.send_message(message.chat.id, "Предлагаю посмотреть онлайн табло.", reply_markup=keyboard) dbworker.set_state(message.chat.id, config.States.S_AIRPORT.value)
def map_indicator(df): mapped_df = df.apply(do_map_indicator, axis=1) mapped_columns = mapped_df.columns.map(lambda x: [x + '_idt', x]) new_val = list(map(lambda x: list(flatten(x)), mapped_df.values)) new_col = list(flatten(mapped_columns)) output_df = pd.DataFrame(new_val, columns=new_col, index=df.index) return output_df
def calc_fscore(r, p): """ given recall and precision arrays, calculate the f-measure (f-score) """ a = array(zip(flatten(r), flatten(p))) r, p = a[:, 0], a[:, 1] idx = where(r) r, p = r[idx], p[idx] F = (2 * p * r / (p + r)).mean() return F
def calc_fscore(r,p): """ given recall and precision arrays, calculate the f-measure (f-score) """ a = array(zip(flatten(r),flatten(p))) r,p = a[:,0],a[:,1] idx = where(r) r,p = r[idx],p[idx] F = (2*p*r/(p+r)).mean() return F
def fit_2dgauss(self, x, y): runs = self.item.datas if self.item.settings.usemask: xss = array( list(flatten(run['col_' + x][run.mask] for run in runs))) yss = array( list(flatten(run['col_' + y][run.mask] for run in runs))) zss = array(list(flatten(run.y[run.mask] for run in runs))) dzss = array(list(flatten(run.dy[run.mask] for run in runs))) else: xss = array(list(flatten(run['col_' + x] for run in runs))) yss = array(list(flatten(run['col_' + y] for run in runs))) zss = array(list(flatten(run.y for run in runs))) dzss = array(list(flatten(run.dy for run in runs))) maxidx = zss.argmax() xdata = array((xss, yss)).T model = Gauss2D(pos_x=xss[maxidx], pos_y=yss[maxidx], fwhm_x=0.5 * (xss.max() - xss.min()), fwhm_y=0.5 * (yss.max() - yss.min()), ampl=zss[maxidx]) data = Dataset.from_arrays('2dgauss', xdata, zss, dzss) res = model.fit(data) xx, yy = mgrid[xss.min():xss.max():100j, yss.min():yss.max():100j] mesh = array((xx.ravel(), yy.ravel())).T zmesh = model.fcn(res.paramvalues, mesh).reshape((100, 100)) ax = self.canvas.figure.gca() ax.contour(xx, yy, zmesh) self.fitParLbl.setText('pos_x: %(pos_x).5f pos_y: %(pos_y).5f ' 'theta: %(theta).5f ' 'fwhm_x: %(fwhm_x).5f fwhm_y: %(fwhm_y).5f ' 'ampl: %(ampl).5f' % res.paramvalues)
def evaluate_ephys(chan_fronts, sync_fronts, show_plots=SHOW_PLOTS): """ check number of detected square pulses and temporal jitter """ # check if all signals have been detected L_sync_up = list(flatten(sync_fronts['fpga up fronts'])) L_sync_down = list(flatten(sync_fronts['fpga down fronts'])) assert len(L_sync_up) == 500, 'not all fpga up fronts detected' assert len(L_sync_down) == 500, 'not all fpga down fronts detected' for i in range(len(chan_fronts)): try: L_chan_up = list(flatten(chan_fronts[i]['ephys up fronts'])) L_chan_down = list(flatten(chan_fronts[i]['ephys down fronts'])) assert len(L_chan_up) == 500, \ 'not all ephys up fronts detected' assert len(L_chan_down) == 500, \ 'not all ephys down fronts detected' break except BaseException: continue ups_errors = np.array(L_chan_up) - np.array(L_sync_up) downs_errors = np.array(L_chan_down) - np.array(L_sync_down) MAX = max([max(ups_errors), max(downs_errors)]) if MAX > 20: print('ATTENTION, the maximal error is unusually high, %s sec' % str(MAX / 30000.)) print('ephys test passed') if show_plots: plt.figure('histogram') # pool up front and down front temporal errors Er = [np.array(ups_errors), np.array(downs_errors)] f = np.reshape(Er, 1000) / 30000. plt.hist(f) plt.xlabel('error between fpga fronts and ephys fronts in sec')
def get_gorod_domodedovo(message): global gorod gorod = message.text.upper() if action == prilet and gorod in ', '.join( sorted(set(flatten(list(stat(prilet)['Аэропорт отправления']))))): data = stat(prilet)[stat(prilet)['Аэропорт отправления'] == gorod][[ '№ Рейса' ]].to_dict('records') for element in data: for key, value in element.items(): if value != '': bot.send_message(message.chat.id, '{}: {}'.format(key, value)) dbworker.set_state(message.chat.id, config.States.S_REIS_NUMBER.value) bot.send_message( message.chat.id, 'Теперь введите номер вашего рейса\n' "Или нажмите /reset для отмены поиска") elif action == vilet and gorod in ', '.join( sorted(set(flatten(list(stat(vilet)['Аэропорт назначения']))))): data = stat(vilet)[stat(vilet)['Аэропорт назначения'] == gorod][[ '№ Рейса' ]].to_dict('records') for element in data: for key, value in element.items(): if value != '': bot.send_message(message.chat.id, '{}: {}'.format(key, value)) dbworker.set_state(message.chat.id, config.States.S_REIS_NUMBER.value) bot.send_message( message.chat.id, 'Теперь введите номер вашего рейса\n' "Или нажмите /reset для отмены поиска") elif gorod not in ', '.join( sorted(set(flatten(list(stat(vilet)['Аэропорт назначения'])))) ) or gorod not in ', '.join( sorted(set(flatten(list(stat(prilet)['Аэропорт отправления']))))): bot.send_message( message.chat.id, "Таких рейсов на сегодня не запланировано.") #Дописать условия keyboard = types.InlineKeyboardMarkup() url_button = types.InlineKeyboardButton( text="Посмотреть онлайн табло", url= 'https://www.dme.ru/book/live-board/?searchText=&column=4&sort=1&start=0&end=4440&direction=A&page=1&count=&isSlider=1)' ) keyboard.add(url_button) bot.send_message(message.chat.id, "Предлагаю посмотреть онлайн табло.", reply_markup=keyboard) dbworker.set_state(message.chat.id, config.States.S_AIRPORT.value)
def evaluate_classifier(fname='saved_data.pickle', use_pca=True, null_clf=False, eps=finfo(float).eps, clip=-100): """ Gaussian classifier for non-tuned / autotuned equal-temparement magnitudes """ with open(fname,'rb') as f: data = pickle.load(f) a0 = array([[dd['nontuned_mags'] for dd in d] for d in data[1::2]]) a1 = array([[dd['autotuned_mags'] for dd in d] for d in data[1::2]]) P,TP,FN,FP,TN,PR,RE = [],[],[],[],[],[],[] T0W0,T0W1,T1W0,T1W1 = [],[],[],[] for song in arange(len(a0)): # per-song precision / recall idx = setdiff1d(arange(len(a0)),[song]) train0=dB(array([a for a in flatten(a0[idx])])) train1=dB(array([a for a in flatten(a1[idx])])) test0=dB(array([a for a in flatten(a0[song])])) test1=dB(array([a for a in flatten(a1[song])])) if use_pca: u,s,v = svd(array([train0,train1]).T,0) train0 = u[:,0] train1 = u[:,1] test = array([test0,test1]).T test = dot(dot(test,v.T),diag(1./s)) test0 = test[:,0] test1 = test[:,1] m0,v0 = train0.mean(),train0.var() m1,v1 = train1.mean(),train1.var() P.append(len(test0)) t1w0,t1w1 = log(eval_gauss(test1,m0,v0)+eps), log(eval_gauss(test1,m1,v1)+eps) t0w0,t0w1 = log(eval_gauss(test0,m0,v0)+eps), log(eval_gauss(test0,m1,v1)+eps) if clip!=0: t1w0[t1w0<clip]=clip t1w1[t1w1<clip]=clip t0w0[t0w0<clip]=clip t0w1[t0w1<clip]=clip T0W0.append(t0w0) T0W1.append(t0w1) T1W0.append(t1w0) T1W1.append(t1w1) TP.append(sum(t1w1>t1w0)) FN.append(sum(t1w1<=t1w0)) FP.append(sum(t0w1>t0w0)) TN.append(sum(t0w1<=t0w0)) prec,rec = calc_precrec(t0w0,t0w1,t1w0,t1w1,null_clf) PR.append(prec) RE.append(rec) F = calc_fscore(RE,PR) return {'P':array(P),'TP':array(TP),'FN':array(FN),'FP':array(FP),'TN':array(TN), 'PR':PR,'RE':RE,'F':F, 'T0W0':T0W0,'T0W1':T0W1,'T1W0':T1W0,'T1W1':T1W1}
def handle_returning_base_goals(self, data=None): if data != None: score_sheet = copy.copy(data) else: score_sheet = copy.copy(self.score_sheet) # now = rospy.Time.now() + rospy.Duration(1.0) # self.listener.waitForTransform('/odom_combined', '/base_link', now, rospy.Duration(10)) # (trans, rot) = self.listener.lookupTransform('/odom_combined', '/base_link', now) # odom_B_pr2 = createBMatrix(trans, rot) best_score_cfg = score_sheet[0, 0] best_score_score = score_sheet[0, 1] pr2_base_output = [] configuration_output = [] # The output is a list of floats that are the position and quaternions for the transform from the goal location # to the ar tag. It also outputs a list of floats that is [robot z axis, bed height, head rest angle (degrees)]. for i in xrange(len(best_score_cfg[0])): origin_B_goal = np.matrix([[m.cos(best_score_cfg[2][i]), -m.sin(best_score_cfg[2][i]), 0., best_score_cfg[0][i]], [m.sin(best_score_cfg[2][i]), m.cos(best_score_cfg[2][i]), 0., best_score_cfg[1][i]], [0., 0., 1., 0.], [0., 0., 0., 1.]]) pr2_B_goal = self.origin_B_pr2.I * origin_B_goal goal_B_ar = pr2_B_goal.I * self.pr2_B_ar pos_goal, ori_goal = Bmat_to_pos_quat(goal_B_ar) # odom_B_goal = odom_B_pr2 * self.origin_B_pr2.I * origin_B_goal # pos_goal, ori_goal = Bmat_to_pos_quat(odom_B_goal) pr2_base_output.append([pos_goal[0], pos_goal[1], m.acos(pr2_B_goal[0, 0])]) configuration_output.append([best_score_cfg[3][i], 100*best_score_cfg[4][i], np.degrees(best_score_cfg[5][i])]) ## I no longer return posestamped messages. Now I return a list of floats. # psm = PoseStamped() # psm.header.frame_id = '/odom_combined' # psm.pose.position.x=pos_goal[0] # psm.pose.position.y=pos_goal[1] # psm.pose.position.z=pos_goal[2] # psm.pose.orientation.x=ori_goal[0] # psm.pose.orientation.y=ori_goal[1] # psm.pose.orientation.z=ori_goal[2] # psm.pose.orientation.w=ori_goal[3] # #print 'The quaternion to the goal location #',i,' is: \n',psm # output.append(psm) print 'Base selection service is done and has output a result.' ## Format of output is a list. Output is position [x,y,z] then quaternion [x,y,z,w] for each base location # (could output multiple base locations). So each set of 7 values is for one base location. return list(flatten(pr2_base_output)), list(flatten(configuration_output))
def parse_parameter_arglist(arg_list): """ Parses a list of lists of strings containing individual numbers (e.g., 0 1 4), comma separated lists (e.g., 0, 2, 5), ranges (e.g., 0-3), or combinations thereof, and reduces them to a unique, ordered list of integers. Such a list of parameter values arises naturally from ArgumentParser append, e.g., from ``parser.add_argument("-p", type=str, nargs='+', action='append')``. Args: arg_list (list): List of lists with strings denoting indexes or ranges of indexes. Returns: (list): Sorted, unique list of integers. """ plist = [] for arg in flatten(arg_list): tokens = arg.split(',') for token in tokens: if ('-' in token): # range toks = token.split('-') plist.extend(list(range(int(toks[0]), int(toks[1]) + 1))) elif (token.isspace() or token == ''): # whitespace or empty continue else: # a number plist.extend([int(token)]) plist = np.unique(np.sort(np.array(plist))) return list(plist)
def coverage(paths, xs, weights): """ Computes coverage of map, using xs as features weighted by weights. """ subset = list(set(cbook.flatten(paths))) total = (1 - np.prod(1 - xs[subset], axis=0)).dot(weights) return total
def remove(self): for c in cbook.flatten( self, scalarp=lambda x: isinstance(x, martist.Artist)): c.remove() if self._remove_method: self._remove_method(self)
def is_empty(value): """ Consider `value` as empty if fit following rules:: - is None - is Sized with zero length - is pandas.DataFrame with zero length - is pandas.NaT - is numpy.nan :param value: Any :return: bool """ if isinstance(value, type(None)): return True if isinstance(value, Sized): # this cover also strings return len(value) == 0 or len(list(flatten(value))) == 0 if isinstance(value, pd.DataFrame): return value.empty if isinstance(value, type(pd.NaT)): return True if up.isnan(value): return True return False
def deal_info(url): response = requests.get(url, headers=head, timeout=(2, 2)) html = etree.HTML(response.text) title = html.xpath("//h2[@class='titlebox']/text()")[0].strip() #售车标题 license_time = html.xpath("//*[@class='one']/span/text()")[0] #上牌时间 Kilometre_number = html.xpath("//*[@class='two']/span/text()")[0] #公里数 city = html.xpath("//*[@class='three']/span/text()")[0] #上牌地 displacement = html.xpath("//*[@class='three']/span/text()")[1] #排量 gear_box = html.xpath("//*[@class='last']/span/text()")[0] #变速箱 price = float( html.xpath("//*[@class='pricestype']/text()")[0].replace('¥', '')) * 10000 base_param1 = html.xpath("//*[@class='td1']/text()") base_param2 = html.xpath("//*[@class='td2']/text()") from matplotlib.cbook import flatten base_param = list(flatten(zip(base_param1, base_param2))) param = ','.join(base_param) try: dataframe = pd.DataFrame({ '售车标题': title, '上牌时间': license_time, '公里数': Kilometre_number, '上牌地': city, '排量': displacement, '变速箱': gear_box, '价格': price, '汽车参数': [param] }) dataframe.to_csv("car.csv", index=False, sep=',', mode='a') except Exception as e: print(e)
def gaussian_kernel(*shape): """ Returns a 2D array with gaussian values to be used in the blob_outliers detection function. Can be anisotripic (oblong). Scaling is determined automatically. Parameters ---------- shape : int, int if one integer is passed the kernel will be isotropic if two integers are passed the kernel will be anisotropic Returns ------- array (float) The 2D representation of the kernel """ from matplotlib.cbook import flatten from numpy import exp, mgrid # make shape a list regardless of input shape = [int(a // 2) for a in flatten([shape])] # anisotropic if len(2) else isotropic if len(shape) == 1: sx, sy = shape[0], shape[0] elif len(shape) == 2: sx, sy = shape # create the x and y grid x, y = mgrid[-sx:sx + 1, -sy:sy + 1] sigma = [sx / 8, sy / 8] # sigma scaled by shape c = tuple([sx, sy]) # centre index of x and y g = 1 * exp(-((x - x[c])**2 / (2 * sigma[0])**2 + (y - y[c])**2 / (2 * sigma[1])**2)) return g
def sample_model_bg(modelnames, bgnames, n_ex_per_model, n_ex, rand=0): """ Samples a list of models and backgrounds for building the dataset. The models will be repeated 'n_ex_per_model' times. modelnames: list of model names bgnames: list of background filenames n_ex_per_model: number of examples per model n_ex: total number of examples modellist: list of 'n_ex' models bglist: list of 'n_ex' background names """ # Make model list modellist = [m for m in flatten(zip(*([modelnames] * n_ex_per_model)))] # Make background list rand = tools.init_rand(rand) bgrand = rand.randint(0, n_bg, n_ex) bglist = [bgnames[r] for r in bgrand] # Make category list # Model root directory model_path = os.path.join(gt.RESOURCE_PATH, "objs") # Get the model info that's contained in the scripts sys.path.append(model_path) model_categories = __import__("model_categories").MODEL_CATEGORIES # Assemble category info in dict with {modelname: category, ...} categories = [] for categ, names in model_categories.iteritems(): categories.extend([(name, categ) for name in names]) categorydict = dict(categories) # The actual list categorylist = [categorydict[model] for model in modellist] return modellist, bglist, categorylist
def generate_venn2(nA_list,nB_list,nBoth_list,nameA,nameB_list,layout_line,layout_col): data = [] colors = [] for i in range(len(nB_list)): tuple_ = (nA_list[i],nB_list[i],nBoth_list[i]) data.append(tuple_) max_area = max(map(sum, data)) colors=["green","green","green","green","red","red","red","red","red"] figure, axes = plt.subplots(layout_line, layout_col, figsize=(30,30)) #figure, axes = plt.subplots(len(nB_list), 1, figsize=(12,12)) #plt.subplots_adjust(left=0.1, bottom=0.1, right=0.9, top=0.9, wspace=0.01, hspace=0.01) line = 0 column = 0 for i in range(len(nB_list)): v = venn2(subsets=data[i], set_labels = (nameA.split("/")[-1][:20], nameB_list[i].split("/")[-1][:20]), ax=axes[line][column]) # v = venn2(subsets=data[i], ax=axes[line][column]) v.get_patch_by_id('100').set_color('lime') v.get_patch_by_id('010').set_color(colors[i]) #plt.title(nameA+" vs "+nameB_list[i].split("/")[-1]) column += 1 print line,column if column == layout_col: line += 1 column = 0 for a, d in zip(flatten(axes), data): set_venn_scale(a, sum(d),max_area) #plt.show() plt.savefig("venn2.png")
def create_time_slots(day): src_slots = dcal.get_working_times(day) slots = [0, src_slots, 24 * 60] slots = tuple(cbook.flatten(slots)) slots = zip(slots[:-1], slots[1:]) #balance non working slots work_time = slot_sum(src_slots) non_work_time = sum_time - work_time non_slots = filter(lambda s: s not in src_slots, slots) non_slots = map(lambda s: (s[1] - s[0], s), non_slots) non_slots.sort() slots = [] i = 0 for l, s in non_slots: delta = non_work_time / (len(non_slots) - i) delta = min(l, delta) non_work_time -= delta slots.append((s[0], s[0] + delta)) i += 1 slots.extend(src_slots) slots.sort() return slots
def create_time_slots(day): src_slots = dcal.get_working_times(day) slots = [0, src_slots, 24*60] slots = tuple(cbook.flatten(slots)) slots = zip(slots[:-1], slots[1:]) #balance non working slots work_time = slot_sum(src_slots) non_work_time = sum_time - work_time non_slots = filter(lambda s: s not in src_slots, slots) non_slots = map(lambda s: (s[1] - s[0], s), non_slots) non_slots.sort() slots = [] i = 0 for l, s in non_slots: delta = non_work_time / (len(non_slots) - i) delta = min(l, delta) non_work_time -= delta slots.append((s[0], s[0] + delta)) i += 1 slots.extend(src_slots) slots.sort() return slots
def annotations(self): from decimal import Decimal # for formatting tex_key = { 'tkin': 'T_K', 'tex': 'T_{ex}', 'ntot': 'N', 'fortho': 'F_o', 'width': '\\sigma', 'xoff_v': 'v', 'fillingfraction': 'FF', 'tau': '\\tau_{1-1}', 'background_tb': 'T_{BG}' } # small hack below: don't quantize if error > value. We want to see the values. label_list = [] for pinfo in self.parinfo: parname = tex_key[pinfo['parname'].strip("0123456789").lower()] parnum = int(pinfo['parname'][-1]) if pinfo['fixed']: formatted_value = "%s" % pinfo['value'] pm = "" formatted_error = "" else: formatted_value = Decimal("%g" % pinfo['value']).quantize( Decimal("%0.2g" % (min(pinfo['error'], pinfo['value'])))) pm = "$\\pm$" formatted_error = Decimal("%g" % pinfo['error']).quantize( Decimal("%0.2g" % pinfo['error'])) label = "$%s(%i)$=%8s %s %8s" % (parname, parnum, formatted_value, pm, formatted_error) label_list.append(label) labels = tuple(mpcb.flatten(label_list)) return labels
def annotations(self, shortvarnames=None, debug=False): """ Return a list of TeX-formatted labels The values and errors are formatted so that only the significant digits are displayed. Rounding is performed using the decimal package. Parameters ---------- shortvarnames : list A list of variable names (tex is allowed) to include in the annotations. Defaults to self.shortvarnames Examples -------- >>> # Annotate a Gaussian >>> sp.specfit.annotate(shortvarnames=['A','\\Delta x','\\sigma']) """ from decimal import Decimal # for formatting svn = self.shortvarnames if shortvarnames is None else shortvarnames # if pars need to be replicated.... if len(svn) < self.npeaks * self.npars: svn = svn * self.npeaks parvals = self.parinfo.values parerrs = self.parinfo.errors loop_list = [ ( parvals[ii + jj * self.npars + self.vheight], parerrs[ii + jj * self.npars + self.vheight], svn[ii + jj * self.npars], self.parinfo.fixed[ii + jj * self.npars + self.vheight], jj, ) for jj in range(self.npeaks) for ii in range(self.npars) ] label_list = [] for (value, error, varname, fixed, varnumber) in loop_list: log.debug(", ".join([str(x) for x in (value, error, varname, fixed, varnumber)])) if fixed or error == 0: label = "$%s(%i)$=%8s" % ( varname, varnumber, Decimal("%g" % value).quantize(Decimal("%0.6g" % (value))), ) else: label = "$%s(%i)$=%8s $\\pm$ %8s" % ( varname, varnumber, Decimal("%g" % value).quantize(Decimal("%0.2g" % (min(np.abs([value, error]))))), Decimal("%g" % error).quantize(Decimal("%0.2g" % (error))), ) label_list.append(label) labels = tuple(mpcb.flatten(label_list)) return labels
def legend(self, *args, **kwargs): if len(args)==0: all_handles = _get_handles(self) for ax in self.parasites: all_handles.extend(_get_handles(ax)) handles = [] labels = [] for handle in all_handles: label = handle.get_label() if (label is not None and label != '' and not label.startswith('_')): handles.append(handle) labels.append(label) if len(handles) == 0: warnings.warn("No labeled objects found. " "Use label='...' kwarg on individual plots.") return None elif len(args)==1: labels = args[0] handles = [h for h, label in zip(all_handles, labels)] elif len(args)==2: if is_string_like(args[1]) or isinstance(args[1], int): labels, loc = args handles = [h for h, label in zip(all_handles, labels)] kwargs['loc'] = loc else: handles, labels = args elif len(args)==3: handles, labels, loc = args kwargs['loc'] = loc else: raise TypeError('Invalid arguments to legend') handles = cbook.flatten(handles) self.legend_ = mlegend.Legend(self, handles, labels, **kwargs) return self.legend_
def subplot2(): #子图相关设置 figure, axes = plt.subplots(3, 3, figsize=(18.5,10.5)) figure.suptitle('species distribution in bgi100 and mgi200') # print(axes) path = r'F:\BGI100_MGI200\BGI100_MGI200.data\1210species_vn.txt' df = pd.read_table(path) cols=df.columns.tolist() data = [tuple(df[col])[:-1] for col in cols[1:]] max_area = max(map(sum, data)) # 根据数据设置子图大小 def set_venn_scale(vd, ax, true_area, reference_area=max_area): sx = np.sqrt(float(reference_area)/true_area) sy = max(vd.radii)*1.5 ax.set_xlim(-sx, sx) ax.set_ylim(-sy, sy) for a,d,col_name in zip(flatten(axes), data,cols[1:]): vd = venn3(subsets = d, set_labels = ('bgi100', 'mgi200(1)','mgi200(2)'), ax=a) a.set_title(col_name) # set_venn_scale(vd, a, sum(d)) figure.tight_layout(pad=0.1) plt.show()
def generate_features(self, depth, subsample_n): NA_VAL=-100 if depth<1: return for relation in random.choice(self.relations.keys(), subsample_n, True): new_obs_for_rel= apply_transforms(self.relations, [relation], self.entities) for ob in frozenset(flatten(new_obs_for_rel)): self.new_features.append(lambda x, rel=relation, t=ob: 1 if is_in_relation(x, self.relations[rel], rel, t) else NA_VAL if len(is_in_relation(x, self.relations[rel], rel))==0 else 0 ) self.new_justify.append('is in relation %s with %s'%(relation, ob)) if depth==2: for relation2 in random.choice(self.relations.keys(), 1): newer_obs= apply_transforms(self.relations, [relation2], new_obs_for_rel) for ob in frozenset(flatten(newer_obs)): self.new_features.append(lambda x, trans=[relation,relation2], t=ob: 1 if t in apply_transforms(self.relations, trans, [x])[0] else NA_VAL if len(apply_transforms(self.relations, trans, [x])[0])==0 else 0) self.new_justify.append('is in relations %s,%s with %s'%(relation, relation2, ob)) pass #if depth=1, go one relation. if depth=2 go 2 relations and so on...
def facet_plot(dframe, facets, props, ydata, layout=None, newfig=True, figsize=None, legend=True, individual_legends=False, hide_additional_axes=True, zorder='default', **kwargs): if newfig: nr_facets = len(dframe.groupby(facets)) if layout is None: for i in range(2, nr_facets // 2): if nr_facets % i == 0: layout = (nr_facets // i, i) break if layout is None: n = int(np.ceil(nr_facets / 2)) layout = (n, 2) fig, axs = plt.subplots( nrows=layout[0], ncols=layout[1], sharex=True, sharey=True, figsize=figsize ) if hide_additional_axes: for ax in fig.axes[nr_facets:]: ax.set_axis_off() else: fig = plt.gcf() axs = fig.axes cycl = cycle(plt.rcParams['axes.prop_cycle']) prop_styles = {ps: next(cycl) for ps, _ in dframe.groupby(props)} if zorder is 'default': dz = 1 zorder = 0 elif zorder is 'reverse': dz = -1 zorder = 0 else: dz = 0 if legend: ax0 = fig.add_subplot(111, frame_on=False, zorder=-9999) ax0.set_axis_off() plot_kwargs = kwargs.copy() for k in ['logx', 'logy', 'loglog']: plot_kwargs.pop(k, None) for l, p in prop_styles.items(): ax0.plot([], label=str(l), **p, **plot_kwargs) ax0.legend(loc='center left', bbox_to_anchor=(1, 0.5), fontsize='x-small') for ax, (ps, df) in zip(flatten(axs), dframe.groupby(facets, squeeze=False)): for prop, df_prop in df.groupby(props): df_prop[ydata].plot(ax=ax, label=str(prop), zorder=zorder, **prop_styles[prop], **kwargs) zorder += dz # ax.title(0.5, 0.1, '{},{}'.format(*ps), transform=ax.transAxes, fontsize='small') ax.set_title('; '.join([str(x) for x in ps]) if isinstance(ps, tuple) else str(ps), fontsize='x-small') if individual_legends: ax.legend(fontsize='x-small') plt.sca(ax) rect = (0, 0, 0.85, 1) if legend else (0, 0, 1, 1) plt.tight_layout(rect=rect, pad=0.1) return fig, axs
def annotations(self): label_list = [( "$A(%i)$=%6.4g $\\pm$ %6.4g" % (jj,self.mpp[0+jj*self.npars],self.mpperr[0+jj*self.npars]), "$x(%i)$=%6.4g $\\pm$ %6.4g" % (jj,self.mpp[1+jj*self.npars],self.mpperr[1+jj*self.npars]), "$\\sigma(%i)$=%6.4g $\\pm$ %6.4g" % (jj,self.mpp[2+jj*self.npars],self.mpperr[2+jj*self.npars]) ) for jj in range(self.npeaks)] labels = tuple(mpcb.flatten(label_list)) return labels
def find_tagging(top_node, train_point): #finds tagging without the query func... if type(top_node.justify)==str and (top_node.justify.startswith('leafed') or top_node.justify.startswith('no')): return top_node.chosen_tag if train_point==[]: return find_tagging(top_node.left_son if []==top_node.left_son.objects[-1] else top_node.right_son, train_point) if train_point in list(flatten(top_node.left_son.objects)): return find_tagging(top_node.left_son, train_point) return find_tagging(top_node.right_son, train_point)
def linear_labels(nestedlabels): def reclabels(labels): lsh = utils.list_shape(labels) if len(lsh) == 1 or len(lsh) == 0: return labels # list of strings first,rest = labels[0], labels[1:] return [[x] + reclabels(rest) for x in first] nested = reclabels(nestedlabels) return list(flatten(nested))
def plot_evaluation(stats, N=10.): figure() PR = array(zip(flatten(stats['RE']),flatten(stats['PR']))) PR[:,0] = fix(PR[:,0]*N)/float(N) # divide recall into deciles precrec = [] for re in unique(PR[:,0]): p = PR[:,1][where(PR[:,0]==re)] precrec.append((re,p.mean(),p.std()/sqrt(len(p)))) errorbar(x=re,y=p.mean(),yerr=p.std()/sqrt(len(p)),color='b') plot(re,p.mean(),'bx') precrec=array(precrec) plot(precrec[:,0],precrec[:,1],'b--') axis([-0.05,1.05,0,1.05]) grid() title('ROC autotuned/non-tuned classifier',fontsize=20) xlabel('Recall (standardized deciles)', fontsize=16) ylabel('Precision', fontsize=16) text(.85,.95,'F1=%.2f'%stats['F'],fontsize=16) return precrec
def plot_evaluation(stats, N=10.): figure() PR = array(zip(flatten(stats['RE']), flatten(stats['PR']))) PR[:, 0] = fix(PR[:, 0] * N) / float(N) # divide recall into deciles precrec = [] for re in unique(PR[:, 0]): p = PR[:, 1][where(PR[:, 0] == re)] precrec.append((re, p.mean(), p.std() / sqrt(len(p)))) errorbar(x=re, y=p.mean(), yerr=p.std() / sqrt(len(p)), color='b') plot(re, p.mean(), 'bx') precrec = array(precrec) plot(precrec[:, 0], precrec[:, 1], 'b--') axis([-0.05, 1.05, 0, 1.05]) grid() title('ROC autotuned/non-tuned classifier', fontsize=20) xlabel('Recall (standardized deciles)', fontsize=16) ylabel('Precision', fontsize=16) text(.85, .95, 'F1=%.2f' % stats['F'], fontsize=16) return precrec
def __init__(self, _haars, _norm=True): """ Initialize an HaarLikeDescriptors object. :param _haars: list a list of feature descriptors. A feature descriptor is a list of points (row, column) in a normalized coordinate system ((0,0) -> (1,1)) describing the "positive" (black) patches from a Haar-like feature. All the patches not specified in this list are considered "negative" (white). The value corresponding to such a feature is the (weighted) sum of pixel intensities covered by "positive" patches from which the (weighted) sum of pixel intensities covered by "negative" patches is subtracted. See some examples at: - http://www.codeproject.com/Articles/27125/Ultra-Rapid-Object-Detection-in-Computer-Vision-Ap - http://en.wikipedia.org/wiki/Haar-like_features Examples of Haar-like features coding: - a Haar-like feature in which the left side is "positive" (*) and the right side "negative" (.): +-------+-------+ |*******|.......| |*******|.......| |*******|.......| |*******|.......| |*******|.......| |*******|.......| +-------+-------+ The corresponding coding is: [[(0.0, 0.0), (0.5, 1.0)]]. - a Haar-like feature with diagonal "positive" (*) patches: +-------+-------+ |*******|.......| |*******|.......| |*******|.......| +-------+-------+ |.......|*******| |.......|*******| |.......|*******| +-------+-------+ The corresponding coding is: [[(0.0, 0.0), (0.5, 0.5)], [(0.5, 0.5), (1.0, 1.0)]]. :param _norm: boolean Should the features be normalized? (scale-independent?) Default: True """ self.haars = _haars self.nfeats = len(_haars) self.norm = _norm # Check that all coordinates are between 0 and 1: if any([_p < 0.0 or _p > 1.0 for _p in flatten(_haars)]): raise ValueError("Improper Haar feature specification.") return
def annotations(self, shortvarnames=None, debug=False): """ Return a list of TeX-formatted labels The values and errors are formatted so that only the significant digits are displayed. Rounding is performed using the decimal package. Parameters ---------- shortvarnames : list A list of variable names (tex is allowed) to include in the annotations. Defaults to self.shortvarnames Examples -------- >>> # Annotate a Gaussian >>> sp.specfit.annotate(shortvarnames=['A','\\Delta x','\\sigma']) """ from decimal import Decimal # for formatting svn = self.shortvarnames if shortvarnames is None else shortvarnames # if pars need to be replicated.... if len(svn) < self.npeaks * self.npars: svn = svn * self.npeaks parvals = self.parinfo.values parerrs = self.parinfo.errors loop_list = [ (parvals[ii + jj * self.npars + self.vheight], parerrs[ii + jj * self.npars + self.vheight], svn[ii + jj * self.npars], self.parinfo.fixed[ii + jj * self.npars + self.vheight], jj) for jj in range(self.npeaks) for ii in range(self.npars) ] label_list = [] for (value, error, varname, fixed, varnumber) in loop_list: log.debug(", ".join( [str(x) for x in (value, error, varname, fixed, varnumber)])) if fixed or error == 0: label = ("$%s(%i)$=%8s" % (varname, varnumber, Decimal("%g" % value).quantize( Decimal("%0.6g" % (value))))) else: label = ("$%s(%i)$=%8s $\\pm$ %8s" % ( varname, varnumber, Decimal("%g" % value).quantize( Decimal("%0.2g" % (min(np.abs([value, error]))))), Decimal("%g" % error).quantize(Decimal("%0.2g" % (error))), )) label_list.append(label) labels = tuple(mpcb.flatten(label_list)) return labels
def annotations(self): label_list = [ ( "$T_K(%i)$=%6.4g $\\pm$ %6.4g" % (jj,self.mpp[0+jj*self.npars],self.mpperr[0+jj*self.npars]), "$T_{ex}(%i)$=%6.4g $\\pm$ %6.4g" % (jj,self.mpp[1+jj*self.npars],self.mpperr[1+jj*self.npars]), "$N$(%i)=%6.4g $\\pm$ %6.4g" % (jj,self.mpp[2+jj*self.npars],self.mpperr[2+jj*self.npars]), "$\\sigma(%i)$=%6.4g $\\pm$ %6.4g" % (jj,self.mpp[3+jj*self.npars],self.mpperr[3+jj*self.npars]), "$v(%i)$=%6.4g $\\pm$ %6.4g" % (jj,self.mpp[4+jj*self.npars],self.mpperr[4+jj*self.npars]), "$F_o(%i)$=%6.4g $\\pm$ %6.4g" % (jj,self.mpp[5+jj*self.npars],self.mpperr[5+jj*self.npars]) ) for jj in range(self.npeaks)] labels = tuple(mpcb.flatten(label_list)) return labels
def enter_reis_num_domodedovo(message): global reis spisok_reisov = [] reis = message.text bot.send_message(message.chat.id, 'Спасибо. Сейчас я обработаю вашу информацию') x = stat(action)['№ Рейса'] if reis in (sorted(list(flatten(list(x))))): for_sending = stat(action)[x == reis] py = for_sending.to_dict('records')[0] for key, value in py.items(): if value != '': bot.send_message(message.chat.id, '{}: {}'.format(key, value)) dbworker.set_state(message.chat.id, config.States.S_AIRPORT.value) else: for i in (sorted(set(flatten(list(x))))): if i.startswith(reis.split()[0]): spisok_reisov.append(i) if spisok_reisov != []: name = air(reis.split()[0]) bot.send_message( message.chat.id, 'Номер рейса ввёден неверно.\n' 'Вероятно Вы искали что-то из рейсов авиакомпании {}: {}'. format(name, ' '.join(spisok_reisov))) else: bot.send_message(message.chat.id, 'К сожалению указанного рейса не существует') if action == prilet: bot.send_message( message.chat.id, 'Введите название города откуда должен вылететь самолёт по вашему рейсу. Например: Ларнака' ) dbworker.set_state(message.chat.id, config.States.S_GOROD.value) elif action == vilet: bot.send_message( message.chat.id, 'Введите название города, в который ожидается выполнение рейса. Например: Сочи' ) dbworker.set_state(message.chat.id, config.States.S_GOROD.value)
def load_data_parallel(directory, do_fit2D = False, do_filtering=False): import os, re dirs = [os.path.join(directory,dr) for dr in os.listdir(directory) if re.match(r'[-+]?[0-9.]+ms',dr)] #from operator import concat #from functools import reduce res = lview.map(imp.single_directory_load, dirs ,[do_fit2D]*len(dirs), [do_filtering]*len(dirs)) res.wait_interactive() all_data = list(flatten(res.result)) # print outputs in each kernel print(''.join([x['stdout'] for x in res.metadata])) print('Total number of images: ', len(all_data)) return all_data
def warp_slow_to_fast(self, data): interpolated_data = [] for i in xrange(len(data)-1): interpolated_data.append(data[i]) interpolated_data.append(data[i] + 0.5*(data[i+1]-data[i])) interpolated_data.append(data[len(data)-1]) interpolated_data = np.array(interpolated_data) warped_data = [] for i in xrange(len(interpolated_data)): if i%3 == 0: warped_data.append(list(flatten([interpolated_data[i, 0]/1.5,interpolated_data[i,1:]]))) return np.array(warped_data)
def split(self, X, y=None, groups=None): X = np.array(X) partition = 2 * self.n_splits #ensure partition is smaller than the input split length if X.shape[0] < partition: partition = X.shape[0] partial_X_row = np.array_split(range(X.shape[0]), partition, axis=0) for ii in range(self.n_splits, partition): if self.fix_window: train_index = list( flatten( map(lambda x: partial_X_row[x], range(ii - self.n_splits, ii)))) else: train_index = list( flatten(map(lambda x: partial_X_row[x], range(ii)))) test_index = partial_X_row[ii] yield np.array(train_index, dtype=np.int64), np.array(test_index, dtype=np.int64)
def get_isi_stats(spikes,epoch,FS=1000,BURST_CUTOFF_MS=10,MIN_NISI=100): ''' Computes a statistical summary of an ISI distribution. Accepts a list of lists of spike times return burstiness, ISI_cv, mean_rate, KS, mode, burst_free_ISI_cv, burst_free_mean_rate, burst_free_mode ''' event,start,stop = epoch duration = (stop-start)/float(FS) ISI_events = list(flatten(map(diff,spikes))) allisi = np.array(ISI_events) if len(ISI_events)<MIN_NISI: return None mode = FS/modefind(allisi) mean_rate = (sum(map(len,spikes))) / float(len(spikes)) / duration ISI_cv = np.std(allisi)/np.mean(allisi) KS = poisson_KS(allisi) burstiness = sum(allisi<BURST_CUTOFF_MS)/float(len(allisi))*100 burst_free_spikes = remove_bursts(spikes, duration=BURST_CUTOFF_MS) burst_free_ISI_events = list(flatten(map(diff,burst_free_spikes))) burst_free_allisi = np.array(burst_free_ISI_events) burst_free_mode = FS/modefind(burst_free_allisi) burst_free_mean_rate = (sum(map(len,burst_free_spikes))) / float(len(burst_free_spikes)) / duration burst_free_ISI_cv = np.std(burst_free_allisi)/np.mean(burst_free_allisi) return burstiness, ISI_cv, mean_rate, KS, mode, burst_free_ISI_cv, burst_free_mean_rate, burst_free_mode
def findChildrenWithAtlasTerms(name,fullhierarchy): atlasterms=[] #print 'checking',name if fullhierarchy[name].has_key('children'): for child in fullhierarchy[name]['children']: if fullhierarchy[child].has_key('atlasterm'): atlasterms.append(fullhierarchy[child]['atlasterm']) #print 'found',atlasterms else: #print 'drilling down:',child at=findChildrenWithAtlasTerms(child,fullhierarchy) atlasterms.append(at) return list(flatten(atlasterms))
def greedy(paths, path, candidates, xs, weights): """ Greedily choose the candidate with max coverage relative to map+path, and add to path. Uses xs as features with the given weights. """ maxCoverage = -float('inf') #note that if weights are negative, we can have negative coverage! if len(candidates) == 0: return totalMap = list(set(cbook.flatten(paths))) + path for p in candidates: c = coverage(totalMap + [p], xs, weights) if c > maxCoverage: maxCoverage = c maxP = p path.append(maxP)
def create_test_data(): filename = "production/test/test_data.fits" datacube = np.arange(120).reshape(4,5,6) key_bases = ['naxis', 'ctype', 'crval', 'cdelt', 'crpix'] keys = list(flatten([[x+'1', x+'2', x+'3'] for x in key_bases])) header = Header.fromkeys(keys) header['ctype1'] = 'VELO-LSR' header['ctype2'] = 'GLON-CAR' header['ctype3'] = 'GLAT-CAR' writeto(open(filename, 'wb'), datacube, header=header)
def get_spikes_session_filtered_by_epoch(session,area,unit,epoch): ''' spike times from session. spike times outside of trials, from bad trials, and outside of epoch on good trials, are removed ''' allspikes = [] event,est,esp = epoch for tr in cgid.data_loader.get_good_trials(session): t = cgid.data_loader.get_trial_event(session,area,tr,4) te = cgid.data_loader.get_trial_event(session,area,tr,event) start = t+te+est stop = t+te+esp sp = get_spikes_session_time(session,area,unit,start,stop) allspikes.append(sp) return np.array(list(flatten(allspikes)),dtype=int32)
def get_new_table(self, test, test_ents, depth): all_words=set() for words in self.objects: all_words.update(words) new_features = list(flatten([self.new_features[i] for i in self.new_features.keys() if i<=depth])) self.table= zeros((len(self.objects), len(all_words)+len(new_features))) self.test= zeros((len(test), len(all_words)+len(new_features))) self.feature_names=[] for i,word in enumerate(all_words): self.table[:,i]= array([1 if (word in obj) else 0 for obj in self.objects]) self.test[:, i]= array([1 if (word in obj) else 0 for obj in test]) self.feature_names.append('has word:%s'%(word)) for j,new_feature in enumerate(new_features): self.table[:, len(all_words)+j]= array([new_feature(ent) for ent in self.entities]) self.test[:, len(all_words)+j]= array([new_feature(ent) for ent in test_ents]) return self.table, self.tagging, self.test, len(new_features)
def OPA_dictionary(self): OPAc = [] for o in self.hws: if o.type == 'Curve': OPAc.append(o) elif o.type == 'OPA': OPAc.append(o.curve) else: OPAc.append(None) color_dics = [] for i in range(len(self.hws)): if OPAc[i]: color_dics.append(dict()) colors = set(flatten(self.grid[:,:,hardwares.index(self.hws[i])])) for color in colors: color_dics[-1][color] = m_pos(OPAc[i],color) else: color_dics.append(None) self.cd = color_dics