repo_name
stringlengths
6
112
path
stringlengths
4
204
copies
stringlengths
1
3
size
stringlengths
4
6
content
stringlengths
714
810k
license
stringclasses
15 values
mhue/scikit-learn
doc/conf.py
210
8446
# -*- coding: utf-8 -*- # # scikit-learn documentation build configuration file, created by # sphinx-quickstart on Fri Jan 8 09:13:42 2010. # # This file is execfile()d with the current directory set to its containing # dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. from __future__ import print_function import sys import os from sklearn.externals.six import u # If extensions (or modules to document with autodoc) are in another # directory, add these directories to sys.path here. If the directory # is relative to the documentation root, use os.path.abspath to make it # absolute, like shown here. sys.path.insert(0, os.path.abspath('sphinxext')) from github_link import make_linkcode_resolve # -- General configuration --------------------------------------------------- # Try to override the matplotlib configuration as early as possible try: import gen_rst except: pass # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom ones. extensions = ['gen_rst', 'sphinx.ext.autodoc', 'sphinx.ext.autosummary', 'sphinx.ext.pngmath', 'numpy_ext.numpydoc', 'sphinx.ext.linkcode', ] autosummary_generate = True autodoc_default_flags = ['members', 'inherited-members'] # Add any paths that contain templates here, relative to this directory. templates_path = ['templates'] # generate autosummary even if no references autosummary_generate = True # The suffix of source filenames. source_suffix = '.rst' # The encoding of source files. #source_encoding = 'utf-8' # Generate the plots for the gallery plot_gallery = True # The master toctree document. master_doc = 'index' # General information about the project. project = u('scikit-learn') copyright = u('2010 - 2014, scikit-learn developers (BSD License)') # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # The short X.Y version. import sklearn version = sklearn.__version__ # The full version, including alpha/beta/rc tags. release = sklearn.__version__ # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. #language = None # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: #today = '' # Else, today_fmt is used as the format for a strftime call. #today_fmt = '%B %d, %Y' # List of documents that shouldn't be included in the build. #unused_docs = [] # List of directories, relative to source directory, that shouldn't be # searched for source files. exclude_trees = ['_build', 'templates', 'includes'] # The reST default role (used for this markup: `text`) to use for all # documents. #default_role = None # If true, '()' will be appended to :func: etc. cross-reference text. add_function_parentheses = False # If true, the current module name will be prepended to all description # unit titles (such as .. function::). #add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. #show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' # A list of ignored prefixes for module index sorting. #modindex_common_prefix = [] # -- Options for HTML output ------------------------------------------------- # The theme to use for HTML and HTML Help pages. Major themes that come with # Sphinx are currently 'default' and 'sphinxdoc'. html_theme = 'scikit-learn' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. html_theme_options = {'oldversion': False, 'collapsiblesidebar': True, 'google_analytics': True, 'surveybanner': False, 'sprintbanner': True} # Add any paths that contain custom themes here, relative to this directory. html_theme_path = ['themes'] # The name for this set of Sphinx documents. If None, it defaults to # "<project> v<release> documentation". #html_title = None # A shorter title for the navigation bar. Default is the same as html_title. html_short_title = 'scikit-learn' # The name of an image file (relative to this directory) to place at the top # of the sidebar. html_logo = 'logos/scikit-learn-logo-small.png' # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. html_favicon = 'logos/favicon.ico' # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ['images'] # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. #html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. #html_use_smartypants = True # Custom sidebar templates, maps document names to template names. #html_sidebars = {} # Additional templates that should be rendered to pages, maps page names to # template names. #html_additional_pages = {} # If false, no module index is generated. html_domain_indices = False # If false, no index is generated. html_use_index = False # If true, the index is split into individual pages for each letter. #html_split_index = False # If true, links to the reST sources are added to the pages. #html_show_sourcelink = True # If true, an OpenSearch description file will be output, and all pages will # contain a <link> tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. #html_use_opensearch = '' # If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml"). #html_file_suffix = '' # Output file base name for HTML help builder. htmlhelp_basename = 'scikit-learndoc' # -- Options for LaTeX output ------------------------------------------------ # The paper size ('letter' or 'a4'). #latex_paper_size = 'letter' # The font size ('10pt', '11pt' or '12pt'). #latex_font_size = '10pt' # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, documentclass # [howto/manual]). latex_documents = [('index', 'user_guide.tex', u('scikit-learn user guide'), u('scikit-learn developers'), 'manual'), ] # The name of an image file (relative to this directory) to place at the top of # the title page. latex_logo = "logos/scikit-learn-logo.png" # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. #latex_use_parts = False # Additional stuff for the LaTeX preamble. latex_preamble = r""" \usepackage{amsmath}\usepackage{amsfonts}\usepackage{bm}\usepackage{morefloats} \usepackage{enumitem} \setlistdepth{10} """ # Documents to append as an appendix to all manuals. #latex_appendices = [] # If false, no module index is generated. latex_domain_indices = False trim_doctests_flags = True def generate_example_rst(app, what, name, obj, options, lines): # generate empty examples files, so that we don't get # inclusion errors if there are no examples for a class / module examples_path = os.path.join(app.srcdir, "modules", "generated", "%s.examples" % name) if not os.path.exists(examples_path): # touch file open(examples_path, 'w').close() def setup(app): # to hide/show the prompt in code examples: app.add_javascript('js/copybutton.js') app.connect('autodoc-process-docstring', generate_example_rst) # The following is used by sphinx.ext.linkcode to provide links to github linkcode_resolve = make_linkcode_resolve('sklearn', u'https://github.com/scikit-learn/' 'scikit-learn/blob/{revision}/' '{package}/{path}#L{lineno}')
bsd-3-clause
chasquiwan/CoCoPy
modules/experiment/backend/backend.py
2
1504
#!/usr/bin/python # -*- coding: utf-8 -*- ################################################################################ # # CoCoPy - A python toolkit for rotational spectroscopy # # Copyright (c) 2013 by David Schmitz ([email protected]). # # Permission is hereby granted, free of charge, to any person obtaining a copy of # this software and associated documentation files (the “Software”), to deal in the # Software without restriction, including without limitation the rights to use, # copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the # Software, and to permit persons to whom the Software is furnished to do so, # subject to the following conditions: # # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, # INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A # PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT # HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN # ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH # THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # # MIT Licence (http://mit-license.org/) # ################################################################################ import numpy as np import matplotlib.pyplot as plt
mit
jmontoyam/mne-python
mne/viz/topomap.py
3
88971
"""Functions to plot M/EEG data e.g. topographies """ from __future__ import print_function # Authors: Alexandre Gramfort <[email protected]> # Denis Engemann <[email protected]> # Martin Luessi <[email protected]> # Eric Larson <[email protected]> # # License: Simplified BSD import math import copy from functools import partial import numpy as np from scipy import linalg from ..baseline import rescale from ..io.constants import FIFF from ..io.pick import (pick_types, _picks_by_type, channel_type, pick_info, _pick_data_channels) from ..utils import _clean_names, _time_mask, verbose, logger, warn from .utils import (tight_layout, _setup_vmin_vmax, _prepare_trellis, _check_delayed_ssp, _draw_proj_checkbox, figure_nobar, plt_show, _process_times, DraggableColorbar, _validate_if_list_of_axes) from ..time_frequency import psd_multitaper from ..defaults import _handle_default from ..channels.layout import _find_topomap_coords from ..io.meas_info import Info def _prepare_topo_plot(inst, ch_type, layout): """"Aux Function""" info = copy.deepcopy(inst if isinstance(inst, Info) else inst.info) if layout is None and ch_type is not 'eeg': from ..channels import find_layout layout = find_layout(info) elif layout == 'auto': layout = None clean_ch_names = _clean_names(info['ch_names']) for ii, this_ch in enumerate(info['chs']): this_ch['ch_name'] = clean_ch_names[ii] info._update_redundant() info._check_consistency() # special case for merging grad channels if (ch_type == 'grad' and FIFF.FIFFV_COIL_VV_PLANAR_T1 in np.unique([ch['coil_type'] for ch in info['chs']])): from ..channels.layout import _pair_grad_sensors picks, pos = _pair_grad_sensors(info, layout) merge_grads = True else: merge_grads = False if ch_type == 'eeg': picks = pick_types(info, meg=False, eeg=True, ref_meg=False, exclude='bads') else: picks = pick_types(info, meg=ch_type, ref_meg=False, exclude='bads') if len(picks) == 0: raise ValueError("No channels of type %r" % ch_type) if layout is None: pos = _find_topomap_coords(info, picks) else: names = [n.upper() for n in layout.names] pos = list() for pick in picks: this_name = info['ch_names'][pick].upper() if this_name in names: pos.append(layout.pos[names.index(this_name)]) else: warn('Failed to locate %s channel positions from layout. ' 'Inferring channel positions from data.' % ch_type) pos = _find_topomap_coords(info, picks) break ch_names = [info['ch_names'][k] for k in picks] if merge_grads: # change names so that vectorview combined grads appear as MEG014x # instead of MEG0142 or MEG0143 which are the 2 planar grads. ch_names = [ch_names[k][:-1] + 'x' for k in range(0, len(ch_names), 2)] pos = np.array(pos)[:, :2] # 2D plot, otherwise interpolation bugs return picks, pos, merge_grads, ch_names, ch_type def _plot_update_evoked_topomap(params, bools): """ Helper to update topomaps """ projs = [proj for ii, proj in enumerate(params['projs']) if ii in np.where(bools)[0]] params['proj_bools'] = bools new_evoked = params['evoked'].copy() new_evoked.info['projs'] = [] new_evoked.add_proj(projs) new_evoked.apply_proj() data = new_evoked.data[np.ix_(params['picks'], params['time_idx'])] * params['scale'] if params['merge_grads']: from ..channels.layout import _merge_grad_data data = _merge_grad_data(data) image_mask = params['image_mask'] pos_x, pos_y = np.asarray(params['pos'])[:, :2].T xi = np.linspace(pos_x.min(), pos_x.max(), params['res']) yi = np.linspace(pos_y.min(), pos_y.max(), params['res']) Xi, Yi = np.meshgrid(xi, yi) for ii, im in enumerate(params['images']): Zi = _griddata(pos_x, pos_y, data[:, ii], Xi, Yi) Zi[~image_mask] = np.nan im.set_data(Zi) for cont in params['contours']: cont.set_array(np.c_[Xi, Yi, Zi]) params['fig'].canvas.draw() def plot_projs_topomap(projs, layout=None, cmap=None, sensors=True, colorbar=False, res=64, size=1, show=True, outlines='head', contours=6, image_interp='bilinear', axes=None): """Plot topographic maps of SSP projections Parameters ---------- projs : list of Projection The projections layout : None | Layout | list of Layout Layout instance specifying sensor positions (does not need to be specified for Neuromag data). Or a list of Layout if projections are from different sensor types. cmap : matplotlib colormap | (colormap, bool) | 'interactive' | None Colormap to use. If tuple, the first value indicates the colormap to use and the second value is a boolean defining interactivity. In interactive mode (only works if ``colorbar=True``) the colors are adjustable by clicking and dragging the colorbar with left and right mouse button. Left mouse button moves the scale up and down and right mouse button adjusts the range. Hitting space bar resets the range. Up and down arrows can be used to change the colormap. If None (default), 'Reds' is used for all positive data, otherwise defaults to 'RdBu_r'. If 'interactive', translates to (None, True). sensors : bool | str Add markers for sensor locations to the plot. Accepts matplotlib plot format string (e.g., 'r+' for red plusses). If True, a circle will be used (via .add_artist). Defaults to True. colorbar : bool Plot a colorbar. res : int The resolution of the topomap image (n pixels along each side). size : scalar Side length of the topomaps in inches (only applies when plotting multiple topomaps at a time). show : bool Show figure if True. outlines : 'head' | 'skirt' | dict | None The outlines to be drawn. If 'head', the default head scheme will be drawn. If 'skirt' the head scheme will be drawn, but sensors are allowed to be plotted outside of the head circle. If dict, each key refers to a tuple of x and y positions, the values in 'mask_pos' will serve as image mask, and the 'autoshrink' (bool) field will trigger automated shrinking of the positions due to points outside the outline. Alternatively, a matplotlib patch object can be passed for advanced masking options, either directly or as a function that returns patches (required for multi-axis plots). If None, nothing will be drawn. Defaults to 'head'. contours : int | False | None The number of contour lines to draw. If 0, no contours will be drawn. image_interp : str The image interpolation to be used. All matplotlib options are accepted. axes : instance of Axes | list | None The axes to plot to. If list, the list must be a list of Axes of the same length as the number of projectors. If instance of Axes, there must be only one projector. Defaults to None. Returns ------- fig : instance of matplotlib figure Figure distributing one image per channel across sensor topography. Notes ----- .. versionadded:: 0.9.0 """ import matplotlib.pyplot as plt from mpl_toolkits.axes_grid1 import make_axes_locatable if layout is None: from ..channels import read_layout layout = read_layout('Vectorview-all') if not isinstance(layout, list): layout = [layout] n_projs = len(projs) nrows = math.floor(math.sqrt(n_projs)) ncols = math.ceil(n_projs / nrows) if cmap == 'interactive': cmap = (None, True) elif not isinstance(cmap, tuple): cmap = (cmap, True) if axes is None: plt.figure() axes = list() for idx in range(len(projs)): ax = plt.subplot(nrows, ncols, idx + 1) axes.append(ax) elif isinstance(axes, plt.Axes): axes = [axes] if len(axes) != len(projs): raise RuntimeError('There must be an axes for each picked projector.') for proj_idx, proj in enumerate(projs): axes[proj_idx].set_title(proj['desc'][:10] + '...') ch_names = _clean_names(proj['data']['col_names']) data = proj['data']['data'].ravel() idx = [] for l in layout: is_vv = l.kind.startswith('Vectorview') if is_vv: from ..channels.layout import _pair_grad_sensors_from_ch_names grad_pairs = _pair_grad_sensors_from_ch_names(ch_names) if grad_pairs: ch_names = [ch_names[i] for i in grad_pairs] idx = [l.names.index(c) for c in ch_names if c in l.names] if len(idx) == 0: continue pos = l.pos[idx] if is_vv and grad_pairs: from ..channels.layout import _merge_grad_data shape = (len(idx) // 2, 2, -1) pos = pos.reshape(shape).mean(axis=1) data = _merge_grad_data(data[grad_pairs]).ravel() break if len(idx): im = plot_topomap(data, pos[:, :2], vmax=None, cmap=cmap[0], sensors=sensors, res=res, axes=axes[proj_idx], outlines=outlines, contours=contours, image_interp=image_interp, show=False)[0] if colorbar: divider = make_axes_locatable(axes[proj_idx]) cax = divider.append_axes("right", size="5%", pad=0.05) cbar = plt.colorbar(im, cax=cax, cmap=cmap) if cmap[1]: axes[proj_idx].CB = DraggableColorbar(cbar, im) else: raise RuntimeError('Cannot find a proper layout for projection %s' % proj['desc']) tight_layout(fig=axes[0].get_figure()) plt_show(show) return axes[0].get_figure() def _check_outlines(pos, outlines, head_pos=None): """Check or create outlines for topoplot """ pos = np.array(pos, float)[:, :2] # ensure we have a copy head_pos = dict() if head_pos is None else head_pos if not isinstance(head_pos, dict): raise TypeError('head_pos must be dict or None') head_pos = copy.deepcopy(head_pos) for key in head_pos.keys(): if key not in ('center', 'scale'): raise KeyError('head_pos must only contain "center" and ' '"scale"') head_pos[key] = np.array(head_pos[key], float) if head_pos[key].shape != (2,): raise ValueError('head_pos["%s"] must have shape (2,), not ' '%s' % (key, head_pos[key].shape)) if outlines in ('head', 'skirt', None): radius = 0.5 l = np.linspace(0, 2 * np.pi, 101) head_x = np.cos(l) * radius head_y = np.sin(l) * radius nose_x = np.array([0.18, 0, -0.18]) * radius nose_y = np.array([radius - .004, radius * 1.15, radius - .004]) ear_x = np.array([.497, .510, .518, .5299, .5419, .54, .547, .532, .510, .489]) ear_y = np.array([.0555, .0775, .0783, .0746, .0555, -.0055, -.0932, -.1313, -.1384, -.1199]) # shift and scale the electrode positions if 'center' not in head_pos: head_pos['center'] = 0.5 * (pos.max(axis=0) + pos.min(axis=0)) pos -= head_pos['center'] if outlines is not None: # Define the outline of the head, ears and nose outlines_dict = dict(head=(head_x, head_y), nose=(nose_x, nose_y), ear_left=(ear_x, ear_y), ear_right=(-ear_x, ear_y)) else: outlines_dict = dict() if outlines == 'skirt': if 'scale' not in head_pos: # By default, fit electrodes inside the head circle head_pos['scale'] = 1.0 / (pos.max(axis=0) - pos.min(axis=0)) pos *= head_pos['scale'] # Make the figure encompass slightly more than all points mask_scale = 1.25 * (pos.max(axis=0) - pos.min(axis=0)) outlines_dict['autoshrink'] = False outlines_dict['mask_pos'] = (mask_scale[0] * head_x, mask_scale[1] * head_y) outlines_dict['clip_radius'] = (mask_scale / 2.) else: if 'scale' not in head_pos: # The default is to make the points occupy a slightly smaller # proportion (0.85) of the total width and height # this number was empirically determined (seems to work well) head_pos['scale'] = 0.85 / (pos.max(axis=0) - pos.min(axis=0)) pos *= head_pos['scale'] outlines_dict['autoshrink'] = True outlines_dict['mask_pos'] = head_x, head_y outlines_dict['clip_radius'] = (0.5, 0.5) outlines = outlines_dict elif isinstance(outlines, dict): if 'mask_pos' not in outlines: raise ValueError('You must specify the coordinates of the image' 'mask') else: raise ValueError('Invalid value for `outlines') return pos, outlines def _draw_outlines(ax, outlines): """Helper for drawing the outlines for a topomap.""" outlines_ = dict([(k, v) for k, v in outlines.items() if k not in ['patch', 'autoshrink']]) for key, (x_coord, y_coord) in outlines_.items(): if 'mask' in key: continue ax.plot(x_coord, y_coord, color='k', linewidth=1, clip_on=False) return outlines_ def _griddata(x, y, v, xi, yi): """Aux function""" xy = x.ravel() + y.ravel() * -1j d = xy[None, :] * np.ones((len(xy), 1)) d = np.abs(d - d.T) n = d.shape[0] d.flat[::n + 1] = 1. g = (d * d) * (np.log(d) - 1.) g.flat[::n + 1] = 0. weights = linalg.solve(g, v.ravel()) m, n = xi.shape zi = np.zeros_like(xi) xy = xy.T g = np.empty(xy.shape) for i in range(m): for j in range(n): d = np.abs(xi[i, j] + -1j * yi[i, j] - xy) mask = np.where(d == 0)[0] if len(mask): d[mask] = 1. np.log(d, out=g) g -= 1. g *= d * d if len(mask): g[mask] = 0. zi[i, j] = g.dot(weights) return zi def _plot_sensors(pos_x, pos_y, sensors, ax): """Aux function""" from matplotlib.patches import Circle if sensors is True: for x, y in zip(pos_x, pos_y): ax.add_artist(Circle(xy=(x, y), radius=0.003, color='k')) else: ax.plot(pos_x, pos_y, sensors) def plot_topomap(data, pos, vmin=None, vmax=None, cmap=None, sensors=True, res=64, axes=None, names=None, show_names=False, mask=None, mask_params=None, outlines='head', image_mask=None, contours=6, image_interp='bilinear', show=True, head_pos=None, onselect=None): """Plot a topographic map as image Parameters ---------- data : array, shape (n_chan,) The data values to plot. pos : array, shape (n_chan, 2) | instance of Info Location information for the data points(/channels). If an array, for each data point, the x and y coordinates. If an Info object, it must contain only one data type and exactly `len(data)` data channels, and the x/y coordinates will be inferred from this Info object. vmin : float | callable | None The value specifying the lower bound of the color range. If None, and vmax is None, -vmax is used. Else np.min(data). If callable, the output equals vmin(data). Defaults to None. vmax : float | callable | None The value specifying the upper bound of the color range. If None, the maximum absolute value is used. If callable, the output equals vmax(data). Defaults to None. cmap : matplotlib colormap | None Colormap to use. If None, 'Reds' is used for all positive data, otherwise defaults to 'RdBu_r'. sensors : bool | str Add markers for sensor locations to the plot. Accepts matplotlib plot format string (e.g., 'r+' for red plusses). If True, a circle will be used (via .add_artist). Defaults to True. res : int The resolution of the topomap image (n pixels along each side). axes : instance of Axes | None The axes to plot to. If None, the current axes will be used. names : list | None List of channel names. If None, channel names are not plotted. show_names : bool | callable If True, show channel names on top of the map. If a callable is passed, channel names will be formatted using the callable; e.g., to delete the prefix 'MEG ' from all channel names, pass the function lambda x: x.replace('MEG ', ''). If `mask` is not None, only significant sensors will be shown. If `True`, a list of names must be provided (see `names` keyword). mask : ndarray of bool, shape (n_channels, n_times) | None The channels to be marked as significant at a given time point. Indices set to `True` will be considered. Defaults to None. mask_params : dict | None Additional plotting parameters for plotting significant sensors. Default (None) equals:: dict(marker='o', markerfacecolor='w', markeredgecolor='k', linewidth=0, markersize=4) outlines : 'head' | 'skirt' | dict | None The outlines to be drawn. If 'head', the default head scheme will be drawn. If 'skirt' the head scheme will be drawn, but sensors are allowed to be plotted outside of the head circle. If dict, each key refers to a tuple of x and y positions, the values in 'mask_pos' will serve as image mask, and the 'autoshrink' (bool) field will trigger automated shrinking of the positions due to points outside the outline. Alternatively, a matplotlib patch object can be passed for advanced masking options, either directly or as a function that returns patches (required for multi-axes plots). If None, nothing will be drawn. Defaults to 'head'. image_mask : ndarray of bool, shape (res, res) | None The image mask to cover the interpolated surface. If None, it will be computed from the outline. contours : int | False | None The number of contour lines to draw. If 0, no contours will be drawn. image_interp : str The image interpolation to be used. All matplotlib options are accepted. show : bool Show figure if True. head_pos : dict | None If None (default), the sensors are positioned such that they span the head circle. If dict, can have entries 'center' (tuple) and 'scale' (tuple) for what the center and scale of the head should be relative to the electrode locations. onselect : callable | None Handle for a function that is called when the user selects a set of channels by rectangle selection (matplotlib ``RectangleSelector``). If None interactive selection is disabled. Defaults to None. Returns ------- im : matplotlib.image.AxesImage The interpolated data. cn : matplotlib.contour.ContourSet The fieldlines. """ import matplotlib.pyplot as plt from matplotlib.widgets import RectangleSelector data = np.asarray(data) if isinstance(pos, Info): # infer pos from Info object picks = _pick_data_channels(pos) # pick only data channels pos = pick_info(pos, picks) # check if there is only 1 channel type, and n_chans matches the data ch_type = set(channel_type(pos, idx) for idx, _ in enumerate(pos["chs"])) info_help = ("Pick Info with e.g. mne.pick_info and " "mne.channels.channel_indices_by_type.") if len(ch_type) > 1: raise ValueError("Multiple channel types in Info structure. " + info_help) elif len(pos["chs"]) != data.shape[0]: raise ValueError("Number of channels in the Info object and " "the data array does not match. " + info_help) else: ch_type = ch_type.pop() if any(type_ in ch_type for type_ in ('planar', 'grad')): # deal with grad pairs from ..channels.layout import (_merge_grad_data, find_layout, _pair_grad_sensors) picks, pos = _pair_grad_sensors(pos, find_layout(pos)) data = _merge_grad_data(data[picks]).reshape(-1) else: picks = list(range(data.shape[0])) pos = _find_topomap_coords(pos, picks=picks) if data.ndim > 1: raise ValueError("Data needs to be array of shape (n_sensors,); got " "shape %s." % str(data.shape)) # Give a helpful error message for common mistakes regarding the position # matrix. pos_help = ("Electrode positions should be specified as a 2D array with " "shape (n_channels, 2). Each row in this matrix contains the " "(x, y) position of an electrode.") if pos.ndim != 2: error = ("{ndim}D array supplied as electrode positions, where a 2D " "array was expected").format(ndim=pos.ndim) raise ValueError(error + " " + pos_help) elif pos.shape[1] == 3: error = ("The supplied electrode positions matrix contains 3 columns. " "Are you trying to specify XYZ coordinates? Perhaps the " "mne.channels.create_eeg_layout function is useful for you.") raise ValueError(error + " " + pos_help) # No error is raised in case of pos.shape[1] == 4. In this case, it is # assumed the position matrix contains both (x, y) and (width, height) # values, such as Layout.pos. elif pos.shape[1] == 1 or pos.shape[1] > 4: raise ValueError(pos_help) if len(data) != len(pos): raise ValueError("Data and pos need to be of same length. Got data of " "length %s, pos of length %s" % (len(data), len(pos))) norm = min(data) >= 0 vmin, vmax = _setup_vmin_vmax(data, vmin, vmax, norm) if cmap is None: cmap = 'Reds' if norm else 'RdBu_r' pos, outlines = _check_outlines(pos, outlines, head_pos) ax = axes if axes else plt.gca() pos_x, pos_y = _prepare_topomap(pos, ax) if outlines is None: xmin, xmax = pos_x.min(), pos_x.max() ymin, ymax = pos_y.min(), pos_y.max() else: xlim = np.inf, -np.inf, ylim = np.inf, -np.inf, mask_ = np.c_[outlines['mask_pos']] xmin, xmax = (np.min(np.r_[xlim[0], mask_[:, 0]]), np.max(np.r_[xlim[1], mask_[:, 0]])) ymin, ymax = (np.min(np.r_[ylim[0], mask_[:, 1]]), np.max(np.r_[ylim[1], mask_[:, 1]])) # interpolate data xi = np.linspace(xmin, xmax, res) yi = np.linspace(ymin, ymax, res) Xi, Yi = np.meshgrid(xi, yi) Zi = _griddata(pos_x, pos_y, data, Xi, Yi) if outlines is None: _is_default_outlines = False elif isinstance(outlines, dict): _is_default_outlines = any(k.startswith('head') for k in outlines) if _is_default_outlines and image_mask is None: # prepare masking image_mask, pos = _make_image_mask(outlines, pos, res) mask_params = _handle_default('mask_params', mask_params) # plot outline linewidth = mask_params['markeredgewidth'] patch = None if 'patch' in outlines: patch = outlines['patch'] patch_ = patch() if callable(patch) else patch patch_.set_clip_on(False) ax.add_patch(patch_) ax.set_transform(ax.transAxes) ax.set_clip_path(patch_) # plot map and countour im = ax.imshow(Zi, cmap=cmap, vmin=vmin, vmax=vmax, origin='lower', aspect='equal', extent=(xmin, xmax, ymin, ymax), interpolation=image_interp) # This tackles an incomprehensible matplotlib bug if no contours are # drawn. To avoid rescalings, we will always draw contours. # But if no contours are desired we only draw one and make it invisible . no_contours = False if contours in (False, None): contours, no_contours = 1, True cont = ax.contour(Xi, Yi, Zi, contours, colors='k', linewidths=linewidth) if no_contours is True: for col in cont.collections: col.set_visible(False) if _is_default_outlines: from matplotlib import patches patch_ = patches.Ellipse((0, 0), 2 * outlines['clip_radius'][0], 2 * outlines['clip_radius'][1], clip_on=True, transform=ax.transData) if _is_default_outlines or patch is not None: im.set_clip_path(patch_) if cont is not None: for col in cont.collections: col.set_clip_path(patch_) if sensors is not False and mask is None: _plot_sensors(pos_x, pos_y, sensors=sensors, ax=ax) elif sensors and mask is not None: idx = np.where(mask)[0] ax.plot(pos_x[idx], pos_y[idx], **mask_params) idx = np.where(~mask)[0] _plot_sensors(pos_x[idx], pos_y[idx], sensors=sensors, ax=ax) elif not sensors and mask is not None: idx = np.where(mask)[0] ax.plot(pos_x[idx], pos_y[idx], **mask_params) if isinstance(outlines, dict): _draw_outlines(ax, outlines) if show_names: if names is None: raise ValueError("To show names, a list of names must be provided" " (see `names` keyword).") if show_names is True: def _show_names(x): return x else: _show_names = show_names show_idx = np.arange(len(names)) if mask is None else np.where(mask)[0] for ii, (p, ch_id) in enumerate(zip(pos, names)): if ii not in show_idx: continue ch_id = _show_names(ch_id) ax.text(p[0], p[1], ch_id, horizontalalignment='center', verticalalignment='center', size='x-small') plt.subplots_adjust(top=.95) if onselect is not None: ax.RS = RectangleSelector(ax, onselect=onselect) plt_show(show) return im, cont def _make_image_mask(outlines, pos, res): """Aux function """ mask_ = np.c_[outlines['mask_pos']] xmin, xmax = (np.min(np.r_[np.inf, mask_[:, 0]]), np.max(np.r_[-np.inf, mask_[:, 0]])) ymin, ymax = (np.min(np.r_[np.inf, mask_[:, 1]]), np.max(np.r_[-np.inf, mask_[:, 1]])) if outlines.get('autoshrink', False) is not False: inside = _inside_contour(pos, mask_) outside = np.invert(inside) outlier_points = pos[outside] while np.any(outlier_points): # auto shrink pos *= 0.99 inside = _inside_contour(pos, mask_) outside = np.invert(inside) outlier_points = pos[outside] image_mask = np.zeros((res, res), dtype=bool) xi_mask = np.linspace(xmin, xmax, res) yi_mask = np.linspace(ymin, ymax, res) Xi_mask, Yi_mask = np.meshgrid(xi_mask, yi_mask) pos_ = np.c_[Xi_mask.flatten(), Yi_mask.flatten()] inds = _inside_contour(pos_, mask_) image_mask[inds.reshape(image_mask.shape)] = True return image_mask, pos def _inside_contour(pos, contour): """Aux function""" npos = len(pos) x, y = pos[:, :2].T check_mask = np.ones((npos), dtype=bool) check_mask[((x < np.min(x)) | (y < np.min(y)) | (x > np.max(x)) | (y > np.max(y)))] = False critval = 0.1 sel = np.where(check_mask)[0] for this_sel in sel: contourx = contour[:, 0] - pos[this_sel, 0] contoury = contour[:, 1] - pos[this_sel, 1] angle = np.arctan2(contoury, contourx) angle = np.unwrap(angle) total = np.sum(np.diff(angle)) check_mask[this_sel] = np.abs(total) > critval return check_mask def _plot_ica_topomap(ica, idx=0, ch_type=None, res=64, layout=None, vmin=None, vmax=None, cmap='RdBu_r', colorbar=False, title=None, show=True, outlines='head', contours=6, image_interp='bilinear', head_pos=None, axes=None): """plot single ica map to axes""" import matplotlib as mpl from ..channels import _get_ch_type from ..preprocessing.ica import _get_ica_map if ica.info is None: raise RuntimeError('The ICA\'s measurement info is missing. Please ' 'fit the ICA or add the corresponding info object.') if not isinstance(axes, mpl.axes.Axes): raise ValueError('axis has to be an instance of matplotlib Axes, ' 'got %s instead.' % type(axes)) ch_type = _get_ch_type(ica, ch_type) data = _get_ica_map(ica, components=idx) data_picks, pos, merge_grads, names, _ = _prepare_topo_plot( ica, ch_type, layout) pos, outlines = _check_outlines(pos, outlines, head_pos) if outlines not in (None, 'head'): image_mask, pos = _make_image_mask(outlines, pos, res) else: image_mask = None data = np.atleast_2d(data) data = data[:, data_picks] if merge_grads: from ..channels.layout import _merge_grad_data data = _merge_grad_data(data) axes.set_title('IC #%03d' % idx, fontsize=12) vmin_, vmax_ = _setup_vmin_vmax(data, vmin, vmax) im = plot_topomap(data.ravel(), pos, vmin=vmin_, vmax=vmax_, res=res, axes=axes, cmap=cmap, outlines=outlines, image_mask=image_mask, contours=contours, image_interp=image_interp, show=show)[0] if colorbar: import matplotlib.pyplot as plt from mpl_toolkits.axes_grid import make_axes_locatable divider = make_axes_locatable(axes) cax = divider.append_axes("right", size="5%", pad=0.05) cbar = plt.colorbar(im, cax=cax, format='%3.2f', cmap=cmap) cbar.ax.tick_params(labelsize=12) cbar.set_ticks((vmin_, vmax_)) cbar.ax.set_title('AU', fontsize=10) _hide_frame(axes) def plot_ica_components(ica, picks=None, ch_type=None, res=64, layout=None, vmin=None, vmax=None, cmap='RdBu_r', sensors=True, colorbar=False, title=None, show=True, outlines='head', contours=6, image_interp='bilinear', head_pos=None, inst=None): """Project unmixing matrix on interpolated sensor topogrpahy. Parameters ---------- ica : instance of mne.preprocessing.ICA The ICA solution. picks : int | array-like | None The indices of the sources to be plotted. If None all are plotted in batches of 20. ch_type : 'mag' | 'grad' | 'planar1' | 'planar2' | 'eeg' | None The channel type to plot. For 'grad', the gradiometers are collected in pairs and the RMS for each pair is plotted. If None, then channels are chosen in the order given above. res : int The resolution of the topomap image (n pixels along each side). layout : None | Layout Layout instance specifying sensor positions (does not need to be specified for Neuromag data). If possible, the correct layout is inferred from the data. vmin : float | callable | None The value specifying the lower bound of the color range. If None, and vmax is None, -vmax is used. Else np.min(data). If callable, the output equals vmin(data). Defaults to None. vmax : float | callable | None The value specifying the upper bound of the color range. If None, the maximum absolute value is used. If callable, the output equals vmax(data). Defaults to None. cmap : matplotlib colormap | (colormap, bool) | 'interactive' | None Colormap to use. If tuple, the first value indicates the colormap to use and the second value is a boolean defining interactivity. In interactive mode the colors are adjustable by clicking and dragging the colorbar with left and right mouse button. Left mouse button moves the scale up and down and right mouse button adjusts the range. Hitting space bar resets the range. Up and down arrows can be used to change the colormap. If None, 'Reds' is used for all positive data, otherwise defaults to 'RdBu_r'. If 'interactive', translates to (None, True). Defaults to 'RdBu_r'. .. warning:: Interactive mode works smoothly only for a small amount of topomaps. sensors : bool | str Add markers for sensor locations to the plot. Accepts matplotlib plot format string (e.g., 'r+' for red plusses). If True, a circle will be used (via .add_artist). Defaults to True. colorbar : bool Plot a colorbar. title : str | None Title to use. show : bool Show figure if True. outlines : 'head' | 'skirt' | dict | None The outlines to be drawn. If 'head', the default head scheme will be drawn. If 'skirt' the head scheme will be drawn, but sensors are allowed to be plotted outside of the head circle. If dict, each key refers to a tuple of x and y positions, the values in 'mask_pos' will serve as image mask, and the 'autoshrink' (bool) field will trigger automated shrinking of the positions due to points outside the outline. Alternatively, a matplotlib patch object can be passed for advanced masking options, either directly or as a function that returns patches (required for multi-axis plots). If None, nothing will be drawn. Defaults to 'head'. contours : int | False | None The number of contour lines to draw. If 0, no contours will be drawn. image_interp : str The image interpolation to be used. All matplotlib options are accepted. head_pos : dict | None If None (default), the sensors are positioned such that they span the head circle. If dict, can have entries 'center' (tuple) and 'scale' (tuple) for what the center and scale of the head should be relative to the electrode locations. inst : Raw | Epochs | None To be able to see component properties after clicking on component topomap you need to pass relevant data - instances of Raw or Epochs (for example the data that ICA was trained on). This takes effect only when running matplotlib in interactive mode. Returns ------- fig : instance of matplotlib.pyplot.Figure or list The figure object(s). """ from ..io import _BaseRaw from ..epochs import _BaseEpochs import matplotlib.pyplot as plt from mpl_toolkits.axes_grid import make_axes_locatable from ..channels import _get_ch_type if picks is None: # plot components by sets of 20 ch_type = _get_ch_type(ica, ch_type) n_components = ica.mixing_matrix_.shape[1] p = 20 figs = [] for k in range(0, n_components, p): picks = range(k, min(k + p, n_components)) fig = plot_ica_components(ica, picks=picks, ch_type=ch_type, res=res, layout=layout, vmax=vmax, cmap=cmap, sensors=sensors, colorbar=colorbar, title=title, show=show, outlines=outlines, contours=contours, image_interp=image_interp, head_pos=head_pos, inst=inst) figs.append(fig) return figs elif np.isscalar(picks): picks = [picks] ch_type = _get_ch_type(ica, ch_type) if cmap == 'interactive': cmap = ('RdBu_r', True) elif not isinstance(cmap, tuple): cmap = (cmap, False if len(picks) > 2 else True) data = np.dot(ica.mixing_matrix_[:, picks].T, ica.pca_components_[:ica.n_components_]) if ica.info is None: raise RuntimeError('The ICA\'s measurement info is missing. Please ' 'fit the ICA or add the corresponding info object.') data_picks, pos, merge_grads, names, _ = _prepare_topo_plot(ica, ch_type, layout) pos, outlines = _check_outlines(pos, outlines, head_pos) if outlines not in (None, 'head'): image_mask, pos = _make_image_mask(outlines, pos, res) else: image_mask = None data = np.atleast_2d(data) data = data[:, data_picks] # prepare data for iteration fig, axes = _prepare_trellis(len(data), max_col=5) if title is None: title = 'ICA components' fig.suptitle(title) if merge_grads: from ..channels.layout import _merge_grad_data for ii, data_, ax in zip(picks, data, axes): ax.set_title('IC #%03d' % ii, fontsize=12) data_ = _merge_grad_data(data_) if merge_grads else data_ vmin_, vmax_ = _setup_vmin_vmax(data_, vmin, vmax) im = plot_topomap(data_.flatten(), pos, vmin=vmin_, vmax=vmax_, res=res, axes=ax, cmap=cmap[0], outlines=outlines, image_mask=image_mask, contours=contours, image_interp=image_interp, show=False)[0] im.axes.set_label('IC #%03d' % ii) if colorbar: divider = make_axes_locatable(ax) cax = divider.append_axes("right", size="5%", pad=0.05) cbar = plt.colorbar(im, cax=cax, format='%3.2f', cmap=cmap) cbar.ax.tick_params(labelsize=12) cbar.set_ticks((vmin_, vmax_)) cbar.ax.set_title('AU', fontsize=10) if cmap[1]: ax.CB = DraggableColorbar(cbar, im) _hide_frame(ax) tight_layout(fig=fig) fig.subplots_adjust(top=0.95) fig.canvas.draw() if isinstance(inst, (_BaseRaw, _BaseEpochs)): def onclick(event, ica=ica, inst=inst): # check which component to plot label = event.inaxes.get_label() if 'IC #' in label: ic = int(label[4:]) ica.plot_properties(inst, picks=ic, show=True) fig.canvas.mpl_connect('button_press_event', onclick) plt_show(show) return fig def plot_tfr_topomap(tfr, tmin=None, tmax=None, fmin=None, fmax=None, ch_type=None, baseline=None, mode='mean', layout=None, vmin=None, vmax=None, cmap=None, sensors=True, colorbar=True, unit=None, res=64, size=2, cbar_fmt='%1.1e', show_names=False, title=None, axes=None, show=True, outlines='head', head_pos=None): """Plot topographic maps of specific time-frequency intervals of TFR data Parameters ---------- tfr : AvereageTFR The AvereageTFR object. tmin : None | float The first time instant to display. If None the first time point available is used. tmax : None | float The last time instant to display. If None the last time point available is used. fmin : None | float The first frequency to display. If None the first frequency available is used. fmax : None | float The last frequency to display. If None the last frequency available is used. ch_type : 'mag' | 'grad' | 'planar1' | 'planar2' | 'eeg' | None The channel type to plot. For 'grad', the gradiometers are collected in pairs and the RMS for each pair is plotted. If None, then channels are chosen in the order given above. baseline : tuple or list of length 2 The time interval to apply rescaling / baseline correction. If None do not apply it. If baseline is (a, b) the interval is between "a (s)" and "b (s)". If a is None the beginning of the data is used and if b is None then b is set to the end of the interval. If baseline is equal to (None, None) all the time interval is used. mode : 'logratio' | 'ratio' | 'zscore' | 'mean' | 'percent' Do baseline correction with ratio (power is divided by mean power during baseline) or z-score (power is divided by standard deviation of power during baseline after subtracting the mean, power = [power - mean(power_baseline)] / std(power_baseline)) If None, baseline no correction will be performed. layout : None | Layout Layout instance specifying sensor positions (does not need to be specified for Neuromag data). If possible, the correct layout file is inferred from the data; if no appropriate layout file was found, the layout is automatically generated from the sensor locations. vmin : float | callable | None The value specifying the lower bound of the color range. If None, and vmax is None, -vmax is used. Else np.min(data) or in case data contains only positive values 0. If callable, the output equals vmin(data). Defaults to None. vmax : float | callable | None The value specifying the upper bound of the color range. If None, the maximum value is used. If callable, the output equals vmax(data). Defaults to None. cmap : matplotlib colormap | (colormap, bool) | 'interactive' | None Colormap to use. If tuple, the first value indicates the colormap to use and the second value is a boolean defining interactivity. In interactive mode the colors are adjustable by clicking and dragging the colorbar with left and right mouse button. Left mouse button moves the scale up and down and right mouse button adjusts the range. Hitting space bar resets the range. Up and down arrows can be used to change the colormap. If None (default), 'Reds' is used for all positive data, otherwise defaults to 'RdBu_r'. If 'interactive', translates to (None, True). sensors : bool | str Add markers for sensor locations to the plot. Accepts matplotlib plot format string (e.g., 'r+' for red plusses). If True, a circle will be used (via .add_artist). Defaults to True. colorbar : bool Plot a colorbar. unit : str | None The unit of the channel type used for colorbar labels. res : int The resolution of the topomap image (n pixels along each side). size : float Side length per topomap in inches (only applies when plotting multiple topomaps at a time). cbar_fmt : str String format for colorbar values. show_names : bool | callable If True, show channel names on top of the map. If a callable is passed, channel names will be formatted using the callable; e.g., to delete the prefix 'MEG ' from all channel names, pass the function lambda x: x.replace('MEG ', ''). If `mask` is not None, only significant sensors will be shown. title : str | None Title. If None (default), no title is displayed. axes : instance of Axis | None The axes to plot to. If None the axes is defined automatically. show : bool Show figure if True. outlines : 'head' | 'skirt' | dict | None The outlines to be drawn. If 'head', the default head scheme will be drawn. If 'skirt' the head scheme will be drawn, but sensors are allowed to be plotted outside of the head circle. If dict, each key refers to a tuple of x and y positions, the values in 'mask_pos' will serve as image mask, and the 'autoshrink' (bool) field will trigger automated shrinking of the positions due to points outside the outline. Alternatively, a matplotlib patch object can be passed for advanced masking options, either directly or as a function that returns patches (required for multi-axis plots). If None, nothing will be drawn. Defaults to 'head'. head_pos : dict | None If None (default), the sensors are positioned such that they span the head circle. If dict, can have entries 'center' (tuple) and 'scale' (tuple) for what the center and scale of the head should be relative to the electrode locations. Returns ------- fig : matplotlib.figure.Figure The figure containing the topography. """ from ..channels import _get_ch_type ch_type = _get_ch_type(tfr, ch_type) import matplotlib.pyplot as plt from mpl_toolkits.axes_grid1 import make_axes_locatable picks, pos, merge_grads, names, _ = _prepare_topo_plot(tfr, ch_type, layout) if not show_names: names = None data = tfr.data data = rescale(data, tfr.times, baseline, mode, copy=True) # crop time itmin, itmax = None, None idx = np.where(_time_mask(tfr.times, tmin, tmax))[0] if tmin is not None: itmin = idx[0] if tmax is not None: itmax = idx[-1] + 1 # crop freqs ifmin, ifmax = None, None idx = np.where(_time_mask(tfr.freqs, fmin, fmax))[0] if fmin is not None: ifmin = idx[0] if fmax is not None: ifmax = idx[-1] + 1 data = data[picks, ifmin:ifmax, itmin:itmax] data = np.mean(np.mean(data, axis=2), axis=1)[:, np.newaxis] if merge_grads: from ..channels.layout import _merge_grad_data data = _merge_grad_data(data) norm = False if np.min(data) < 0 else True vmin, vmax = _setup_vmin_vmax(data, vmin, vmax, norm) if cmap is None or cmap == 'interactive': cmap = ('Reds', True) if norm else ('RdBu_r', True) elif not isinstance(cmap, tuple): cmap = (cmap, True) if axes is None: fig = plt.figure() ax = fig.gca() else: fig = axes.figure ax = axes _hide_frame(ax) if title is not None: ax.set_title(title) fig_wrapper = list() selection_callback = partial(_onselect, tfr=tfr, pos=pos, ch_type=ch_type, itmin=itmin, itmax=itmax, ifmin=ifmin, ifmax=ifmax, cmap=cmap[0], fig=fig_wrapper, layout=layout) im, _ = plot_topomap(data[:, 0], pos, vmin=vmin, vmax=vmax, axes=ax, cmap=cmap[0], image_interp='bilinear', contours=False, names=names, show_names=show_names, show=False, onselect=selection_callback) if colorbar: divider = make_axes_locatable(ax) cax = divider.append_axes("right", size="5%", pad=0.05) cbar = plt.colorbar(im, cax=cax, format=cbar_fmt, cmap=cmap[0]) cbar.set_ticks((vmin, vmax)) cbar.ax.tick_params(labelsize=12) cbar.ax.set_title('AU') if cmap[1]: ax.CB = DraggableColorbar(cbar, im) plt_show(show) return fig def plot_evoked_topomap(evoked, times="auto", ch_type=None, layout=None, vmin=None, vmax=None, cmap=None, sensors=True, colorbar=True, scale=None, scale_time=1e3, unit=None, res=64, size=1, cbar_fmt='%3.1f', time_format='%01d ms', proj=False, show=True, show_names=False, title=None, mask=None, mask_params=None, outlines='head', contours=6, image_interp='bilinear', average=None, head_pos=None, axes=None): """Plot topographic maps of specific time points of evoked data Parameters ---------- evoked : Evoked The Evoked object. times : float | array of floats | "auto" | "peaks". The time point(s) to plot. If "auto", the number of ``axes`` determines the amount of time point(s). If ``axes`` is also None, 10 topographies will be shown with a regular time spacing between the first and last time instant. If "peaks", finds time points automatically by checking for local maxima in global field power. ch_type : 'mag' | 'grad' | 'planar1' | 'planar2' | 'eeg' | None The channel type to plot. For 'grad', the gradiometers are collected in pairs and the RMS for each pair is plotted. If None, then channels are chosen in the order given above. layout : None | Layout Layout instance specifying sensor positions (does not need to be specified for Neuromag data). If possible, the correct layout file is inferred from the data; if no appropriate layout file was found, the layout is automatically generated from the sensor locations. vmin : float | callable | None The value specifying the lower bound of the color range. If None, and vmax is None, -vmax is used. Else np.min(data). If callable, the output equals vmin(data). Defaults to None. vmax : float | callable | None The value specifying the upper bound of the color range. If None, the maximum absolute value is used. If callable, the output equals vmax(data). Defaults to None. cmap : matplotlib colormap | (colormap, bool) | 'interactive' | None Colormap to use. If tuple, the first value indicates the colormap to use and the second value is a boolean defining interactivity. In interactive mode the colors are adjustable by clicking and dragging the colorbar with left and right mouse button. Left mouse button moves the scale up and down and right mouse button adjusts the range. Hitting space bar resets the range. Up and down arrows can be used to change the colormap. If None (default), 'Reds' is used for all positive data, otherwise defaults to 'RdBu_r'. If 'interactive', translates to (None, True). .. warning:: Interactive mode works smoothly only for a small amount of topomaps. sensors : bool | str Add markers for sensor locations to the plot. Accepts matplotlib plot format string (e.g., 'r+' for red plusses). If True, a circle will be used (via .add_artist). Defaults to True. colorbar : bool Plot a colorbar. scale : dict | float | None Scale the data for plotting. If None, defaults to 1e6 for eeg, 1e13 for grad and 1e15 for mag. scale_time : float | None Scale the time labels. Defaults to 1e3 (ms). unit : dict | str | None The unit of the channel type used for colorbar label. If scale is None the unit is automatically determined. res : int The resolution of the topomap image (n pixels along each side). size : float Side length per topomap in inches. cbar_fmt : str String format for colorbar values. time_format : str String format for topomap values. Defaults to "%01d ms" proj : bool | 'interactive' If true SSP projections are applied before display. If 'interactive', a check box for reversible selection of SSP projection vectors will be show. show : bool Show figure if True. show_names : bool | callable If True, show channel names on top of the map. If a callable is passed, channel names will be formatted using the callable; e.g., to delete the prefix 'MEG ' from all channel names, pass the function lambda x: x.replace('MEG ', ''). If `mask` is not None, only significant sensors will be shown. title : str | None Title. If None (default), no title is displayed. mask : ndarray of bool, shape (n_channels, n_times) | None The channels to be marked as significant at a given time point. Indices set to `True` will be considered. Defaults to None. mask_params : dict | None Additional plotting parameters for plotting significant sensors. Default (None) equals:: dict(marker='o', markerfacecolor='w', markeredgecolor='k', linewidth=0, markersize=4) outlines : 'head' | 'skirt' | dict | None The outlines to be drawn. If 'head', the default head scheme will be drawn. If 'skirt' the head scheme will be drawn, but sensors are allowed to be plotted outside of the head circle. If dict, each key refers to a tuple of x and y positions, the values in 'mask_pos' will serve as image mask, and the 'autoshrink' (bool) field will trigger automated shrinking of the positions due to points outside the outline. Alternatively, a matplotlib patch object can be passed for advanced masking options, either directly or as a function that returns patches (required for multi-axis plots). If None, nothing will be drawn. Defaults to 'head'. contours : int | False | None The number of contour lines to draw. If 0, no contours will be drawn. image_interp : str The image interpolation to be used. All matplotlib options are accepted. average : float | None The time window around a given time to be used for averaging (seconds). For example, 0.01 would translate into window that starts 5 ms before and ends 5 ms after a given time point. Defaults to None, which means no averaging. head_pos : dict | None If None (default), the sensors are positioned such that they span the head circle. If dict, can have entries 'center' (tuple) and 'scale' (tuple) for what the center and scale of the head should be relative to the electrode locations. axes : instance of Axes | list | None The axes to plot to. If list, the list must be a list of Axes of the same length as ``times`` (unless ``times`` is None). If instance of Axes, ``times`` must be a float or a list of one float. Defaults to None. Returns ------- fig : instance of matplotlib.figure.Figure The figure. """ from ..channels import _get_ch_type ch_type = _get_ch_type(evoked, ch_type) import matplotlib.pyplot as plt from mpl_toolkits.axes_grid1 import make_axes_locatable # noqa mask_params = _handle_default('mask_params', mask_params) mask_params['markersize'] *= size / 2. mask_params['markeredgewidth'] *= size / 2. picks, pos, merge_grads, names, ch_type = _prepare_topo_plot( evoked, ch_type, layout) # project before picks if proj is True and evoked.proj is not True: data = evoked.copy().apply_proj().data else: data = evoked.data evoked = evoked.copy().pick_channels( [evoked.ch_names[pick] for pick in picks]) if axes is not None: if isinstance(axes, plt.Axes): axes = [axes] times = _process_times(evoked, times, n_peaks=len(axes)) else: times = _process_times(evoked, times, n_peaks=None) space = 1 / (2. * evoked.info['sfreq']) if (max(times) > max(evoked.times) + space or min(times) < min(evoked.times) - space): raise ValueError('Times should be between {0:0.3f} and ' '{1:0.3f}.'.format(evoked.times[0], evoked.times[-1])) n_times = len(times) nax = n_times + bool(colorbar) width = size * nax height = size + max(0, 0.1 * (4 - size)) + bool(title) * 0.5 if axes is None: plt.figure(figsize=(width, height)) axes = list() for ax_idx in range(len(times)): if colorbar: # Make room for the colorbar axes.append(plt.subplot(1, n_times + 1, ax_idx + 1)) else: axes.append(plt.subplot(1, n_times, ax_idx + 1)) elif colorbar: warn('Colorbar is drawn to the rightmost column of the figure. Be ' 'sure to provide enough space for it or turn it off with ' 'colorbar=False.') if len(axes) != n_times: raise RuntimeError('Axes and times must be equal in sizes.') if ch_type.startswith('planar'): key = 'grad' else: key = ch_type scale = _handle_default('scalings', scale)[key] unit = _handle_default('units', unit)[key] if not show_names: names = None w_frame = plt.rcParams['figure.subplot.wspace'] / (2 * nax) top_frame = max((0.05 if title is None else 0.25), .2 / size) fig = axes[0].get_figure() fig.subplots_adjust(left=w_frame, right=1 - w_frame, bottom=0, top=1 - top_frame) # find first index that's >= (to rounding error) to each time point time_idx = [np.where(_time_mask(evoked.times, tmin=t, tmax=None, sfreq=evoked.info['sfreq']))[0][0] for t in times] if average is None: data = data[np.ix_(picks, time_idx)] elif isinstance(average, float): if not average > 0: raise ValueError('The average parameter must be positive. You ' 'passed a negative value') data_ = np.zeros((len(picks), len(time_idx))) ave_time = float(average) / 2. iter_times = evoked.times[time_idx] for ii, (idx, tmin_, tmax_) in enumerate(zip(time_idx, iter_times - ave_time, iter_times + ave_time)): my_range = (tmin_ < evoked.times) & (evoked.times < tmax_) data_[:, ii] = data[picks][:, my_range].mean(-1) data = data_ else: raise ValueError('The average parameter must be None or a float.' 'Check your input.') data *= scale if merge_grads: from ..channels.layout import _merge_grad_data data = _merge_grad_data(data) images, contours_ = [], [] if mask is not None: _picks = picks[::2 if ch_type not in ['mag', 'eeg'] else 1] mask_ = mask[np.ix_(_picks, time_idx)] pos, outlines = _check_outlines(pos, outlines, head_pos) if outlines is not None: image_mask, pos = _make_image_mask(outlines, pos, res) else: image_mask = None vlims = [_setup_vmin_vmax(data[:, i], vmin, vmax, norm=merge_grads) for i in range(len(times))] vmin = np.min(vlims) vmax = np.max(vlims) if cmap == 'interactive': cmap = (None, True) elif not isinstance(cmap, tuple): cmap = (cmap, False if len(times) > 2 else True) for idx, time in enumerate(times): tp, cn = plot_topomap(data[:, idx], pos, vmin=vmin, vmax=vmax, sensors=sensors, res=res, names=names, show_names=show_names, cmap=cmap[0], mask=mask_[:, idx] if mask is not None else None, mask_params=mask_params, axes=axes[idx], outlines=outlines, image_mask=image_mask, contours=contours, image_interp=image_interp, show=False) images.append(tp) if cn is not None: contours_.append(cn) if time_format is not None: axes[idx].set_title(time_format % (time * scale_time)) if title is not None: plt.suptitle(title, verticalalignment='top', size='x-large') if colorbar: # works both when fig axes pre-defined and when not n_fig_axes = max(nax, len(fig.get_axes())) cax = plt.subplot(1, n_fig_axes + 1, n_fig_axes + 1) # resize the colorbar (by default the color fills the whole axes) cpos = cax.get_position() if size <= 1: cpos.x0 = 1 - (.7 + .1 / size) / n_fig_axes cpos.x1 = cpos.x0 + .1 / n_fig_axes cpos.y0 = .2 cpos.y1 = .7 cax.set_position(cpos) if unit is not None: cax.set_title(unit) cbar = fig.colorbar(images[-1], ax=cax, cax=cax, format=cbar_fmt) cbar.set_ticks([cbar.vmin, 0, cbar.vmax]) if cmap[1]: for im in images: im.axes.CB = DraggableColorbar(cbar, im) if proj == 'interactive': _check_delayed_ssp(evoked) params = dict(evoked=evoked, fig=fig, projs=evoked.info['projs'], picks=picks, images=images, contours=contours_, time_idx=time_idx, scale=scale, merge_grads=merge_grads, res=res, pos=pos, image_mask=image_mask, plot_update_proj_callback=_plot_update_evoked_topomap) _draw_proj_checkbox(None, params) plt_show(show) return fig def _plot_topomap_multi_cbar(data, pos, ax, title=None, unit=None, vmin=None, vmax=None, cmap=None, outlines='head', colorbar=False, cbar_fmt='%3.3f'): """Aux Function""" import matplotlib.pyplot as plt from mpl_toolkits.axes_grid1 import make_axes_locatable _hide_frame(ax) vmin = np.min(data) if vmin is None else vmin vmax = np.max(data) if vmax is None else vmax if cmap == 'interactive': cmap = (None, True) elif not isinstance(cmap, tuple): cmap = (cmap, True) if title is not None: ax.set_title(title, fontsize=10) im, _ = plot_topomap(data, pos, vmin=vmin, vmax=vmax, axes=ax, cmap=cmap[0], image_interp='bilinear', contours=False, outlines=outlines, show=False) if colorbar is True: divider = make_axes_locatable(ax) cax = divider.append_axes("right", size="10%", pad=0.25) cbar = plt.colorbar(im, cax=cax, format=cbar_fmt) cbar.set_ticks((vmin, vmax)) if unit is not None: cbar.ax.set_title(unit, fontsize=8) cbar.ax.tick_params(labelsize=8) if cmap[1]: ax.CB = DraggableColorbar(cbar, im) @verbose def plot_epochs_psd_topomap(epochs, bands=None, vmin=None, vmax=None, tmin=None, tmax=None, proj=False, bandwidth=None, adaptive=False, low_bias=True, normalization='length', ch_type=None, layout=None, cmap='RdBu_r', agg_fun=None, dB=False, n_jobs=1, normalize=False, cbar_fmt='%0.3f', outlines='head', axes=None, show=True, verbose=None): """Plot the topomap of the power spectral density across epochs Parameters ---------- epochs : instance of Epochs The epochs object bands : list of tuple | None The lower and upper frequency and the name for that band. If None, (default) expands to: bands = [(0, 4, 'Delta'), (4, 8, 'Theta'), (8, 12, 'Alpha'), (12, 30, 'Beta'), (30, 45, 'Gamma')] vmin : float | callable | None The value specifying the lower bound of the color range. If None np.min(data) is used. If callable, the output equals vmin(data). vmax : float | callable | None The value specifying the upper bound of the color range. If None, the maximum absolute value is used. If callable, the output equals vmax(data). Defaults to None. tmin : float | None Start time to consider. tmax : float | None End time to consider. proj : bool Apply projection. bandwidth : float The bandwidth of the multi taper windowing function in Hz. The default value is a window half-bandwidth of 4 Hz. adaptive : bool Use adaptive weights to combine the tapered spectra into PSD (slow, use n_jobs >> 1 to speed up computation). low_bias : bool Only use tapers with more than 90% spectral concentration within bandwidth. normalization : str Either "full" or "length" (default). If "full", the PSD will be normalized by the sampling rate as well as the length of the signal (as in nitime). ch_type : 'mag' | 'grad' | 'planar1' | 'planar2' | 'eeg' | None The channel type to plot. For 'grad', the gradiometers are collected in pairs and the RMS for each pair is plotted. If None, then first available channel type from order given above is used. Defaults to None. layout : None | Layout Layout instance specifying sensor positions (does not need to be specified for Neuromag data). If possible, the correct layout file is inferred from the data; if no appropriate layout file was found, the layout is automatically generated from the sensor locations. cmap : matplotlib colormap | (colormap, bool) | 'interactive' | None Colormap to use. If tuple, the first value indicates the colormap to use and the second value is a boolean defining interactivity. In interactive mode the colors are adjustable by clicking and dragging the colorbar with left and right mouse button. Left mouse button moves the scale up and down and right mouse button adjusts the range. Hitting space bar resets the range. Up and down arrows can be used to change the colormap. If None (default), 'Reds' is used for all positive data, otherwise defaults to 'RdBu_r'. If 'interactive', translates to (None, True). agg_fun : callable The function used to aggregate over frequencies. Defaults to np.sum. if normalize is True, else np.mean. dB : bool If True, transform data to decibels (with ``10 * np.log10(data)``) following the application of `agg_fun`. Only valid if normalize is False. n_jobs : int Number of jobs to run in parallel. normalize : bool If True, each band will be divided by the total power. Defaults to False. cbar_fmt : str The colorbar format. Defaults to '%0.3f'. outlines : 'head' | 'skirt' | dict | None The outlines to be drawn. If 'head', the default head scheme will be drawn. If 'skirt' the head scheme will be drawn, but sensors are allowed to be plotted outside of the head circle. If dict, each key refers to a tuple of x and y positions, the values in 'mask_pos' will serve as image mask, and the 'autoshrink' (bool) field will trigger automated shrinking of the positions due to points outside the outline. Alternatively, a matplotlib patch object can be passed for advanced masking options, either directly or as a function that returns patches (required for multi-axis plots). If None, nothing will be drawn. Defaults to 'head'. axes : list of axes | None List of axes to plot consecutive topographies to. If None the axes will be created automatically. Defaults to None. show : bool Show figure if True. verbose : bool, str, int, or None If not None, override default verbose level (see mne.verbose). Returns ------- fig : instance of matplotlib figure Figure distributing one image per channel across sensor topography. """ from ..channels import _get_ch_type ch_type = _get_ch_type(epochs, ch_type) picks, pos, merge_grads, names, ch_type = _prepare_topo_plot( epochs, ch_type, layout) psds, freqs = psd_multitaper(epochs, tmin=tmin, tmax=tmax, bandwidth=bandwidth, adaptive=adaptive, low_bias=low_bias, normalization=normalization, picks=picks, proj=proj, n_jobs=n_jobs) psds = np.mean(psds, axis=0) if merge_grads: from ..channels.layout import _merge_grad_data psds = _merge_grad_data(psds) return plot_psds_topomap( psds=psds, freqs=freqs, pos=pos, agg_fun=agg_fun, vmin=vmin, vmax=vmax, bands=bands, cmap=cmap, dB=dB, normalize=normalize, cbar_fmt=cbar_fmt, outlines=outlines, axes=axes, show=show) def plot_psds_topomap( psds, freqs, pos, agg_fun=None, vmin=None, vmax=None, bands=None, cmap=None, dB=True, normalize=False, cbar_fmt='%0.3f', outlines='head', axes=None, show=True): """Plot spatial maps of PSDs Parameters ---------- psds : np.ndarray of float, shape (n_channels, n_freqs) Power spectral densities freqs : np.ndarray of float, shape (n_freqs) Frequencies used to compute psds. pos : numpy.ndarray of float, shape (n_sensors, 2) The positions of the sensors. agg_fun : callable The function used to aggregate over frequencies. Defaults to np.sum. if normalize is True, else np.mean. vmin : float | callable | None The value specifying the lower bound of the color range. If None np.min(data) is used. If callable, the output equals vmin(data). vmax : float | callable | None The value specifying the upper bound of the color range. If None, the maximum absolute value is used. If callable, the output equals vmax(data). Defaults to None. bands : list of tuple | None The lower and upper frequency and the name for that band. If None, (default) expands to: bands = [(0, 4, 'Delta'), (4, 8, 'Theta'), (8, 12, 'Alpha'), (12, 30, 'Beta'), (30, 45, 'Gamma')] cmap : matplotlib colormap | (colormap, bool) | 'interactive' | None Colormap to use. If tuple, the first value indicates the colormap to use and the second value is a boolean defining interactivity. In interactive mode the colors are adjustable by clicking and dragging the colorbar with left and right mouse button. Left mouse button moves the scale up and down and right mouse button adjusts the range. Hitting space bar resets the range. Up and down arrows can be used to change the colormap. If None (default), 'Reds' is used for all positive data, otherwise defaults to 'RdBu_r'. If 'interactive', translates to (None, True). dB : bool If True, transform data to decibels (with ``10 * np.log10(data)``) following the application of `agg_fun`. Only valid if normalize is False. normalize : bool If True, each band will be divided by the total power. Defaults to False. cbar_fmt : str The colorbar format. Defaults to '%0.3f'. outlines : 'head' | 'skirt' | dict | None The outlines to be drawn. If 'head', the default head scheme will be drawn. If 'skirt' the head scheme will be drawn, but sensors are allowed to be plotted outside of the head circle. If dict, each key refers to a tuple of x and y positions, the values in 'mask_pos' will serve as image mask, and the 'autoshrink' (bool) field will trigger automated shrinking of the positions due to points outside the outline. Alternatively, a matplotlib patch object can be passed for advanced masking options, either directly or as a function that returns patches (required for multi-axis plots). If None, nothing will be drawn. Defaults to 'head'. axes : list of axes | None List of axes to plot consecutive topographies to. If None the axes will be created automatically. Defaults to None. show : bool Show figure if True. Returns ------- fig : instance of matplotlib figure Figure distributing one image per channel across sensor topography. """ import matplotlib.pyplot as plt if bands is None: bands = [(0, 4, 'Delta'), (4, 8, 'Theta'), (8, 12, 'Alpha'), (12, 30, 'Beta'), (30, 45, 'Gamma')] if agg_fun is None: agg_fun = np.sum if normalize is True else np.mean if normalize is True: psds /= psds.sum(axis=-1)[..., None] assert np.allclose(psds.sum(axis=-1), 1.) n_axes = len(bands) if axes is not None: _validate_if_list_of_axes(axes, n_axes) fig = axes[0].figure else: fig, axes = plt.subplots(1, n_axes, figsize=(2 * n_axes, 1.5)) if n_axes == 1: axes = [axes] for ax, (fmin, fmax, title) in zip(axes, bands): freq_mask = (fmin < freqs) & (freqs < fmax) if freq_mask.sum() == 0: raise RuntimeError('No frequencies in band "%s" (%s, %s)' % (title, fmin, fmax)) data = agg_fun(psds[:, freq_mask], axis=1) if dB is True and normalize is False: data = 10 * np.log10(data) unit = 'dB' else: unit = 'power' _plot_topomap_multi_cbar(data, pos, ax, title=title, vmin=vmin, vmax=vmax, cmap=cmap, outlines=outlines, colorbar=True, unit=unit, cbar_fmt=cbar_fmt) tight_layout(fig=fig) fig.canvas.draw() plt_show(show) return fig def plot_layout(layout, show=True): """Plot the sensor positions. Parameters ---------- layout : None | Layout Layout instance specifying sensor positions. show : bool Show figure if True. Defaults to True. Returns ------- fig : instance of matplotlib figure Figure containing the sensor topography. Notes ----- .. versionadded:: 0.12.0 """ import matplotlib.pyplot as plt fig = plt.figure() ax = fig.add_subplot(111) fig.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=None, hspace=None) ax.set_xticks([]) ax.set_yticks([]) pos = [(p[0] + p[2] / 2., p[1] + p[3] / 2.) for p in layout.pos] pos, outlines = _check_outlines(pos, 'head') _draw_outlines(ax, outlines) for ii, (this_pos, ch_id) in enumerate(zip(pos, layout.names)): ax.annotate(ch_id, xy=this_pos[:2], horizontalalignment='center', verticalalignment='center', size='x-small') plt_show(show) return fig def _onselect(eclick, erelease, tfr, pos, ch_type, itmin, itmax, ifmin, ifmax, cmap, fig, layout=None): """Callback called from topomap for drawing average tfr over channels.""" import matplotlib.pyplot as plt pos, _ = _check_outlines(pos, outlines='head', head_pos=None) ax = eclick.inaxes xmin = min(eclick.xdata, erelease.xdata) xmax = max(eclick.xdata, erelease.xdata) ymin = min(eclick.ydata, erelease.ydata) ymax = max(eclick.ydata, erelease.ydata) indices = [i for i in range(len(pos)) if pos[i][0] < xmax and pos[i][0] > xmin and pos[i][1] < ymax and pos[i][1] > ymin] for idx, circle in enumerate(ax.artists): if idx in indices: circle.set_color('r') else: circle.set_color('black') plt.gcf().canvas.draw() if not indices: return data = tfr.data if ch_type == 'mag': picks = pick_types(tfr.info, meg=ch_type, ref_meg=False) data = np.mean(data[indices, ifmin:ifmax, itmin:itmax], axis=0) chs = [tfr.ch_names[picks[x]] for x in indices] elif ch_type == 'grad': from ..channels.layout import _pair_grad_sensors grads = _pair_grad_sensors(tfr.info, layout=layout, topomap_coords=False) idxs = list() for idx in indices: idxs.append(grads[idx * 2]) idxs.append(grads[idx * 2 + 1]) # pair of grads data = np.mean(data[idxs, ifmin:ifmax, itmin:itmax], axis=0) chs = [tfr.ch_names[x] for x in idxs] elif ch_type == 'eeg': picks = pick_types(tfr.info, meg=False, eeg=True, ref_meg=False) data = np.mean(data[indices, ifmin:ifmax, itmin:itmax], axis=0) chs = [tfr.ch_names[picks[x]] for x in indices] logger.info('Averaging TFR over channels ' + str(chs)) if len(fig) == 0: fig.append(figure_nobar()) if not plt.fignum_exists(fig[0].number): fig[0] = figure_nobar() ax = fig[0].add_subplot(111) itmax = len(tfr.times) - 1 if itmax is None else min(itmax, len(tfr.times) - 1) ifmax = len(tfr.freqs) - 1 if ifmax is None else min(ifmax, len(tfr.freqs) - 1) if itmin is None: itmin = 0 if ifmin is None: ifmin = 0 extent = (tfr.times[itmin] * 1e3, tfr.times[itmax] * 1e3, tfr.freqs[ifmin], tfr.freqs[ifmax]) title = 'Average over %d %s channels.' % (len(chs), ch_type) ax.set_title(title) ax.set_xlabel('Time (ms)') ax.set_ylabel('Frequency (Hz)') img = ax.imshow(data, extent=extent, aspect="auto", origin="lower", cmap=cmap) if len(fig[0].get_axes()) < 2: fig[0].get_axes()[1].cbar = fig[0].colorbar(mappable=img) else: fig[0].get_axes()[1].cbar.on_mappable_changed(mappable=img) fig[0].canvas.draw() plt.figure(fig[0].number) plt_show(True) def _prepare_topomap(pos, ax): """Helper for preparing the topomap.""" pos_x = pos[:, 0] pos_y = pos[:, 1] _hide_frame(ax) if any([not pos_y.any(), not pos_x.any()]): raise RuntimeError('No position information found, cannot compute ' 'geometries for topomap.') return pos_x, pos_y def _hide_frame(ax): """Helper to hide axis frame for topomaps.""" ax.get_yticks() ax.xaxis.set_ticks([]) ax.yaxis.set_ticks([]) ax.set_frame_on(False) def _init_anim(ax, ax_line, ax_cbar, params, merge_grads): """Initialize animated topomap.""" from matplotlib import pyplot as plt, patches logger.info('Initializing animation...') data = params['data'] items = list() if params['butterfly']: all_times = params['all_times'] for idx in range(len(data)): ax_line.plot(all_times, data[idx], color='k') vmin, vmax = _setup_vmin_vmax(data, None, None) ax_line.set_yticks(np.around(np.linspace(vmin, vmax, 5), -1)) params['line'], = ax_line.plot([all_times[0], all_times[0]], ax_line.get_ylim(), color='r') items.append(params['line']) if merge_grads: from mne.channels.layout import _merge_grad_data data = _merge_grad_data(data) norm = True if np.min(data) > 0 else False cmap = 'Reds' if norm else 'RdBu_r' vmin, vmax = _setup_vmin_vmax(data, None, None, norm) pos, outlines = _check_outlines(params['pos'], 'head', None) pos_x = pos[:, 0] pos_y = pos[:, 1] _hide_frame(ax) xlim = np.inf, -np.inf, ylim = np.inf, -np.inf, mask_ = np.c_[outlines['mask_pos']] xmin, xmax = (np.min(np.r_[xlim[0], mask_[:, 0]]), np.max(np.r_[xlim[1], mask_[:, 0]])) ymin, ymax = (np.min(np.r_[ylim[0], mask_[:, 1]]), np.max(np.r_[ylim[1], mask_[:, 1]])) res = 64 xi = np.linspace(xmin, xmax, res) yi = np.linspace(ymin, ymax, res) Xi, Yi = np.meshgrid(xi, yi) params['Zis'] = list() for frame in params['frames']: Zi = _griddata(pos_x, pos_y, data[:, frame], Xi, Yi) params['Zis'].append(Zi) Zi = params['Zis'][0] zi_min = np.min(params['Zis']) zi_max = np.max(params['Zis']) cont_lims = np.linspace(zi_min, zi_max, 7, endpoint=False)[1:] _, pos = _make_image_mask(outlines, pos, res) params.update({'vmin': vmin, 'vmax': vmax, 'Xi': Xi, 'Yi': Yi, 'Zi': Zi, 'extent': (xmin, xmax, ymin, ymax), 'cmap': cmap, 'cont_lims': cont_lims}) # plot map and countour im = ax.imshow(Zi, cmap=cmap, vmin=vmin, vmax=vmax, origin='lower', aspect='equal', extent=(xmin, xmax, ymin, ymax), interpolation='bilinear') plt.colorbar(im, cax=ax_cbar, cmap=cmap) cont = ax.contour(Xi, Yi, Zi, levels=cont_lims, colors='k', linewidths=1) patch_ = patches.Ellipse((0, 0), 2 * outlines['clip_radius'][0], 2 * outlines['clip_radius'][1], clip_on=True, transform=ax.transData) im.set_clip_path(patch_) text = ax.text(0.55, 0.95, '', transform=ax.transAxes, va='center', ha='right') params['text'] = text items.append(im) items.append(text) for col in cont.collections: col.set_clip_path(patch_) outlines_ = _draw_outlines(ax, outlines) params.update({'patch': patch_, 'outlines': outlines_}) return tuple(items) + tuple(cont.collections) def _animate(frame, ax, ax_line, params): """Updates animated topomap.""" if params['pause']: frame = params['frame'] time_idx = params['frames'][frame] title = '%6.0f ms' % (params['times'][frame] * 1e3) if params['blit']: text = params['text'] else: ax.cla() # Clear old contours. text = ax.text(0.45, 1.15, '', transform=ax.transAxes) for k, (x, y) in params['outlines'].items(): if 'mask' in k: continue ax.plot(x, y, color='k', linewidth=1, clip_on=False) _hide_frame(ax) text.set_text(title) vmin = params['vmin'] vmax = params['vmax'] Xi = params['Xi'] Yi = params['Yi'] Zi = params['Zis'][frame] extent = params['extent'] cmap = params['cmap'] patch = params['patch'] im = ax.imshow(Zi, cmap=cmap, vmin=vmin, vmax=vmax, origin='lower', aspect='equal', extent=extent, interpolation='bilinear') cont_lims = params['cont_lims'] cont = ax.contour(Xi, Yi, Zi, levels=cont_lims, colors='k', linewidths=1) im.set_clip_path(patch) items = [im, text] for col in cont.collections: col.set_clip_path(patch) if params['butterfly']: all_times = params['all_times'] line = params['line'] line.remove() params['line'] = ax_line.plot([all_times[time_idx], all_times[time_idx]], ax_line.get_ylim(), color='r')[0] items.append(params['line']) params['frame'] = frame return tuple(items) + tuple(cont.collections) def _pause_anim(event, params): """Function for pausing and continuing the animation on mouse click""" params['pause'] = not params['pause'] def _key_press(event, params): """Function for handling key presses for the animation.""" if event.key == 'left': params['pause'] = True params['frame'] = max(params['frame'] - 1, 0) elif event.key == 'right': params['pause'] = True params['frame'] = min(params['frame'] + 1, len(params['frames']) - 1) def _topomap_animation(evoked, ch_type='mag', times=None, frame_rate=None, butterfly=False, blit=True, show=True): """Make animation of evoked data as topomap timeseries. Animation can be paused/resumed with left mouse button. Left and right arrow keys can be used to move backward or forward in time. Parameters ---------- evoked : instance of Evoked The evoked data. ch_type : str | None Channel type to plot. Accepted data types: 'mag', 'grad', 'eeg'. If None, first available channel type from ('mag', 'grad', 'eeg') is used. Defaults to None. times : array of floats | None The time points to plot. If None, 10 evenly spaced samples are calculated over the evoked time series. Defaults to None. frame_rate : int | None Frame rate for the animation in Hz. If None, frame rate = sfreq / 10. Defaults to None. butterfly : bool Whether to plot the data as butterfly plot under the topomap. Defaults to False. blit : bool Whether to use blit to optimize drawing. In general, it is recommended to use blit in combination with ``show=True``. If you intend to save the animation it is better to disable blit. For MacOSX blit is always disabled. Defaults to True. show : bool Whether to show the animation. Defaults to True. Returns ------- fig : instance of matplotlib figure The figure. anim : instance of matplotlib FuncAnimation Animation of the topomap. Notes ----- .. versionadded:: 0.12.0 """ from matplotlib import pyplot as plt, animation if ch_type is None: ch_type = _picks_by_type(evoked.info)[0][0] if ch_type not in ('mag', 'grad', 'eeg'): raise ValueError("Channel type not supported. Supported channel " "types include 'mag', 'grad' and 'eeg'.") if times is None: times = np.linspace(evoked.times[0], evoked.times[-1], 10) times = np.array(times) if times.ndim != 1: raise ValueError('times must be 1D, got %d dimensions' % times.ndim) if max(times) > evoked.times[-1] or min(times) < evoked.times[0]: raise ValueError('All times must be inside the evoked time series.') frames = [np.abs(evoked.times - time).argmin() for time in times] blit = False if plt.get_backend() == 'MacOSX' else blit picks, pos, merge_grads, _, ch_type = _prepare_topo_plot(evoked, ch_type=ch_type, layout=None) data = evoked.data[picks, :] data *= _handle_default('scalings')[ch_type] fig = plt.figure() offset = 0. if blit else 0.4 # XXX: blit changes the sizes for some reason ax = plt.axes([0. + offset / 2., 0. + offset / 2., 1. - offset, 1. - offset], xlim=(-1, 1), ylim=(-1, 1)) if butterfly: ax_line = plt.axes([0.2, 0.05, 0.6, 0.1], xlim=(evoked.times[0], evoked.times[-1])) else: ax_line = None if isinstance(frames, int): frames = np.linspace(0, len(evoked.times) - 1, frames).astype(int) ax_cbar = plt.axes([0.85, 0.1, 0.05, 0.8]) ax_cbar.set_title(_handle_default('units')[ch_type], fontsize=10) params = {'data': data, 'pos': pos, 'all_times': evoked.times, 'frame': 0, 'frames': frames, 'butterfly': butterfly, 'blit': blit, 'pause': False, 'times': times} init_func = partial(_init_anim, ax=ax, ax_cbar=ax_cbar, ax_line=ax_line, params=params, merge_grads=merge_grads) animate_func = partial(_animate, ax=ax, ax_line=ax_line, params=params) pause_func = partial(_pause_anim, params=params) fig.canvas.mpl_connect('button_press_event', pause_func) key_press_func = partial(_key_press, params=params) fig.canvas.mpl_connect('key_press_event', key_press_func) if frame_rate is None: frame_rate = evoked.info['sfreq'] / 10. interval = 1000 / frame_rate # interval is in ms anim = animation.FuncAnimation(fig, animate_func, init_func=init_func, frames=len(frames), interval=interval, blit=blit) fig.mne_animation = anim # to make sure anim is not garbage collected plt_show(show, block=False) if 'line' in params: # Finally remove the vertical line so it does not appear in saved fig. params['line'].remove() return fig, anim
bsd-3-clause
anntzer/scikit-learn
examples/cross_decomposition/plot_pcr_vs_pls.py
15
6952
""" ================================================================== Principal Component Regression vs Partial Least Squares Regression ================================================================== This example compares `Principal Component Regression <https://en.wikipedia.org/wiki/Principal_component_regression>`_ (PCR) and `Partial Least Squares Regression <https://en.wikipedia.org/wiki/Partial_least_squares_regression>`_ (PLS) on a toy dataset. Our goal is to illustrate how PLS can outperform PCR when the target is strongly correlated with some directions in the data that have a low variance. PCR is a regressor composed of two steps: first, :class:`~sklearn.decomposition.PCA` is applied to the training data, possibly performing dimensionality reduction; then, a regressor (e.g. a linear regressor) is trained on the transformed samples. In :class:`~sklearn.decomposition.PCA`, the transformation is purely unsupervised, meaning that no information about the targets is used. As a result, PCR may perform poorly in some datasets where the target is strongly correlated with *directions* that have low variance. Indeed, the dimensionality reduction of PCA projects the data into a lower dimensional space where the variance of the projected data is greedily maximized along each axis. Despite them having the most predictive power on the target, the directions with a lower variance will be dropped, and the final regressor will not be able to leverage them. PLS is both a transformer and a regressor, and it is quite similar to PCR: it also applies a dimensionality reduction to the samples before applying a linear regressor to the transformed data. The main difference with PCR is that the PLS transformation is supervised. Therefore, as we will see in this example, it does not suffer from the issue we just mentioned. """ print(__doc__) # %% # The data # -------- # # We start by creating a simple dataset with two features. Before we even dive # into PCR and PLS, we fit a PCA estimator to display the two principal # components of this dataset, i.e. the two directions that explain the most # variance in the data. import numpy as np import matplotlib.pyplot as plt from sklearn.decomposition import PCA rng = np.random.RandomState(0) n_samples = 500 cov = [[3, 3], [3, 4]] X = rng.multivariate_normal(mean=[0, 0], cov=cov, size=n_samples) pca = PCA(n_components=2).fit(X) plt.scatter(X[:, 0], X[:, 1], alpha=.3, label='samples') for i, (comp, var) in enumerate(zip(pca.components_, pca.explained_variance_)): comp = comp * var # scale component by its variance explanation power plt.plot([0, comp[0]], [0, comp[1]], label=f"Component {i}", linewidth=5, color=f"C{i + 2}") plt.gca().set(aspect='equal', title="2-dimensional dataset with principal components", xlabel='first feature', ylabel='second feature') plt.legend() plt.show() # %% # For the purpose of this example, we now define the target `y` such that it is # strongly correlated with a direction that has a small variance. To this end, # we will project `X` onto the second component, and add some noise to it. y = X.dot(pca.components_[1]) + rng.normal(size=n_samples) / 2 fig, axes = plt.subplots(1, 2, figsize=(10, 3)) axes[0].scatter(X.dot(pca.components_[0]), y, alpha=.3) axes[0].set(xlabel='Projected data onto first PCA component', ylabel='y') axes[1].scatter(X.dot(pca.components_[1]), y, alpha=.3) axes[1].set(xlabel='Projected data onto second PCA component', ylabel='y') plt.tight_layout() plt.show() # %% # Projection on one component and predictive power # ------------------------------------------------ # # We now create two regressors: PCR and PLS, and for our illustration purposes # we set the number of components to 1. Before feeding the data to the PCA step # of PCR, we first standardize it, as recommended by good practice. The PLS # estimator has built-in scaling capabilities. # # For both models, we plot the projected data onto the first component against # the target. In both cases, this projected data is what the regressors will # use as training data. from sklearn.model_selection import train_test_split from sklearn.pipeline import make_pipeline from sklearn.linear_model import LinearRegression from sklearn.preprocessing import StandardScaler from sklearn.decomposition import PCA from sklearn.cross_decomposition import PLSRegression X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=rng) pcr = make_pipeline(StandardScaler(), PCA(n_components=1), LinearRegression()) pcr.fit(X_train, y_train) pca = pcr.named_steps['pca'] # retrieve the PCA step of the pipeline pls = PLSRegression(n_components=1) pls.fit(X_train, y_train) fig, axes = plt.subplots(1, 2, figsize=(10, 3)) axes[0].scatter(pca.transform(X_test), y_test, alpha=.3, label='ground truth') axes[0].scatter(pca.transform(X_test), pcr.predict(X_test), alpha=.3, label='predictions') axes[0].set(xlabel='Projected data onto first PCA component', ylabel='y', title='PCR / PCA') axes[0].legend() axes[1].scatter(pls.transform(X_test), y_test, alpha=.3, label='ground truth') axes[1].scatter(pls.transform(X_test), pls.predict(X_test), alpha=.3, label='predictions') axes[1].set(xlabel='Projected data onto first PLS component', ylabel='y', title='PLS') axes[1].legend() plt.tight_layout() plt.show() # %% # As expected, the unsupervised PCA transformation of PCR has dropped the # second component, i.e. the direction with the lowest variance, despite # it being the most predictive direction. This is because PCA is a completely # unsupervised transformation, and results in the projected data having a low # predictive power on the target. # # On the other hand, the PLS regressor manages to capture the effect of the # direction with the lowest variance, thanks to its use of target information # during the transformation: it can recogize that this direction is actually # the most predictive. We note that the first PLS component is negatively # correlated with the target, which comes from the fact that the signs of # eigenvectors are arbitrary. # # We also print the R-squared scores of both estimators, which further confirms # that PLS is a better alternative than PCR in this case. A negative R-squared # indicates that PCR performs worse than a regressor that would simply predict # the mean of the target. print(f"PCR r-squared {pcr.score(X_test, y_test):.3f}") print(f"PLS r-squared {pls.score(X_test, y_test):.3f}") # %% # As a final remark, we note that PCR with 2 components performs as well as # PLS: this is because in this case, PCR was able to leverage the second # component which has the most preditive power on the target. pca_2 = make_pipeline(PCA(n_components=2), LinearRegression()) pca_2.fit(X_train, y_train) print(f"PCR r-squared with 2 components {pca_2.score(X_test, y_test):.3f}")
bsd-3-clause
marcsans/cnn-physics-perception
phy/lib/python2.7/site-packages/matplotlib/backends/backend_qt5agg.py
4
7845
""" Render to qt from agg """ from __future__ import (absolute_import, division, print_function, unicode_literals) from matplotlib.externals import six import ctypes import sys import traceback from matplotlib.figure import Figure from .backend_agg import FigureCanvasAgg from .backend_qt5 import QtCore from .backend_qt5 import QtGui from .backend_qt5 import FigureManagerQT from .backend_qt5 import NavigationToolbar2QT ##### Modified Qt5 backend import from .backend_qt5 import FigureCanvasQT ##### not used from .backend_qt5 import show from .backend_qt5 import draw_if_interactive from .backend_qt5 import backend_version ###### from .qt_compat import QT_API DEBUG = False _decref = ctypes.pythonapi.Py_DecRef _decref.argtypes = [ctypes.py_object] _decref.restype = None def new_figure_manager(num, *args, **kwargs): """ Create a new figure manager instance """ if DEBUG: print('backend_qt5agg.new_figure_manager') FigureClass = kwargs.pop('FigureClass', Figure) thisFig = FigureClass(*args, **kwargs) return new_figure_manager_given_figure(num, thisFig) def new_figure_manager_given_figure(num, figure): """ Create a new figure manager instance for the given figure. """ canvas = FigureCanvasQTAgg(figure) return FigureManagerQT(canvas, num) class FigureCanvasQTAggBase(object): """ The canvas the figure renders into. Calls the draw and print fig methods, creates the renderers, etc... Public attribute figure - A Figure instance """ def __init__(self, figure): super(FigureCanvasQTAggBase, self).__init__(figure=figure) self._agg_draw_pending = False def drawRectangle(self, rect): self._drawRect = rect self.update() def paintEvent(self, e): """ Copy the image from the Agg canvas to the qt.drawable. In Qt, all drawing should be done inside of here when a widget is shown onscreen. """ # if the canvas does not have a renderer, then give up and wait for # FigureCanvasAgg.draw(self) to be called if not hasattr(self, 'renderer'): return if DEBUG: print('FigureCanvasQtAgg.paintEvent: ', self, self.get_width_height()) if self.blitbox is None: # matplotlib is in rgba byte order. QImage wants to put the bytes # into argb format and is in a 4 byte unsigned int. Little endian # system is LSB first and expects the bytes in reverse order # (bgra). if QtCore.QSysInfo.ByteOrder == QtCore.QSysInfo.LittleEndian: stringBuffer = self.renderer._renderer.tostring_bgra() else: stringBuffer = self.renderer._renderer.tostring_argb() refcnt = sys.getrefcount(stringBuffer) # convert the Agg rendered image -> qImage qImage = QtGui.QImage(stringBuffer, self.renderer.width, self.renderer.height, QtGui.QImage.Format_ARGB32) # get the rectangle for the image rect = qImage.rect() p = QtGui.QPainter(self) # reset the image area of the canvas to be the back-ground color p.eraseRect(rect) # draw the rendered image on to the canvas p.drawPixmap(QtCore.QPoint(0, 0), QtGui.QPixmap.fromImage(qImage)) # draw the zoom rectangle to the QPainter if self._drawRect is not None: p.setPen(QtGui.QPen(QtCore.Qt.black, 1, QtCore.Qt.DotLine)) x, y, w, h = self._drawRect p.drawRect(x, y, w, h) p.end() # This works around a bug in PySide 1.1.2 on Python 3.x, # where the reference count of stringBuffer is incremented # but never decremented by QImage. # TODO: revert PR #1323 once the issue is fixed in PySide. del qImage if refcnt != sys.getrefcount(stringBuffer): _decref(stringBuffer) else: bbox = self.blitbox l, b, r, t = bbox.extents w = int(r) - int(l) h = int(t) - int(b) t = int(b) + h reg = self.copy_from_bbox(bbox) stringBuffer = reg.to_string_argb() qImage = QtGui.QImage(stringBuffer, w, h, QtGui.QImage.Format_ARGB32) # Adjust the stringBuffer reference count to work around a memory # leak bug in QImage() under PySide on Python 3.x if QT_API == 'PySide' and six.PY3: ctypes.c_long.from_address(id(stringBuffer)).value = 1 pixmap = QtGui.QPixmap.fromImage(qImage) p = QtGui.QPainter(self) p.drawPixmap(QtCore.QPoint(l, self.renderer.height-t), pixmap) # draw the zoom rectangle to the QPainter if self._drawRect is not None: p.setPen(QtGui.QPen(QtCore.Qt.black, 1, QtCore.Qt.DotLine)) x, y, w, h = self._drawRect p.drawRect(x, y, w, h) p.end() self.blitbox = None def draw(self): """ Draw the figure with Agg, and queue a request for a Qt draw. """ # The Agg draw is done here; delaying causes problems with code that # uses the result of the draw() to update plot elements. FigureCanvasAgg.draw(self) self.update() def draw_idle(self): """ Queue redraw of the Agg buffer and request Qt paintEvent. """ # The Agg draw needs to be handled by the same thread matplotlib # modifies the scene graph from. Post Agg draw request to the # current event loop in order to ensure thread affinity and to # accumulate multiple draw requests from event handling. # TODO: queued signal connection might be safer than singleShot if not self._agg_draw_pending: self._agg_draw_pending = True QtCore.QTimer.singleShot(0, self.__draw_idle_agg) def __draw_idle_agg(self, *args): if self.height() < 0 or self.width() < 0: self._agg_draw_pending = False return try: FigureCanvasAgg.draw(self) self.update() except Exception: # Uncaught exceptions are fatal for PyQt5, so catch them instead. traceback.print_exc() finally: self._agg_draw_pending = False def blit(self, bbox=None): """ Blit the region in bbox """ # If bbox is None, blit the entire canvas. Otherwise # blit only the area defined by the bbox. if bbox is None and self.figure: bbox = self.figure.bbox self.blitbox = bbox l, b, w, h = bbox.bounds t = b + h self.repaint(l, self.renderer.height-t, w, h) def print_figure(self, *args, **kwargs): FigureCanvasAgg.print_figure(self, *args, **kwargs) self.draw() class FigureCanvasQTAgg(FigureCanvasQTAggBase, FigureCanvasQT, FigureCanvasAgg): """ The canvas the figure renders into. Calls the draw and print fig methods, creates the renderers, etc. Modified to import from Qt5 backend for new-style mouse events. Public attribute figure - A Figure instance """ def __init__(self, figure): if DEBUG: print('FigureCanvasQtAgg: ', figure) super(FigureCanvasQTAgg, self).__init__(figure=figure) self._drawRect = None self.blitbox = None self.setAttribute(QtCore.Qt.WA_OpaquePaintEvent) FigureCanvas = FigureCanvasQTAgg FigureManager = FigureManagerQT
mit
holdenk/spark
python/pyspark/sql/tests/test_pandas_cogrouped_map.py
20
9306
# # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You under the Apache License, Version 2.0 # (the "License"); you may not use this file except in compliance with # the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # import unittest from pyspark.sql.functions import array, explode, col, lit, udf, pandas_udf from pyspark.sql.types import DoubleType, StructType, StructField, Row from pyspark.testing.sqlutils import ReusedSQLTestCase, have_pandas, have_pyarrow, \ pandas_requirement_message, pyarrow_requirement_message from pyspark.testing.utils import QuietTest if have_pandas: import pandas as pd from pandas.testing import assert_frame_equal if have_pyarrow: import pyarrow as pa # noqa: F401 @unittest.skipIf( not have_pandas or not have_pyarrow, pandas_requirement_message or pyarrow_requirement_message) # type: ignore[arg-type] class CogroupedMapInPandasTests(ReusedSQLTestCase): @property def data1(self): return self.spark.range(10).toDF('id') \ .withColumn("ks", array([lit(i) for i in range(20, 30)])) \ .withColumn("k", explode(col('ks')))\ .withColumn("v", col('k') * 10)\ .drop('ks') @property def data2(self): return self.spark.range(10).toDF('id') \ .withColumn("ks", array([lit(i) for i in range(20, 30)])) \ .withColumn("k", explode(col('ks'))) \ .withColumn("v2", col('k') * 100) \ .drop('ks') def test_simple(self): self._test_merge(self.data1, self.data2) def test_left_group_empty(self): left = self.data1.where(col("id") % 2 == 0) self._test_merge(left, self.data2) def test_right_group_empty(self): right = self.data2.where(col("id") % 2 == 0) self._test_merge(self.data1, right) def test_different_schemas(self): right = self.data2.withColumn('v3', lit('a')) self._test_merge(self.data1, right, 'id long, k int, v int, v2 int, v3 string') def test_complex_group_by(self): left = pd.DataFrame.from_dict({ 'id': [1, 2, 3], 'k': [5, 6, 7], 'v': [9, 10, 11] }) right = pd.DataFrame.from_dict({ 'id': [11, 12, 13], 'k': [5, 6, 7], 'v2': [90, 100, 110] }) left_gdf = self.spark\ .createDataFrame(left)\ .groupby(col('id') % 2 == 0) right_gdf = self.spark \ .createDataFrame(right) \ .groupby(col('id') % 2 == 0) def merge_pandas(l, r): return pd.merge(l[['k', 'v']], r[['k', 'v2']], on=['k']) result = left_gdf \ .cogroup(right_gdf) \ .applyInPandas(merge_pandas, 'k long, v long, v2 long') \ .sort(['k']) \ .toPandas() expected = pd.DataFrame.from_dict({ 'k': [5, 6, 7], 'v': [9, 10, 11], 'v2': [90, 100, 110] }) assert_frame_equal(expected, result) def test_empty_group_by(self): left = self.data1 right = self.data2 def merge_pandas(l, r): return pd.merge(l, r, on=['id', 'k']) result = left.groupby().cogroup(right.groupby())\ .applyInPandas(merge_pandas, 'id long, k int, v int, v2 int') \ .sort(['id', 'k']) \ .toPandas() left = left.toPandas() right = right.toPandas() expected = pd \ .merge(left, right, on=['id', 'k']) \ .sort_values(by=['id', 'k']) assert_frame_equal(expected, result) def test_mixed_scalar_udfs_followed_by_cogrouby_apply(self): df = self.spark.range(0, 10).toDF('v1') df = df.withColumn('v2', udf(lambda x: x + 1, 'int')(df['v1'])) \ .withColumn('v3', pandas_udf(lambda x: x + 2, 'int')(df['v1'])) result = df.groupby().cogroup(df.groupby()) \ .applyInPandas(lambda x, y: pd.DataFrame([(x.sum().sum(), y.sum().sum())]), 'sum1 int, sum2 int').collect() self.assertEqual(result[0]['sum1'], 165) self.assertEqual(result[0]['sum2'], 165) def test_with_key_left(self): self._test_with_key(self.data1, self.data1, isLeft=True) def test_with_key_right(self): self._test_with_key(self.data1, self.data1, isLeft=False) def test_with_key_left_group_empty(self): left = self.data1.where(col("id") % 2 == 0) self._test_with_key(left, self.data1, isLeft=True) def test_with_key_right_group_empty(self): right = self.data1.where(col("id") % 2 == 0) self._test_with_key(self.data1, right, isLeft=False) def test_with_key_complex(self): def left_assign_key(key, l, _): return l.assign(key=key[0]) result = self.data1 \ .groupby(col('id') % 2 == 0)\ .cogroup(self.data2.groupby(col('id') % 2 == 0)) \ .applyInPandas(left_assign_key, 'id long, k int, v int, key boolean') \ .sort(['id', 'k']) \ .toPandas() expected = self.data1.toPandas() expected = expected.assign(key=expected.id % 2 == 0) assert_frame_equal(expected, result) def test_wrong_return_type(self): # Test that we get a sensible exception invalid values passed to apply left = self.data1 right = self.data2 with QuietTest(self.sc): with self.assertRaisesRegex( NotImplementedError, 'Invalid return type.*ArrayType.*TimestampType'): left.groupby('id').cogroup(right.groupby('id')).applyInPandas( lambda l, r: l, 'id long, v array<timestamp>') def test_wrong_args(self): left = self.data1 right = self.data2 with self.assertRaisesRegex(ValueError, 'Invalid function'): left.groupby('id').cogroup(right.groupby('id')) \ .applyInPandas(lambda: 1, StructType([StructField("d", DoubleType())])) def test_case_insensitive_grouping_column(self): # SPARK-31915: case-insensitive grouping column should work. df1 = self.spark.createDataFrame([(1, 1)], ("column", "value")) row = df1.groupby("ColUmn").cogroup( df1.groupby("COLUMN") ).applyInPandas(lambda r, l: r + l, "column long, value long").first() self.assertEqual(row.asDict(), Row(column=2, value=2).asDict()) df2 = self.spark.createDataFrame([(1, 1)], ("column", "value")) row = df1.groupby("ColUmn").cogroup( df2.groupby("COLUMN") ).applyInPandas(lambda r, l: r + l, "column long, value long").first() self.assertEqual(row.asDict(), Row(column=2, value=2).asDict()) def test_self_join(self): # SPARK-34319: self-join with FlatMapCoGroupsInPandas df = self.spark.createDataFrame([(1, 1)], ("column", "value")) row = df.groupby("ColUmn").cogroup( df.groupby("COLUMN") ).applyInPandas(lambda r, l: r + l, "column long, value long") row = row.join(row).first() self.assertEqual(row.asDict(), Row(column=2, value=2).asDict()) @staticmethod def _test_with_key(left, right, isLeft): def right_assign_key(key, l, r): return l.assign(key=key[0]) if isLeft else r.assign(key=key[0]) result = left \ .groupby('id') \ .cogroup(right.groupby('id')) \ .applyInPandas(right_assign_key, 'id long, k int, v int, key long') \ .toPandas() expected = left.toPandas() if isLeft else right.toPandas() expected = expected.assign(key=expected.id) assert_frame_equal(expected, result) @staticmethod def _test_merge(left, right, output_schema='id long, k int, v int, v2 int'): def merge_pandas(l, r): return pd.merge(l, r, on=['id', 'k']) result = left \ .groupby('id') \ .cogroup(right.groupby('id')) \ .applyInPandas(merge_pandas, output_schema)\ .sort(['id', 'k']) \ .toPandas() left = left.toPandas() right = right.toPandas() expected = pd \ .merge(left, right, on=['id', 'k']) \ .sort_values(by=['id', 'k']) assert_frame_equal(expected, result) if __name__ == "__main__": from pyspark.sql.tests.test_pandas_cogrouped_map import * # noqa: F401 try: import xmlrunner # type: ignore[import] testRunner = xmlrunner.XMLTestRunner(output='target/test-reports', verbosity=2) except ImportError: testRunner = None unittest.main(testRunner=testRunner, verbosity=2)
apache-2.0
ph4m/eand
eand/demo/multidiff_regular_demo.py
1
2528
''' eand package (Easy Algebraic Numerical Differentiation) Copyright (C) 2013 Tu-Hoa Pham This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. ''' import matplotlib.pyplot as plt from math import cos,sin import numpy as np from eand.mddig.multidiff import MultiDiff print 'Initializing estimation parameters...' Ns = 500 t1Min = -1.0 t1Max = 1.0 t2Min = -1.0 t2Max = 1.0 nSamplesSorted = [25,25] dtVec = [(t1Max-t1Min)/nSamplesSorted[0],(t2Max-t2Min)/nSamplesSorted[1]] tProto = np.arange(-1.,1.05,0.05) t1 = [] t2 = [] for i in tProto: for j in tProto: t1.append(i) t2.append(j) n1 = 1 alpha1 = 3 beta1 = 3 n2 = 0 alpha2 = 0 beta2 = 0 T1 = 0.25 T2 = 0.25 ''' # 1D case paramVec = [[n1,alpha1,beta1,T1]] tVec = [t1] ''' # 2D case paramVec = [[n1,alpha1,beta1,T1],[n2,alpha2,beta2,T2]] tVec = [t1,t2] nDim = len(tVec) nSamples = len(tVec[0]) signal = [cos(2*sum([t[i] for t in tVec])) for i in range(nSamples)] tVec = np.array(tVec) alreadySorted = 2 nSamplesSorted = [len(tProto),len(tProto)] toNextValueSorted = [round(np.product([nSamplesSorted[dim] for dim in range(i+1,alreadySorted)])) for i in range(alreadySorted)] dtVec = [tVec[i][toNextValueSorted[i]]-tVec[i][0] for i in range(alreadySorted)] print 'Building differentiator...' multiDiff = MultiDiff(paramVec,tVec,alreadySorted,nSamplesSorted) print 'Plotting partition...' multiDiff.plotPartition(0) print 'Commencing differentiation...' (tPostVec,dPost) = multiDiff.differentiate(signal) print 'Calculating reference derivative...' tSlice,dSlice = multiDiff.plotSlice(tPostVec,dPost,1,0.,0.1,0) if sum([paramVec[i][0] for i in range(nDim)]) == 1: dRef = [-2*sin(2*i) for i in tSlice] elif sum([paramVec[i][0] for i in range(nDim)]) == 2: dRef = [-4*cos(2*i) for i in tSlice] plt.plot(tSlice,dRef,'r.') print 'Plotting derivative estimate...' multiDiff.plotScatter(tPostVec, dPost,0) multiDiff.plotSurface(tPostVec, dPost,0) plt.show() print 'SUCCESS!' ''' '''
gpl-3.0
julioasotodv/spark-df-profiling
setup.py
1
1412
import os __location__ = os.path.dirname(__file__) try: from setuptools import setup except ImportError: from distutils.core import setup setup( name='spark-df-profiling', version='1.1.13', author='Julio Antonio Soto de Vicente', author_email='[email protected]', packages=['spark_df_profiling'], url='https://github.com/julioasotodv/spark-df-profiling', license='MIT', description='Create HTML profiling reports from Apache Spark DataFrames', install_requires=[ "pandas>=0.17.0", "matplotlib>=1.4", "jinja2>=2.8", "six>=1.9.0" ], include_package_data = True, classifiers=[ 'Development Status :: 3 - Alpha', 'Topic :: Software Development :: Build Tools', 'License :: OSI Approved :: MIT License', 'Environment :: Console', 'Operating System :: OS Independent', 'Intended Audience :: Science/Research', 'Intended Audience :: Developers', 'Topic :: Scientific/Engineering', 'Framework :: IPython', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.4', 'Programming Language :: Python :: 3.5' ], keywords='spark pyspark report big-data pandas data-science data-analysis python jupyter ipython', )
mit
ominux/scikit-learn
sklearn/svm/tests/test_bounds.py
2
2389
import nose import numpy as np from scipy import sparse as sp from sklearn.svm.bounds import l1_min_c from sklearn.svm import LinearSVC from sklearn.linear_model.logistic import LogisticRegression from sklearn.svm.sparse import LinearSVC as SparseSVC from sklearn.linear_model.sparse.logistic import LogisticRegression as \ SparseLogRegression dense_X = [[-1, 0], [0, 1], [1, 1], [1, 1]] sparse_X = sp.csr_matrix(dense_X) Y1 = [0, 1, 1, 1] Y2 = [2, 1, 0, 0] def test_l1_min_c(): losses = ['l2', 'log'] Xs = {'sparse': sparse_X, 'dense': dense_X} Ys = {'two-classes': Y1, 'multi-class': Y2} intercepts = {'no-intercept': {'fit_intercept': False}, 'fit-intercept': {'fit_intercept': True, 'intercept_scaling': 10}} for loss in losses: for X_label, X in Xs.items(): for Y_label, Y in Ys.items(): for intercept_label, intercept_params in intercepts.items(): check = lambda: check_l1_min_c(X, Y, loss, **intercept_params) check.description = 'Test l1_min_c loss=%r %s %s %s' % \ (loss, X_label, Y_label, intercept_label) yield check def check_l1_min_c(X, y, loss, fit_intercept=True, intercept_scaling=None): min_c = l1_min_c(X, y, loss, fit_intercept, intercept_scaling) clf = { ('log', False): LogisticRegression(penalty='l1'), ('log', True): SparseLogRegression(penalty='l1'), ('l2', False): LinearSVC(loss='l2', penalty='l1', dual=False), ('l2', True): SparseSVC(loss='l2', penalty='l1', dual=False), }[loss, sp.issparse(X)] clf.fit_intercept = fit_intercept clf.intercept_scaling = intercept_scaling clf.C = min_c clf.fit(X, y) assert (np.asanyarray(clf.coef_) == 0).all() assert (np.asanyarray(clf.intercept_) == 0).all() clf.C = min_c * 1.01 clf.fit(X, y) assert (np.asanyarray(clf.coef_) != 0).any() or \ (np.asanyarray(clf.intercept_) != 0).any() @nose.tools.raises(ValueError) def test_ill_posed_min_c(): X = [[0, 0], [0, 0]] y = [0, 1] l1_min_c(X, y) @nose.tools.raises(ValueError) def test_unsupported_loss(): l1_min_c(dense_X, Y1, 'l1')
bsd-3-clause
dfdx/masque
others/faceless-python-old/faceless/procrustes_simple.py
1
3486
import cv2 from numpy import * import matplotlib.delaunay as triang import pylab from helpers import * def mean_of_columns(mat): """Returns 1-row matrix representing means of corresponding columns """ return mat.mean(axis=0) def center(shp): return mean_of_columns(shp) def move_to(shp, p): """Moves shape so that its center is in point p """ center = mean_of_columns(shp) # print center return (shp + p - center).astype(int) def move_to_origin(pts): """Moves shape to origin and returns previous coordinates of center of the shape """ avgs = mean_of_columns(pts) for i in range(avgs.shape[0]): pts[:, i] = pts[:, i] - avgs[i] return avgs.tolist() def dist_from_origin(pts): """Returns distance of every point from origin. Points should be given as column matrix, where each row represents point in N-dimensional space""" x2 = pow(pts[:, 0], 2) y2 = pow(pts[:, 1], 2) return sqrt(x2 + y2) def scale_factor(pts, pts_r): dist = dist_from_origin(pts) dist_r = dist_from_origin(pts_r) return mean(dist) / mean(dist_r) def rotate(shp, angle): rot_mat = array([[cos(angle), -sin(angle)], [sin(angle), cos(angle)]]) shp_t = shp.transpose() return dot(rot_mat, shp_t).transpose() def rad_to_degree(radians): return double(radians) * 180 / pi def degree_to_rad(degrees): return double(degrees) * pi / 180 def angle_diff(a, b): # return arctan2(sin(a - b), cos(a - b)) # print a, b d = a - b if d > pi: d -= 2 * pi if d < -pi: d += 2 * pi return d def angle_diff2(x, y): return [angle_diff(a, b) for a, b in zip(x.tolist(), y.tolist())] def move_to_center(shp, size=(480, 640, 3)): hm = size[0] / 2 wm = size[1] / 2 return move_to(shp, (wm, hm)) def procrustes(shape_ref, shape): """ Aligns N dimentional shape represented as N-column matrix "shape" to reference shape "shape_ref" of same dimentions """ shp = copy(shape) shp_ref = copy(shape_ref) move_to_origin(shp) center = move_to_origin(shp_ref) scale = scale_factor(shp, shp_ref) shp *= scale rot = arctan2(shp[:, 1], shp[:, 0]) rot_r = arctan2(shp_ref[:, 1], shp_ref[:, 0]) rot_offset = -mean(angle_diff2(rot, rot_r)) shp = rotate(shp, rot_offset) shp = move_to(shp, center) return shp.astype(int) # def procrustes(shapes): # shp_ref = move_to_center(shapes[0]) # return [align(shp_ref, shp) for shp in shapes] ######### shortcuts ######### def show_aligned(shp_ref, shp): shp_aligned = align(shp_ref, shp) black = zeros((480, 640, 3)) drawshape(black, shp_ref, color=(255, 0, 0), method='poly') drawshape(black, shp, color=(0, 255, 0), method='poly') drawshape(black, shp_aligned, color=(255, 255, 255), method='poly') show(black) def plot_delaunay(pts): x = pts[:, 0] y = pts[:, 1] cens, edg, tri, neig = triang.delaunay(x, y) for t in tri: t_i = [t[0], t[1], t[2], t[0]] pylab.plot(x[t_i], y[t_i]) pylab.plot(x, y, 'o') pylab.show() def show_pdm(shapes, size=(480, 640)): black = zeros(size) shapes = procrustes(shapes) for shp in shapes: drawshape(black, shp, pt_sz=1) show(black) ########################### def go(): shapes = icaam_shapes() show_pdm(shapes)
mit
jelledevleeschouwer/geomess
apps/IEEE802154/plot.py
4
1038
import numpy as np import matplotlib.pyplot as plt import matplotlib.animation as animation import sys maxrange = 0 minrange = 0 fig1 = plt.figure() ax = fig1.add_subplot(111, aspect = "equal") def addnode(x,y,rm,rg, minrange, maxrange): ax.plot([x],[y], 'ro') circle=plt.Circle((x,y),rm,color='r', fill=False) circleg=plt.Circle((x,y),rg,color='g', fill=False) fig1.gca().add_artist(circle) fig1.gca().add_artist(circleg) if maxrange < x + rm: maxrange = x + rm if maxrange < y + rm: maxrange = y + rm if minrange > x - rm: minrange = x - rm if minrange > y - rm: minrange = y - rm return minrange,maxrange f = open("map.csv") or sys.exit() while True: l = f.readline() if l == "": break pos = l.split(',') minrange,maxrange = addnode(int(pos[0]), int(pos[1]), int(pos[2]), int(pos[3]), minrange,maxrange) f.close() print("min max:",minrange," ",maxrange) ax.set_xlim((minrange,maxrange)) ax.set_ylim((minrange,maxrange)) plt.show()
gpl-2.0
rhiever/sklearn-benchmarks
model_code/random_search_preprocessing/BernoulliNB.py
1
2184
import sys import pandas as pd import numpy as np from sklearn.preprocessing import Binarizer, MaxAbsScaler, MinMaxScaler from sklearn.preprocessing import Normalizer, PolynomialFeatures, RobustScaler, StandardScaler from sklearn.decomposition import FastICA, PCA from sklearn.kernel_approximation import RBFSampler, Nystroem from sklearn.cluster import FeatureAgglomeration from sklearn.feature_selection import SelectFwe, SelectPercentile, VarianceThreshold from sklearn.feature_selection import SelectFromModel, RFE from sklearn.ensemble import ExtraTreesClassifier from sklearn.naive_bayes import BernoulliNB from evaluate_model import evaluate_model dataset = sys.argv[1] num_param_combinations = int(sys.argv[2]) random_seed = int(sys.argv[3]) preprocessor_num = int(sys.argv[4]) np.random.seed(random_seed) preprocessor_list = [Binarizer, MaxAbsScaler, MinMaxScaler, Normalizer, PolynomialFeatures, RobustScaler, StandardScaler, FastICA, PCA, RBFSampler, Nystroem, FeatureAgglomeration, SelectFwe, SelectPercentile, VarianceThreshold, SelectFromModel, RFE] chosen_preprocessor = preprocessor_list[preprocessor_num] pipeline_components = [chosen_preprocessor, BernoulliNB] pipeline_parameters = {} alpha_values = np.random.uniform(low=0., high=50., size=num_param_combinations) fit_prior_values = np.random.choice([True, False], size=num_param_combinations) binarize_values = np.random.uniform(low=0., high=1., size=num_param_combinations) all_param_combinations = zip(alpha_values, fit_prior_values, binarize_values) pipeline_parameters[BernoulliNB] = [{'alpha': alpha, 'fit_prior': fit_prior, 'binarize': binarize} for (alpha, fit_prior, binarize) in all_param_combinations] if chosen_preprocessor is SelectFromModel: pipeline_parameters[SelectFromModel] = [{'estimator': ExtraTreesClassifier(n_estimators=100, random_state=324089)}] elif chosen_preprocessor is RFE: pipeline_parameters[RFE] = [{'estimator': ExtraTreesClassifier(n_estimators=100, random_state=324089)}] evaluate_model(dataset, pipeline_components, pipeline_parameters)
mit
zdvresearch/fast15-paper-extras
tape_mounts/robot_mount_logs/src/robot_components.py
1
135522
__author__ = 'maesker' from bisect import bisect_left, bisect_right from collections import Counter import json, os, string, re, csv, StringIO, sys, time, datetime, gzip, glob, calendar, math, copy import threading, multiprocessing, Queue, gc from multiprocessing.sharedctypes import Value, Array from correlation import corrPearson from StateMachine import FiniteStateMachine import python_daemon try: from HandyHelperTools.plotting import fast_plot import matplotlib.pyplot as plt import numpy #from TimeTools import get_epochs, Timer except: pass ## multi processing callback functions def _cb_gzipdmp(prefix, result): file = os.path.join("/tmp", "%s_%s.json"%(prefix,os.getpid())) print file with open(file, 'w') as f: json.dump(result, f, indent=1) def _cb_gzipload(file): res = None with open(file, 'r') as f: res = json.load(f) return res def calc_correlation(inque, correlated, getcrtcb, prefix, interval_secs): success = {} for i in sorted(interval_secs): success[i] = [] tmptotale, tmptotals = 0,0 while True: try: cid = inque.get(True,10) except Queue.Empty: break procs = [] crt = getcrtcb(cid, False) if crt: #print 'running cid', cid s,e = 0,0 for cid2 in sorted(correlated[cid]): crt2 = getcrtcb(cid2, False) if crt2: for event in crt.data['data']: (res, diffneg, diffpos) = crt2.will_see_mount_request(event[DATA_INDEX_REQM]) if res: if diffpos <= max(interval_secs): s += 1 index = bisect_left(interval_secs, diffpos) # print diff, interval_secs[index] success[interval_secs[index]].append(diffpos) continue # prefers positive diffs over negative, since positiv diffs are successful # prefetces. Negativ diffs are recent mounts that could be used to prevent # false prefetches #print cid, cid2, event, diff if abs(diffneg) <= max(interval_secs): s += 1 index = bisect_left(interval_secs, diffneg) # print diff, interval_secs[index] success[interval_secs[index]].append(diffneg) continue # continue with negative mount request diff. e+=1 # print "%s-%s: e:%i,\t s+:%i, \t s-:%i, \t"%(cid,cid2,e,s,s2) tmptotale += e tmptotals += s else: print "crt %s not found."%(cid) output = { 'errorcnt': tmptotale, 'successcnt': tmptotals, 'interval' : success } file = os.path.join("/tmp", "%s_%s.json.gz"%(prefix,os.getpid())) print 'writing ',file with gzip.open(file, 'w') as f: json.dump(output, f, indent=1) print 'exit' def add_correlated(d, a, b): for i in [a,b]: if i not in d.keys(): d[i]=set() d[a].add(b) d[b].add(a) def _tapestats(inqueue, slot, crtlist, getcrt, drvlist, getdrv, atts, prefix): x = {slot:{}} while True: try: tsstr = inqueue.get(True,10) ts = datetime.datetime.strptime(tsstr, "%Y-%m-%d %H:%M:%S") epochts = int(calendar.timegm(ts.utctimetuple())) epochse = epochts + get_slot_size_seconds(slot, ts.month, ts.year) #print slot,ts, epochts, epochse x[slot][tsstr]={VOL_MNT_LENGTH:0, CLN_TIME_LENGTH:0} for crt in crtlist: # not sorted x[slot][tsstr][VOL_MNT_LENGTH] += crt.get_volume(slot, ts) wq2 = multiprocessing.Queue() for drv in drvlist: x[slot][tsstr][CLN_TIME_LENGTH] += sum(drv.estimate_cleaning_time(epochts,epochse)) for att in atts: if att not in x[slot][tsstr].keys(): x[slot][tsstr][att] = 0 for drv in drvlist: val = drv.get_pertime(slot, ts, att) #print drv, slot, ts, att, val x[slot][tsstr][att] += val except Queue.Empty: break fn = "%s_%s"%(prefix,slot) _cb_gzipdmp(fn,x) def _cb_pertime(inqueue): while True: try: obj = inqueue.get(True, 10) obj.pertime() except Queue.Empty: break def _cb_drvclntime(epochts,epochse, inqueue, output, lock): res = 0 while True: try: drv = inqueue.get(True, 10) except Queue.Empty: break lock.acquire(True) output.value = output.value + res lock.release() def get_epoch(ts): t = time.strptime(ts, '%Y%m%d:%H%M%S') epoch = calendar.timegm(t) return epoch def unix_time(dt): epoch = datetime.datetime.utcfromtimestamp(0) delta = dt - epoch return delta.total_seconds() HID_INT_MAP = {'o':0} DRV_INT_MAP = {'o':0} def plot_dict(d, fn=None): keys = sorted(d.keys()) n = numpy.arange(len(keys)) ticksstep = int(math.sqrt(len(keys))) #print keys for k in keys: plt.bar(k, d[k]) plt.xticks(n[0::ticksstep], keys[0::ticksstep]) if fn: plt.savefig(fn) else: plt.show() def percentile(N, P): """ Find the percentile of a list of values @parameter N - A list of values. N must be sorted. @parameter P - A float value from 0.0 to 1.0 @return - The percentile of the values. """ if len(N)==0: return 0.0 n = int(round(P * len(N) + 0.5)) return N[n-1] def linebuf_write(buf, value): if type(value)==type(0.0): buf.write(";%.3f"%round(value,3)) elif type(value)==type(2): buf.write(";%i"%value) else: buf.write(";%s"%value) crtfilter_a = ['B' ,'P', 'Q', 'E', 'D'] crtfilter_b = ['MP', 'RT', 'ME', 'MS', 'M0', 'MA'] FULLRUN=False TIME_BTWN_MNTS = 'tbm' # time between dismount and mount cartridge CRT_MNT_LENGTH = 'ml' # time between mnt and dismount cartridge VOL_MNT_LENGTH = "vol_ml" # volume mount length CLN_TIME_LENGTH = 'clntm' # cleaning time TOTAL_MNTS = 'tm' TOTAL_MNT_TIME = 'tmt' LATENCY_MNT = "latmnt" # time between mnt request and mount LATENCY_DMNT = "latdismnt" # time between dismnt request and dismnt LATENCY_DMV_DMCR = "lat_dmv_dmcr" # time between volume dismount and cartridge dismount request LATENCY_HOME_AVG = "latency_mean" HOME_TOTAL_OPS = "home_total_ops" REMNT_30_SEC = 'rem_30_sec' # in percent REMNT_60_SEC = 'rem_60_sec' # in percent REMNT_120_SEC = 'rem_120_sec' # in percent REMNT_300_SEC = 'rem_300_sec' # in percent REMNT_600_SEC = 'rem_600_sec' # in percent REMNT_1800_SEC = 'rem_1800_sec' REMNT_3600_SEC = 'rem_3600_sec' # in percent REMNT_7200_SEC = 'rem_7200_sec' # in percent REMNT_86400_SEC = 'rem_86400_sec' # in percent REMNT_regexpattern = re.compile("rem_([0-9]+)_sec") HOTNESS = "hot" # hotness in hours PERTIMESLOT = ['per_hour', 'per_day', 'per_week','per_month', 'per_year'] def get_slot_end(ts, slot): return ts+datetime.timedelta(seconds=get_slot_size_seconds(slot,ts.month, ts.year)) def get_slot_size_seconds(slot, month, year): hour = 3600.0 if slot=='per_hour': return hour elif slot=='per_day': return hour*24 elif slot=='per_week': return hour*24*7 elif slot == 'per_month': if month in [0, 2, 4, 6, 7, 9, 11]: return hour*24*31 if month in [3, 5, 8, 10]: return hour*24*30 if not year % 4: return hour*24*29 return hour*24*28 elif slot == 'per_year': if not year%4: return hour*24*366 # leap year return hour*24*365 GLOBAL_CRT = [TOTAL_MNTS, REMNT_30_SEC, REMNT_60_SEC, REMNT_120_SEC, REMNT_300_SEC , REMNT_600_SEC, REMNT_1800_SEC, REMNT_3600_SEC, REMNT_7200_SEC,REMNT_86400_SEC ] GLOBAL_DRV = [TOTAL_MNTS, REMNT_30_SEC, REMNT_60_SEC, REMNT_120_SEC, REMNT_300_SEC , REMNT_600_SEC, REMNT_1800_SEC, REMNT_3600_SEC, REMNT_7200_SEC,REMNT_86400_SEC ] SPECIAL_CRT = [CRT_MNT_LENGTH, TIME_BTWN_MNTS, LATENCY_MNT, LATENCY_DMNT, LATENCY_DMV_DMCR] SPECIAL_DRV = [CRT_MNT_LENGTH, TIME_BTWN_MNTS, LATENCY_MNT, LATENCY_DMNT, CLN_TIME_LENGTH] GLOBAL_HM = [LATENCY_HOME_AVG, HOME_TOTAL_OPS] HOME_OPERATION_EJECT = 0 HOME_OPERATION_INJECT = 1 DATA_INDEX_REQM = 0 # request mount DATA_INDEX_M = 1 # mount done DATA_INDEX_VOLUME = 2 # volume (mount-dismounts) DATA_INDEX_REQD = 3 # request dismount cartridge DATA_INDEX_D = 4 # dismount cartridge DATA_INDEX_MH = 5 DATA_INDEX_DH = 6 DATA_INDEX_DRV = 7 # drive id, cartridge id or home id, FSM_CRT_HOME = 1 FSM_CRT_LOADING = 3 FSM_CRT_VOLMNTED = 4 FSM_CRT_LOADED = 5 FSM_CRT_UNLOADING = 6 FSM_CRT_NEW = 7 FSM_CRT_IMPLICIT_CRTMNT = 10 FSM_CRT_VOLMNTDISMNTFU = 11 FSM_CRT_ERROR = 20 FSM_CRT_ERROR_FATAL = 21 FSM_CRT_D2DMV = 22 FSM_CRT_EJECTED = 23 FSM_DRV_LOADED = 30 #FSM_DRV_DISMNTREQ = 31 FSM_DRV_EMPTY = 32 FSM_DRV_ERROR = 40 FSM_DRV_ERROR_FATAL = 41 FSM_DRV_MAYBERECOVERED = 42 FSM_EVNT_INJECT = 50 FSM_EVNT_EJECT = 51 FSM_EVNT_MNTREQ = 52 FSM_EVNT_MNTCMPLT = 53 FSM_EVNT_VOLDMNT = 54 FSM_EVNT_VOLMNT = 55 FSM_EVNT_DISMNTCRTCMPLT = 56 FSM_EVNT_DISMNTCRTREQ = 57 FSM_EVNT_FATALERROR_1 = 60 FSM_EVNT_RECOVER_FAT1 = 61 FSM_EVNT_D2DMV = 62 FSM_EVNT_ROB1 = 63 # robot unable to find cartridge FSM_EVNT_DELDRIVE = 64 class BaseStats: def __init__(self, basedir): self.data = { 'id':None, 'errors':[], 'inject':[], 'eject':[], 'data': [], } self.fsm = FiniteStateMachine() self.basedir = basedir if not os.path.exists(self.basedir ): os.makedirs(self.basedir) self.pertimeres = None self.flushactive() def active_is_nonempty(self): for i in [self.active['reqm'], self.active['m'], self.active['reqd'], self.active['d']]: return True if max(self.active['vol'].keys()) > 0: return True return False def flusherror(self): if self.active_is_nonempty(): self.data['errors'].append(self.active) self.flushactive() def _transform_dictentry(self, entry): y = [] if type(entry['vol'])==type({}): for k,v in sorted(entry['vol'].items()): y.append((int(k),int(v))) if type(entry['vol']) == type([]): for elem in sorted(entry['vol']): for k,v in elem.items(): y.append((int(k),int(v))) return [entry['reqm'], entry['m'], y, entry['reqd'], entry['d'], entry['mh'],entry['dh'], entry['drv']] def dataappend(self): if len(self.active['drv']) > 0 and \ (self.active['m'] > 0 or self.active['reqm']) and \ (self.active['d'] > 0 or self.active['reqd']): # entry look at DATA_INDEX_xxx global variables self.data['data'].append(self._transform_dictentry(self.active)) self.flushactive() else: self.flusherror() def datainsert(self, entry): for i in self.data['data']: if i[DATA_INDEX_REQM] >= entry['d']: index = self.data['data'].index(i) self.data['data'].insert(index, self._transform_dictentry(entry)) return self.data['data'].append(self._transform_dictentry(entry)) def flushactive(self): self.active = { 'reqm': 0, 'm' : 0, 'vol':{0:0}, 'reqd':0, 'd':0, 'mh':0, 'dh':0, 'drv':"" } def __repr__(self): return self.data['id'] def estimate_cleaning_time(self, start=None, end=None): return []# dummy, cartridge doesnt need this # ----------------------------- def collect_recovered_errors(self): total = len(self.data['errors']) def isvalid(entry): for k in ['m','d','reqd','reqm']: if not k in entry: return False if entry[k] <= 0: return False for k in ['mh','dh','drv']: if not k in entry: return False if type(entry[k])==type(1) or len(entry[k]) < 2: return False self.datainsert(entry) return True self.data['errors'][:] = [x for x in self.data['errors'] if not isvalid(x)] remaining = len(self.data['errors']) return (total-remaining, remaining) def get_successful_cycles(self): return len(self.data['data']) def get_failed_cycles(self): return len(self.data['errors']) def binsearch(self, data, entry, referenceindex, lo=0, hi=None): if hi is None: hi = max(0,len(data)-1 ) if abs(hi-lo)<2: if len(data)<hi: if data[hi][referenceindex] < entry: return hi return lo pos = (hi+lo)/2 if data[pos][referenceindex]>entry: hi = pos else: lo = pos return self.binsearch(data,entry,referenceindex,lo,hi) def robot_mount(self, epoch, drive, library): most_likeley_entry = {} startindex = self.binsearch(self.data['data'], epoch, DATA_INDEX_REQM) while(startindex < len(self.data['data'])): entry = self.data['data'][startindex] if entry[DATA_INDEX_REQM] < epoch: if entry[DATA_INDEX_DRV] == drive: diff_m = entry[DATA_INDEX_M] - epoch if abs(diff_m) <= 600 : index = self.data['data'].index(entry) most_likeley_entry[diff_m]=index else: break startindex += 1 if len(most_likeley_entry)>0: x = min(most_likeley_entry.keys()) #print x, most_likeley_entry[x] entry = self.data['data'][most_likeley_entry[x]] entry[DATA_INDEX_MH] = library return True else: plausible_entries = {} for entry in self.data['errors']: if entry['drv'] == drive: diff = entry['m'] - epoch if abs(diff) <= 120: #print "ok error entry found... ", entry entry['mh']=library return True diff_mr = epoch - entry['reqm'] if diff_mr > 0 and diff_mr < 120: entry['m']=epoch entry['mh']=library return True if entry['d'] > epoch: diff = entry['d'] - epoch plausible_entries[diff] = entry if len(plausible_entries)>0: entry = plausible_entries[min(plausible_entries.keys())] entry['m']=epoch entry['mh']=library return True self.data['errors'].append({'m':epoch, 'reqm':0, 'reqd':0, 'd':0, 'vol':{0:0}, 'mh':library, 'drv':drive, 'dh':""}) #print "mount Nothing found" def robot_dismount(self, epoch, drive, library): most_likeley_entry = {} startindex = self.binsearch(self.data['data'], epoch, DATA_INDEX_REQD) while(startindex < len(self.data['data'])): entry = self.data['data'][startindex] #for entry in self.data['data']: if entry[DATA_INDEX_REQD] < epoch: if entry[DATA_INDEX_DRV] == drive: diff_m = entry[DATA_INDEX_D] - epoch if diff_m >= 0 or entry[DATA_INDEX_D]==0: index = self.data['data'].index(entry) most_likeley_entry[diff_m]=index else: break startindex += 1 if len(most_likeley_entry)>0: x = min(most_likeley_entry.keys()) #print x, most_likeley_entry[x] entry = self.data['data'][most_likeley_entry[x]] entry[DATA_INDEX_DH] = library if entry[DATA_INDEX_D]==0: entry[DATA_INDEX_D]=epoch return True else: plausible_entries = {} for entry in self.data['errors']: if entry['drv']==drive: if entry['d'] <= epoch: diff = entry['d'] - epoch if diff >= 0 and diff < 120: #print "ok error entry found... ", entry entry['dh']=library return True if entry['reqd'] <= epoch: diff = epoch - entry['reqd'] if diff < 120: #print "ok error entry found... ", entry entry['d'] = epoch entry['dh']=library return True if entry['m'] < epoch: diff = epoch - entry['m'] plausible_entries[diff]=entry if len(plausible_entries)>0: entry = plausible_entries[min(plausible_entries.keys())] entry['d']=epoch entry['dh']=library return True self.data['errors'].append({'d':epoch, 'reqm':0, 'reqd':0, 'm':0, 'vol':{0:0}, 'dh':library, 'drv':drive, 'mh':""}) #print "dismount Nothing found" def get_predecessor_of_entry(self, epoch, reference=DATA_INDEX_M): # for e in self.data['data']: if e[reference] > epoch: index = self.data['data'].index(e) - 1 if index >= 0: return self.data['data'][index] def will_see_mount_request(self, epoch): # return # (False,None): not mounted, never willbe # (True, x) : x diff to mount event # : negativ x means already mounted x = None index = self.binsearch(self.data['data'], epoch, referenceindex=DATA_INDEX_REQM) mindistneg = -sys.maxint mindistpos = sys.maxint breakat = 1800 while True: if len(self.data['data'])>index: entry = self.data['data'][index] entrydiff = entry[DATA_INDEX_REQM] - epoch # negative or zero if entry[DATA_INDEX_REQM] < epoch: if entry[DATA_INDEX_REQD] >= epoch: # already mounted return (True, max(-1799, entrydiff),mindistpos) # is still mounted mindistneg = max(mindistneg, entrydiff) else: # else switch to positive mounts if entrydiff <= breakat: mindistpos = entrydiff return (True, mindistneg, mindistpos) # negative mount closer to zero if entrydiff > breakat: break index += 1 else: break if mindistneg == -sys.maxint and mindistpos == sys.maxint: return (False, None, None) return (True, mindistneg, mindistpos) # --------------------- def coredump(self): for i in self.data['data']: print i print self.active print self sys.exit(1) def sanitycheck(self): lm=None restart = None for i in self.data['data']: if i[DATA_INDEX_REQM] > i[DATA_INDEX_M]: print "Error ", i[DATA_INDEX_REQM], i[DATA_INDEX_M] return False if i[DATA_INDEX_REQD] > i[DATA_INDEX_D]: print "Error ", i[DATA_INDEX_REQD], i[DATA_INDEX_D] return False if lm: if lm[DATA_INDEX_D] > i[DATA_INDEX_M]: print "Error, dmnt larger than following mnt",lm[DATA_INDEX_D], i[DATA_INDEX_M], self print lm print i if 1: index = self.data['data'].index(lm) del self.data['data'][index] index = self.data['data'].index(i) del self.data['data'][index] return self.sanitycheck() else: return False lm = i return True def sortdata(self): tmp = [] ref = self.data['data'] for i in ref: index = ref.index(i) if index > 0: if ref[index][DATA_INDEX_M] < ref[index-1][DATA_INDEX_M]: print "error mount timestamp" if ref[index][DATA_INDEX_D] < ref[index-1][DATA_INDEX_D]: print "error dismount timestamp" if ref[index][DATA_INDEX_M] < ref[index-1][DATA_INDEX_D]: print "error dismount timestamp m-d" def checkerrors(self): self.sortdata() if not self.sanitycheck(): self.coredump() if len(self.data['errors'])>0: #print self.data['errors'] pass return len(self.data['errors']) def handle_special(self,res, data, key): if len(data)>0: res['%s_mean'%key] = numpy.mean(data) res['%s_sum'%key] = sum(data) res['%s_min'%key] = min(data) res['%s_max'%key] = max(data) res['%s_p05'%key] = percentile(sorted(data), 0.05) res['%s_p10'%key] = percentile(sorted(data), 0.1) #res['%s_p20'%key] = percentile(sorted(data), 0.2) res['%s_p33'%key] = percentile(sorted(data), 0.33) #res['%s_p40'%key] = percentile(sorted(data), 0.4) res['%s_p50'%key] = percentile(sorted(data), 0.5) res['%s_p67'%key] = percentile(sorted(data), 0.67) #res['%s_p70'%key] = percentile(sorted(data), 0.7) #res['%s_p80'%key] = percentile(sorted(data), 0.8) res['%s_p90'%key] = percentile(sorted(data), 0.9) res['%s_p95'%key] = percentile(sorted(data), 0.95) def pertime(self, data=None): def handle_lowlevel(ref, tmpts, curmnt, curdmnt, increment): tmpmnt = max(curmnt, tmpts) nextts=None tmptsstring = tmpts.strftime("%Y-%m-%d %H:%M:%S") if not tmptsstring in ref: ref[tmptsstring] = {} obj = ref[tmptsstring] for x in [TOTAL_MNT_TIME, TOTAL_MNTS]: if not x in obj.keys(): obj[x] = 0 if tmpmnt < tmpts: print "wtf", tmpmnt, tmpts, increment, curdmnt #return tmpts return (False, tmpts) if type(increment)==type("string"): if increment=='month': m = (tmpts.month)%12 y = tmpts.year if (tmpts.month)/12: y += 1 nextts = datetime.datetime(year=y, month=m+1, day=1) elif increment == 'year': nextts = datetime.datetime(year=tmpts.year+1, month=1, day=1) else: nextts = tmpts + increment #print nextts, increment,tmpts if tmpmnt <= nextts: # noch im momentanen ts weitermachen if curdmnt <= nextts: ### case a td = curdmnt - tmpmnt obj[TOTAL_MNT_TIME] += td.seconds + td.days*24*60*60 obj[TOTAL_MNTS] += 1 else: td = nextts - tmpmnt obj[TOTAL_MNT_TIME] += td.seconds + td.days*24*60*60 ### case b return (True, nextts) #return handle_lowlevel(ref, nextts, nextts, curdmnt, increment) else: # neuen ts nutzen #return handle_lowlevel(ref, nextts, curmnt, curdmnt, increment) return (True, nextts) return (False, tmpts) if self.pertimeres != None: return self.pertimeres res = { 'per_hour' : {}, 'per_day' : {}, 'per_week' : {}, 'per_month' : {}, 'per_year' : {} } file = os.path.join(self.basedir,"crt_%s_pertime.json"%self) if not os.path.isfile(file): if data==None: data = self.data['data'] if len(data)>0: init_mount = datetime.datetime.fromtimestamp(data[0][DATA_INDEX_M]) tmpts_perhour = datetime.datetime(init_mount.year, init_mount.month, init_mount.day, init_mount.hour,0) tmpts_perday = datetime.datetime(init_mount.year, init_mount.month, init_mount.day,0,0) tmpts_perweek = datetime.datetime(init_mount.year, init_mount.month, 1, 0, 0) tmpts_permonth = datetime.datetime(init_mount.year, init_mount.month, 1, 0, 0) tmpts_peryear = datetime.datetime(init_mount.year, 1, 1, 0, 0) increment_hour = datetime.timedelta(hours=1) increment_day = datetime.timedelta(days=1) increment_week = datetime.timedelta(days=7) for i in data: mount = datetime.datetime.fromtimestamp(i[DATA_INDEX_M]) dismount = datetime.datetime.fromtimestamp(i[DATA_INDEX_D]) tmpts_perhour = datetime.datetime(mount.year, mount.month, mount.day, 0,0) tmpts_perday = datetime.datetime(mount.year, mount.month, mount.day, 0,0) # for (ref, tmpts, incr) in ['per_hour', ] cont = True while cont: (cont,tmpts_perhour) = handle_lowlevel(res['per_hour'], tmpts_perhour, mount, dismount,increment_hour) cont = True while cont: (cont,tmpts_perday) = handle_lowlevel(res['per_day'], tmpts_perday, mount, dismount,increment_day) cont = True while cont: (cont,tmpts_perweek) = handle_lowlevel(res['per_week'], tmpts_perweek, mount, dismount,increment_week) cont = True while cont: (cont,tmpts_permonth) = handle_lowlevel(res['per_month'], tmpts_permonth, mount, dismount,"month") cont = True while cont: (cont,tmpts_peryear) = handle_lowlevel(res['per_year'], tmpts_peryear, mount, dismount,"year") else: print self, "no data available" for slot in PERTIMESLOT: ## add attribute hotness hotness = 0.0 for entryts in sorted(res[slot].keys()): #print entryts dt = datetime.datetime.strptime(entryts, "%Y-%m-%d %H:%M:%S") totalslottime = get_slot_size_seconds(slot, dt.month, dt.year) hotness = (hotness + res[slot][entryts].get(TOTAL_MNT_TIME,0)/totalslottime)/2.0 res[slot][entryts][HOTNESS] = hotness for slot in PERTIMESLOT: ## print to csv name = os.path.join(self.basedir, "%s_%s.csv"%(self,slot)) with open(name, 'w') as csv_file: sortres = [] lineBuf = StringIO.StringIO() cnt=1 for entryts in sorted(res[slot].keys()): if lineBuf.len==0: lineBuf.write("timestamp;index") sortres = sorted(res[slot][entryts].keys()) for k in sortres: lineBuf.write(";%s"%k) lineBuf.write("\n") lineBuf.write(";%s;%i"%(entryts,cnt)) for k in sortres: linebuf_write(lineBuf, res[slot][entryts].get(k,0)) lineBuf.write("\n") cnt+=1 csv_file.write(lineBuf.getvalue()) csv_file.close() with open(file, 'w') as f: json.dump(res, f, indent=1) else: print "reading file" with open(file, 'r') as f: res = json.load(f) self.pertimeres = res return res def stats(self, atts, special): res = {} for a in atts: match = REMNT_regexpattern.match(a) if match: slot = int(match.group(1)) lm = None tmpres = [] for i in self.data['data']: if lm != None: if lm > 0: if i[DATA_INDEX_M] - lm <= slot: tmpres.append(1) else: tmpres.append(0) else: print 'no lm' lm = i[DATA_INDEX_D] res[a] = numpy.mean(tmpres) elif a == 'id': res['id'] = self.data['id'] elif a == TOTAL_MNTS: res[a] = len(self.data['data']) for a in special: x = [] errcnt = 0 if a == CRT_MNT_LENGTH: for i in self.data['data']: if i[DATA_INDEX_M] > 0 and i[DATA_INDEX_D] > 0: diff = i[DATA_INDEX_D] - i[DATA_INDEX_M] if diff >= 0: x.append(diff) else: print "Mount before dismount wtf" errcnt += 1 #for (m,d) in i[DATA_INDEX_VOLUME].items(): # diff = int(m)-int(d) # if diff > 0: # x.append(diff) else: errcnt+=1 elif a == TIME_BTWN_MNTS: lm = 0 for i in self.data['data']: if lm > 1: if i[DATA_INDEX_M] > 0: x.append(i[DATA_INDEX_M]-lm) lm = i[DATA_INDEX_D] elif a == LATENCY_MNT: for i in self.data['data']: diff = i[DATA_INDEX_M] - i[DATA_INDEX_REQM] if diff < 0 or diff > 6*3600: errcnt += 1 #print "error diff:",diff, '\t', self else: x.append(diff) elif a == LATENCY_DMNT: for i in self.data['data']: diff = i[DATA_INDEX_D] - i[DATA_INDEX_REQD] if diff < 0 or diff > 6*3600: errcnt+=1 #print "error diff:",diff, '\t', self else: x.append(diff) elif a == LATENCY_DMV_DMCR: for i in self.data['data']: last_voldismnt = 0 for m,d in i[DATA_INDEX_VOLUME]: last_voldismnt = max(last_voldismnt, d) diff = i[DATA_INDEX_REQD] - last_voldismnt if diff < 0 or diff > 6*3600: errcnt+=1 #print "error diff:",diff, '\t', self else: x.append(diff) # if errcnt: # print self, a, len(x), 'error cnt', errcnt self.handle_special(res, x, a) return res def get_pertime(self,slot, ts, attribute): res = self.pertime() uts = unicode(ts) if slot in res.keys(): #print res[slot] if uts in res[slot].keys(): #print res[slot][uts] return res[slot][uts].get(attribute,0) if type(ts) == type(" "): dt = datetime.datetime.strptime(ts, "%Y-%m-%d %H:%M:%S") if dt in res[slot].keys(): return res[slot][dt].get(attribute,0) else: print "no slot", slot return 0 def handle_error(self, epoch, drive=None): self.data['minor'].append(epoch) def handle_mount_req(self, epoch): # either full cartridge mount or volume mount drv = None if not self.active['reqm']: if int(epoch) < self.active['m'] or self.active['m'] == 0: self.active['reqm'] = int(epoch) drv = self.active['drv'] keys = self.active['vol'].keys() keys.append(0) m = max(keys) if m > 0: voldm = self.active['vol'][m] if voldm <= int(epoch) or int(epoch) == self.active['reqm']: # ok, last mount dismount happened before current timestamp self.active['vol'][int(epoch)]=0 drv = self.active['drv'] else: print "voldm greater epoch", epoch #self.coredump() else: if epoch != self.active['reqm']: print "m less equal 0", epoch #self.coredump() return drv def handle_dismount_req(self, epoch): drv = None if not self.active['reqd']: self.active['reqd'] = int(epoch) drv = self.active['drv'] else: print "handle dismount request: why existing" return drv #def old_search_for_mountentry(self, epoch, reference=DATA_INDEX_M): # for e in self.data['data']: # if e[reference] >= epoch: # #if e[DATA_INDEX_D] == 0: # return self.data['data'].index(e) # print "no entry found", self, epoch # return None #def old_entryexists(self, epoch, reference=DATA_INDEX_M, drive=""): # for e in self.data['data']: # if abs(e[reference] - epoch) <= 10: # if e[DATA_INDEX_DRV] == drive: # return True #def old_errorentryexists(self, epoch, reference=DATA_INDEX_D): # for e in self.data['errors']: # diff = e[reference] - epoch # if diff: #q return True class Cartridge(BaseStats): def __init__(self,id, basedir): BaseStats.__init__(self, os.path.join(basedir, "cartridges")) self.data['id']=id self.fsm.state=FSM_CRT_ERROR self.fsm.add_transition(FSM_EVNT_INJECT, FSM_CRT_NEW, FSM_CRT_HOME, self._cb_inject) self.fsm.add_transition(FSM_EVNT_INJECT, FSM_CRT_ERROR, FSM_CRT_HOME, self._cb_inject) self.fsm.add_transition(FSM_EVNT_INJECT, FSM_CRT_EJECTED, FSM_CRT_HOME, self._cb_inject) self.fsm.add_transition(FSM_EVNT_INJECT, FSM_CRT_ERROR_FATAL, FSM_CRT_HOME, self._cb_inject) self.fsm.add_transition(FSM_EVNT_INJECT, FSM_CRT_HOME,FSM_CRT_HOME, None) self.fsm.add_transition(FSM_EVNT_MNTREQ, FSM_CRT_LOADING,FSM_CRT_LOADING, None) # ignore double mount req self.fsm.add_transition(FSM_EVNT_MNTREQ, FSM_CRT_IMPLICIT_CRTMNT, FSM_CRT_LOADING, None) self.fsm.add_transition(FSM_EVNT_MNTREQ, FSM_CRT_HOME, FSM_CRT_LOADING, self._cb_mntreq) self.fsm.add_transition(FSM_EVNT_MNTREQ, FSM_CRT_VOLMNTDISMNTFU, FSM_CRT_LOADING , self._cb_voldmfu_to_loading) self.fsm.add_transition(FSM_EVNT_MNTREQ, FSM_CRT_ERROR, FSM_CRT_LOADING, self._cb_recover_to_loading) self.fsm.add_transition(FSM_EVNT_MNTREQ, FSM_CRT_UNLOADING, FSM_CRT_LOADING, self._cb_unloading_timeout) self.fsm.add_transition(FSM_EVNT_MNTREQ, FSM_CRT_LOADED, FSM_CRT_LOADING, self._cb_loaded_to_loading) self.fsm.add_transition(FSM_EVNT_MNTREQ, FSM_CRT_D2DMV, FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_MNTREQ, FSM_CRT_VOLMNTED, FSM_CRT_LOADING, self._cb_volmnt_to_loading) self.fsm.add_transition(FSM_EVNT_MNTREQ, FSM_CRT_ERROR_FATAL, FSM_CRT_ERROR_FATAL, self._cb_error) self.fsm.add_transition(FSM_EVNT_MNTCMPLT, FSM_CRT_D2DMV, FSM_CRT_VOLMNTED, self._cb_d2dmv_to_loaded) self.fsm.add_transition(FSM_EVNT_MNTCMPLT, FSM_CRT_LOADING, FSM_CRT_VOLMNTED, self._cb_mntcmplt) self.fsm.add_transition(FSM_EVNT_MNTCMPLT, FSM_CRT_IMPLICIT_CRTMNT, FSM_CRT_VOLMNTED, self._cb_implicit_crtmnt_cmplt) self.fsm.add_transition(FSM_EVNT_MNTCMPLT, FSM_CRT_HOME, FSM_CRT_ERROR_FATAL, self._cb_error) self.fsm.add_transition(FSM_EVNT_MNTCMPLT, FSM_CRT_UNLOADING, FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_MNTCMPLT, FSM_CRT_LOADED, FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_MNTCMPLT, FSM_CRT_VOLMNTED, FSM_CRT_VOLMNTED, None) self.fsm.add_transition(FSM_EVNT_MNTCMPLT, FSM_CRT_ERROR, FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_MNTCMPLT, FSM_CRT_ERROR_FATAL, FSM_CRT_ERROR_FATAL, self._cb_error) self.fsm.add_transition(FSM_EVNT_MNTCMPLT, FSM_CRT_VOLMNTDISMNTFU, FSM_CRT_ERROR, self._cb_error ) self.fsm.add_transition(FSM_EVNT_VOLMNT, FSM_CRT_UNLOADING, FSM_CRT_UNLOADING, None) self.fsm.add_transition(FSM_EVNT_VOLMNT, FSM_CRT_LOADING, FSM_CRT_LOADING, None) self.fsm.add_transition(FSM_EVNT_VOLMNT, FSM_CRT_LOADED, FSM_CRT_VOLMNTED, self._cb_volmnt) self.fsm.add_transition(FSM_EVNT_VOLMNT, FSM_CRT_VOLMNTED, FSM_CRT_VOLMNTDISMNTFU, None) self.fsm.add_transition(FSM_EVNT_VOLMNT, FSM_CRT_HOME, FSM_CRT_IMPLICIT_CRTMNT, self._cb_implicit_crtmnt) self.fsm.add_transition(FSM_EVNT_VOLMNT, FSM_CRT_IMPLICIT_CRTMNT, FSM_CRT_IMPLICIT_CRTMNT,None) self.fsm.add_transition(FSM_EVNT_VOLMNT, FSM_CRT_ERROR, FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_VOLMNT, FSM_CRT_ERROR_FATAL, FSM_CRT_ERROR_FATAL, self._cb_error) self.fsm.add_transition(FSM_EVNT_VOLMNT, FSM_CRT_EJECTED, FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_VOLMNT, FSM_CRT_VOLMNTDISMNTFU,FSM_CRT_VOLMNTDISMNTFU,None ) self.fsm.add_transition(FSM_EVNT_VOLMNT, FSM_CRT_D2DMV, FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_VOLDMNT, FSM_CRT_VOLMNTED, FSM_CRT_LOADED, self._cb_voldmnt) self.fsm.add_transition(FSM_EVNT_VOLDMNT, FSM_CRT_VOLMNTDISMNTFU, FSM_CRT_VOLMNTED , None) self.fsm.add_transition(FSM_EVNT_VOLDMNT, FSM_CRT_IMPLICIT_CRTMNT, FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_VOLDMNT, FSM_CRT_D2DMV, FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_VOLDMNT, FSM_CRT_LOADING, FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_VOLDMNT, FSM_CRT_LOADED, FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_VOLDMNT, FSM_CRT_HOME, FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_VOLDMNT, FSM_CRT_ERROR, FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_VOLDMNT, FSM_CRT_ERROR_FATAL, FSM_CRT_ERROR_FATAL, self._cb_error) self.fsm.add_transition(FSM_EVNT_VOLDMNT, FSM_CRT_UNLOADING, FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_DISMNTCRTREQ, FSM_CRT_D2DMV,FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_DISMNTCRTREQ, FSM_CRT_UNLOADING,FSM_CRT_UNLOADING, None) self.fsm.add_transition(FSM_EVNT_DISMNTCRTREQ, FSM_CRT_VOLMNTDISMNTFU, FSM_CRT_UNLOADING, self._cb_dismnt_crt_req) self.fsm.add_transition(FSM_EVNT_DISMNTCRTREQ, FSM_CRT_LOADED, FSM_CRT_UNLOADING, self._cb_dismnt_crt_req) self.fsm.add_transition(FSM_EVNT_DISMNTCRTREQ, FSM_CRT_VOLMNTED, FSM_CRT_UNLOADING, self._cb_implicit_crtdism_while_volmnt) self.fsm.add_transition(FSM_EVNT_DISMNTCRTREQ, FSM_CRT_IMPLICIT_CRTMNT, FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_DISMNTCRTREQ, FSM_CRT_HOME, FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_DISMNTCRTREQ, FSM_CRT_LOADING, FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_DISMNTCRTREQ, FSM_CRT_ERROR, FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_DISMNTCRTREQ, FSM_CRT_ERROR_FATAL, FSM_CRT_ERROR_FATAL, self._cb_error) self.fsm.add_transition(FSM_EVNT_DISMNTCRTCMPLT, FSM_CRT_VOLMNTDISMNTFU, FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_DISMNTCRTCMPLT, FSM_CRT_LOADING, FSM_CRT_HOME, self._cb_recover_to_home) self.fsm.add_transition(FSM_EVNT_DISMNTCRTCMPLT, FSM_CRT_UNLOADING, FSM_CRT_HOME, self._cb_dismnt_crt_cmplt) self.fsm.add_transition(FSM_EVNT_DISMNTCRTCMPLT, FSM_CRT_LOADED, FSM_CRT_HOME, self._cb_dismnt_crt_cmplt) self.fsm.add_transition(FSM_EVNT_DISMNTCRTCMPLT, FSM_CRT_ERROR, FSM_CRT_HOME, self._cb_recover_to_home) self.fsm.add_transition(FSM_EVNT_DISMNTCRTCMPLT, FSM_CRT_ERROR_FATAL, FSM_CRT_HOME, self._cb_recover_to_home) self.fsm.add_transition(FSM_EVNT_DISMNTCRTCMPLT, FSM_CRT_VOLMNTED, FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_DISMNTCRTCMPLT, FSM_CRT_HOME,FSM_CRT_HOME,None) # ignore duplicates self.fsm.add_transition(FSM_EVNT_DISMNTCRTCMPLT, FSM_CRT_D2DMV, FSM_CRT_HOME, self._cb_recover_to_home ) self.fsm.add_transition(FSM_EVNT_DISMNTCRTCMPLT, FSM_CRT_IMPLICIT_CRTMNT, FSM_CRT_HOME, self._cb_recover_to_home ) #d2d mv self.fsm.add_transition(FSM_EVNT_D2DMV, FSM_CRT_VOLMNTED,FSM_CRT_D2DMV, self._cb_loaded_to_d2dmv) self.fsm.add_transition(FSM_EVNT_D2DMV, FSM_CRT_D2DMV,FSM_CRT_D2DMV, None) self.fsm.add_transition(FSM_EVNT_D2DMV, FSM_CRT_LOADING,FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_D2DMV, FSM_CRT_UNLOADING,FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_D2DMV, FSM_CRT_ERROR_FATAL,FSM_CRT_ERROR_FATAL, self._cb_error) self.fsm.add_transition(FSM_EVNT_D2DMV, FSM_CRT_ERROR, FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_D2DMV, FSM_CRT_HOME, FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_D2DMV, FSM_CRT_LOADED, FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_ROB1, FSM_CRT_LOADING, FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_ROB1, FSM_CRT_ERROR_FATAL, FSM_CRT_ERROR_FATAL, self._cb_error) self.fsm.add_transition(FSM_EVNT_ROB1, FSM_CRT_ERROR, FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_ROB1, FSM_CRT_HOME, FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_ROB1, FSM_CRT_D2DMV, FSM_CRT_ERROR, self._cb_error) self.fsm.add_transition(FSM_EVNT_EJECT, FSM_CRT_ERROR, FSM_CRT_EJECTED, self._cb_eject_error) self.fsm.add_transition(FSM_EVNT_EJECT, FSM_CRT_HOME, FSM_CRT_EJECTED, self._cb_eject) self.fsm.add_transition(FSM_EVNT_EJECT, FSM_CRT_UNLOADING, FSM_CRT_EJECTED, self._cb_eject_error) self.fsm.add_transition(FSM_EVNT_EJECT, FSM_CRT_ERROR_FATAL, FSM_CRT_ERROR, self._cb_eject) self.fsm.add_transition(FSM_EVNT_EJECT, FSM_CRT_VOLMNTED, FSM_CRT_ERROR, self._cb_eject_error) self.fsm.add_transition(FSM_EVNT_EJECT, FSM_CRT_LOADED, FSM_CRT_ERROR, self._cb_eject_error) self.fsm.add_transition(FSM_EVNT_EJECT, FSM_CRT_LOADING, FSM_CRT_ERROR, self._cb_eject_error) self.fsm.add_transition(FSM_EVNT_EJECT, FSM_CRT_IMPLICIT_CRTMNT, FSM_CRT_ERROR, self._cb_eject_error) self.fsm.add_transition(FSM_EVNT_EJECT, FSM_CRT_EJECTED, FSM_CRT_EJECTED, None) self.fsm.add_transition(FSM_EVNT_FATALERROR_1, FSM_CRT_D2DMV, FSM_CRT_ERROR , self._cb_error) self.fsm.add_transition(FSM_EVNT_FATALERROR_1, FSM_CRT_ERROR_FATAL, FSM_CRT_ERROR_FATAL, self._cb_error) self.fsm.add_transition(FSM_EVNT_FATALERROR_1, FSM_CRT_EJECTED, FSM_CRT_EJECTED, None) for state in [FSM_CRT_HOME,FSM_CRT_LOADING,FSM_CRT_VOLMNTED,FSM_CRT_LOADED,FSM_CRT_UNLOADING,FSM_CRT_NEW,\ FSM_CRT_IMPLICIT_CRTMNT,FSM_CRT_VOLMNTDISMNTFU,FSM_CRT_ERROR]: self.fsm.add_transition(FSM_EVNT_FATALERROR_1, state, FSM_CRT_ERROR_FATAL, self._cb_error) def handle_event(self, event, args): return self.fsm.handle_event(event, args) def _cb_volmnt(self,event, args): self.active['vol'][int(args['epoch'])] = 0 return (True, None) def _cb_voldmnt(self,event, args): m = max(self.active['vol'].keys()) if m > 0: voldm = self.active['vol'][m] if voldm <= 0 and m <= int(args['epoch']): self.active['vol'][m]=int(args['epoch']) return (True, None) return (False, None) def _cb_inject(self,event, args): self.data['inject'].append(args['epoch']) self.flusherror() return (True,None) def _cb_error(self,event, args): if event == FSM_EVNT_DISMNTCRTCMPLT: self.active['d'] = args['epoch'] ret={'drive':self.active['drv'],'reqm':self.active['reqm'],'reqd':self.active['reqd'],'cid':self.data['id']} return (True, ret) elif event == FSM_EVNT_VOLMNT: self.active['vol'][int(args['epoch'])] = 0 elif event == FSM_EVNT_VOLDMNT: return self._cb_voldmnt(event, args) elif event == FSM_EVNT_MNTCMPLT: self.active['m'] = args['epoch'] self.active['vol'] = {int(args['epoch']):0} self.active['drv'] = args['drive'] return (True, {'drive':args['drive']}) elif event == FSM_EVNT_DISMNTCRTREQ: self.active['reqd'] = args['epoch'] elif event == FSM_EVNT_MNTREQ: self.active['reqm'] = args['epoch'] return (True, None) def _cb_recover_to_loading(self, event, args): self.flusherror() return self._cb_mntreq(event,args) def _cb_recover_to_home(self,event, args): self.active['d'] = args['epoch'] self.flusherror() return (True, args) # - - - - def _cb_error_fatal(self, event, args): self.flusherror() return (True,None) def _cb_eject(self, event,args): self.data['eject']=args['epoch'] return (True, None) def _cb_eject_error(self,event, args): self.flusherror() return self._cb_eject(event,args) def _cb_voldmfu_to_loading(self,event, args): self.flusherror() return self._cb_mntreq(event,args) def _cb_volmnt_to_loading(self,event, args): self.flusherror() return self._cb_mntreq(event,args) def _cb_loaded_to_loading(self,event, args): self.flusherror() return self._cb_mntreq(event,args) def _cb_mntcmplt(self, event,args): self.active['m'] = args['epoch'] self.active['vol'] = {int(args['epoch']):0} self.active['drv'] = args['drive'] return (True, {'drive':args['drive']}) def _cb_mntreq(self,event, args): self.active['reqm'] = args['epoch'] return (True, None) def _cb_dismnt_crt_cmplt(self,event, args): self.active['d'] = args['epoch'] ret ={'drive':self.active['drv'], 'reqm':self.active['reqm'], 'reqd':self.active['reqd'], 'cid':self.data['id']} self.dataappend() return (True, ret) def _cb_dismnt_crt_req(self,event, args): self.active['reqd'] = args['epoch'] return (True, None) def _cb_implicit_crtmnt(self,event, args): self.active['reqm'] = args['epoch'] return (True, None) def _cb_implicit_crtmnt_cmplt(self,event, args): return self._cb_mntcmplt(event,args) def _cb_implicit_crtdism_while_volmnt(self,event, args): (ret, a) = self._cb_voldmnt(event,args) if ret: return self._cb_dismnt_crt_req(event,args) raise BaseException("What happened") def _cb_unloading_timeout(self,event, args): self.flusherror() return self._cb_mntreq(event,args) def _cb_loaded_to_d2dmv(self,event, args): #self.active['d'] = args['epoch'] #self.active['reqd'] = args['epoch'] ret = { 'reqm' : self.active['reqm'], #'reqd' : self.active['reqd'] 'reqd' : args['epoch'] } #self.dataappend() #self.active['reqm'] = args['epoch'] self._cb_voldmnt(event,args) return (True, ret) def _cb_d2dmv_to_loaded(self,event, args): self.active['drv'] = args['drive'] self.active['m'] = args['epoch'] self.active['reqm'] = args['epoch'] self.active['vol'] = {args['epoch']:0} return (True, args) ## -------------------------------- def force_last_event_flush(self, epoch): if len(self.data['data']) > 0: evntdata = self.data['data'].pop() e = { 'm':evntdata[DATA_INDEX_M], 'd':evntdata[DATA_INDEX_D], 'reqm':evntdata[DATA_INDEX_REQM], 'reqd':evntdata[DATA_INDEX_REQD], 'drv':evntdata[DATA_INDEX_DRV], 'vol':{} } for [m,d] in evntdata[DATA_INDEX_VOLUME]: #e['vol'].append({m:d}) e['vol'][int(m)]=int(d) self.data['errors'].append(e) self.handle_event(FSM_EVNT_FATALERROR_1, {'epoch':epoch}) ##------------------- def handle_enter(self, epoch): self.data['enter'] = epoch #self.tmp_state = {'m':0, 'd':0, 'reqM':0, 'reqD':0} def handle_eject(self, epoch): self.data['eject'] = epoch #self.tmp_state = {'m':0, 'd':0, 'reqM':0, 'reqD':0} def get_volume(self, slot, ts): if slot == 'per_year': nextts = datetime.datetime(year=ts.year+1, month=1, day=1, hour=0 ,minute=0) if slot == 'per_month': m = (ts.month)%12 y = ts.year if (ts.month)/12: y += 1 nextts = datetime.datetime(year=y, month=m+1, day=1) if slot == 'per_week': nextts = ts + datetime.timedelta(days=7) if slot == 'per_day': nextts = ts + datetime.timedelta(days=1) if slot == 'per_hour': nextts = ts + datetime.timedelta(hours=1) res = 0 tsep = unix_time(ts) nexttsep = unix_time(nextts) index = self.binsearch(self.data['data'],tsep,DATA_INDEX_M) while True: if len(self.data['data']) > index: e = self.data['data'][index] for m,d in e[DATA_INDEX_VOLUME]: if m != 0 and d != 0: end = min(nexttsep, d) if m >= tsep and m <= nexttsep: res += d - m elif m > nexttsep: break if e[DATA_INDEX_M]> nexttsep: break index += 1 else: break return res #print m,d def get_tbm(self): res = [] lastevent = None for event in self.data['data']: if lastevent!=None: res.append(event[DATA_INDEX_REQM] - lastevent[DATA_INDEX_D]) lastevent=event return res def get_latency(self): res = [] for event in self.data['data']: lm = event[DATA_INDEX_M] - event[DATA_INDEX_REQM] ld = event[DATA_INDEX_D] - event[DATA_INDEX_REQD] if ld < 1800: res.append(ld) if lm < 1800: res.append(lm) return res class Drive(BaseStats): def __init__(self, id, basedir): BaseStats.__init__(self,os.path.join(basedir, "drives")) self.data['id']=id self.data['data'] =[] # (dummy, mount epoch, dummy, dismount epoch, cid) self.data['cleaning']=[] self.fsm.state=FSM_DRV_ERROR self.fsm.add_transition(FSM_EVNT_DISMNTCRTCMPLT, FSM_DRV_LOADED, FSM_DRV_EMPTY, self._cb_dmntcmplt) self.fsm.add_transition(FSM_EVNT_MNTCMPLT, FSM_DRV_EMPTY, FSM_DRV_LOADED, self._cb_mountcmplt) # from error states self.fsm.add_transition(FSM_EVNT_D2DMV, FSM_DRV_LOADED, FSM_DRV_ERROR, self._cb_loadedtoerror) self.fsm.add_transition(FSM_EVNT_D2DMV, FSM_DRV_ERROR_FATAL, FSM_DRV_ERROR_FATAL, None) self.fsm.add_transition(FSM_EVNT_D2DMV, FSM_DRV_MAYBERECOVERED, FSM_DRV_ERROR_FATAL, self._cb_error_fatal) self.fsm.add_transition(FSM_EVNT_D2DMV, FSM_DRV_ERROR, FSM_DRV_ERROR, None) self.fsm.add_transition(FSM_EVNT_D2DMV, FSM_DRV_EMPTY, FSM_DRV_EMPTY, None) self.fsm.add_transition(FSM_EVNT_MNTCMPLT, FSM_DRV_ERROR, FSM_DRV_LOADED, self._cb_errortoloaded) self.fsm.add_transition(FSM_EVNT_DISMNTCRTCMPLT, FSM_DRV_ERROR, FSM_DRV_EMPTY, self._cb_errortoempty) self.fsm.add_transition(FSM_EVNT_MNTCMPLT, FSM_DRV_LOADED, FSM_DRV_ERROR, self._cb_loadedtoerror) # fatal error, admin action going on for state in [FSM_DRV_LOADED,FSM_DRV_EMPTY, FSM_DRV_ERROR, FSM_DRV_ERROR_FATAL, FSM_DRV_MAYBERECOVERED]: self.fsm.add_transition(FSM_EVNT_FATALERROR_1, state, FSM_DRV_ERROR_FATAL, self._cb_error_fatal) self.fsm.add_transition(FSM_EVNT_DELDRIVE, state, FSM_DRV_ERROR_FATAL,self._cb_error_fatal) self.fsm.add_transition(FSM_EVNT_DISMNTCRTCMPLT, FSM_DRV_ERROR_FATAL, FSM_DRV_ERROR_FATAL, self._cb_errortoempty) self.fsm.add_transition(FSM_EVNT_MNTCMPLT, FSM_DRV_ERROR_FATAL, FSM_DRV_MAYBERECOVERED, self._cb_errortoloaded) self.fsm.add_transition(FSM_EVNT_DISMNTCRTCMPLT, FSM_DRV_MAYBERECOVERED, FSM_DRV_EMPTY, self._cb_dmntcmplt) self.fsm.add_transition(FSM_EVNT_MNTCMPLT, FSM_DRV_MAYBERECOVERED, FSM_DRV_ERROR_FATAL, self._cb_error_fatal) self.fsm.add_transition(FSM_EVNT_ROB1, FSM_DRV_EMPTY,FSM_DRV_EMPTY, None) self.fsm.add_transition(FSM_EVNT_ROB1, FSM_DRV_LOADED,FSM_DRV_ERROR, self._cb_error_fatal) self.fsm.add_transition(FSM_EVNT_ROB1, FSM_DRV_ERROR_FATAL,FSM_DRV_ERROR_FATAL, None) self.fsm.add_transition(FSM_EVNT_DISMNTCRTCMPLT, FSM_DRV_EMPTY, FSM_DRV_EMPTY, None) # probably initial drive start self.fsm.add_transition(FSM_EVNT_RECOVER_FAT1, FSM_DRV_ERROR, FSM_DRV_EMPTY, self._cb_recover_fatal1) self.fsm.add_transition(FSM_EVNT_RECOVER_FAT1, FSM_DRV_LOADED, FSM_DRV_EMPTY, self._cb_recover_fatal1) self.fsm.add_transition(FSM_EVNT_RECOVER_FAT1, FSM_DRV_EMPTY,FSM_DRV_EMPTY, self._cb_double_admin_enable) self.fsm.add_transition(FSM_EVNT_RECOVER_FAT1, FSM_DRV_ERROR_FATAL,FSM_DRV_EMPTY, self._cb_recover_fatal1) self.fsm.add_transition(FSM_EVNT_RECOVER_FAT1,FSM_DRV_MAYBERECOVERED,FSM_DRV_EMPTY, self._cb_recover_fatal1) def _transform_dictentry(self, entry): return [entry['reqm'], entry['m'], 0, entry['reqd'], entry['d'], entry['mh'],entry['dh'], entry['drv']] def handle_event(self, event, args): return self.fsm.handle_event(event, args) def _cb_error_fatal(self, event, args): self.flusherror() return (True,None) def _cb_double_admin_enable(self, event, args): self._cb_error_fatal(event,args) return (True, None) def _cb_mountcmplt(self,event,args): self.active['m'] = args['epoch'] self.active['drv'] = args['cid'] return (True, None) def _cb_dmntcmplt(self,event, args): if args['cid'] != self.active['drv']: #print "invalid dismount received" return (False, {'cid':args['cid']}) else: # if not 'reqd' in args.keys(): self.active['reqd'] = args['reqd'] self.active['reqm'] = args['reqm'] self.active['d'] = args['epoch'] self.dataappend() return (True, None) def _cb_loadedtoerror(self,event, args): self.flusherror() self.fsm.subsequent_events.append([FSM_EVNT_MNTCMPLT, args]) return (True, None) def _cb_errortoloaded(self, event,args): self.flusherror() return self._cb_mountcmplt(event,args) def _cb_errortoempty(self,event, args): self.flusherror() return (True, None) def _cb_recover_fatal1(self,event, args): self.flusherror() return (True, None) def get_latencies(self): res = [] def _add(start, end, home, cid, op): diff = end-start if 0<=diff and diff <= 3600: res.append((end, diff, home, cid, op)) for (reqm, m, dmvol, reqd, d, mh, dh, cid) in self.data['data']: _add(reqm, m, mh, cid, HOME_OPERATION_EJECT) # home to drive _add(reqd, d, dh, cid, HOME_OPERATION_INJECT)# drive to home return res def data_import(self, reqm, m, reqd, d, mh, dh, cid): ent = (reqm,m,None,reqd,d,mh,dh,cid) for tmp in self.data['data']: if m > 0: if tmp[1] > m: index = self.data['data'].index(tmp) self.data['data'].insert(index, ent) return if reqm > 0: if tmp[0] > reqm: index = self.data['data'].index(tmp) self.data['data'].insert(index, ent) return if m == 0: self.data['errors'].append({'reqm':reqm,'m':m,'reqd':reqd,'d':d,'mh':mh,'dh':dh,'drv':cid, 'vol':0 }) else: self.data['data'].append(ent) def handle_disable(self, epoch): self.data['disabled'].append([epoch,0]) self.flusherror() #self.state = DRIVE_STATE_DISABLED def handle_enable(self, epoch): x = self.data['disabled'].pop() print x if x[1] != 0: print "wtf drive enable" else: x[1]=epoch self.data['disabled'].append(x) self.state = DRIVE_STATE_IDLE def handle_cleaning_crt_dismnt(self, epoch): self.data['cleaning'].append(epoch) def estimate_cleaning_time(self, start=None, end=None): t = [] for cln in self.data['cleaning']: if start < cln and cln <= end: entry = self.get_predecessor_of_entry(cln, DATA_INDEX_D) if entry: t.append(cln-entry[DATA_INDEX_D]) if cln > end: break return t class Home: def __init__(self, hid, basedir): self.basedir = os.path.join(basedir, "homes") if not os.path.exists(self.basedir): os.makedirs(self.basedir) self.stats_calculated=False self.data = { 'id' : str(hid), 'data' : [], 'perdrive' : {} # entries: driveid= (numops, avglatency) } def __repr__(self): return self.data['id'] def handle_event(self, epoch, latency, drive, cid, optype): # if optype == HOME_OPERATION_EJECT: # self.eject_event(epoch, latency, drive, cid) # elif optype == HOME_OPERATION_INJECT: # self.inject_event(epoch, latency, drive, cid) self.data['data'].append((epoch, latency, drive, cid, optype)) def get_stats(self, atts): if not self.stats_calculated: self.stats() res = {} for i in atts: res[i] = self.data.get(i, 0) return res def stats(self): _drivestats = {} for (epoch, latency, drive, cid, optype) in self.data['data']: obj = _drivestats.setdefault(drive, []) obj.append(latency) tmp = [] l = 0 for drive, val in _drivestats.items(): t = numpy.mean(val) tmp.append(t) l += len(val) self.data['perdrive'][drive] = (len(val),t) self.data[LATENCY_HOME_AVG] = numpy.mean(tmp) self.data[HOME_TOTAL_OPS] = l with open(os.path.join(self.basedir, str(self)), 'w') as csv_file: lineBuf = StringIO.StringIO() lineBuf.write("drive;%s;%s"%(HOME_TOTAL_OPS, LATENCY_HOME_AVG)) for d,(num,lat) in self.data['perdrive'].items(): linebuf_write(lineBuf, "\n%s;%s;%s"%(d,num,lat)) csv_file.write(lineBuf.getvalue()) csv_file.close() self.stats_calculated=True def cost_drive(self, drv=None): if not drv: return self.data['perdrive'] res = self.data['perdrive'].get(drv, None) if not res: return self.data[LATENCY_HOME_AVG] else: return res[1] class God: def __init__(self, basedir): self.basedir = basedir self.outputdir = os.path.join(basedir, "stats") self.whpssdir = os.path.join(basedir, "../whpss") self.robotdir = os.path.join(self.basedir, '../robot/robot_mounts*.gz') #self._perdrive_outputdir = os.path.join(self.outputdir, 'drives') #self._percartridge_outputdir = os.path.join(self.outputdir, 'cartridges') self._global_crt_csv = os.path.join(self.outputdir ,'global_crt.csv') self._global_drv_csv = os.path.join(self.outputdir ,'global_drv.csv') self._global_hm_csv = os.path.join(self.outputdir ,'global_hm.csv') self._json_dump_robot = os.path.join(basedir, "robot_classes") self.crt = {} self.drv = {} self.hm = {} self.robot_totalcnt = 0 self.robot_errorcnt_crt = 0 self.robot_errorcnt_drv = 0 for i in [self.outputdir]: if not os.path.exists(i): os.makedirs(i) def _get_hm(self, hid, create=True): if hid not in self.hm and create: self.hm[hid] = Home(hid, self.outputdir) return self.hm.get(hid,None) def _get_crt(self, cid, create=True): if cid not in self.crt and create: self.crt[cid] = Cartridge(cid, self.outputdir) return self.crt.get(cid,None) def _get_drv(self, drv, create=True): if drv not in self.drv and create: self.drv[drv] = Drive(drv, self.outputdir) return self.drv.get(drv,None) def handle_event(self, evnt, arguments): if 'cid' in arguments.keys(): cartridge_id = arguments['cid'] if cartridge_id[:2] in crtfilter_b or cartridge_id[:1] in crtfilter_a: # filter cartridges return crt = self._get_crt(cartridge_id ) if evnt == None: pass #dummy else: a = crt.handle_event(evnt,arguments) if a: for k,v in a.items(): arguments[k]=v #else: # print "no cid... what the fuck" if 'drive' in arguments.keys(): if len(arguments['drive'])>0: #if arguments['drive'][0] not in ['4', '3']: if len(arguments['drive']) <= 6: drv = self._get_drv(arguments['drive']) if evnt == None: pass #dummy else: ret = drv.handle_event(evnt, arguments) if ret: if 'cid' in ret.keys(): # error in cids last event self.force_last_event_flush(cid=ret['cid'], epoch=arguments['epoch']) else: "no drive provided, or needed" def force_last_event_flush(self, cid, epoch): crt = self._get_crt(cid, False) if crt: crt.force_last_event_flush(epoch) def robot_dismount(self, cid, epoch, drive, library): self.robot_totalcnt+=1 crt = self._get_crt(cid, False) if crt: if not crt.robot_dismount(epoch, drive, library): #print "error robot dismount" self.robot_errorcnt_crt+=1 else: pass #print "Unknown crt",cid, epoch drv = self._get_drv(drive , False) if drv: if cid[:3] != 'CLN': if not drv.robot_dismount(epoch, cid, library): self.robot_errorcnt_drv+=1 else: drv.handle_cleaning_crt_dismnt(epoch) def robot_mount(self,cid, epoch, drive, library): self.robot_totalcnt+=1 crt = self._get_crt(cid, False) if crt: if not crt.robot_mount(epoch, drive, library): #print "error robot mount" self.robot_errorcnt_crt+=1 else: pass #print "Unknown crt",cid, epoch drv = self._get_drv(drive , False) if drv: if not drv.robot_mount(epoch, cid, library): self.robot_errorcnt_drv+=1 def collect_recovered_errors(self): recovered = 0 remaining = 0 for cid,crt in self.crt.items(): a,b = crt.collect_recovered_errors() recovered += a remaining += b for did,drv in self.drv.items(): a,b = drv.collect_recovered_errors() recovered += a remaining += b print "Recovered:%i, Remaining:%i"%(recovered, remaining) def handle_warning(self, epoch, drive, cid): crt = self._get_crt(cid, False) if crt: crt.flushactive() def jsonload(self, skipdrives=False): jsondir = os.path.join(self.basedir, 'json') if not skipdrives: drvf = "%s_drv.json"%self._json_dump_robot if os.path.isfile(drvf): with open(drvf, 'r') as f: #print "Reading %s"%drvf for e in json.load(f): obj = Drive(e['id'], self.outputdir) obj.data = e self.drv[e['id']]=obj all_crt_files = sorted(glob.glob(os.path.join(jsondir, 'crt_*.json'))) for crtf in all_crt_files: with open(crtf, 'r') as f: #print "Reading %s"%crtf e = json.load(f) obj = Cartridge(e['id'], self.outputdir) obj.data = e self.crt[e['id']]=obj hmf = "%s_hm.json"%self._json_dump_robot if os.path.isfile(hmf): with open(hmf, 'r') as f: #print "Reading %s"%hmf for e in json.load(f): obj = Home(e['id'], self.outputdir) obj.data = e self.hm[e['id']]=obj def jsondump(self): def _dmp(file, data): with open(file, 'w') as f: json.dump(data, f, indent=1) jsondir = os.path.join(self.basedir, "json") if not os.path.isdir(jsondir): os.makedirs(jsondir) drv = [] hm = [] for obj in self.crt.values(): fn = os.path.join(jsondir,"crt_%s.json"%obj.data['id']) _dmp(fn, obj.data) for obj in self.drv.values(): drv.append(obj.data) for obj in self.hm.values(): hm.append(obj.data) _dmp(os.path.join(jsondir,"%s_drv.json"%self._json_dump_robot), drv) _dmp(os.path.join(jsondir,"%s_hm.json"%self._json_dump_robot), hm) def derive_homes(self): #for cid, crt in self.crt.items(): # for op in crt.data['data']: # if len(op[DATA_INDEX_DRV]) > 0: # drv = self._get_drv(op[DATA_INDEX_DRV], True) # reqm = op[DATA_INDEX_REQM] # m = op[DATA_INDEX_M] # reqd = op[DATA_INDEX_REQD] # d = op[DATA_INDEX_D] # dh = op[DATA_INDEX_DH] # mh = op[DATA_INDEX_MH] # drv.data_import(reqm, m, reqd, d, mh, dh, cid) for id,drv in self.drv.items(): for (epoch, latency, home, cid, optype) in drv.get_latencies(): if home and len(home) >3: hobj = self._get_hm(home, True) hobj.handle_event(epoch, latency, id, cid, optype) def stats(self): if FULLRUN or 1: ### generate global cartridge statistics with open(self._global_crt_csv, 'w') as csv_file: atts = ['id'] atts.extend(GLOBAL_CRT) special = [] special.extend(SPECIAL_CRT) sortres = [] lineBuf = StringIO.StringIO() cnt=1 for id in sorted(self.crt.keys()): obj = self.crt.get(id) res = obj.stats(atts,special) if lineBuf.len==0: lineBuf.write("index") sortres = sorted(res.keys()) for k in sortres: lineBuf.write(";%s"%k) lineBuf.write("\n%i"%cnt) for k in sortres: linebuf_write(lineBuf, res.get(k,0)) #lineBuf.write("\n") cnt+=1 csv_file.write(lineBuf.getvalue()) csv_file.close() lineBuf.flush() if FULLRUN or 1: ### generate global cartridge statistics with open(self._global_hm_csv, 'w') as csv_file: sortres = [] lineBuf = StringIO.StringIO() cnt=1 for id in sorted(self.hm.keys()): obj = self.hm.get(id) res = obj.get_stats(GLOBAL_HM) if lineBuf.len==0: lineBuf.write("id;index") sortres = sorted(res.keys()) for k in sortres: lineBuf.write(";%s"%k) lineBuf.write("\n") lineBuf.write("%s;%i"%(id,cnt)) for k in sortres: linebuf_write(lineBuf, res.get(k,0)) lineBuf.write("\n") cnt+=1 csv_file.write(lineBuf.getvalue()) csv_file.close() lineBuf.flush() if FULLRUN or 1: ### generate lobal drive statistics with open(self._global_drv_csv, 'w') as csv_file: atts = ['id'] atts.extend(GLOBAL_DRV) special = [] special.extend(SPECIAL_DRV) lineBuf = StringIO.StringIO() sortres = [] cnt=1 for id in sorted(self.drv.keys()): obj = self.drv.get(id) res = obj.stats(atts,special) if lineBuf.len==0: lineBuf.write("id;index") sortres = sorted(res.keys()) for k in sortres: lineBuf.write(";%s"%k) lineBuf.write("\n") lineBuf.write("%s;%i"%(id,cnt)) for k in sortres: linebuf_write(lineBuf,res.get(k,0)) lineBuf.write("\n") cnt+=1 csv_file.write(lineBuf.getvalue()) csv_file.close() lineBuf.flush() ### generate per timeslot statistics if FULLRUN or 0: # stopit tup = [] tup.append((self.crt,'cartridges')) #tup.append((self.drv,'drives')) for (dataref,stringref) in tup: for key in ['per_hour','per_day','per_week','per_month', 'per_year']: for opt in [TOTAL_MNT_TIME, TOTAL_MNTS, HOTNESS]: f = os.path.join(self.outputdir, '%s_%s_%s.csv'%(stringref, opt, key)) ids = [] with open(f, 'w') as csv_file: d = {} for id, obj in sorted(dataref.items()): if id not in ids: ids.append(id) res = obj.pertime(obj.data['data']) for ts,data in res[key].items(): if ts not in d.keys(): d[ts] = {} d[ts][id] = data.get(opt,0) lineBuf = StringIO.StringIO() lineBuf.write("timestamp") for id in ids: lineBuf.write(";%s"%id) for ts in sorted(d.keys()): lineBuf.write('\n%s'%ts) for id in ids: linebuf_write(lineBuf,d[ts].get(id,0)) csv_file.write(lineBuf.getvalue()) csv_file.close() lineBuf.flush() if FULLRUN or 0: for id,hobj in self.hm.items(): hobj.stats() def robot_read(self): def _handle_file(filelist, obj): for filename in filelist: with gzip.open(filename, 'r') as source_file: for line in source_file: match = re_line.search(line) if match: g = match.groups() epoch = get_epoch(g[0]) action = g[1] cartridge_id = g[2] library_pos = g[3] # not used right now. rawdrive = string.split(g[5], ',') if len(rawdrive)>3: drive = "%i%02i%i%02i"%(int(rawdrive[0]),int(rawdrive[1]),int(rawdrive[2]),int(rawdrive[3])) else: drive = rawdrive if action == "MOUNT": obj.robot_mount(cartridge_id, epoch, drive, library_pos) continue if action == "DISMOUNT": # be aware of cleaning cartridges obj.robot_dismount(cartridge_id, epoch, drive, library_pos) continue # elif action == "ENTER": # self.handle_enter(cartridge_id, epoch) # elif action == "EJECT": # self.handle_eject(cartridge_id, epoch) # elif action == 'ACSMV': # self.handle_move(epoch, library_pos, drive) if action == 'ACSCR': if line.__contains__('STATUS_VOLUME_NOT_FOUND'): continue print 'unparsed' ,line, re_line = re.compile(".*([0-9]{8}:[0-9]{6}).* (ACSMV|ACSCR|AUDIT|EJECT|ENTER|MOUNT|DISMOUNT) ([0-9a-zA-Z]{6}) Home ([0-9,]*) ([a-zA-Z\s]+) ([0-9,]*) .*") re_line_not_found = re.compile(".*([0-9]{8}:[0-9]{6}).* (ACSCR|AUDIT) ([0-9a-zA-Z]{6}).* (STATUS_VOLUME_NOT_FOUND) .*") numthrads = 2 threadfiles = {} for i in range(numthrads): threadfiles[i]= [] all_log_files = sorted(glob.glob(self.robotdir)) #for i in all_log_files: # index = all_log_files.index(i)%numthrads # threadfiles[index].append(i) #threads = [] #for i in range(numthrads): # t1 = threading.Thread(target=_handle_file, args=(threadfiles[i],self)) # threads.append(t1) # t1.start() #for i in threads: # i.run() # alive = 0 if 1: for filename in all_log_files: print filename with Timer("Finished: %s:" % (filename)): with gzip.open(filename, 'r') as source_file: for line in source_file: # alive +=1 match = re_line.search(line) # if not alive%1000: # print line, # alive=0 if match: g = match.groups() epoch = get_epoch(g[0]) action = g[1] cartridge_id = g[2] library_pos = g[3] # not used right now. rawdrive = string.split(g[5], ',') if len(rawdrive)>3: drive = "%i%02i%i%02i"%(int(rawdrive[0]),int(rawdrive[1]),int(rawdrive[2]),int(rawdrive[3])) else: drive = rawdrive if action == "MOUNT": self.robot_mount(cartridge_id, epoch, drive, library_pos) continue if action == "DISMOUNT": # be aware of cleaning cartridges self.robot_dismount(cartridge_id, epoch, drive, library_pos) continue # elif action == "ENTER": # self.handle_enter(cartridge_id, epoch) # elif action == "EJECT": # self.handle_eject(cartridge_id, epoch) # elif action == 'ACSMV': # self.handle_move(epoch, library_pos, drive) if action == 'ACSCR': if line.__contains__('STATUS_VOLUME_NOT_FOUND'): continue print 'unparsed' ,line, print 'total', self.robot_totalcnt, 'error', self.robot_errorcnt_crt, self.robot_errorcnt_drv def whpss_read(self): re_generic_crt = re.compile(".* cartridge\s*=\s*\"([0-9A-Z]+)\".*") re_generic_drv = re.compile(".* drive = \"([0-9]+)\".*") # 05/26 00:15:46 *** re_time = re.compile("([0-9]{2})/([0-9]{2}) ([0-9]{2}):([0-9]{2}):([0-9]{2}) ([A-Z]+) .*") re_filename_date = re.compile("([0-9]{4})([0-9]{2})([0-9]{2})_([0-9]{2})([0-9]{2})([0-9]{2}).gz") re_crtanddrv = re.compile(".* cartridge = \"([0-9A-Z]+)\", drive = \"([0-9]+)\".*") # 03/12 20:53:36 RQST PVRS0004 Entering pvr_Mount, cartridge = "CC0968", drive = "0" re_pvr_Mount = re.compile(".* pvr_Mount,.*cartridge = \"([0-9A-Z]+)\".*") re_pvl_Mount = re.compile(".* \"pvl_MountAdd\", .* arg = \"([0-9A-Z]+)\".*") # 03/07 17:51:11 DBUG PVRS0379 STK Request: acs_mount: seq= 23557, cart= WB2125 re_acs_mount = re.compile(".* cart= ([0-9A-Z]+)") # 05/26 00:15:46 RQST PVLS0002 Exiting, function = "pvl_MountCompleted", jobid = "11644979", drive = "101101", arg = "WB3134" re_pvl_MountCompleted = re.compile(".* jobid = \"([0-9]+)\".* drive = \"([0-9]+)\", arg = \"([0-9A-Z]+)\".*") re_pvl_MountCompleted2 = re.compile(".* jobid = \"([0-9]+)\".* arg = \"([0-9A-Z]+)\"") re_warning = re.compile(".* jobid = \"([0-9]+)\".* arg = \"([0-9A-Z]+)\"") re_warn_d1 = re.compile(".* Error reading device ([0-9]+).* vol ([A-Z0-9]+).*") re_warn_drive = re.compile(".* Drive disabled, drive = \"(([0-9]+))\".*") re_warn_c = re.compile(".*Could not mount volume\: ([A-Z0-9]+)\:.*") re_evnt_drive_enabl = re.compile(".* Drv= ([0-9]+), Enabled.*") re_alrm_a = re.compile(".*Dismount ([A-Z0-9]+) pends.*") re_pvr_DismountCart = re.compile(".*cartridge = \"([0-9A-Z]+)\".*") re_pvl_DismountVol = re.compile(".*arg\s*=\s*\"([0-9A-Z]+)\".*") # 03/01 08:28:11 RQST PVRS0012 Entering pvr_Inject, cartridge = "RC2773", drive = "0" re_pvr_Inject = re.compile(". cartridge = \"([0-9A-Z]+)\"") # 03/01 08:23:37 EVNT PVRS0043 Ejecting cartridge="P54892", manufacturer="IBM LTO3-1", lot="Jul09", began service Tue Aug 25 12:44:27 2009, last maintained Thu Jan 1 00:00:00 1970, last mounted Tue Feb 26 22:10:33 2013, total mounts=12, mounts since last maintained=12 re_pvr_Eject = re.compile(".* cartridge = \"([0-9A-Z]+)\".*") # 01/02 18:34:59 MINR PVRS0141 Robot unable to find cartridge, cartridge = "CB5564", drive = "1,3,1,3", drive = "0" re_minr_lost_cartridge = re.compile(".* MINR .* Robot unable to find .* cartridge = \"([0-9A-Z]+)\", drive = \"([,0-9]+)\", .*") re_minr_lost_cartridge2 = re.compile(".* MINR .* Robot unable to find .* cartridge = \"([0-9A-Z]+)\", drive = \"0\".*") re_minr_drv_stuck = re.compile('.* drive in use or locked by .* drive = \"([0-9,]+)\", drive .*') # nunn lines re_nunn_importerr = re.compile(".*Import of cartridge '([A-Z0-9]+)' failed.*") last_epoch=0 log_creation_date = None files = sorted(glob.glob(os.path.join(self.whpssdir,'whpss_log_*.gz'))) for f in files: m = re.search(re_filename_date, os.path.basename(f)) if not m: print ("ERROR, cannot process invalid file name: %s" % (f)) return x = m.groups() if not log_creation_date: log_creation_date = datetime.datetime(int(x[0]), int(x[1]),int(x[2]),int(x[3]),int(x[4]),int(x[5])) print "--------------------------------------------------------------------------------------------------" print "Reading file %s.\n"%f with gzip.open(f, 'r') as source: for line in source.readlines(): try: time_match = re_time.search(line) if time_match: x = time_match.groups() log_entry_date = datetime.datetime(log_creation_date.year, int(x[0]), int(x[1]),int(x[2]),int(x[3]),int(x[4])) epoch = int(calendar.timegm(log_entry_date.utctimetuple())) if epoch >= last_epoch: # chronologic order last_epoch = epoch else: print "last epoch", last_epoch print 'current epoch', epoch, x if int(x[0])==1 and int(x[1])==1: log_creation_date = datetime.datetime(log_creation_date.year+1, int(x[0]), int(x[1]),int(x[2]),int(x[3]),int(x[4])) log_entry_date = datetime.datetime(log_creation_date.year, int(x[0]), int(x[1]),int(x[2]),int(x[3]),int(x[4])) epoch = int(calendar.timegm(log_entry_date.utctimetuple())) print 'fixed epoch', epoch #print "Hard abort due to chronologic error in line: \n\t%s" % (line) #sys.exit(1) #raw_input("Is this ok?") if line.__contains__(" DBUG "): continue if line.__contains__(' RQST '): if line.__contains__('Entering'): if line.__contains__("pvl_MountAdd"): # ok # match = re_pvl_Mount.search(line) if match: cartridge_id = match.groups()[0][:6] if cartridge_id[:2] not in crtfilter_b and cartridge_id[:1] not in crtfilter_a: self.handle_event(FSM_EVNT_VOLMNT, {'cid':cartridge_id, 'epoch':epoch}) continue if line.__contains__('pvr_Mount'): match2 = re_pvr_Mount.search(line) if match2: cartridge_id = match2.groups()[0][:6] if cartridge_id[:2] not in crtfilter_b and cartridge_id[:1] not in crtfilter_a: self.handle_event(FSM_EVNT_MNTREQ, {'cid':cartridge_id, 'epoch':epoch}) continue if line.__contains__("pvr_DismountCart"): match = re_pvr_DismountCart.search(line) if match: cartridge_id = match.groups()[0][:6] if cartridge_id[:2] not in crtfilter_b and cartridge_id[:1] not in crtfilter_a: self.handle_event(FSM_EVNT_DISMNTCRTREQ, {'cid':cartridge_id, 'epoch':epoch}) continue if line.__contains__("pvl_DismountVolume"): match = re_pvl_DismountVol.search(line) if match: cartridge_id = match.groups()[0][:6] if cartridge_id[:2] not in crtfilter_b and cartridge_id[:1] not in crtfilter_a: self.handle_event(FSM_EVNT_VOLDMNT, {'cid':cartridge_id, 'epoch':epoch}) continue if line.__contains__("pvr_Inject"): # a new cartridge is added, add it to list of injected_cartridges match = re_pvr_Inject.search(line) if match: self.handle_event(FSM_EVNT_INJECT, {'epoch': epoch, 'cid':match.groups()[0][:6]}) continue if line.__contains__("pvr_Eject"): match = re_pvr_Eject.search(line) if match: self.handle_event(FSM_EVNT_EJECT, {'cid':match.groups()[0][:6], 'epoch':epoch}) continue if line.__contains__("Exiting"): # can happen multiple times within 'cartridge_mount_process' last seen pvl_MountCompleted is assumed to be successfull. if line.__contains__("pvl_MountCompleted"): match = re_pvl_MountCompleted.search(line) if match: job_id = match.groups()[0] drive = match.groups()[1] cartridge_id = match.groups()[2][:6] if cartridge_id[:2] not in crtfilter_b and cartridge_id[:1] not in crtfilter_a: self.handle_event(FSM_EVNT_MNTCMPLT, {'cid':cartridge_id, 'epoch':epoch, 'drive':drive}) continue match2 = re_pvl_MountCompleted2.search(line) if match2: job_id = match2.groups()[0] cartridge_id = match2.groups()[1][:6] #print "bad mount: maybe ejected from library. check CB5564 2.jan 19.06.17 entry, jobid:", job_id, cartridge_id self.handle_event(FSM_EVNT_FATALERROR_1, {'epoch':epoch, 'cid':cartridge_id}) continue if line.__contains__("pvr_DismountCart"): match = re_pvr_DismountCart.search(line) if match: cartridge_id = match.groups()[0][:6] if cartridge_id[:2] not in crtfilter_b and cartridge_id[:1] not in crtfilter_a: self.handle_event(FSM_EVNT_DISMNTCRTCMPLT, {'cid':cartridge_id, 'epoch':epoch}) continue if line.__contains__("pvl_DeleteDrive"): m = re_generic_drv.match(line) if m: self.handle_event(FSM_EVNT_DELDRIVE, {'drive':m.groups()[0], 'epoch':epoch}) continue if line.__contains__("Entering"): if line.__contains__("pvl_MountCompleted") or \ line.__contains__("pvl_DeleteDrive"): continue if line.__contains__("Exiting"): if line.__contains__('pvl_MountAdd') or \ line.__contains__('pvr_Mount') or \ line.__contains__('pvl_DismountVolume') or \ line.__contains__('pvr_Eject') or \ line.__contains__('pvr_Inject') : continue docont = False for x in ['pvl_RequestSetAttrs', 'pvl_RequestGetAttrs','pvl_MountNew', 'pvr_CartridgeGetAttrs', 'pvr_CartridgeSetAttrs', 'pvr_MountComplete', 'pvl_MountCommit',"pvl_QueueGetAttrs","pvl_QueueSetAttrs",'pvl_DriveSetAttrs', 'pvl_VolumeGetAttrs', 'pvl_VolumeSetAttrs', 'pvl_PVLSetAttrs', "pvr_ServerSetAttrs",'pvl_ServerSetAttrs', 'pvl_DismountJobId', 'pvl_AllocateVol', 'pvl_DeallocateVol', 'pvl_Import', 'pvl_Export', 'pvl_CheckInCompleted', 'pvl_DriveGetAttrs', 'pvl_CreateDrive','pvl_Terminate', 'pvl_Move', 'pvl_CancelAllJobs']: if line.__contains__(x): docont = True break if docont: continue if line.__contains__(' MINR '): m = re_minr_lost_cartridge.search(line) if m: cartridge_id = m.groups()[0][:6] drive = m.groups()[1] rawdrive = string.split(drive, ',') if len(rawdrive)>3: drive = "%i%02i%i%02i"%(int(rawdrive[0]),int(rawdrive[1]),int(rawdrive[2]),int(rawdrive[3])) self.handle_event(FSM_EVNT_ROB1, {'epoch':epoch, 'cid':cartridge_id, 'drive':drive}) continue m = re_minr_lost_cartridge2.match(line) if m: cartridge_id = m.groups()[0][:6] self.handle_event(FSM_EVNT_ROB1, {'epoch':epoch, 'cid':cartridge_id}) continue m = re_minr_drv_stuck.match(line) if m: drive = m.groups()[0] rawdrive = string.split(drive, ',') if len(rawdrive)>3: drive = "%i%02i%i%02i"%(int(rawdrive[0]),int(rawdrive[1]),int(rawdrive[2]),int(rawdrive[3])) self.handle_event(FSM_EVNT_FATALERROR_1, {'epoch':epoch, 'drive':drive}) continue if line.__contains__("Intervention necessary"): m = re_generic_crt.match(line) if m: cartridge_id = m.groups()[0] self.handle_event(FSM_EVNT_FATALERROR_1, {'epoch':epoch, 'cid':cartridge_id}) continue if line.__contains__('Dismount failed due to STK IN_TRANSIT status'): m = re_generic_crt.match(line) if m: self.handle_event(FSM_EVNT_FATALERROR_1, {'epoch':epoch, 'cid':m.groups()[0]}) continue if line.__contains__("Could not mount volume"): m =re_warn_c.match(line) if m: cr = m.groups()[0][:6] self.handle_event(FSM_EVNT_FATALERROR_1,{'epoch':epoch, 'cid':cr}) continue if line.__contains__("Drive Disabled"): m = re_pvl_MountCompleted.match(line) # to extract vars if m: j, drv, crt = m.groups() self.handle_event(FSM_EVNT_FATALERROR_1, {'epoch':epoch, 'cid':crt[:6], 'drive':drv}) continue if line.__contains__("Not owner") or \ line.__contains__(" Rewind of device 40") or \ line.__contains__("Stage failed, all retries exhausted") or \ line.__contains__("Request for locked or disabled device") or \ line.__contains__('Unexpected error in LTO Library') or \ line.__contains__('LTO I/O failure') or \ line.__contains__('"sendIOD"') or \ line.__contains__('hpss_RPCGetReply') or \ line.__contains__("gk_Cleanup") or \ line.__contains__("gk_Close failed") or \ line.__contains__('Invalid parameters passed to LTO Library') or \ line.__contains__('Open of device 4') or \ line.__contains__('pos failed on dev 4') or \ line.__contains__('Retrying stage from level') or \ line.__contains__('Cartridge not found in LTO library') or \ line.__contains__("Read of label on") or \ line.__contains__('Can not find the PVL') or \ line.__contains__('all retries exhausted') or \ line.__contains__('locked by non-HPSS') or \ line.__contains__('SCSI ') or \ line.__contains__('hpss_RPCSendRequest') or \ line.__contains__('Forward space file failed') or \ line.__contains__('Verification of label on dev') or \ line.__contains__('Open of device') or \ line.__contains__('No space left on device') or \ line.__contains__('Metadata manager error') or \ line.__contains__('Connection refused') or \ line.__contains__('Connection timed out') or \ line.__contains__('ACSLM spawned process') or \ line.__contains__('Cannot Establish Connection') or \ line.__contains__('VV metadata') or \ line.__contains__('Open of delog') or \ line.__contains__('database deadlock condition') or \ line.__contains__('to execute stateme') or \ line.__contains__('LOCKING the DRIVE') or \ line.__contains__('Returned, function') or\ line.__contains__('storage service start') or \ line.__contains__('Invalid session') or \ line.__contains__('repair to server') or \ line.__contains__('MM error'): continue # minor if line.__contains__(' WARN '): # drive = "102100", arg = "XB063500" #m = re_warning.match(line) #if m: #self.handle_warning(epoch, m.groups()[0], m.groups()[1][:6]) m2 = re_warn_drive.match(line) if m2: drive = m2.groups()[0] self.handle_event(FSM_EVNT_FATALERROR_1, {'drive':drive,'epoch':epoch}) continue m3 = re_warn_d1.match(line) if m3: cartridge_id = m3.groups()[1][:6] drive = m3.groups()[0] #self.handle_event(FSM_EVNT_FATALERROR_1, {'drive':drive, 'cid':cartridge_id, 'epoch':epoch}) continue if line.__contains__("will retry in another drive,"): m = re_crtanddrv.match(line) if m: crt = m.groups()[0] drv = m.groups()[1] self.handle_event(FSM_EVNT_D2DMV, {'drive':drv, 'epoch':epoch, 'cid':crt}) continue if line.__contains__('"read_label"') or \ line.__contains__('are disabled,') or \ line.__contains__("LOCKING the DRIVE will exit the dismount loop") or \ line.__contains__(' no response from robot') or \ line.__contains__('rtm_GetRequestEntries') or \ line.__contains__('NOT exist in DriveTable') or \ line.__contains__('cartridge = "MP') or \ line.__contains__('label written') or \ line.__contains__('Client Cancels All Jobs') or \ line.__contains__('Job recovered, di') or \ line.__contains__('hardware defined in HPSS does not exist') or \ line.__contains__('Dismount reason') or \ line.__contains__('Job not found in queue') or \ line.__contains__(' PVR) are disabled, arg = "MA') or \ line.__contains__('Cache Overflow') or \ line.__contains__('Cartridge has not been checked in') or \ line.__contains__('No drives of this type in') or \ line.__contains__('not found in LTO') or \ line.__contains__('Not enough drives of this type') or \ line.__contains__('Drive Notify failed') or \ line.__contains__('= "eject_cart"') or \ line.__contains__('information request failed') or \ line.__contains__(' STATUS_') or \ line.__contains__('Address types'): continue #warn if line.__contains__(' Dismount reason') and line.__contains__('drive = "4'): continue if line.__contains__(' EVNT '): m1 = re_evnt_drive_enabl .match(line) if m1: drive = m1.groups()[0] self.handle_event(FSM_EVNT_RECOVER_FAT1, {'drive':drive, 'epoch':epoch}) continue if line.__contains__("Client logged ") or \ line.__contains__('Total Drive Count') or \ line.__contains__(' logfiles ') or \ line.__contains__('Storage map state') or \ line.__contains__("CONAN") or \ line.__contains__("erver 'Mover") or \ line.__contains__("'STK PVR'") or \ line.__contains__("Connection table full") or \ line.__contains__("Open files on connection shutdown") or \ line.__contains__("Repack Completed SClassId") or \ line.__contains__('robot is offline, drive = "0') or \ line.__contains__("Deferred state change") or \ line.__contains__("End of media on ") or \ line.__contains__('Reclaim completed for storage') or \ line.__contains__("Request w/o client") or \ line.__contains__("Exporting cartridge") or \ line.__contains__("Export of ") or \ (line.__contains__(", Disabled") and line.__contains__("dmin drive change") )or\ line.__contains__("av_Initialize") or \ line.__contains__("Mount failed, no drives") or \ line.__contains__("Import of cartridge ") or \ line.__contains__("STK volume ejects are done asynchronously") or \ line.__contains__("could not be mounted, Condition") or \ line.__contains__('Job not found in queue') or \ line.__contains__("Core Server shutting") or \ line.__contains__('All disk storage maps') or \ line.__contains__('SSMS0115') or \ line.__contains__('Core Server Shutdown Complete') or \ line.__contains__('Running with restricted') or \ line.__contains__('No initialization is necessary') or \ line.__contains__('Reissuing ') or \ line.__contains__(' in PVR') or \ line.__contains__('mm_ReadPVR') or \ line.__contains__('Ejecting cartridge=') or \ line.__contains__('Core Server startup') or \ line.__contains__('Starting server') or \ line.__contains__('been shutdown') or \ line.__contains__('Delog complete') or \ line.__contains__('Startup of server') or \ line.__contains__('core_SignalThread') or \ line.__contains__('has been renamed') or \ line.__contains__('abel written') or \ line.__contains__('CHECK_DISK_') or \ line.__contains__('Core Server Admin'): continue #evnt if line.__contains__(" ALRM "): if line.__contains__(" Write request failed") or \ line.__contains__(" Read request failed") or \ line.__contains__('Data copy operation failed') or \ line.__contains__("Cannot lock VV cache record") or \ line.__contains__("Connection timed out") or\ line.__contains__("Not owner") or \ line.__contains__('No such file or ') or \ line.__contains__("HPSS system failure") or \ line.__contains__(" request descriptor table") or \ line.__contains__('Error creating credentials') or \ line.__contains__('File too large') or \ line.__contains__('hpss_FilesetGetAttributes') or \ line.__contains__('request threads busy') or \ line.__contains__('DB connection has been busy') or \ line.__contains__('Failed to get RTM records') or \ line.__contains__("Retrying read from level") or \ line.__contains__(" Rewind of device") or \ line.__contains__('PVR reports mounting a cartridge in a drive which') or \ line.__contains__('Request queue full') or \ line.__contains__('No space left on device') or \ line.__contains__('Internal software error') or \ line.__contains__('Unable to obtain the Fileset') or \ line.__contains__(' CAP priorit') or \ line.__contains__('Restricted User list') or \ line.__contains__('sending RPC reply') or \ line.__contains__('Error sending data') or \ line.__contains__('Deferred state change') or \ line.__contains__('rtm_Reconnect') or \ line.__contains__(' SAN3P ') or \ line.__contains__('Resource locked') or \ line.__contains__('missing mover error ') : continue #alrm if line.__contains__('Cartridge reported IN_TRANSIT'): m = re_alrm_a.match(line) if m: self.handle_event(FSM_EVNT_FATALERROR_1, {'epoch':epoch, 'cid':m.groups()[0]}) continue if line.__contains__(" NUNN "): m = re_nunn_importerr.match(line) if m: self.handle_event(FSM_EVNT_FATALERROR_1, {'epoch':epoch, 'cid':m.groups()[0]}) continue if line.__contains__('Error no owner found') or \ line.__contains__('on write()') or \ line.__contains__('SS and BFS '): continue if line.__contains__(" MAJR "): if line.__contains__("Gatekeeper Server") or \ line.__contains__("RPC reply") or \ line.__contains__('hpss_ConnMgrGrabConn') or \ line.__contains__('died on host') or \ line.__contains__('not initialize socket') or \ line.__contains__('Error receiving data') or \ line.__contains__('rror obtaining transmit'): continue if line.__contains__("ECFS "): if line.__contains__("CORE") or \ line.__contains__('MPS'): continue if line.__contains__('MARS '): if line.__contains__('CORE') or \ line.__contains__('MPS') : continue if line.__contains__('ROOT' ): if line.__contains__(' MPS') or \ line.__contains__(' CORE'): continue if line.__contains__(' HPSS '): continue if line.__contains__('Checking out cartridge') or \ line.__contains__('Shutdown of server') or \ line.__contains__('Tape aggregation') or \ line.__contains__('itfile') or \ line.__contains__('PVR reestablished') or \ line.__contains__('eer uuid') or \ line.__contains__('hpss_RPC') or \ line.__contains__('RPC runtime error') or \ line.__contains__('pvr_PVRSetAttrs') or \ line.__contains__("Gatekeeper") or \ line.__contains__("GateKeeper") or \ line.__contains__('Authentication') or \ line.__contains__('Bad connection handle') or \ line.__contains__("PVR 'STK PVR") or \ line.__contains__(' log files ') or \ line.__contains__(' Mover ') or \ line.__contains__('passive side of') or \ line.__contains__('einitialization ') or \ line.__contains__('hpss_prod') or \ line.__contains__('136.156.') or \ line.__contains__(' TRAC ') or \ line.__contains__('-mvr1') or \ line.__contains__('USERSPACE1') or \ line.__contains__('pvr_Check') or \ line.__contains__('hdrv01'): continue if line.__contains__('Failure'): if line.__contains__('querying') or \ line.__contains__: continue print "unparsed line", line, else: pass #if len(line)> 16: # print "time did not match", line except: print "unknown", line raise sys.exit() #print " file done" #sys.exit() def correlation(self): #with Timer("Correlation-Finished:"): def _exec_(csvfile, p): c = corrPearson() print datetime.datetime.now() print csvfile c.read(csvfile) #while True: #p = q.get() if p in string.ascii_uppercase: # p = 'Y' # for p in reversed(string.ascii_uppercase): # print p fields = c.filter_fields(['%s.+'%p], []) if len(fields) > 1: print "Run for argument ", p res = c.full_correlation_matrix(fields, "correlation_%s"%p) c.jsondump("%s_proj_%s.json"%(csvfile, p),res) #sorted_res = {} #for x in res.keys(): # for y,v in res[x].items(): # if not v in sorted_res.keys(): # sorted_res[v[0]]=[] # sorted_res[v[0]].append((x,y)) #for i in sorted(sorted_res.keys()): # print i, sorted_res[i] # else: # break a = 'cartridges_tmt_per_hour.csv' csvfile = os.path.join(self.outputdir,a) #for p in ['Z']: for p in reversed(string.ascii_uppercase): _exec_(csvfile,p) gc.collect() print "done" def highestlevelstats(self): res = {} res3d = [] for drv in sorted(self.drv.keys()): curmax = max(DRV_INT_MAP.values()) DRV_INT_MAP[drv] = curmax+1 for hid in sorted(self.hm.keys()): curmax = max(HID_INT_MAP.values()) HID_INT_MAP[hid] = curmax+1 for hid, obj in self.hm.items(): c = obj.cost_drive() for k,v in c.items(): if v[1]< 600: res3d.append([HID_INT_MAP[hid],DRV_INT_MAP[k],v[1], v[0]]) latency = round(v[1] ,0) ent = res.setdefault(latency, 0) res[latency] = ent+1 filtered = {} for i in range(0,300): v = res.setdefault(i, 0) filtered[i]=v figp = os.path.join(self.outputdir, "drive_home_latency.png") plot_dict(filtered, figp) costhd = os.path.join(self.outputdir, "home_drive_costs.csv") with open(costhd , 'w') as mesh_file: lineBuf = StringIO.StringIO() lineBuf.write("home;drive;latency;observations") for [x,y,z,n] in res3d: lineBuf.write("\n%i;%i;%.1f;%.1f"%(x,y,z,n)) mesh_file.write(lineBuf.getvalue()) mesh_file.close() #vis = fast_plot.Visualizer("Home", "Drive", "AvgLatency") #vis.new_group_data(res3d) #vis.show() def checkerrors(self): operations = 0 successful_crt_cycles = 0.0 failed_crt_cycles = 0.0 for crt, obj in self.crt.items(): successful_crt_cycles += obj.get_successful_cycles() failed_crt_cycles += obj.get_failed_cycles() #err = obj.checkerrors() #if err >0: # print crt, err#obj, err #sys.exit(1) print 'Failed ',failed_crt_cycles print 'Successful:' , successful_crt_cycles print 'Failed Percent', failed_crt_cycles/((failed_crt_cycles+successful_crt_cycles)/100) sys.exit() for d,obj in self.drv.items(): err = obj.checkerrors() if err >0: print err, d #, obj #sys.exit(1) o = len(obj.data['data']) c = len(obj.data['cleaning']) #print d, o, c operations += o+c print operations def paperoutput(self): numrmounts = 0 numvmounts = 0 tapemnts = {} for cid, obj in self.crt.items(): r,v,e = 0,0,0 for m in obj.data['data']: r += 1 v += len(m[DATA_INDEX_VOLUME]) for m in obj.data['errors']: if m['m']>0: e += 1 numvmounts += v numrmounts += r tapemnts[cid] = (r,v,e) self._jsondmp(tapemnts, 'crtmnts.json', self.basedir) print "Tapemount stats done" # general data # number of tapes: numtapes = len(self.crt.keys()) numdrives = len(self.drv.keys()) numhomes = len(self.hm.keys()) print '#Robot mounts', numrmounts print '#Volume mounts', numvmounts print '#Tapes', numtapes print '#Drives', numdrives print '#Homes', numhomes def _jsondmp(self, obj, file, basedir=None): x = file if basedir: x = os.path.join(basedir, file) with open(x, 'w') as f: json.dump(obj, f, indent=1) def parallel_correlation_analysis(self): print " entering parallel correlation analysis " interval_secs = [-1800, -1200, -600, -300, -120, -60, 0, 60, 120, 300, 600,1200, 1800] pat = re.compile(".*cartridges_tmt_per_hour\.csv_proj_([A-Z]+)\.json") marstotal = {} for i in interval_secs: marstotal[i] = [] marstotal['possum']=0 marstotal['negsum']=0 marstotal['totalerror']=0 lineBuf = StringIO.StringIO() lineBuf.write("Project") for i in sorted(interval_secs): lineBuf.write(";%i"%i) lineBuf.write(";TotalFail;NegativeSum;PositiveSum;Correlation0.8Pairs;AllPairs") infiles = glob.glob(os.path.join(self.outputdir, 'cartridges_tmt_per_hour.csv_proj_*.json')) for infile in reversed(infiles): scnt=0 cnt = 0 gc.collect() print "Starting with file ", infile totalsuccess,totalfail = 0,0 correlated = {} m = pat.match(infile) project = m.groups()[0] lineBuf.write("\n%s"%project) with open(infile, 'r') as f: entries = json.load(f) t = len(entries) for (x,y,p,s) in entries: #print "Entry ", cnt, ' of ', t if p >= 0.8 : add_correlated(correlated, x,y) scnt += 1 cnt += 1 print "finished generating correlations, found %s, failed:%i"%(scnt,cnt) #globalsuccess = Counter() #for i in sorted(interval_secs): # globalsuccess[i] = [] #lock = multiprocessing.Lock() prefix = "correlation_result_%s"%project corrkeys = multiprocessing.Queue() for cid in sorted(correlated.keys()): corrkeys.put(cid) procs = [] for i in range(multiprocessing.cpu_count()): proc = multiprocessing.Process(target=calc_correlation, args=(corrkeys, correlated, self._get_crt, prefix, interval_secs)) proc.daemon=False procs.append(proc) proc.start() for p in procs: #p = procs.pop() p.join() print "waiting for process ", p possum, negsum = 0,0 r2 = {} for i in interval_secs: r2[i]=[] files = glob.glob(os.path.join("/tmp", "%s_*.json.gz"%(prefix))) for file in files: print 'reading',file with gzip.open(file, 'r') as f: result = json.load(f) for interv, entries in result['interval'].items(): #print interv, entries i = int(interv) r2[i].extend(entries) if i > 0: possum += len(entries) else: negsum += len(entries) totalfail += result['errorcnt'] if project in ['R','S', 'U','V','W', 'X', 'Y']: marstotal['totalerror'] += totalfail marstotal['possum'] += possum marstotal['negsum'] += negsum for i in sorted(interval_secs): marstotal[i].extend(r2[i]) for i in sorted(interval_secs): lineBuf.write(";%s"%len(r2[i])) lineBuf.write(";%i;%i;%i"%(totalfail,negsum,possum)) lineBuf.write('\nMARS') for i in sorted(interval_secs): lineBuf.write(";%s"%len(marstotal[i])) lineBuf.write(";%i;%i;%i;%i;%i"%(marstotal['totalerror'],marstotal['negsum'],marstotal['possum'],scnt,cnt)) with open(os.path.join(self.outputdir, "crt_correlation.csv"), 'w') as csv_file: csv_file.write(lineBuf.getvalue()) csv_file.close() lineBuf.flush() def debug(self): pat = re.compile(".*cartridges_tmt_per_hour\.csv_proj_([A-Z]+)\.json") total=0 slot='per_day' lock = multiprocessing.Lock() if FULLRUN or 1: # tape system stats #res = self.drv.values()[0].pertime() res = set() atts = set() #tsset = set() slotted_ts = {} crtlist = [] drvlist=[] wq1 = multiprocessing.Queue() for id in self.drv.keys(): wq1.put(id) drvlist.append(id) for id in self.crt.keys(): # not sorted wq1.put(id) crtlist.append(id) procs = [] for i in range(multiprocessing.cpu_count()): proc = multiprocessing.Process(target=_cb_pertime, args=(wq1,)) proc.daemon=False procs.append(proc) proc.start() for p in procs: p.join() print "waiting for process ", p print datetime.datetime.now(), "starting" for id, drv in self.drv.items(): tmp = drv.pertime() for k,v in tmp.items(): print datetime.datetime.now(), id, "drv.pertime ", k if not k in slotted_ts.keys(): slotted_ts[k]=[] slot = slotted_ts.get(k) for ts in v.keys(): if not ts in slot: slot.append(ts) res.update([k]) if len(atts)==0: atts.update(v[v.keys()[0]].keys()) #tsset.update(v.keys()) x = Counter() prefix = 'tapestats' print "first loop done ", datetime.datetime.now() gc.collect() for slot in res: x[slot]={} print datetime.datetime.now(), "slot " , slot inqueue = multiprocessing.Queue() for tsstr in sorted(slotted_ts[slot]): inqueue.put(tsstr) procs = [] #for i in range(1): for i in range(multiprocessing.cpu_count()/2): proc = multiprocessing.Process(target=_tapestats, args=(inqueue, slot, crtlist, self._get_crt, drvlist, self._get_drv, atts, prefix)) proc.daemon=False procs.append(proc) proc.start() for p in procs: p.join() print "waiting for process ", p files = glob.glob("/tmp/%s_*.json"%prefix) for file in files: print "reading ", file res = _cb_gzipload(file) for slot,elems in res.items(): if not slot in x.keys(): x[slot]={} xs = x[slot] for ts, tmpatt in elems.items(): if ts not in xs.keys(): xs[ts] = {} xsts = xs[ts] for a,v in tmpatt.items(): xsts[a] = v for slot in sorted(x.keys()): atts.add(VOL_MNT_LENGTH) atts.add(CLN_TIME_LENGTH) f = os.path.join(self.outputdir,"tapesystem_%s.csv"%slot) print f with open(f, 'w') as csv_file: lineBuf = StringIO.StringIO() lineBuf.write("timestamp") for att in atts: lineBuf.write(";%s"%att) for ts in sorted(x[slot].keys()): lineBuf.write("\n%s"%ts) for att in sorted(atts): linebuf_write(lineBuf,x[slot][ts].get(att, 0) ) csv_file.write(lineBuf.getvalue()) csv_file.close() lineBuf.flush() def debug2(self): res = {} files = glob.glob(os.path.join(self.outputdir, "drives","crt_*_pertime.json")) for file in files: #print file with open(file, 'r') as f: tmp = json.load(f) for slot, slotobj in tmp.items(): if slot != 'per_hour': continue if not slot in res.keys(): res[slot] = {} for ts, args in slotobj.items(): if not ts in res[slot].keys(): res[slot][ts] = {} for k,v in args.items(): if not k in res[slot][ts].keys(): res[slot][ts][k]=0 res[slot][ts][k] += v #print slot,ts,k,v for slot in res.keys(): if slot != 'per_hour': continue for tsstr in sorted(res[slot].keys()): ts = datetime.datetime.strptime(tsstr, "%Y-%m-%d %H:%M:%S") epochts = int(calendar.timegm(ts.utctimetuple())) epochse = epochts + get_slot_size_seconds(slot, ts.month, ts.year) # print slot,ts res[slot][tsstr][VOL_MNT_LENGTH]=0 res[slot][tsstr][CLN_TIME_LENGTH]=0 for crt in self.crt.values(): # not sorted res[slot][tsstr][VOL_MNT_LENGTH] += crt.get_volume(slot, ts) for drv in self.drv.values(): res[slot][tsstr][CLN_TIME_LENGTH] += sum(drv.estimate_cleaning_time(epochts,epochse)) self._jsondmp(res, 'taperesults.json', self.outputdir) atts = [CLN_TIME_LENGTH,VOL_MNT_LENGTH,TOTAL_MNT_TIME,TOTAL_MNTS] for slot,slotobj in res.items(): if slot != 'per_hour': continue file = os.path.join(self.outputdir, "tapesystem2_%s.csv"%slot) with open(file, 'w') as csv_file: lineBuf = StringIO.StringIO() lineBuf.write("timestamp") for att in atts: lineBuf.write(";%s"%att) for ts in sorted(slotobj.keys()): lineBuf.write("\n%s"%ts) for att in atts: linebuf_write(lineBuf,slotobj[ts].get(att, 0) ) csv_file.write(lineBuf.getvalue()) csv_file.close() lineBuf.flush() def debug3(self): # cdf time between mounts res = [] for cid, crt in self.crt.items(): res.extend(crt.get_tbm()) file = os.path.join(self.outputdir, "timebetweenmounts_.csv") r = sorted(res) with open(file, 'w') as csv_file: lineBuf = StringIO.StringIO() lineBuf.write("percentile;timebetweenmounts") for p in [0.01,0.05,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,0.95,0.99]: pt = percentile(r,p) lineBuf.write("\n%s;%s"%(p,pt)) csv_file.write(lineBuf.getvalue()) csv_file.close() lineBuf.flush() res = [] for cid, crt in self.crt.items(): res.extend(crt.get_latency()) file = os.path.join(self.outputdir, "latency.csv") r = sorted(res) with open(file, 'w') as csv_file: lineBuf = StringIO.StringIO() lineBuf.write("percentile;latency") for p in [0.01,0.05,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,0.95,0.99]: pt = percentile(r,p) lineBuf.write("\n%s;%s"%(p,pt)) csv_file.write(lineBuf.getvalue()) csv_file.close() lineBuf.flush() # usage: # 1. aggregate results, using the robot analyse py "aggregate" function # 2. run this script with either # a) full (takes looong, dont know how long) # b) "-w" to load the whpss data and # "-r" to integrate robot logs # "-z" to check wheather the robotlogs fixed some broken whpss entries # "-y" to derive "home" classes # 3. "-c" to run correlation results # "-s" to collect general statistics # "-p" for some stats generated specifically for the fast paper, (not all of them are generated here!) if __name__ == '__main__': if len(sys.argv)>1: if '-d' in sys.argv: print "daemonizing" python_daemon.createDaemon() sys.stdout.close() #we close /dev/null sys.stderr.close() os.close(2) # and associated fd's os.close(1) # now we open a new stdout # * notice that underlying fd is 1 # * bufsize is 1 because we want stdout line buffered (it's my log file) sys.stdout = open('/tmp/bla','w',1) # redirect stdout os.dup2(1,2) # fd 2 is now a duplicate of fd 1 sys.stderr = os.fdopen(2,'a',0) # redirect stderr # from now on sys.stderr appends to fd 2 # * bufsize is 0, I saw this somewhere, I guess no bufferization at all is better for stderr # now some tests... we want to know if it's bufferized or not print "stdout" print >> sys.stderr, "stderr" os.system("echo stdout-echo") # this is unix only... os.system("echo stderr-echo > /dev/stderr") # cat /tmp/bla and check that it's ok; to kill use: pkill -f bla.py dodump = False if '-f' in sys.argv: FULLRUN = True x = os.path.join(os.getcwd(),sys.argv[1]) god = God(x) if '-c' in sys.argv or FULLRUN: # with Timer('Correlation (-c)'): god.correlation() #dodump=True sys.exit() elif '--correlationanalysis' in sys.argv: #god.debug() god.jsonload(True) god.parallel_correlation_analysis() sys.exit() else: # with Timer('jsonload'): god.jsonload() if '--debug' in sys.argv: god.debug() sys.exit() if '--debug2' in sys.argv: god.debug2() sys.exit() if '--debug3' in sys.argv: god.debug3() sys.exit() # with Timer('WHPSS read (-w)'): if '-w' in sys.argv or FULLRUN: god.whpss_read() # with Timer('WHPSSdone, Immediately json dump'): god.jsondump() #with Timer("Robot read: (-r)"): if '-r' in sys.argv or FULLRUN: god.robot_read() # with Timer('Robotdone, Immediately json dump'): god.jsondump() pass # with Timer("Check for fixed errors: (-z)"): if '-z' in sys.argv or FULLRUN: god.collect_recovered_errors() dodump=True # with Timer("derive homes (-y)"): if '-y' in sys.argv or FULLRUN: god.derive_homes() dodump = True # with Timer("Cnt errors (-e)"): if '-e' in sys.argv: god.checkerrors() dodump=True #with Timer('stats: (-s)'): if '-s' in sys.argv or FULLRUN: god.stats() #dodump=True #with Timer("Highest Level Stats (-hh)"): if '-hh' in sys.argv or FULLRUN: god.highestlevelstats() #with Timer ("Generate Paper output (-p)"): if '-p' in sys.argv or FULLRUN: god.paperoutput() if dodump: # with Timer('json dump'): god.jsondump()
mit
altairpearl/scikit-learn
examples/linear_model/plot_lasso_and_elasticnet.py
73
2074
""" ======================================== Lasso and Elastic Net for Sparse Signals ======================================== Estimates Lasso and Elastic-Net regression models on a manually generated sparse signal corrupted with an additive noise. Estimated coefficients are compared with the ground-truth. """ print(__doc__) import numpy as np import matplotlib.pyplot as plt from sklearn.metrics import r2_score ############################################################################### # generate some sparse data to play with np.random.seed(42) n_samples, n_features = 50, 200 X = np.random.randn(n_samples, n_features) coef = 3 * np.random.randn(n_features) inds = np.arange(n_features) np.random.shuffle(inds) coef[inds[10:]] = 0 # sparsify coef y = np.dot(X, coef) # add noise y += 0.01 * np.random.normal((n_samples,)) # Split data in train set and test set n_samples = X.shape[0] X_train, y_train = X[:n_samples / 2], y[:n_samples / 2] X_test, y_test = X[n_samples / 2:], y[n_samples / 2:] ############################################################################### # Lasso from sklearn.linear_model import Lasso alpha = 0.1 lasso = Lasso(alpha=alpha) y_pred_lasso = lasso.fit(X_train, y_train).predict(X_test) r2_score_lasso = r2_score(y_test, y_pred_lasso) print(lasso) print("r^2 on test data : %f" % r2_score_lasso) ############################################################################### # ElasticNet from sklearn.linear_model import ElasticNet enet = ElasticNet(alpha=alpha, l1_ratio=0.7) y_pred_enet = enet.fit(X_train, y_train).predict(X_test) r2_score_enet = r2_score(y_test, y_pred_enet) print(enet) print("r^2 on test data : %f" % r2_score_enet) plt.plot(enet.coef_, color='lightgreen', linewidth=2, label='Elastic net coefficients') plt.plot(lasso.coef_, color='gold', linewidth=2, label='Lasso coefficients') plt.plot(coef, '--', color='navy', label='original coefficients') plt.legend(loc='best') plt.title("Lasso R^2: %f, Elastic Net R^2: %f" % (r2_score_lasso, r2_score_enet)) plt.show()
bsd-3-clause
ywang007/odo
odo/backends/sql.py
1
22308
from __future__ import absolute_import, division, print_function from operator import attrgetter import os import re import subprocess from itertools import chain from collections import Iterator from datetime import datetime, date from distutils.spawn import find_executable import pandas as pd import sqlalchemy as sa from sqlalchemy import inspect from sqlalchemy.ext.compiler import compiles from sqlalchemy import event from sqlalchemy.schema import CreateSchema from multipledispatch import MDNotImplementedError import datashape from datashape import DataShape, Record, Option, var, dshape from datashape.predicates import isdimension, isrecord, isscalar from datashape import discover from datashape.dispatch import dispatch from toolz import (partition_all, keyfilter, memoize, valfilter, identity, concat, curry, merge) from toolz.curried import pluck, map from ..compatibility import unicode from ..utils import keywords, ignoring, iter_except from ..convert import convert, ooc_types from ..append import append from ..resource import resource from ..chunks import Chunks from .csv import CSV base = (int, float, datetime, date, bool, str) # http://docs.sqlalchemy.org/en/latest/core/types.html types = { 'int64': sa.types.BigInteger, 'int32': sa.types.Integer, 'int': sa.types.Integer, 'int16': sa.types.SmallInteger, 'float32': sa.types.Float(precision=24), # sqlalchemy uses mantissa 'float64': sa.types.Float(precision=53), # for precision 'float': sa.types.Float(precision=53), 'real': sa.types.Float(precision=53), 'string': sa.types.Text, 'date': sa.types.Date, 'time': sa.types.Time, 'datetime': sa.types.DateTime, 'bool': sa.types.Boolean, "timedelta[unit='D']": sa.types.Interval(second_precision=0, day_precision=9), "timedelta[unit='h']": sa.types.Interval(second_precision=0, day_precision=0), "timedelta[unit='m']": sa.types.Interval(second_precision=0, day_precision=0), "timedelta[unit='s']": sa.types.Interval(second_precision=0, day_precision=0), "timedelta[unit='ms']": sa.types.Interval(second_precision=3, day_precision=0), "timedelta[unit='us']": sa.types.Interval(second_precision=6, day_precision=0), "timedelta[unit='ns']": sa.types.Interval(second_precision=9, day_precision=0), # ??: sa.types.LargeBinary, # Decimal: sa.types.Numeric, # ??: sa.types.PickleType, # unicode: sa.types.Unicode, # unicode: sa.types.UnicodeText, # str: sa.types.Text, # ?? } revtypes = dict(map(reversed, types.items())) revtypes.update({ sa.types.DATETIME: 'datetime', sa.types.TIMESTAMP: 'datetime', sa.types.FLOAT: 'float64', sa.types.DATE: 'date', sa.types.BIGINT: 'int64', sa.types.INTEGER: 'int', sa.types.NUMERIC: 'float64', # TODO: extend datashape to decimal sa.types.BIGINT: 'int64', sa.types.NullType: 'string', sa.types.Float: 'float64', }) # interval types are special cased in discover_typeengine so remove them from # revtypes revtypes = valfilter(lambda x: not isinstance(x, sa.types.Interval), revtypes) units_of_power = { 0: 's', 3: 'ms', 6: 'us', 9: 'ns' } # these aren't loaded by sqlalchemy by default sa.dialects.registry.load('oracle') sa.dialects.registry.load('postgresql') def batch(sel, chunksize=10000): """Execute `sel`, streaming row at a time and fetching from the database in batches of size `chunksize`. Parameters ---------- sel : sa.sql.Selectable Selectable to execute chunksize : int, optional, default 10000 Number of rows to fetch from the database """ def rowterator(sel, chunksize=chunksize): with sel.bind.connect() as conn: result = conn.execute(sel) yield result.keys() for rows in iter_except(curry(result.fetchmany, size=chunksize), sa.exc.ResourceClosedError): if rows: yield rows else: return terator = rowterator(sel) return next(terator), concat(terator) @discover.register(sa.dialects.postgresql.base.INTERVAL) def discover_postgresql_interval(t): return discover(sa.types.Interval(day_precision=0, second_precision=t.precision)) @discover.register(sa.dialects.oracle.base.INTERVAL) def discover_oracle_interval(t): return discover(t.adapt(sa.types.Interval)) @discover.register(sa.sql.type_api.TypeEngine) def discover_typeengine(typ): if isinstance(typ, sa.types.Interval): if typ.second_precision is None and typ.day_precision is None: return datashape.TimeDelta(unit='us') elif typ.second_precision == 0 and typ.day_precision == 0: return datashape.TimeDelta(unit='s') if typ.second_precision in units_of_power and not typ.day_precision: units = units_of_power[typ.second_precision] elif typ.day_precision > 0: units = 'D' else: raise ValueError('Cannot infer INTERVAL type with parameters' 'second_precision=%d, day_precision=%d' % (typ.second_precision, typ.day_precision)) return datashape.TimeDelta(unit=units) if typ in revtypes: return dshape(revtypes[typ])[0] if type(typ) in revtypes: return dshape(revtypes[type(typ)])[0] if isinstance(typ, (sa.String, sa.Unicode)): return datashape.String(typ.length, typ.collation) else: for k, v in revtypes.items(): if isinstance(k, type) and (isinstance(typ, k) or hasattr(typ, 'impl') and isinstance(typ.impl, k)): return v if k == typ: return v raise NotImplementedError("No SQL-datashape match for type %s" % typ) @discover.register(sa.Column) def discover_sqlalchemy_column(col): optionify = Option if col.nullable else identity return Record([[col.name, optionify(discover(col.type))]]) @discover.register(sa.sql.FromClause) def discover_sqlalchemy_selectable(t): records = list(sum([discover(c).parameters[0] for c in t.columns], ())) return var * Record(records) @memoize def metadata_of_engine(engine, schema=None): return sa.MetaData(engine, schema=schema) def create_engine(uri, *args, **kwargs): if ':memory:' in uri: return sa.create_engine(uri, *args, **kwargs) else: return memoized_create_engine(uri, *args, **kwargs) memoized_create_engine = memoize(sa.create_engine) @dispatch(sa.engine.base.Engine, str) def discover(engine, tablename): metadata = metadata_of_engine(engine) if tablename not in metadata.tables: try: metadata.reflect(engine, views=metadata.bind.dialect.supports_views) except NotImplementedError: metadata.reflect(engine) table = metadata.tables[tablename] return discover(table) @dispatch(sa.engine.base.Engine) def discover(engine): metadata = metadata_of_engine(engine) return discover(metadata) @dispatch(sa.MetaData) def discover(metadata): try: metadata.reflect(views=metadata.bind.dialect.supports_views) except NotImplementedError: metadata.reflect() pairs = [] for table in sorted(metadata.tables.values(), key=attrgetter('name')): name = table.name try: pairs.append([name, discover(table)]) except sa.exc.CompileError as e: print("Can not discover type of table %s.\n" % name + "SQLAlchemy provided this error message:\n\t%s" % e.message + "\nSkipping.") except NotImplementedError as e: print("Blaze does not understand a SQLAlchemy type.\n" "Blaze provided the following error:\n\t%s" % "\n\t".join(e.args) + "\nSkipping.") return DataShape(Record(pairs)) @discover.register(sa.engine.RowProxy) def discover_row_proxy(rp): return Record(list(zip(rp.keys(), map(discover, rp.values())))) def dshape_to_table(name, ds, metadata=None): """ Create a SQLAlchemy table from a datashape and a name >>> dshape_to_table('bank', '{name: string, amount: int}') # doctest: +NORMALIZE_WHITESPACE Table('bank', MetaData(bind=None), Column('name', Text(), table=<bank>, nullable=False), Column('amount', Integer(), table=<bank>, nullable=False), schema=None) """ if isinstance(ds, str): ds = dshape(ds) if metadata is None: metadata = sa.MetaData() cols = dshape_to_alchemy(ds) t = sa.Table(name, metadata, *cols, schema=metadata.schema) return attach_schema(t, t.schema) @dispatch(object, str) def create_from_datashape(o, ds, **kwargs): return create_from_datashape(o, dshape(ds), **kwargs) @dispatch(sa.engine.base.Engine, DataShape) def create_from_datashape(engine, ds, schema=None, **kwargs): assert isrecord(ds), 'datashape must be Record type, got %s' % ds metadata = metadata_of_engine(engine, schema=schema) for name, sub_ds in ds[0].dict.items(): t = dshape_to_table(name, sub_ds, metadata=metadata) t.create() return engine def dshape_to_alchemy(dshape): """ >>> dshape_to_alchemy('int') <class 'sqlalchemy.sql.sqltypes.Integer'> >>> dshape_to_alchemy('string') <class 'sqlalchemy.sql.sqltypes.Text'> >>> dshape_to_alchemy('{name: string, amount: int}') [Column('name', Text(), table=None, nullable=False), Column('amount', Integer(), table=None, nullable=False)] >>> dshape_to_alchemy('{name: ?string, amount: ?int}') [Column('name', Text(), table=None), Column('amount', Integer(), table=None)] """ if isinstance(dshape, str): dshape = datashape.dshape(dshape) if isinstance(dshape, Option): return dshape_to_alchemy(dshape.ty) if str(dshape) in types: return types[str(dshape)] if isinstance(dshape, datashape.Record): return [sa.Column(name, dshape_to_alchemy(typ), nullable=isinstance(typ[0], Option)) for name, typ in dshape.parameters[0]] if isinstance(dshape, datashape.DataShape): if isdimension(dshape[0]): return dshape_to_alchemy(dshape[1]) else: return dshape_to_alchemy(dshape[0]) if isinstance(dshape, datashape.String): fixlen = dshape[0].fixlen if fixlen is None: return sa.types.Text string_types = dict(U=sa.types.Unicode, A=sa.types.String) assert dshape.encoding is not None return string_types[dshape.encoding[0]](length=fixlen) if isinstance(dshape, datashape.DateTime): if dshape.tz: return sa.types.DateTime(timezone=True) else: return sa.types.DateTime(timezone=False) raise NotImplementedError("No SQLAlchemy dtype match for datashape: %s" % dshape) @convert.register(Iterator, sa.Table, cost=300.0) def sql_to_iterator(t, **kwargs): _, rows = batch(sa.select([t])) return map(tuple, rows) @convert.register(Iterator, sa.sql.Select, cost=300.0) def select_to_iterator(sel, dshape=None, **kwargs): func = pluck(0) if dshape and isscalar(dshape.measure) else map(tuple) _, rows = batch(sel) return func(rows) @convert.register(base, sa.sql.Select, cost=300.0) def select_to_base(sel, dshape=None, **kwargs): assert not dshape or isscalar(dshape), \ 'dshape should be None or scalar, got %s' % dshape with sel.bind.connect() as conn: return conn.execute(sel).scalar() @append.register(sa.Table, Iterator) def append_iterator_to_table(t, rows, dshape=None, **kwargs): assert not isinstance(t, type) rows = iter(rows) # We see if the sequence is of tuples or dicts # If tuples then we coerce them to dicts try: row = next(rows) except StopIteration: return rows = chain([row], rows) if isinstance(row, (tuple, list)): if dshape and isinstance(dshape.measure, datashape.Record): names = dshape.measure.names if set(names) != set(discover(t).measure.names): raise ValueError("Column names of incoming data don't match " "column names of existing SQL table\n" "Names in SQL table: %s\n" "Names from incoming data: %s\n" % (discover(t).measure.names, names)) else: names = discover(t).measure.names rows = (dict(zip(names, row)) for row in rows) engine = t.bind with engine.connect() as conn: for chunk in partition_all(1000, rows): # TODO: 1000 is hardcoded conn.execute(t.insert(), chunk) return t @append.register(sa.Table, Chunks) def append_anything_to_sql_Table(t, c, **kwargs): for item in c: append(t, item, **kwargs) return t @append.register(sa.Table, object) def append_anything_to_sql_Table(t, o, **kwargs): return append(t, convert(Iterator, o, **kwargs), **kwargs) @append.register(sa.Table, sa.Table) def append_table_to_sql_Table(t, o, **kwargs): # This condition is an ugly kludge and should be removed once # https://github.com/dropbox/PyHive/issues/15 is resolved if t.bind.name == o.bind.name == 'hive': with t.bind.connect() as conn: conn.execute('INSERT INTO TABLE %s SELECT * FROM %s' % (t.name, o.name)) return t s = sa.select([o]) return append(t, s, **kwargs) @append.register(sa.Table, sa.sql.Select) def append_select_statement_to_sql_Table(t, o, **kwargs): if not o.bind == t.bind: return append(t, convert(Iterator, o, **kwargs), **kwargs) assert o.bind.has_table(t.name, t.schema), \ 'tables must come from the same database' query = t.insert().from_select(o.columns.keys(), o) with o.bind.connect() as conn: conn.execute(query) return t def should_create_schema(ddl, target, bind, tables=None, state=None, checkfirst=None, **kwargs): return ddl.element not in inspect(target.bind).get_schema_names() def attach_schema(obj, schema): if schema is not None: ddl = CreateSchema(schema, quote=True) event.listen(obj, 'before_create', ddl.execute_if(callable_=should_create_schema, dialect='postgresql')) return obj def fullname(table, compiler): preparer = compiler.dialect.identifier_preparer fullname = preparer.quote_identifier(table.name) schema = table.schema if schema is not None: fullname = '%s.%s' % (preparer.quote_schema(schema), fullname) return fullname @resource.register(r'(.*sql.*|oracle|redshift)(\+\w+)?://.+') def resource_sql(uri, *args, **kwargs): kwargs2 = keyfilter(keywords(sa.create_engine).__contains__, kwargs) engine = create_engine(uri, **kwargs2) ds = kwargs.get('dshape') schema = kwargs.get('schema') # we were also given a table name if args and isinstance(args[0], (str, unicode)): table_name, args = args[0], args[1:] metadata = metadata_of_engine(engine, schema=schema) with ignoring(sa.exc.NoSuchTableError): return attach_schema(sa.Table(table_name, metadata, autoload=True, autoload_with=engine, schema=schema), schema) if ds: t = dshape_to_table(table_name, ds, metadata=metadata) t.create() return t else: raise ValueError("Table does not exist and no dshape provided") # We were not given a table name if ds: create_from_datashape(engine, ds, schema=schema) return engine @resource.register('impala://.+') def resource_impala(uri, *args, **kwargs): try: import impala.sqlalchemy except ImportError: raise ImportError("Please install or update `impyla` library") return resource_sql(uri, *args, **kwargs) @resource.register('monetdb://.+') def resource_monet(uri, *args, **kwargs): try: import monetdb except ImportError: raise ImportError("Please install the `sqlalchemy_monetdb` library") return resource_sql(uri, *args, **kwargs) @resource.register('hive://.+') def resource_hive(uri, *args, **kwargs): try: import pyhive except ImportError: raise ImportError("Please install the `PyHive` library.") pattern = 'hive://((?P<user>[a-zA-Z_]\w*)@)?(?P<host>[\w.]+)(:(?P<port>\d*))?(/(?P<database>\w*))?' d = re.search(pattern, uri.split('::')[0]).groupdict() defaults = {'port': '10000', 'user': 'hdfs', 'database': 'default'} for k, v in d.items(): if not v: d[k] = defaults[k] if d['user']: d['user'] += '@' uri2 = 'hive://%(user)s%(host)s:%(port)s/%(database)s' % d if '::' in uri: uri2 += '::' + uri.split('::')[1] return resource_sql(uri2, *args, **kwargs) ooc_types.add(sa.Table) @dispatch(sa.Table) def drop(table): table.drop(table.bind, checkfirst=True) @convert.register(pd.DataFrame, (sa.sql.Select, sa.sql.Selectable), cost=200.0) def select_or_selectable_to_frame(el, **kwargs): columns, rows = batch(el) row = next(rows, None) if row is None: return pd.DataFrame(columns=columns) return pd.DataFrame(list(chain([tuple(row)], map(tuple, rows))), columns=columns) class CopyToCSV(sa.sql.expression.Executable, sa.sql.ClauseElement): def __init__(self, element, path, delimiter=',', quotechar='"', lineterminator=r'\n', escapechar='\\', header=True, na_value=''): self.element = element self.path = path self.delimiter = delimiter self.quotechar = quotechar self.lineterminator = lineterminator # mysql cannot write headers self.header = header and element.bind.dialect.name != 'mysql' self.escapechar = escapechar self.na_value = na_value @compiles(CopyToCSV, 'postgresql') def compile_copy_to_csv_postgres(element, compiler, **kwargs): selectable = element.element istable = isinstance(selectable, sa.Table) template = """COPY %s TO '{path}' WITH CSV {header} DELIMITER '{delimiter}' QUOTE '{quotechar}' NULL '{na_value}' ESCAPE '{escapechar}' """ % ('{query}' if istable else '({query})') processed = (fullname(selectable, compiler) if istable else compiler.process(selectable)) assert processed, ('got empty string from processing element of type %r' % type(selectable).__name__) return template.format(query=processed, path=element.path, header='HEADER' if element.header else '', delimiter=element.delimiter, quotechar=element.quotechar, na_value=element.na_value, escapechar=element.escapechar) @compiles(CopyToCSV, 'mysql') def compile_copy_to_csv_mysql(element, compiler, **kwargs): selectable = element.element if isinstance(selectable, sa.Table): processed = 'SELECT * FROM %(table)s' % dict(table=selectable.name) else: processed = compiler.process(selectable) assert processed, ('got empty string from processing element of type %r' % type(selectable).__name__) template = """{query} INTO OUTFILE '{path}' FIELDS TERMINATED BY '{delimiter}' OPTIONALLY ENCLOSED BY '{quotechar}' ESCAPED BY '{escapechar}' LINES TERMINATED BY '{lineterminator}'""" return template.format(query=processed, path=element.path, delimiter=element.delimiter, lineterminator=element.lineterminator, escapechar=element.escapechar.encode('unicode-escape').decode(), quotechar=element.quotechar) @compiles(CopyToCSV, 'sqlite') def compile_copy_to_csv_sqlite(element, compiler, **kwargs): if not find_executable('sqlite3'): raise MDNotImplementedError("Could not find sqlite executable") selectable = element.element sql = (compiler.process(sa.select([selectable]) if isinstance(selectable, sa.Table) else selectable) + ';') sql = re.sub(r'\s{2,}', ' ', re.sub(r'\s*\n\s*', ' ', sql)).encode() cmd = ['sqlite3', '-csv', '-%sheader' % ('no' if not element.header else ''), '-separator', element.delimiter, selectable.bind.url.database] with open(element.path, mode='at') as f: subprocess.Popen(cmd, stdout=f, stdin=subprocess.PIPE).communicate(sql) # This will be a no-op since we're doing the write during the compile return '' @append.register(CSV, sa.sql.Selectable) def append_table_to_csv(csv, selectable, dshape=None, **kwargs): kwargs = keyfilter(keywords(CopyToCSV).__contains__, merge(csv.dialect, kwargs)) stmt = CopyToCSV(selectable, os.path.abspath(csv.path), **kwargs) with selectable.bind.begin() as conn: conn.execute(stmt) csv.has_header = stmt.header return csv try: from .hdfs import HDFS except ImportError: pass else: @append.register(HDFS(CSV), sa.sql.Selectable) def append_selectable_to_hdfs_csv(*args, **kwargs): raise MDNotImplementedError()
bsd-3-clause
LiaoPan/scikit-learn
sklearn/utils/random.py
234
10510
# Author: Hamzeh Alsalhi <[email protected]> # # License: BSD 3 clause from __future__ import division import numpy as np import scipy.sparse as sp import operator import array from sklearn.utils import check_random_state from sklearn.utils.fixes import astype from ._random import sample_without_replacement __all__ = ['sample_without_replacement', 'choice'] # This is a backport of np.random.choice from numpy 1.7 # The function can be removed when we bump the requirements to >=1.7 def choice(a, size=None, replace=True, p=None, random_state=None): """ choice(a, size=None, replace=True, p=None) Generates a random sample from a given 1-D array .. versionadded:: 1.7.0 Parameters ----------- a : 1-D array-like or int If an ndarray, a random sample is generated from its elements. If an int, the random sample is generated as if a was np.arange(n) size : int or tuple of ints, optional Output shape. Default is None, in which case a single value is returned. replace : boolean, optional Whether the sample is with or without replacement. p : 1-D array-like, optional The probabilities associated with each entry in a. If not given the sample assumes a uniform distribtion over all entries in a. random_state : int, RandomState instance or None, optional (default=None) If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`. Returns -------- samples : 1-D ndarray, shape (size,) The generated random samples Raises ------- ValueError If a is an int and less than zero, if a or p are not 1-dimensional, if a is an array-like of size 0, if p is not a vector of probabilities, if a and p have different lengths, or if replace=False and the sample size is greater than the population size See Also --------- randint, shuffle, permutation Examples --------- Generate a uniform random sample from np.arange(5) of size 3: >>> np.random.choice(5, 3) # doctest: +SKIP array([0, 3, 4]) >>> #This is equivalent to np.random.randint(0,5,3) Generate a non-uniform random sample from np.arange(5) of size 3: >>> np.random.choice(5, 3, p=[0.1, 0, 0.3, 0.6, 0]) # doctest: +SKIP array([3, 3, 0]) Generate a uniform random sample from np.arange(5) of size 3 without replacement: >>> np.random.choice(5, 3, replace=False) # doctest: +SKIP array([3,1,0]) >>> #This is equivalent to np.random.shuffle(np.arange(5))[:3] Generate a non-uniform random sample from np.arange(5) of size 3 without replacement: >>> np.random.choice(5, 3, replace=False, p=[0.1, 0, 0.3, 0.6, 0]) ... # doctest: +SKIP array([2, 3, 0]) Any of the above can be repeated with an arbitrary array-like instead of just integers. For instance: >>> aa_milne_arr = ['pooh', 'rabbit', 'piglet', 'Christopher'] >>> np.random.choice(aa_milne_arr, 5, p=[0.5, 0.1, 0.1, 0.3]) ... # doctest: +SKIP array(['pooh', 'pooh', 'pooh', 'Christopher', 'piglet'], dtype='|S11') """ random_state = check_random_state(random_state) # Format and Verify input a = np.array(a, copy=False) if a.ndim == 0: try: # __index__ must return an integer by python rules. pop_size = operator.index(a.item()) except TypeError: raise ValueError("a must be 1-dimensional or an integer") if pop_size <= 0: raise ValueError("a must be greater than 0") elif a.ndim != 1: raise ValueError("a must be 1-dimensional") else: pop_size = a.shape[0] if pop_size is 0: raise ValueError("a must be non-empty") if None != p: p = np.array(p, dtype=np.double, ndmin=1, copy=False) if p.ndim != 1: raise ValueError("p must be 1-dimensional") if p.size != pop_size: raise ValueError("a and p must have same size") if np.any(p < 0): raise ValueError("probabilities are not non-negative") if not np.allclose(p.sum(), 1): raise ValueError("probabilities do not sum to 1") shape = size if shape is not None: size = np.prod(shape, dtype=np.intp) else: size = 1 # Actual sampling if replace: if None != p: cdf = p.cumsum() cdf /= cdf[-1] uniform_samples = random_state.random_sample(shape) idx = cdf.searchsorted(uniform_samples, side='right') # searchsorted returns a scalar idx = np.array(idx, copy=False) else: idx = random_state.randint(0, pop_size, size=shape) else: if size > pop_size: raise ValueError("Cannot take a larger sample than " "population when 'replace=False'") if None != p: if np.sum(p > 0) < size: raise ValueError("Fewer non-zero entries in p than size") n_uniq = 0 p = p.copy() found = np.zeros(shape, dtype=np.int) flat_found = found.ravel() while n_uniq < size: x = random_state.rand(size - n_uniq) if n_uniq > 0: p[flat_found[0:n_uniq]] = 0 cdf = np.cumsum(p) cdf /= cdf[-1] new = cdf.searchsorted(x, side='right') _, unique_indices = np.unique(new, return_index=True) unique_indices.sort() new = new.take(unique_indices) flat_found[n_uniq:n_uniq + new.size] = new n_uniq += new.size idx = found else: idx = random_state.permutation(pop_size)[:size] if shape is not None: idx.shape = shape if shape is None and isinstance(idx, np.ndarray): # In most cases a scalar will have been made an array idx = idx.item(0) # Use samples as indices for a if a is array-like if a.ndim == 0: return idx if shape is not None and idx.ndim == 0: # If size == () then the user requested a 0-d array as opposed to # a scalar object when size is None. However a[idx] is always a # scalar and not an array. So this makes sure the result is an # array, taking into account that np.array(item) may not work # for object arrays. res = np.empty((), dtype=a.dtype) res[()] = a[idx] return res return a[idx] def random_choice_csc(n_samples, classes, class_probability=None, random_state=None): """Generate a sparse random matrix given column class distributions Parameters ---------- n_samples : int, Number of samples to draw in each column. classes : list of size n_outputs of arrays of size (n_classes,) List of classes for each column. class_probability : list of size n_outputs of arrays of size (n_classes,) Optional (default=None). Class distribution of each column. If None the uniform distribution is assumed. random_state : int, RandomState instance or None, optional (default=None) If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`. Returns ------- random_matrix : sparse csc matrix of size (n_samples, n_outputs) """ data = array.array('i') indices = array.array('i') indptr = array.array('i', [0]) for j in range(len(classes)): classes[j] = np.asarray(classes[j]) if classes[j].dtype.kind != 'i': raise ValueError("class dtype %s is not supported" % classes[j].dtype) classes[j] = astype(classes[j], np.int64, copy=False) # use uniform distribution if no class_probability is given if class_probability is None: class_prob_j = np.empty(shape=classes[j].shape[0]) class_prob_j.fill(1 / classes[j].shape[0]) else: class_prob_j = np.asarray(class_probability[j]) if np.sum(class_prob_j) != 1.0: raise ValueError("Probability array at index {0} does not sum to " "one".format(j)) if class_prob_j.shape[0] != classes[j].shape[0]: raise ValueError("classes[{0}] (length {1}) and " "class_probability[{0}] (length {2}) have " "different length.".format(j, classes[j].shape[0], class_prob_j.shape[0])) # If 0 is not present in the classes insert it with a probability 0.0 if 0 not in classes[j]: classes[j] = np.insert(classes[j], 0, 0) class_prob_j = np.insert(class_prob_j, 0, 0.0) # If there are nonzero classes choose randomly using class_probability rng = check_random_state(random_state) if classes[j].shape[0] > 1: p_nonzero = 1 - class_prob_j[classes[j] == 0] nnz = int(n_samples * p_nonzero) ind_sample = sample_without_replacement(n_population=n_samples, n_samples=nnz, random_state=random_state) indices.extend(ind_sample) # Normalize probabilites for the nonzero elements classes_j_nonzero = classes[j] != 0 class_probability_nz = class_prob_j[classes_j_nonzero] class_probability_nz_norm = (class_probability_nz / np.sum(class_probability_nz)) classes_ind = np.searchsorted(class_probability_nz_norm.cumsum(), rng.rand(nnz)) data.extend(classes[j][classes_j_nonzero][classes_ind]) indptr.append(len(indices)) return sp.csc_matrix((data, indices, indptr), (n_samples, len(classes)), dtype=int)
bsd-3-clause
pnedunuri/scikit-learn
sklearn/cross_validation.py
47
67782
""" The :mod:`sklearn.cross_validation` module includes utilities for cross- validation and performance evaluation. """ # Author: Alexandre Gramfort <[email protected]>, # Gael Varoquaux <[email protected]>, # Olivier Grisel <[email protected]> # License: BSD 3 clause from __future__ import print_function from __future__ import division import warnings from itertools import chain, combinations from math import ceil, floor, factorial import numbers import time from abc import ABCMeta, abstractmethod import numpy as np import scipy.sparse as sp from .base import is_classifier, clone from .utils import indexable, check_random_state, safe_indexing from .utils.validation import (_is_arraylike, _num_samples, check_array, column_or_1d) from .utils.multiclass import type_of_target from .externals.joblib import Parallel, delayed, logger from .externals.six import with_metaclass from .externals.six.moves import zip from .metrics.scorer import check_scoring from .utils.fixes import bincount __all__ = ['KFold', 'LabelKFold', 'LeaveOneLabelOut', 'LeaveOneOut', 'LeavePLabelOut', 'LeavePOut', 'ShuffleSplit', 'StratifiedKFold', 'StratifiedShuffleSplit', 'PredefinedSplit', 'LabelShuffleSplit', 'check_cv', 'cross_val_score', 'cross_val_predict', 'permutation_test_score', 'train_test_split'] class _PartitionIterator(with_metaclass(ABCMeta)): """Base class for CV iterators where train_mask = ~test_mask Implementations must define `_iter_test_masks` or `_iter_test_indices`. Parameters ---------- n : int Total number of elements in dataset. """ def __init__(self, n): if abs(n - int(n)) >= np.finfo('f').eps: raise ValueError("n must be an integer") self.n = int(n) def __iter__(self): ind = np.arange(self.n) for test_index in self._iter_test_masks(): train_index = np.logical_not(test_index) train_index = ind[train_index] test_index = ind[test_index] yield train_index, test_index # Since subclasses must implement either _iter_test_masks or # _iter_test_indices, neither can be abstract. def _iter_test_masks(self): """Generates boolean masks corresponding to test sets. By default, delegates to _iter_test_indices() """ for test_index in self._iter_test_indices(): test_mask = self._empty_mask() test_mask[test_index] = True yield test_mask def _iter_test_indices(self): """Generates integer indices corresponding to test sets.""" raise NotImplementedError def _empty_mask(self): return np.zeros(self.n, dtype=np.bool) class LeaveOneOut(_PartitionIterator): """Leave-One-Out cross validation iterator. Provides train/test indices to split data in train test sets. Each sample is used once as a test set (singleton) while the remaining samples form the training set. Note: ``LeaveOneOut(n)`` is equivalent to ``KFold(n, n_folds=n)`` and ``LeavePOut(n, p=1)``. Due to the high number of test sets (which is the same as the number of samples) this cross validation method can be very costly. For large datasets one should favor KFold, StratifiedKFold or ShuffleSplit. Read more in the :ref:`User Guide <cross_validation>`. Parameters ---------- n : int Total number of elements in dataset. Examples -------- >>> from sklearn import cross_validation >>> X = np.array([[1, 2], [3, 4]]) >>> y = np.array([1, 2]) >>> loo = cross_validation.LeaveOneOut(2) >>> len(loo) 2 >>> print(loo) sklearn.cross_validation.LeaveOneOut(n=2) >>> for train_index, test_index in loo: ... print("TRAIN:", train_index, "TEST:", test_index) ... X_train, X_test = X[train_index], X[test_index] ... y_train, y_test = y[train_index], y[test_index] ... print(X_train, X_test, y_train, y_test) TRAIN: [1] TEST: [0] [[3 4]] [[1 2]] [2] [1] TRAIN: [0] TEST: [1] [[1 2]] [[3 4]] [1] [2] See also -------- LeaveOneLabelOut for splitting the data according to explicit, domain-specific stratification of the dataset. """ def _iter_test_indices(self): return range(self.n) def __repr__(self): return '%s.%s(n=%i)' % ( self.__class__.__module__, self.__class__.__name__, self.n, ) def __len__(self): return self.n class LeavePOut(_PartitionIterator): """Leave-P-Out cross validation iterator Provides train/test indices to split data in train test sets. This results in testing on all distinct samples of size p, while the remaining n - p samples form the training set in each iteration. Note: ``LeavePOut(n, p)`` is NOT equivalent to ``KFold(n, n_folds=n // p)`` which creates non-overlapping test sets. Due to the high number of iterations which grows combinatorically with the number of samples this cross validation method can be very costly. For large datasets one should favor KFold, StratifiedKFold or ShuffleSplit. Read more in the :ref:`User Guide <cross_validation>`. Parameters ---------- n : int Total number of elements in dataset. p : int Size of the test sets. Examples -------- >>> from sklearn import cross_validation >>> X = np.array([[1, 2], [3, 4], [5, 6], [7, 8]]) >>> y = np.array([1, 2, 3, 4]) >>> lpo = cross_validation.LeavePOut(4, 2) >>> len(lpo) 6 >>> print(lpo) sklearn.cross_validation.LeavePOut(n=4, p=2) >>> for train_index, test_index in lpo: ... print("TRAIN:", train_index, "TEST:", test_index) ... X_train, X_test = X[train_index], X[test_index] ... y_train, y_test = y[train_index], y[test_index] TRAIN: [2 3] TEST: [0 1] TRAIN: [1 3] TEST: [0 2] TRAIN: [1 2] TEST: [0 3] TRAIN: [0 3] TEST: [1 2] TRAIN: [0 2] TEST: [1 3] TRAIN: [0 1] TEST: [2 3] """ def __init__(self, n, p): super(LeavePOut, self).__init__(n) self.p = p def _iter_test_indices(self): for comb in combinations(range(self.n), self.p): yield np.array(comb) def __repr__(self): return '%s.%s(n=%i, p=%i)' % ( self.__class__.__module__, self.__class__.__name__, self.n, self.p, ) def __len__(self): return int(factorial(self.n) / factorial(self.n - self.p) / factorial(self.p)) class _BaseKFold(with_metaclass(ABCMeta, _PartitionIterator)): """Base class to validate KFold approaches""" @abstractmethod def __init__(self, n, n_folds, shuffle, random_state): super(_BaseKFold, self).__init__(n) if abs(n_folds - int(n_folds)) >= np.finfo('f').eps: raise ValueError("n_folds must be an integer") self.n_folds = n_folds = int(n_folds) if n_folds <= 1: raise ValueError( "k-fold cross validation requires at least one" " train / test split by setting n_folds=2 or more," " got n_folds={0}.".format(n_folds)) if n_folds > self.n: raise ValueError( ("Cannot have number of folds n_folds={0} greater" " than the number of samples: {1}.").format(n_folds, n)) if not isinstance(shuffle, bool): raise TypeError("shuffle must be True or False;" " got {0}".format(shuffle)) self.shuffle = shuffle self.random_state = random_state class KFold(_BaseKFold): """K-Folds cross validation iterator. Provides train/test indices to split data in train test sets. Split dataset into k consecutive folds (without shuffling by default). Each fold is then used a validation set once while the k - 1 remaining fold form the training set. Read more in the :ref:`User Guide <cross_validation>`. Parameters ---------- n : int Total number of elements. n_folds : int, default=3 Number of folds. Must be at least 2. shuffle : boolean, optional Whether to shuffle the data before splitting into batches. random_state : None, int or RandomState When shuffle=True, pseudo-random number generator state used for shuffling. If None, use default numpy RNG for shuffling. Examples -------- >>> from sklearn.cross_validation import KFold >>> X = np.array([[1, 2], [3, 4], [1, 2], [3, 4]]) >>> y = np.array([1, 2, 3, 4]) >>> kf = KFold(4, n_folds=2) >>> len(kf) 2 >>> print(kf) # doctest: +NORMALIZE_WHITESPACE sklearn.cross_validation.KFold(n=4, n_folds=2, shuffle=False, random_state=None) >>> for train_index, test_index in kf: ... print("TRAIN:", train_index, "TEST:", test_index) ... X_train, X_test = X[train_index], X[test_index] ... y_train, y_test = y[train_index], y[test_index] TRAIN: [2 3] TEST: [0 1] TRAIN: [0 1] TEST: [2 3] Notes ----- The first n % n_folds folds have size n // n_folds + 1, other folds have size n // n_folds. See also -------- StratifiedKFold: take label information into account to avoid building folds with imbalanced class distributions (for binary or multiclass classification tasks). LabelKFold: K-fold iterator variant with non-overlapping labels. """ def __init__(self, n, n_folds=3, shuffle=False, random_state=None): super(KFold, self).__init__(n, n_folds, shuffle, random_state) self.idxs = np.arange(n) if shuffle: rng = check_random_state(self.random_state) rng.shuffle(self.idxs) def _iter_test_indices(self): n = self.n n_folds = self.n_folds fold_sizes = (n // n_folds) * np.ones(n_folds, dtype=np.int) fold_sizes[:n % n_folds] += 1 current = 0 for fold_size in fold_sizes: start, stop = current, current + fold_size yield self.idxs[start:stop] current = stop def __repr__(self): return '%s.%s(n=%i, n_folds=%i, shuffle=%s, random_state=%s)' % ( self.__class__.__module__, self.__class__.__name__, self.n, self.n_folds, self.shuffle, self.random_state, ) def __len__(self): return self.n_folds class LabelKFold(_BaseKFold): """K-fold iterator variant with non-overlapping labels. The same label will not appear in two different folds (the number of distinct labels has to be at least equal to the number of folds). The folds are approximately balanced in the sense that the number of distinct labels is approximately the same in each fold. Parameters ---------- labels : array-like with shape (n_samples, ) Contains a label for each sample. The folds are built so that the same label does not appear in two different folds. n_folds : int, default=3 Number of folds. Must be at least 2. shuffle : boolean, optional Whether to shuffle the data before splitting into batches. random_state : None, int or RandomState When shuffle=True, pseudo-random number generator state used for shuffling. If None, use default numpy RNG for shuffling. Examples -------- >>> from sklearn.cross_validation import LabelKFold >>> X = np.array([[1, 2], [3, 4], [5, 6], [7, 8]]) >>> y = np.array([1, 2, 3, 4]) >>> labels = np.array([0, 0, 2, 2]) >>> label_kfold = LabelKFold(labels, n_folds=2) >>> len(label_kfold) 2 >>> print(label_kfold) sklearn.cross_validation.LabelKFold(n_labels=4, n_folds=2) >>> for train_index, test_index in label_kfold: ... print("TRAIN:", train_index, "TEST:", test_index) ... X_train, X_test = X[train_index], X[test_index] ... y_train, y_test = y[train_index], y[test_index] ... print(X_train, X_test, y_train, y_test) ... TRAIN: [0 1] TEST: [2 3] [[1 2] [3 4]] [[5 6] [7 8]] [1 2] [3 4] TRAIN: [2 3] TEST: [0 1] [[5 6] [7 8]] [[1 2] [3 4]] [3 4] [1 2] See also -------- LeaveOneLabelOut for splitting the data according to explicit, domain-specific stratification of the dataset. """ def __init__(self, labels, n_folds=3, shuffle=False, random_state=None): super(LabelKFold, self).__init__(len(labels), n_folds, shuffle, random_state) unique_labels, labels = np.unique(labels, return_inverse=True) n_labels = len(unique_labels) if n_folds > n_labels: raise ValueError( ("Cannot have number of folds n_folds={0} greater" " than the number of labels: {1}.").format(n_folds, n_labels)) # Weight labels by their number of occurences n_samples_per_label = np.bincount(labels) # Distribute the most frequent labels first indices = np.argsort(n_samples_per_label)[::-1] n_samples_per_label = n_samples_per_label[indices] # Total weight of each fold n_samples_per_fold = np.zeros(n_folds) # Mapping from label index to fold index label_to_fold = np.zeros(len(unique_labels)) # Distribute samples by adding the largest weight to the lightest fold for label_index, weight in enumerate(n_samples_per_label): lightest_fold = np.argmin(n_samples_per_fold) n_samples_per_fold[lightest_fold] += weight label_to_fold[indices[label_index]] = lightest_fold self.idxs = label_to_fold[labels] if shuffle: rng = check_random_state(self.random_state) rng.shuffle(self.idxs) def _iter_test_indices(self): for i in range(self.n_folds): yield (self.idxs == i) def __repr__(self): return '{0}.{1}(n_labels={2}, n_folds={3})'.format( self.__class__.__module__, self.__class__.__name__, self.n, self.n_folds, ) def __len__(self): return self.n_folds class StratifiedKFold(_BaseKFold): """Stratified K-Folds cross validation iterator Provides train/test indices to split data in train test sets. This cross-validation object is a variation of KFold that returns stratified folds. The folds are made by preserving the percentage of samples for each class. Read more in the :ref:`User Guide <cross_validation>`. Parameters ---------- y : array-like, [n_samples] Samples to split in K folds. n_folds : int, default=3 Number of folds. Must be at least 2. shuffle : boolean, optional Whether to shuffle each stratification of the data before splitting into batches. random_state : None, int or RandomState When shuffle=True, pseudo-random number generator state used for shuffling. If None, use default numpy RNG for shuffling. Examples -------- >>> from sklearn.cross_validation import StratifiedKFold >>> X = np.array([[1, 2], [3, 4], [1, 2], [3, 4]]) >>> y = np.array([0, 0, 1, 1]) >>> skf = StratifiedKFold(y, n_folds=2) >>> len(skf) 2 >>> print(skf) # doctest: +NORMALIZE_WHITESPACE sklearn.cross_validation.StratifiedKFold(labels=[0 0 1 1], n_folds=2, shuffle=False, random_state=None) >>> for train_index, test_index in skf: ... print("TRAIN:", train_index, "TEST:", test_index) ... X_train, X_test = X[train_index], X[test_index] ... y_train, y_test = y[train_index], y[test_index] TRAIN: [1 3] TEST: [0 2] TRAIN: [0 2] TEST: [1 3] Notes ----- All the folds have size trunc(n_samples / n_folds), the last one has the complementary. See also -------- LabelKFold: K-fold iterator variant with non-overlapping labels. """ def __init__(self, y, n_folds=3, shuffle=False, random_state=None): super(StratifiedKFold, self).__init__( len(y), n_folds, shuffle, random_state) y = np.asarray(y) n_samples = y.shape[0] unique_labels, y_inversed = np.unique(y, return_inverse=True) label_counts = bincount(y_inversed) min_labels = np.min(label_counts) if self.n_folds > min_labels: warnings.warn(("The least populated class in y has only %d" " members, which is too few. The minimum" " number of labels for any class cannot" " be less than n_folds=%d." % (min_labels, self.n_folds)), Warning) # don't want to use the same seed in each label's shuffle if self.shuffle: rng = check_random_state(self.random_state) else: rng = self.random_state # pre-assign each sample to a test fold index using individual KFold # splitting strategies for each label so as to respect the # balance of labels per_label_cvs = [ KFold(max(c, self.n_folds), self.n_folds, shuffle=self.shuffle, random_state=rng) for c in label_counts] test_folds = np.zeros(n_samples, dtype=np.int) for test_fold_idx, per_label_splits in enumerate(zip(*per_label_cvs)): for label, (_, test_split) in zip(unique_labels, per_label_splits): label_test_folds = test_folds[y == label] # the test split can be too big because we used # KFold(max(c, self.n_folds), self.n_folds) instead of # KFold(c, self.n_folds) to make it possible to not crash even # if the data is not 100% stratifiable for all the labels # (we use a warning instead of raising an exception) # If this is the case, let's trim it: test_split = test_split[test_split < len(label_test_folds)] label_test_folds[test_split] = test_fold_idx test_folds[y == label] = label_test_folds self.test_folds = test_folds self.y = y def _iter_test_masks(self): for i in range(self.n_folds): yield self.test_folds == i def __repr__(self): return '%s.%s(labels=%s, n_folds=%i, shuffle=%s, random_state=%s)' % ( self.__class__.__module__, self.__class__.__name__, self.y, self.n_folds, self.shuffle, self.random_state, ) def __len__(self): return self.n_folds class LeaveOneLabelOut(_PartitionIterator): """Leave-One-Label_Out cross-validation iterator Provides train/test indices to split data according to a third-party provided label. This label information can be used to encode arbitrary domain specific stratifications of the samples as integers. For instance the labels could be the year of collection of the samples and thus allow for cross-validation against time-based splits. Read more in the :ref:`User Guide <cross_validation>`. Parameters ---------- labels : array-like of int with shape (n_samples,) Arbitrary domain-specific stratification of the data to be used to draw the splits. Examples -------- >>> from sklearn import cross_validation >>> X = np.array([[1, 2], [3, 4], [5, 6], [7, 8]]) >>> y = np.array([1, 2, 1, 2]) >>> labels = np.array([1, 1, 2, 2]) >>> lol = cross_validation.LeaveOneLabelOut(labels) >>> len(lol) 2 >>> print(lol) sklearn.cross_validation.LeaveOneLabelOut(labels=[1 1 2 2]) >>> for train_index, test_index in lol: ... print("TRAIN:", train_index, "TEST:", test_index) ... X_train, X_test = X[train_index], X[test_index] ... y_train, y_test = y[train_index], y[test_index] ... print(X_train, X_test, y_train, y_test) TRAIN: [2 3] TEST: [0 1] [[5 6] [7 8]] [[1 2] [3 4]] [1 2] [1 2] TRAIN: [0 1] TEST: [2 3] [[1 2] [3 4]] [[5 6] [7 8]] [1 2] [1 2] See also -------- LabelKFold: K-fold iterator variant with non-overlapping labels. """ def __init__(self, labels): super(LeaveOneLabelOut, self).__init__(len(labels)) # We make a copy of labels to avoid side-effects during iteration self.labels = np.array(labels, copy=True) self.unique_labels = np.unique(labels) self.n_unique_labels = len(self.unique_labels) def _iter_test_masks(self): for i in self.unique_labels: yield self.labels == i def __repr__(self): return '%s.%s(labels=%s)' % ( self.__class__.__module__, self.__class__.__name__, self.labels, ) def __len__(self): return self.n_unique_labels class LeavePLabelOut(_PartitionIterator): """Leave-P-Label_Out cross-validation iterator Provides train/test indices to split data according to a third-party provided label. This label information can be used to encode arbitrary domain specific stratifications of the samples as integers. For instance the labels could be the year of collection of the samples and thus allow for cross-validation against time-based splits. The difference between LeavePLabelOut and LeaveOneLabelOut is that the former builds the test sets with all the samples assigned to ``p`` different values of the labels while the latter uses samples all assigned the same labels. Read more in the :ref:`User Guide <cross_validation>`. Parameters ---------- labels : array-like of int with shape (n_samples,) Arbitrary domain-specific stratification of the data to be used to draw the splits. p : int Number of samples to leave out in the test split. Examples -------- >>> from sklearn import cross_validation >>> X = np.array([[1, 2], [3, 4], [5, 6]]) >>> y = np.array([1, 2, 1]) >>> labels = np.array([1, 2, 3]) >>> lpl = cross_validation.LeavePLabelOut(labels, p=2) >>> len(lpl) 3 >>> print(lpl) sklearn.cross_validation.LeavePLabelOut(labels=[1 2 3], p=2) >>> for train_index, test_index in lpl: ... print("TRAIN:", train_index, "TEST:", test_index) ... X_train, X_test = X[train_index], X[test_index] ... y_train, y_test = y[train_index], y[test_index] ... print(X_train, X_test, y_train, y_test) TRAIN: [2] TEST: [0 1] [[5 6]] [[1 2] [3 4]] [1] [1 2] TRAIN: [1] TEST: [0 2] [[3 4]] [[1 2] [5 6]] [2] [1 1] TRAIN: [0] TEST: [1 2] [[1 2]] [[3 4] [5 6]] [1] [2 1] See also -------- LabelKFold: K-fold iterator variant with non-overlapping labels. """ def __init__(self, labels, p): # We make a copy of labels to avoid side-effects during iteration super(LeavePLabelOut, self).__init__(len(labels)) self.labels = np.array(labels, copy=True) self.unique_labels = np.unique(labels) self.n_unique_labels = len(self.unique_labels) self.p = p def _iter_test_masks(self): comb = combinations(range(self.n_unique_labels), self.p) for idx in comb: test_index = self._empty_mask() idx = np.array(idx) for l in self.unique_labels[idx]: test_index[self.labels == l] = True yield test_index def __repr__(self): return '%s.%s(labels=%s, p=%s)' % ( self.__class__.__module__, self.__class__.__name__, self.labels, self.p, ) def __len__(self): return int(factorial(self.n_unique_labels) / factorial(self.n_unique_labels - self.p) / factorial(self.p)) class BaseShuffleSplit(with_metaclass(ABCMeta)): """Base class for ShuffleSplit and StratifiedShuffleSplit""" def __init__(self, n, n_iter=10, test_size=0.1, train_size=None, random_state=None): self.n = n self.n_iter = n_iter self.test_size = test_size self.train_size = train_size self.random_state = random_state self.n_train, self.n_test = _validate_shuffle_split(n, test_size, train_size) def __iter__(self): for train, test in self._iter_indices(): yield train, test return @abstractmethod def _iter_indices(self): """Generate (train, test) indices""" class ShuffleSplit(BaseShuffleSplit): """Random permutation cross-validation iterator. Yields indices to split data into training and test sets. Note: contrary to other cross-validation strategies, random splits do not guarantee that all folds will be different, although this is still very likely for sizeable datasets. Read more in the :ref:`User Guide <cross_validation>`. Parameters ---------- n : int Total number of elements in the dataset. n_iter : int (default 10) Number of re-shuffling & splitting iterations. test_size : float (default 0.1), int, or None If float, should be between 0.0 and 1.0 and represent the proportion of the dataset to include in the test split. If int, represents the absolute number of test samples. If None, the value is automatically set to the complement of the train size. train_size : float, int, or None (default is None) If float, should be between 0.0 and 1.0 and represent the proportion of the dataset to include in the train split. If int, represents the absolute number of train samples. If None, the value is automatically set to the complement of the test size. random_state : int or RandomState Pseudo-random number generator state used for random sampling. Examples -------- >>> from sklearn import cross_validation >>> rs = cross_validation.ShuffleSplit(4, n_iter=3, ... test_size=.25, random_state=0) >>> len(rs) 3 >>> print(rs) ... # doctest: +ELLIPSIS ShuffleSplit(4, n_iter=3, test_size=0.25, ...) >>> for train_index, test_index in rs: ... print("TRAIN:", train_index, "TEST:", test_index) ... TRAIN: [3 1 0] TEST: [2] TRAIN: [2 1 3] TEST: [0] TRAIN: [0 2 1] TEST: [3] >>> rs = cross_validation.ShuffleSplit(4, n_iter=3, ... train_size=0.5, test_size=.25, random_state=0) >>> for train_index, test_index in rs: ... print("TRAIN:", train_index, "TEST:", test_index) ... TRAIN: [3 1] TEST: [2] TRAIN: [2 1] TEST: [0] TRAIN: [0 2] TEST: [3] """ def _iter_indices(self): rng = check_random_state(self.random_state) for i in range(self.n_iter): # random partition permutation = rng.permutation(self.n) ind_test = permutation[:self.n_test] ind_train = permutation[self.n_test:self.n_test + self.n_train] yield ind_train, ind_test def __repr__(self): return ('%s(%d, n_iter=%d, test_size=%s, ' 'random_state=%s)' % ( self.__class__.__name__, self.n, self.n_iter, str(self.test_size), self.random_state, )) def __len__(self): return self.n_iter def _validate_shuffle_split(n, test_size, train_size): if test_size is None and train_size is None: raise ValueError( 'test_size and train_size can not both be None') if test_size is not None: if np.asarray(test_size).dtype.kind == 'f': if test_size >= 1.: raise ValueError( 'test_size=%f should be smaller ' 'than 1.0 or be an integer' % test_size) elif np.asarray(test_size).dtype.kind == 'i': if test_size >= n: raise ValueError( 'test_size=%d should be smaller ' 'than the number of samples %d' % (test_size, n)) else: raise ValueError("Invalid value for test_size: %r" % test_size) if train_size is not None: if np.asarray(train_size).dtype.kind == 'f': if train_size >= 1.: raise ValueError("train_size=%f should be smaller " "than 1.0 or be an integer" % train_size) elif np.asarray(test_size).dtype.kind == 'f' and \ train_size + test_size > 1.: raise ValueError('The sum of test_size and train_size = %f, ' 'should be smaller than 1.0. Reduce ' 'test_size and/or train_size.' % (train_size + test_size)) elif np.asarray(train_size).dtype.kind == 'i': if train_size >= n: raise ValueError("train_size=%d should be smaller " "than the number of samples %d" % (train_size, n)) else: raise ValueError("Invalid value for train_size: %r" % train_size) if np.asarray(test_size).dtype.kind == 'f': n_test = ceil(test_size * n) elif np.asarray(test_size).dtype.kind == 'i': n_test = float(test_size) if train_size is None: n_train = n - n_test else: if np.asarray(train_size).dtype.kind == 'f': n_train = floor(train_size * n) else: n_train = float(train_size) if test_size is None: n_test = n - n_train if n_train + n_test > n: raise ValueError('The sum of train_size and test_size = %d, ' 'should be smaller than the number of ' 'samples %d. Reduce test_size and/or ' 'train_size.' % (n_train + n_test, n)) return int(n_train), int(n_test) class StratifiedShuffleSplit(BaseShuffleSplit): """Stratified ShuffleSplit cross validation iterator Provides train/test indices to split data in train test sets. This cross-validation object is a merge of StratifiedKFold and ShuffleSplit, which returns stratified randomized folds. The folds are made by preserving the percentage of samples for each class. Note: like the ShuffleSplit strategy, stratified random splits do not guarantee that all folds will be different, although this is still very likely for sizeable datasets. Read more in the :ref:`User Guide <cross_validation>`. Parameters ---------- y : array, [n_samples] Labels of samples. n_iter : int (default 10) Number of re-shuffling & splitting iterations. test_size : float (default 0.1), int, or None If float, should be between 0.0 and 1.0 and represent the proportion of the dataset to include in the test split. If int, represents the absolute number of test samples. If None, the value is automatically set to the complement of the train size. train_size : float, int, or None (default is None) If float, should be between 0.0 and 1.0 and represent the proportion of the dataset to include in the train split. If int, represents the absolute number of train samples. If None, the value is automatically set to the complement of the test size. random_state : int or RandomState Pseudo-random number generator state used for random sampling. Examples -------- >>> from sklearn.cross_validation import StratifiedShuffleSplit >>> X = np.array([[1, 2], [3, 4], [1, 2], [3, 4]]) >>> y = np.array([0, 0, 1, 1]) >>> sss = StratifiedShuffleSplit(y, 3, test_size=0.5, random_state=0) >>> len(sss) 3 >>> print(sss) # doctest: +ELLIPSIS StratifiedShuffleSplit(labels=[0 0 1 1], n_iter=3, ...) >>> for train_index, test_index in sss: ... print("TRAIN:", train_index, "TEST:", test_index) ... X_train, X_test = X[train_index], X[test_index] ... y_train, y_test = y[train_index], y[test_index] TRAIN: [1 2] TEST: [3 0] TRAIN: [0 2] TEST: [1 3] TRAIN: [0 2] TEST: [3 1] """ def __init__(self, y, n_iter=10, test_size=0.1, train_size=None, random_state=None): super(StratifiedShuffleSplit, self).__init__( len(y), n_iter, test_size, train_size, random_state) self.y = np.array(y) self.classes, self.y_indices = np.unique(y, return_inverse=True) n_cls = self.classes.shape[0] if np.min(bincount(self.y_indices)) < 2: raise ValueError("The least populated class in y has only 1" " member, which is too few. The minimum" " number of labels for any class cannot" " be less than 2.") if self.n_train < n_cls: raise ValueError('The train_size = %d should be greater or ' 'equal to the number of classes = %d' % (self.n_train, n_cls)) if self.n_test < n_cls: raise ValueError('The test_size = %d should be greater or ' 'equal to the number of classes = %d' % (self.n_test, n_cls)) def _iter_indices(self): rng = check_random_state(self.random_state) cls_count = bincount(self.y_indices) p_i = cls_count / float(self.n) n_i = np.round(self.n_train * p_i).astype(int) t_i = np.minimum(cls_count - n_i, np.round(self.n_test * p_i).astype(int)) for n in range(self.n_iter): train = [] test = [] for i, cls in enumerate(self.classes): permutation = rng.permutation(cls_count[i]) cls_i = np.where((self.y == cls))[0][permutation] train.extend(cls_i[:n_i[i]]) test.extend(cls_i[n_i[i]:n_i[i] + t_i[i]]) # Because of rounding issues (as n_train and n_test are not # dividers of the number of elements per class), we may end # up here with less samples in train and test than asked for. if len(train) < self.n_train or len(test) < self.n_test: # We complete by affecting randomly the missing indexes missing_idx = np.where(bincount(train + test, minlength=len(self.y)) == 0, )[0] missing_idx = rng.permutation(missing_idx) train.extend(missing_idx[:(self.n_train - len(train))]) test.extend(missing_idx[-(self.n_test - len(test)):]) train = rng.permutation(train) test = rng.permutation(test) yield train, test def __repr__(self): return ('%s(labels=%s, n_iter=%d, test_size=%s, ' 'random_state=%s)' % ( self.__class__.__name__, self.y, self.n_iter, str(self.test_size), self.random_state, )) def __len__(self): return self.n_iter class PredefinedSplit(_PartitionIterator): """Predefined split cross validation iterator Splits the data into training/test set folds according to a predefined scheme. Each sample can be assigned to at most one test set fold, as specified by the user through the ``test_fold`` parameter. Read more in the :ref:`User Guide <cross_validation>`. Parameters ---------- test_fold : "array-like, shape (n_samples,) test_fold[i] gives the test set fold of sample i. A value of -1 indicates that the corresponding sample is not part of any test set folds, but will instead always be put into the training fold. Examples -------- >>> from sklearn.cross_validation import PredefinedSplit >>> X = np.array([[1, 2], [3, 4], [1, 2], [3, 4]]) >>> y = np.array([0, 0, 1, 1]) >>> ps = PredefinedSplit(test_fold=[0, 1, -1, 1]) >>> len(ps) 2 >>> print(ps) # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS sklearn.cross_validation.PredefinedSplit(test_fold=[ 0 1 -1 1]) >>> for train_index, test_index in ps: ... print("TRAIN:", train_index, "TEST:", test_index) ... X_train, X_test = X[train_index], X[test_index] ... y_train, y_test = y[train_index], y[test_index] TRAIN: [1 2 3] TEST: [0] TRAIN: [0 2] TEST: [1 3] """ def __init__(self, test_fold): super(PredefinedSplit, self).__init__(len(test_fold)) self.test_fold = np.array(test_fold, dtype=np.int) self.test_fold = column_or_1d(self.test_fold) self.unique_folds = np.unique(self.test_fold) self.unique_folds = self.unique_folds[self.unique_folds != -1] def _iter_test_indices(self): for f in self.unique_folds: yield np.where(self.test_fold == f)[0] def __repr__(self): return '%s.%s(test_fold=%s)' % ( self.__class__.__module__, self.__class__.__name__, self.test_fold) def __len__(self): return len(self.unique_folds) class LabelShuffleSplit(ShuffleSplit): '''Shuffle-Labels-Out cross-validation iterator Provides randomized train/test indices to split data according to a third-party provided label. This label information can be used to encode arbitrary domain specific stratifications of the samples as integers. For instance the labels could be the year of collection of the samples and thus allow for cross-validation against time-based splits. The difference between LeavePLabelOut and LabelShuffleSplit is that the former generates splits using all subsets of size ``p`` unique labels, whereas LabelShuffleSplit generates a user-determined number of random test splits, each with a user-determined fraction of unique labels. For example, a less computationally intensive alternative to ``LeavePLabelOut(labels, p=10)`` would be ``LabelShuffleSplit(labels, test_size=10, n_iter=100)``. Note: The parameters ``test_size`` and ``train_size`` refer to labels, and not to samples, as in ShuffleSplit. Parameters ---------- labels : array, [n_samples] Labels of samples n_iter : int (default 5) Number of re-shuffling & splitting iterations. test_size : float (default 0.2), int, or None If float, should be between 0.0 and 1.0 and represent the proportion of the labels to include in the test split. If int, represents the absolute number of test labels. If None, the value is automatically set to the complement of the train size. train_size : float, int, or None (default is None) If float, should be between 0.0 and 1.0 and represent the proportion of the labels to include in the train split. If int, represents the absolute number of train labels. If None, the value is automatically set to the complement of the test size. random_state : int or RandomState Pseudo-random number generator state used for random sampling. ''' def __init__(self, labels, n_iter=5, test_size=0.2, train_size=None, random_state=None): classes, label_indices = np.unique(labels, return_inverse=True) super(LabelShuffleSplit, self).__init__( len(classes), n_iter=n_iter, test_size=test_size, train_size=train_size, random_state=random_state) self.labels = labels self.classes = classes self.label_indices = label_indices def __repr__(self): return ('%s(labels=%s, n_iter=%d, test_size=%s, ' 'random_state=%s)' % ( self.__class__.__name__, self.labels, self.n_iter, str(self.test_size), self.random_state, )) def __len__(self): return self.n_iter def _iter_indices(self): for label_train, label_test in super(LabelShuffleSplit, self)._iter_indices(): # these are the indices of classes in the partition # invert them into data indices train = np.flatnonzero(np.in1d(self.label_indices, label_train)) test = np.flatnonzero(np.in1d(self.label_indices, label_test)) yield train, test ############################################################################## def _index_param_value(X, v, indices): """Private helper function for parameter value indexing.""" if not _is_arraylike(v) or _num_samples(v) != _num_samples(X): # pass through: skip indexing return v if sp.issparse(v): v = v.tocsr() return safe_indexing(v, indices) def cross_val_predict(estimator, X, y=None, cv=None, n_jobs=1, verbose=0, fit_params=None, pre_dispatch='2*n_jobs'): """Generate cross-validated estimates for each input data point Read more in the :ref:`User Guide <cross_validation>`. Parameters ---------- estimator : estimator object implementing 'fit' and 'predict' The object to use to fit the data. X : array-like The data to fit. Can be, for example a list, or an array at least 2d. y : array-like, optional, default: None The target variable to try to predict in the case of supervised learning. cv : int, cross-validation generator or an iterable, optional Determines the cross-validation splitting strategy. Possible inputs for cv are: - None, to use the default 3-fold cross-validation, - integer, to specify the number of folds. - An object to be used as a cross-validation generator. - An iterable yielding train/test splits. For integer/None inputs, if ``y`` is binary or multiclass, :class:`StratifiedKFold` used. If the estimator is a classifier or if ``y`` is neither binary nor multiclass, :class:`KFold` is used. Refer :ref:`User Guide <cross_validation>` for the various cross-validation strategies that can be used here. n_jobs : integer, optional The number of CPUs to use to do the computation. -1 means 'all CPUs'. verbose : integer, optional The verbosity level. fit_params : dict, optional Parameters to pass to the fit method of the estimator. pre_dispatch : int, or string, optional Controls the number of jobs that get dispatched during parallel execution. Reducing this number can be useful to avoid an explosion of memory consumption when more jobs get dispatched than CPUs can process. This parameter can be: - None, in which case all the jobs are immediately created and spawned. Use this for lightweight and fast-running jobs, to avoid delays due to on-demand spawning of the jobs - An int, giving the exact number of total jobs that are spawned - A string, giving an expression as a function of n_jobs, as in '2*n_jobs' Returns ------- preds : ndarray This is the result of calling 'predict' """ X, y = indexable(X, y) cv = check_cv(cv, X, y, classifier=is_classifier(estimator)) # We clone the estimator to make sure that all the folds are # independent, and that it is pickle-able. parallel = Parallel(n_jobs=n_jobs, verbose=verbose, pre_dispatch=pre_dispatch) preds_blocks = parallel(delayed(_fit_and_predict)(clone(estimator), X, y, train, test, verbose, fit_params) for train, test in cv) preds = [p for p, _ in preds_blocks] locs = np.concatenate([loc for _, loc in preds_blocks]) if not _check_is_partition(locs, _num_samples(X)): raise ValueError('cross_val_predict only works for partitions') inv_locs = np.empty(len(locs), dtype=int) inv_locs[locs] = np.arange(len(locs)) # Check for sparse predictions if sp.issparse(preds[0]): preds = sp.vstack(preds, format=preds[0].format) else: preds = np.concatenate(preds) return preds[inv_locs] def _fit_and_predict(estimator, X, y, train, test, verbose, fit_params): """Fit estimator and predict values for a given dataset split. Read more in the :ref:`User Guide <cross_validation>`. Parameters ---------- estimator : estimator object implementing 'fit' and 'predict' The object to use to fit the data. X : array-like of shape at least 2D The data to fit. y : array-like, optional, default: None The target variable to try to predict in the case of supervised learning. train : array-like, shape (n_train_samples,) Indices of training samples. test : array-like, shape (n_test_samples,) Indices of test samples. verbose : integer The verbosity level. fit_params : dict or None Parameters that will be passed to ``estimator.fit``. Returns ------- preds : sequence Result of calling 'estimator.predict' test : array-like This is the value of the test parameter """ # Adjust length of sample weights fit_params = fit_params if fit_params is not None else {} fit_params = dict([(k, _index_param_value(X, v, train)) for k, v in fit_params.items()]) X_train, y_train = _safe_split(estimator, X, y, train) X_test, _ = _safe_split(estimator, X, y, test, train) if y_train is None: estimator.fit(X_train, **fit_params) else: estimator.fit(X_train, y_train, **fit_params) preds = estimator.predict(X_test) return preds, test def _check_is_partition(locs, n): """Check whether locs is a reordering of the array np.arange(n) Parameters ---------- locs : ndarray integer array to test n : int number of expected elements Returns ------- is_partition : bool True iff sorted(locs) is range(n) """ if len(locs) != n: return False hit = np.zeros(n, bool) hit[locs] = True if not np.all(hit): return False return True def cross_val_score(estimator, X, y=None, scoring=None, cv=None, n_jobs=1, verbose=0, fit_params=None, pre_dispatch='2*n_jobs'): """Evaluate a score by cross-validation Read more in the :ref:`User Guide <cross_validation>`. Parameters ---------- estimator : estimator object implementing 'fit' The object to use to fit the data. X : array-like The data to fit. Can be, for example a list, or an array at least 2d. y : array-like, optional, default: None The target variable to try to predict in the case of supervised learning. scoring : string, callable or None, optional, default: None A string (see model evaluation documentation) or a scorer callable object / function with signature ``scorer(estimator, X, y)``. cv : int, cross-validation generator or an iterable, optional Determines the cross-validation splitting strategy. Possible inputs for cv are: - None, to use the default 3-fold cross-validation, - integer, to specify the number of folds. - An object to be used as a cross-validation generator. - An iterable yielding train/test splits. For integer/None inputs, if ``y`` is binary or multiclass, :class:`StratifiedKFold` used. If the estimator is a classifier or if ``y`` is neither binary nor multiclass, :class:`KFold` is used. Refer :ref:`User Guide <cross_validation>` for the various cross-validation strategies that can be used here. n_jobs : integer, optional The number of CPUs to use to do the computation. -1 means 'all CPUs'. verbose : integer, optional The verbosity level. fit_params : dict, optional Parameters to pass to the fit method of the estimator. pre_dispatch : int, or string, optional Controls the number of jobs that get dispatched during parallel execution. Reducing this number can be useful to avoid an explosion of memory consumption when more jobs get dispatched than CPUs can process. This parameter can be: - None, in which case all the jobs are immediately created and spawned. Use this for lightweight and fast-running jobs, to avoid delays due to on-demand spawning of the jobs - An int, giving the exact number of total jobs that are spawned - A string, giving an expression as a function of n_jobs, as in '2*n_jobs' Returns ------- scores : array of float, shape=(len(list(cv)),) Array of scores of the estimator for each run of the cross validation. """ X, y = indexable(X, y) cv = check_cv(cv, X, y, classifier=is_classifier(estimator)) scorer = check_scoring(estimator, scoring=scoring) # We clone the estimator to make sure that all the folds are # independent, and that it is pickle-able. parallel = Parallel(n_jobs=n_jobs, verbose=verbose, pre_dispatch=pre_dispatch) scores = parallel(delayed(_fit_and_score)(clone(estimator), X, y, scorer, train, test, verbose, None, fit_params) for train, test in cv) return np.array(scores)[:, 0] class FitFailedWarning(RuntimeWarning): pass def _fit_and_score(estimator, X, y, scorer, train, test, verbose, parameters, fit_params, return_train_score=False, return_parameters=False, error_score='raise'): """Fit estimator and compute scores for a given dataset split. Parameters ---------- estimator : estimator object implementing 'fit' The object to use to fit the data. X : array-like of shape at least 2D The data to fit. y : array-like, optional, default: None The target variable to try to predict in the case of supervised learning. scorer : callable A scorer callable object / function with signature ``scorer(estimator, X, y)``. train : array-like, shape (n_train_samples,) Indices of training samples. test : array-like, shape (n_test_samples,) Indices of test samples. verbose : integer The verbosity level. error_score : 'raise' (default) or numeric Value to assign to the score if an error occurs in estimator fitting. If set to 'raise', the error is raised. If a numeric value is given, FitFailedWarning is raised. This parameter does not affect the refit step, which will always raise the error. parameters : dict or None Parameters to be set on the estimator. fit_params : dict or None Parameters that will be passed to ``estimator.fit``. return_train_score : boolean, optional, default: False Compute and return score on training set. return_parameters : boolean, optional, default: False Return parameters that has been used for the estimator. Returns ------- train_score : float, optional Score on training set, returned only if `return_train_score` is `True`. test_score : float Score on test set. n_test_samples : int Number of test samples. scoring_time : float Time spent for fitting and scoring in seconds. parameters : dict or None, optional The parameters that have been evaluated. """ if verbose > 1: if parameters is None: msg = "no parameters to be set" else: msg = '%s' % (', '.join('%s=%s' % (k, v) for k, v in parameters.items())) print("[CV] %s %s" % (msg, (64 - len(msg)) * '.')) # Adjust length of sample weights fit_params = fit_params if fit_params is not None else {} fit_params = dict([(k, _index_param_value(X, v, train)) for k, v in fit_params.items()]) if parameters is not None: estimator.set_params(**parameters) start_time = time.time() X_train, y_train = _safe_split(estimator, X, y, train) X_test, y_test = _safe_split(estimator, X, y, test, train) try: if y_train is None: estimator.fit(X_train, **fit_params) else: estimator.fit(X_train, y_train, **fit_params) except Exception as e: if error_score == 'raise': raise elif isinstance(error_score, numbers.Number): test_score = error_score if return_train_score: train_score = error_score warnings.warn("Classifier fit failed. The score on this train-test" " partition for these parameters will be set to %f. " "Details: \n%r" % (error_score, e), FitFailedWarning) else: raise ValueError("error_score must be the string 'raise' or a" " numeric value. (Hint: if using 'raise', please" " make sure that it has been spelled correctly.)" ) else: test_score = _score(estimator, X_test, y_test, scorer) if return_train_score: train_score = _score(estimator, X_train, y_train, scorer) scoring_time = time.time() - start_time if verbose > 2: msg += ", score=%f" % test_score if verbose > 1: end_msg = "%s -%s" % (msg, logger.short_format_time(scoring_time)) print("[CV] %s %s" % ((64 - len(end_msg)) * '.', end_msg)) ret = [train_score] if return_train_score else [] ret.extend([test_score, _num_samples(X_test), scoring_time]) if return_parameters: ret.append(parameters) return ret def _safe_split(estimator, X, y, indices, train_indices=None): """Create subset of dataset and properly handle kernels.""" if hasattr(estimator, 'kernel') and callable(estimator.kernel): # cannot compute the kernel values with custom function raise ValueError("Cannot use a custom kernel function. " "Precompute the kernel matrix instead.") if not hasattr(X, "shape"): if getattr(estimator, "_pairwise", False): raise ValueError("Precomputed kernels or affinity matrices have " "to be passed as arrays or sparse matrices.") X_subset = [X[idx] for idx in indices] else: if getattr(estimator, "_pairwise", False): # X is a precomputed square kernel matrix if X.shape[0] != X.shape[1]: raise ValueError("X should be a square kernel matrix") if train_indices is None: X_subset = X[np.ix_(indices, indices)] else: X_subset = X[np.ix_(indices, train_indices)] else: X_subset = safe_indexing(X, indices) if y is not None: y_subset = safe_indexing(y, indices) else: y_subset = None return X_subset, y_subset def _score(estimator, X_test, y_test, scorer): """Compute the score of an estimator on a given test set.""" if y_test is None: score = scorer(estimator, X_test) else: score = scorer(estimator, X_test, y_test) if not isinstance(score, numbers.Number): raise ValueError("scoring must return a number, got %s (%s) instead." % (str(score), type(score))) return score def _permutation_test_score(estimator, X, y, cv, scorer): """Auxiliary function for permutation_test_score""" avg_score = [] for train, test in cv: estimator.fit(X[train], y[train]) avg_score.append(scorer(estimator, X[test], y[test])) return np.mean(avg_score) def _shuffle(y, labels, random_state): """Return a shuffled copy of y eventually shuffle among same labels.""" if labels is None: ind = random_state.permutation(len(y)) else: ind = np.arange(len(labels)) for label in np.unique(labels): this_mask = (labels == label) ind[this_mask] = random_state.permutation(ind[this_mask]) return y[ind] def check_cv(cv, X=None, y=None, classifier=False): """Input checker utility for building a CV in a user friendly way. Parameters ---------- cv : int, cross-validation generator or an iterable, optional Determines the cross-validation splitting strategy. Possible inputs for cv are: - None, to use the default 3-fold cross-validation, - integer, to specify the number of folds. - An object to be used as a cross-validation generator. - An iterable yielding train/test splits. For integer/None inputs, if ``y`` is binary or multiclass, :class:`StratifiedKFold` used. If the estimator is a classifier or if ``y`` is neither binary nor multiclass, :class:`KFold` is used. Refer :ref:`User Guide <cross_validation>` for the various cross-validation strategies that can be used here. X : array-like The data the cross-val object will be applied on. y : array-like The target variable for a supervised learning problem. classifier : boolean optional Whether the task is a classification task, in which case stratified KFold will be used. Returns ------- checked_cv: a cross-validation generator instance. The return value is guaranteed to be a cv generator instance, whatever the input type. """ is_sparse = sp.issparse(X) if cv is None: cv = 3 if isinstance(cv, numbers.Integral): if classifier: if type_of_target(y) in ['binary', 'multiclass']: cv = StratifiedKFold(y, cv) else: cv = KFold(_num_samples(y), cv) else: if not is_sparse: n_samples = len(X) else: n_samples = X.shape[0] cv = KFold(n_samples, cv) return cv def permutation_test_score(estimator, X, y, cv=None, n_permutations=100, n_jobs=1, labels=None, random_state=0, verbose=0, scoring=None): """Evaluate the significance of a cross-validated score with permutations Read more in the :ref:`User Guide <cross_validation>`. Parameters ---------- estimator : estimator object implementing 'fit' The object to use to fit the data. X : array-like of shape at least 2D The data to fit. y : array-like The target variable to try to predict in the case of supervised learning. scoring : string, callable or None, optional, default: None A string (see model evaluation documentation) or a scorer callable object / function with signature ``scorer(estimator, X, y)``. cv : int, cross-validation generator or an iterable, optional Determines the cross-validation splitting strategy. Possible inputs for cv are: - None, to use the default 3-fold cross-validation, - integer, to specify the number of folds. - An object to be used as a cross-validation generator. - An iterable yielding train/test splits. For integer/None inputs, if ``y`` is binary or multiclass, :class:`StratifiedKFold` used. If the estimator is a classifier or if ``y`` is neither binary nor multiclass, :class:`KFold` is used. Refer :ref:`User Guide <cross_validation>` for the various cross-validation strategies that can be used here. n_permutations : integer, optional Number of times to permute ``y``. n_jobs : integer, optional The number of CPUs to use to do the computation. -1 means 'all CPUs'. labels : array-like of shape [n_samples] (optional) Labels constrain the permutation among groups of samples with a same label. random_state : RandomState or an int seed (0 by default) A random number generator instance to define the state of the random permutations generator. verbose : integer, optional The verbosity level. Returns ------- score : float The true score without permuting targets. permutation_scores : array, shape (n_permutations,) The scores obtained for each permutations. pvalue : float The returned value equals p-value if `scoring` returns bigger numbers for better scores (e.g., accuracy_score). If `scoring` is rather a loss function (i.e. when lower is better such as with `mean_squared_error`) then this is actually the complement of the p-value: 1 - p-value. Notes ----- This function implements Test 1 in: Ojala and Garriga. Permutation Tests for Studying Classifier Performance. The Journal of Machine Learning Research (2010) vol. 11 """ X, y = indexable(X, y) cv = check_cv(cv, X, y, classifier=is_classifier(estimator)) scorer = check_scoring(estimator, scoring=scoring) random_state = check_random_state(random_state) # We clone the estimator to make sure that all the folds are # independent, and that it is pickle-able. score = _permutation_test_score(clone(estimator), X, y, cv, scorer) permutation_scores = Parallel(n_jobs=n_jobs, verbose=verbose)( delayed(_permutation_test_score)( clone(estimator), X, _shuffle(y, labels, random_state), cv, scorer) for _ in range(n_permutations)) permutation_scores = np.array(permutation_scores) pvalue = (np.sum(permutation_scores >= score) + 1.0) / (n_permutations + 1) return score, permutation_scores, pvalue permutation_test_score.__test__ = False # to avoid a pb with nosetests def train_test_split(*arrays, **options): """Split arrays or matrices into random train and test subsets Quick utility that wraps input validation and ``next(iter(ShuffleSplit(n_samples)))`` and application to input data into a single call for splitting (and optionally subsampling) data in a oneliner. Read more in the :ref:`User Guide <cross_validation>`. Parameters ---------- *arrays : sequence of arrays or scipy.sparse matrices with same shape[0] Python lists or tuples occurring in arrays are converted to 1D numpy arrays. test_size : float, int, or None (default is None) If float, should be between 0.0 and 1.0 and represent the proportion of the dataset to include in the test split. If int, represents the absolute number of test samples. If None, the value is automatically set to the complement of the train size. If train size is also None, test size is set to 0.25. train_size : float, int, or None (default is None) If float, should be between 0.0 and 1.0 and represent the proportion of the dataset to include in the train split. If int, represents the absolute number of train samples. If None, the value is automatically set to the complement of the test size. random_state : int or RandomState Pseudo-random number generator state used for random sampling. stratify : array-like or None (default is None) If not None, data is split in a stratified fashion, using this as the labels array. Returns ------- splitting : list of arrays, length=2 * len(arrays) List containing train-test split of input array. Examples -------- >>> import numpy as np >>> from sklearn.cross_validation import train_test_split >>> X, y = np.arange(10).reshape((5, 2)), range(5) >>> X array([[0, 1], [2, 3], [4, 5], [6, 7], [8, 9]]) >>> list(y) [0, 1, 2, 3, 4] >>> X_train, X_test, y_train, y_test = train_test_split( ... X, y, test_size=0.33, random_state=42) ... >>> X_train array([[4, 5], [0, 1], [6, 7]]) >>> y_train [2, 0, 3] >>> X_test array([[2, 3], [8, 9]]) >>> y_test [1, 4] """ n_arrays = len(arrays) if n_arrays == 0: raise ValueError("At least one array required as input") test_size = options.pop('test_size', None) train_size = options.pop('train_size', None) random_state = options.pop('random_state', None) dtype = options.pop('dtype', None) if dtype is not None: warnings.warn("dtype option is ignored and will be removed in 0.18.", DeprecationWarning) allow_nd = options.pop('allow_nd', None) allow_lists = options.pop('allow_lists', None) stratify = options.pop('stratify', None) if allow_lists is not None: warnings.warn("The allow_lists option is deprecated and will be " "assumed True in 0.18 and removed.", DeprecationWarning) if options: raise TypeError("Invalid parameters passed: %s" % str(options)) if allow_nd is not None: warnings.warn("The allow_nd option is deprecated and will be " "assumed True in 0.18 and removed.", DeprecationWarning) if allow_lists is False or allow_nd is False: arrays = [check_array(x, 'csr', allow_nd=allow_nd, force_all_finite=False, ensure_2d=False) if x is not None else x for x in arrays] if test_size is None and train_size is None: test_size = 0.25 arrays = indexable(*arrays) if stratify is not None: cv = StratifiedShuffleSplit(stratify, test_size=test_size, train_size=train_size, random_state=random_state) else: n_samples = _num_samples(arrays[0]) cv = ShuffleSplit(n_samples, test_size=test_size, train_size=train_size, random_state=random_state) train, test = next(iter(cv)) return list(chain.from_iterable((safe_indexing(a, train), safe_indexing(a, test)) for a in arrays)) train_test_split.__test__ = False # to avoid a pb with nosetests
bsd-3-clause
alexblaessle/PyFRAP
pyfrp/modules/pyfrp_gmsh_geometry.py
2
149622
#===================================================================================================================================== #Copyright #===================================================================================================================================== #Copyright (C) 2014 Alexander Blaessle, Patrick Mueller and the Friedrich Miescher Laboratory of the Max Planck Society #This software is distributed under the terms of the GNU General Public License. #This file is part of PyFRAP. #PyFRAP is free software: you can redistribute it and/or modify #it under the terms of the GNU General Public License as published by #the Free Software Foundation, either version 3 of the License, or #(at your option) any later version. #This program is distributed in the hope that it will be useful, #but WITHOUT ANY WARRANTY; without even the implied warranty of #MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the #GNU General Public License for more details. #You should have received a copy of the GNU General Public License #along with this program. If not, see <http://www.gnu.org/licenses/>. #=========================================================================================================================================================================== #Module Description #=========================================================================================================================================================================== """PyFRAP module for creating/extracting gmsh geometries for PyFRAP toolbox. Module mainly has the following classes: * A ``domain`` class, acting as a canvas. * A ``vertex`` class, substituting gmsh's *Point*. * A ``edge`` class, parenting all different kind of edges. * A ``line`` class, substituting gmsh's *Line*. * A ``arc`` class, substituting gmsh's *Circle*. * A ``bSpline`` class, substituting gmsh's *bSpline*. * A ``lineLoop`` class, substituting gmsh's *Line Loop*. * A ``ruledSurface`` class, substituting gmsh's *Ruled Surface*. * A ``surfaceLoop`` class, substituting gmsh's *Surface Loop*. * A ``volume`` class, substituting gmsh's *Volume*. * A ``field`` class, parenting all different kind of fields. * A ``attractorField`` class, substituting gmsh's *Attractor* field. * A ``boundaryLayerField`` class, substituting gmsh's *Boundary Layer* field. * A ``thresholdField`` class, substituting gmsh's *Threshold* field. * A ``minField`` class, substituting gmsh's *Min* field. This module together with pyfrp.pyfrp_gmsh_IO_module and pyfrp.pyfrp_gmsh_module works partially as a python gmsh wrapper, however is incomplete. If you want to know more about gmsh, go to http://gmsh.info/doc/texinfo/gmsh.html . """ #=========================================================================================================================================================================== #Importing necessary modules #=========================================================================================================================================================================== #Numpy/Scipy import numpy as np #String import string #PyFRAP modules import pyfrp_plot_module from pyfrp_term_module import * import pyfrp_misc_module import pyfrp_gmsh_IO_module import pyfrp_idx_module import pyfrp_geometry_module import pyfrp_IO_module import pyfrp_vtk_module #Matplotlib from mpl_toolkits.mplot3d.art3d import Poly3DCollection import copy as cpy #=========================================================================================================================================================================== #Class definitions #=========================================================================================================================================================================== class domain: """Domain class storing embryo geometry entities. Args: edges (list): List of edges. vertices (list): List of vertices. arcs (list): List of arcs. lines (list): List of lines. bSplines (list): List of bSplines. lineLoops (list): List of lineLoops. surfaceLoops (list): List of surfaceLoops. ruledSurfaces (list): List of ruledSurfaces. volumes (list): List of volumes. fields (list): List of fields. annXOffset (float): Offset of annotations in x-direction. annYOffset (float): Offset of annotations in y-direction. annZOffset (float): Offset of annotations in z-direction. """ def __init__(self): #Lists to keep track of all geometrical entities. self.edges=[] self.vertices=[] self.arcs=[] self.lines=[] self.bSplines=[] self.lineLoops=[] self.ruledSurfaces=[] self.surfaceLoops=[] self.volumes=[] self.fields=[] self.bkgdField=None #Some settings for plotting self.annXOffset=3. self.annYOffset=3. self.annZOffset=3. def addVertex(self,x,Id=None,volSize=None,checkExist=False): """Adds new :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.vertex` instance at point ``x`` and appends it to ``vertices`` list. .. note:: ``volSize`` does not have any effect on the geometry itself but is simply stored in the vertex object for further usage. If ``checkExist=True``, checks if a vertex at same location already exists. If so, will return that vertex instead. Args: x (numpy.ndarray): Coordinate of vertex. Keyword Args: Id (int): ID of vertex. volSize (float): Element size at vertex. checkExist (bool): Checks if a vertex at same location already exists. Returns: pyfrp.modules.pyfrp_gmsh_geometry.vertex: New vertex instance. """ if checkExist: for v in self.vertices: if (v.x==x).all(): return v newId=self.getNewId(self.vertices,Id) v=vertex(self,x,newId,volSize=volSize) self.vertices.append(v) return v def addLine(self,v1,v2,Id=None): """Adds new :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.line` instance at point ``x`` and appends it to ``edges`` and ``lines`` list. Args: v1 (pyfrp.modules.pyfrp_gmsh_geometry.vertex): Start vertex. v2 (pyfrp.modules.pyfrp_gmsh_geometry.vertex): End vertex. Keyword Args: Id (int): ID of line. Returns: pyfrp.modules.pyfrp_gmsh_geometry.line: New line instance. """ newId=self.getNewId(self.edges,Id) e=line(self,v1,v2,newId) self.lines.append(e) self.edges.append(e) return e def addArc(self,vstart,vcenter,vend,Id=None): """Adds new :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.arc` instance at point ``x`` and appends it to ``edges`` and ``arcs`` list. Args: vstart (pyfrp.modules.pyfrp_gmsh_geometry.vertex): Start vertex. vcenter (pyfrp.modules.pyfrp_gmsh_geometry.vertex): Center vertex. vend (pyfrp.modules.pyfrp_gmsh_geometry.vertex): End vertex. Keyword Args: Id (int): ID of arc. Returns: pyfrp.modules.pyfrp_gmsh_geometry.arc: New line instance. """ newId=self.getNewId(self.edges,Id) a=arc(self,vstart,vcenter,vend,newId) self.arcs.append(a) self.edges.append(a) return a def addBSpline(self,vertices,Id=None): """Adds new :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.line` instance at point ``x`` and appends it to ``edges`` and ``lines`` list. Args: vertices (list): List of vertex objects. Keyword Args: Id (int): ID of spline. Returns: pyfrp.modules.pyfrp_gmsh_geometry.bSpline: New spline instance. """ newId=self.getNewId(self.edges,Id) e=bSpline(self,vertices,newId) self.bSplines.append(e) self.edges.append(e) return e def addCircleByParameters(self,center,radius,z,volSize,plane="z",genLoop=False,genSurface=False,checkExist=True): """Adds circle to domain by given center and radius. Will create 5 new :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.vertex` objects ``[vcenter,v1,v2,v3,v4]`` and four new `pyfrp.modules.pyfrp_gmsh_geometry.arc` objects [a1,a2,a3,a4] and builds circle. Circle will be at ``z=z`` and vertices will have mesh size ``volSize``. For example: >>> d=pyfrp_gmsh_geometry.domain() >>> d.addCircleByParameters([256,256],100,50,30.) >>> d.addCircleByParameters([256,256],100,50,30.,plane="x") >>> d.addCircleByParameters([256,256],100,50,30.,plane="y") >>> d.draw() will generate: .. image:: ../imgs/pyfrp_gmsh_geometry/addCircleByParameters.png .. note:: Plane can be given as ``"x","y","z"``. See also :py:func:`pyfrp.modules.pyfrp_geometry_module.flipCoordinate`. Args: center (numpy.ndarray): Center of circle. radius (float): Radius of the circle. z (float): Height at which circle is placed. volSize (float): Mesh size of vertices. Keyword Args: plane (str): Plane in which circle is placed. genLoop (bool): Create lineLoop. genSurface (bool): Create ruledSurface. checkExist (bool): Checks if a vertex at same location already exists. Returns: tuple: Tuple containing: * vertices (list): List of vertices. * arcs (list): List of arcs. * loop (pyfrp.modules.pyfrp_gmsh_geometry.lineLoop): Line loop. * surface (pyfrp.modules.pyfrp_gmsh_geometry.ruledSurface): Ruled Surface. """ # Define coordinates xcenter=pyfrp_geometry_module.flipCoordinate([center[0],center[1],z],plane,origAxis="z") x1=pyfrp_geometry_module.flipCoordinate([center[0]+radius,center[1],z],plane,origAxis="z") x2=pyfrp_geometry_module.flipCoordinate([center[0],center[1]+radius,z],plane,origAxis="z") x3=pyfrp_geometry_module.flipCoordinate([center[0]-radius,center[1],z],plane,origAxis="z") x4=pyfrp_geometry_module.flipCoordinate([center[0],center[1]-radius,z],plane,origAxis="z") # Add vertices vcenter=self.addVertex(xcenter,volSize=volSize) v1=self.addVertex(x1,volSize=volSize,checkExist=checkExist) v2=self.addVertex(x2,volSize=volSize,checkExist=checkExist) v3=self.addVertex(x3,volSize=volSize,checkExist=checkExist) v4=self.addVertex(x4,volSize=volSize,checkExist=checkExist) # Add Arcs a1=self.addArc(v1,vcenter,v2) a2=self.addArc(v2,vcenter,v3) a3=self.addArc(v3,vcenter,v4) a4=self.addArc(v4,vcenter,v1) if genLoop or genSurface: loop=self.addLineLoop(edgeIDs=[a1.Id,a2.Id,a3.Id,a4.Id]) else: loop=None if genSurface: surface=self.addRuledSurface(lineLoopID=loop.Id) else: surface=None return [vcenter,v1,v2,v3,v4],[a1,a2,a3,a4],loop,surface def addPolygonByParameters(self,coords,volSize,z=0.,plane="z",genLoop=False,genSurface=False): """Adds polygon to domain by given vertex coordinates. Will create a list of new :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.vertex` objects and a list of new `pyfrp.modules.pyfrp_gmsh_geometry.line` objects connecting the vertices. .. note:: Plane can be given as ``"x","y","z"``. See also :py:func:`pyfrp.modules.pyfrp_geometry_module.flipCoordinate`. .. note:: Vertices can be given either as a * list of coordinate triples ``[[x1,y1,z1],[x2,y2,z2],...]``. * list of x-y-coordinates and a given z-coordinate ``[[x1,y1,z],[x2,y2,z],...]``. For example: >>> d=pyfrp_gmsh_geometry.domain() >>> d.addPolygonByParameters([[100,100,100],[200,200,100],[200,100,100]],30.) >>> d.addPolygonByParameters([[100,100,100],[200,200,100],[200,100,100]],30.,plane="x") >>> d.addPolygonByParameters([[100,100,100],[200,200,100],[200,100,100]],30.,plane="y") >>> d.draw() will generate: .. image:: ../imgs/pyfrp_gmsh_geometry/addPolygonByParameters.png .. note:: Vertices are created in the order of the coordinates and connected in the same order. Args: coords (list): List of coordinates. volSize (float): Mesh size of vertices. Keyword Args: plane (str): Plane in which polygon is placed. z (float): Height at which polygon is placed. genLoop (bool): Create lineLoop. genSurface (bool): Create ruledSurface. Returns: tuple: Tuple containing: * vertices (list): List of vertices. * lines (list): List of connecting lines. * loop (pyfrp.modules.pyfrp_gmsh_geometry.lineLoop): Line loop. * surface (pyfrp.modules.pyfrp_gmsh_geometry.ruledSurface): Ruled Surface. """ # Define coordinates xs=[] for c in coords: if len(c)==3: xs.append(pyfrp_geometry_module.flipCoordinate([c[0],c[1],c[2]],plane,origAxis="z")) else: xs.append(pyfrp_geometry_module.flipCoordinate([c[0],c[1],z],plane,origAxis="z")) # Add vertices vertices=[] for x in xs: vertices.append(self.addVertex(x,volSize=volSize)) # Add Lines lines=[] for i in range(len(vertices)): lines.append(self.addLine(vertices[i],vertices[pyfrp_misc_module.modIdx(i+1,vertices)])) # Add LineLoop if genLoop or genSurface: loop=self.addLineLoop(edgeIDs=pyfrp_misc_module.objAttrToList(lines,'Id')) else: loop=None # Add surface if genSurface: surface=self.addRuledSurface(lineLoopID=loop.Id) else: surface=None return vertices,lines,loop,surface def addRectangleByParameters(self,offset,sidelengthX,sidelengthY,z,volSize,plane="z"): """Adds rectangle to domain by given offset and sidelengths. Will create a list of four :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.vertex` objects and a list of four `pyfrp.modules.pyfrp_gmsh_geometry.line` objects connecting the vertices. .. note:: Plane can be given as ``"x","y","z"``. See also :py:func:`pyfrp.modules.pyfrp_geometry_module.flipCoordinate`. .. note:: The ``offset`` is defined as the bottom left corner. For example: >>> d=pyfrp_gmsh_geometry.domain() >>> d.addRectangleByParameters([256,256],100,200,50,30.) >>> d.addRectangleByParameters([256,256],100,200,50,30.,plane="x") >>> d.addRectangleByParameters([256,256],100,200,50,30.,plane="y") >>> d.draw() will generate: .. image:: ../imgs/pyfrp_gmsh_geometry/addRectangleByParameters.png Args: offset (numpy.ndarray): Offset of rectangle. sidelengthX (float): Sidelength in x-direction. sidelengthY (float): Sidelength in y-direction. z (float): Height at which rectangle is placed. volSize (float): Mesh size of vertices. Keyword Args: plane (str): Plane in which rectangle is placed. genLoop (bool): Create lineLoop. genSurface (bool): Create ruledSurface. Returns: tuple: Tuple containing: * vertices (list): List of vertices. * lines (list): List of connecting lines. * loop (pyfrp.modules.pyfrp_gmsh_geometry.lineLoop): Line loop. * surface (pyfrp.modules.pyfrp_gmsh_geometry.ruledSurface): Ruled Surface. """ coords=[[offset[0],offset[1],z],[offset[0]+sidelengthX,offset[1],z], [offset[0]+sidelengthX,offset[1]+sidelengthY,z],[offset[0],offset[1]+sidelengthY,z]] return self.addPolygonByParameters(coords,volSize,plane=plane) def addSquareByParameters(self,offset,sidelength,z,volSize,plane="z"): """Adds square to domain by given offset and sidelength. Will create a list of four :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.vertex` objects and a list of four `pyfrp.modules.pyfrp_gmsh_geometry.line` objects connecting the vertices. .. note:: Plane can be given as ``"x","y","z"``. See also :py:func:`pyfrp.modules.pyfrp_geometry_module.flipCoordinate`. .. note:: The ``offset`` is defined as the bottom left corner. For example: >>> d=pyfrp_gmsh_geometry.domain() >>> d.addSquareByParameters([256,256],100,50,30.) >>> d.addSquareByParameters([256,256],100,50,30.,plane="x") >>> d.addSquareByParameters([256,256],100,50,30.,plane="y") >>> d.draw() will generate: .. image:: ../imgs/pyfrp_gmsh_geometry/addSquareByParameters.png Args: offset (numpy.ndarray): Offset of square. sidelength (float): Sidelength of square. z (float): Height at which square is placed. volSize (float): Mesh size of vertices. Keyword Args: plane (str): Plane in which square is placed. genLoop (bool): Create lineLoop. genSurface (bool): Create ruledSurface. Returns: tuple: Tuple containing: * vertices (list): List of vertices. * lines (list): List of connecting lines. * loop (pyfrp.modules.pyfrp_gmsh_geometry.lineLoop): Line loop. * surface (pyfrp.modules.pyfrp_gmsh_geometry.ruledSurface): Ruled Surface. """ return self.addRectangleByParameters(offset,sidelength,sidelength,z,volSize,plane=plane) def addPrismByParameters(self,coords,volSize,height=1.,z=0.,plane="z",genLoops=True,genSurfaces=True,genSurfaceLoop=True,genVol=True): r"""Adds prism to domain by given vertex coordinates. Will create: * 2 new polygons, see :py:func:`pyfrp.modules.pyfrp_gmsh_geometry.domain.addPolygonByParameters`. * n :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.line` objects connecting the two polyogns. If selected, will create: * n+2 :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.lineLoop` objects around the 6 surfaces. * n+2 corresponding :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.ruledSurface` objects. * 1 :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.surfaceLoop`. * 1 corresponding :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.volume`. .. note:: Plane can be given as ``"x","y","z"``. See also :py:func:`pyfrp.modules.pyfrp_geometry_module.flipCoordinate`. .. note:: Vertices can be given either as a * list of coordinate triples ``[[x1,y1,z1],[x2,y2,z2],...]``. Then the list of vertices needs to be of length :math:`2n`, where where :math:`n` is the number of corners of the top and lower polygon. Otherwise :py:func:`addPrismByParameters` will crash. * list of x-y-coordinates, a given z-coordinate and height. This will place the vertices at ``[[x1,y1,z],[x2,y2,z],...]`` and ``[[x1,y1,z+height],[x2,y2,z+height],...]``. For example: >>> d=pyfrp_gmsh_geometry.domain() >>> d.addPrismByParameters([[256,256],[200,220],[200,200],[210,210],[220,200]],30.,z=50.,height=40.,plane="z",genLoops=True,genSurfaces=True,genVol=True) >>> d.draw() will generate: .. image:: ../imgs/pyfrp_gmsh_geometry/addPrismByParameters.png .. note:: Vertices are created in the order of the coordinates and connected in the same order. Args: coords (list): List of coordinates. volSize (float): Mesh size of vertices. Keyword Args: plane (str): Plane in which prism is placed. z (float): Height at which first polygon is placed. height (float): Height of prism. genLoops (bool): Generate line loops. genSurfaces (bool): Generate surfaces. genSurfaceLoop (bool): Generate surface loop. genVol (bool): Generate corresponding volume. Returns: tuple: Tuple containing: * vertices (list): List of vertices. * lines (list): List of lines. * loops (list): List of loops. * surfaces (list): List of surfaces. * surfaceLoop (pyfrp.modules.pyfrp_gmsh_geometry.surfaceLoop): Generated surface loop. * vol (pyfrp.modules.pyfrp_gmsh_geometry.volume): Generated volume. """ # Create upper and lower polygons if len(coords[0])==3: if np.mod(len(coords),2)!=0: printError("addPrismByParameters: You gave a list of 3-dimensional vertex coordinates. However,the number of coordinates is odd, will not be able to continue.") return vertices,lines,ltemp,stemp = self.addPolygonByParameters(coords,volSize,z=0.,plane="z",genSurface=genSurface,genLoop=genLoop) vertices1=vertices[:len(vertices)/2] vertices2=vertices[len(vertices)/2:] lines1=lines[:len(lines)/2] lines2=lines[len(lines)/2:] else: vertices1,lines1,ltemp,stemp = self.addPolygonByParameters(coords,volSize,z=z,plane="z") vertices2,lines2,ltemp,stemp = self.addPolygonByParameters(coords,volSize,z=z+height,plane="z") # Connect them with lines lines3=[] for i in range(len(vertices1)): lines3.append(self.addLine(vertices1[i],vertices2[i])) # Add loops loops=[] if genLoops: # Loops of upper and lower polygon loops.append(self.addLineLoop(edgeIDs=pyfrp_misc_module.objAttrToList(lines1,"Id"))) loops.append(self.addLineLoop(edgeIDs=pyfrp_misc_module.objAttrToList(lines2,"Id"))) # Loops of side faces for i in range(len(lines1)): loops.append(self.addLineLoop(edgeIDs=[-lines1[i].Id,lines3[i].Id,lines2[i].Id,-lines3[pyfrp_misc_module.modIdx(i+1,lines1)].Id])) # Add surfaces surfaces=[] if genSurfaces: for loop in loops: surfaces.append(self.addRuledSurface(lineLoopID=loop.Id)) # Make surface loop if genSurfaceLoop: surfaceLoop=self.addSurfaceLoop(surfaceIDs=pyfrp_misc_module.objAttrToList(surfaces,'Id')) else: surfaceLoop=None # Make volume if genVol: vol=self.addVolume(surfaceLoopID=surfaceLoop.Id) else: vol=None return [vertices1,vertices2],[lines1,lines2,lines3],loops,surfaces,surfaceLoop,vol def addCuboidByParameters(self,offset,sidelengthX,sidelengthY,height,volSize,plane="z",genLoops=True,genSurfaces=True,genSurfaceLoop=True,genVol=True): """Adds Cuboid to domain by given offset, sidelengths in x- and y-direction and height. Will define vertices and then call :py:func:`pyfrp.modules.pyfrp_gmsh_geometry.domain.addPrismByParameters`. .. note:: Plane can be given as ``"x","y","z"``. See also :py:func:`pyfrp.modules.pyfrp_geometry_module.flipCoordinate`. For example: >>> d=pyfrp_gmsh_geometry.domain() >>> d.draw() will generate: .. image:: ../imgs/pyfrp_gmsh_geometry/addCuboidByParameters.png Args: offset (numpy.ndarray): Offset of cuboid. sidelengthX (float): Sidelength in x-direction. sidelengthY (float): Sidelength in y-direction. height (float): Height of cuboid. volSize (float): Mesh size of vertices. Keyword Args: plane (str): Plane in which prism is placed. genLoops (bool): Generate line loops. genSurfaces (bool): Generate surfaces. genSurfaceLoop (bool): Generate surface loop. genVol (bool): Generate corresponding volume. Returns: tuple: Tuple containing: * vertices (list): List of vertices. * lines (list): List of lines. * loops (list): List of loops. * surfaces (list): List of surfaces. * surfaceLoop (pyfrp.modules.pyfrp_gmsh_geometry.surfaceLoop): Generated surface loop. * vol (pyfrp.modules.pyfrp_gmsh_geometry.volume): Generated volume. """ # Define coordinates coords=[[offset[0],offset[1]],[offset[0]+sidelengthX,offset[1]], [offset[0]+sidelengthX,offset[1]+sidelengthY],[offset[0],offset[1]+sidelengthY]] return self.addPrismByParameters(coords,volSize,height=height,z=offset[2],plane="z",genLoops=genLoops,genSurfaces=genSurfaces,genSurfaceLoop=genSurfaceLoop,genVol=genVol) def addBallByParameters(self,center,radius,z,volSize,genLoops=True,genSurfaces=True,genSurfaceLoop=True,genVol=True,checkExist=True): """Adds ball to domain by given center and radius. Will create. * 3 new circles, see :py:func:`pyfrp.modules.pyfrp_gmsh_geometry.domain.addCircleByParameters`. If selected, will create: * 8 :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.lineLoop` objects around the 8 surfaces. * 8 corresponding :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.ruledSurface` objects. * 1 :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.surfaceLoop`. * 1 corresponding :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.volume`. For example: >>> center=[256,50] >>> radius=100 >>> Z=0 >>> volSize=20 >>> d=pyfrp_gmsh_geometry.domain() >>> d.addBallByParameters(center,radius,Z,volSize,genLoops=True,genSurfaces=True,genVol=True,checkExist=True) >>> d.draw() would return: .. image:: ../imgs/pyfrp_gmsh_geometry/addBallByParameters.png Args: center (numpy.ndarray): Center of cylinder. radius (float): Radius of the cylinder. z (float): Height at which cylinder is placed. volSize (float): Mesh size of vertices. Keyword Args: genLoops (bool): Generate line loops. genSurfaces (bool): Generate surfaces. genSurfaceLoop (bool): Generate surface loop. genVol (bool): Generate volume. checkExist (bool): Checks if a vertex at same location already exists. Returns: tuple: Tuple containing: * vertices (list): List of vertices. * arcs (list): List of arcs. * loops (list): List of loops. * surfaces (list): List of surfaces. * surfaceLoop (pyfrp.modules.pyfrp_gmsh_geometry.surfaceLoop): Generated surface loop. * vol (pyfrp.modules.pyfrp_gmsh_geometry.volume): Generated volume. """ # Add 3 circles v1,a1,ll1,s1=self.addCircleByParameters(center,radius,z,volSize,genLoop=False) v2,a2,ll2,s2=self.addCircleByParameters([z,center[0]],radius,center[1],volSize,genLoop=False,plane='x') v3,a3,ll3,s3=self.addCircleByParameters([center[1],z],radius,center[0],volSize,genLoop=False,plane='y') vertices=v1+v2+v3 arcs=a1+a2+a3 # Define line loops ll=[] ll.append([a1[0],a2[0],a3[0]]) ll.append([a1[1],a3[0],a2[3]]) ll.append([a1[2],a2[3],a3[1]]) ll.append([a1[3],a3[1],a2[0]]) ll.append([a1[0],a2[1],a3[3]]) ll.append([a1[1],a3[3],a2[2]]) ll.append([a1[2],a2[2],a3[2]]) ll.append([a1[3],a3[2],a2[1]]) # Generate line loops lineLoops=[] if genLoops: for l in ll: lnew=self.addLineLoop(edgeIDs=pyfrp_misc_module.objAttrToList(l,'Id')) lnew.fix() lineLoops.append(lnew) # Generate surfaces surfaces=[] if genSurfaces: for l in lineLoops: surfaces.append(self.addRuledSurface(lineLoopID=l.Id)) # Make surface loop if genSurfaceLoop: surfaceLoop=self.addSurfaceLoop(surfaceIDs=pyfrp_misc_module.objAttrToList(surfaces,'Id')) else: surfaceLoop=None # Make volume if genVol: vol=self.addVolume(surfaceLoopID=surfaceLoop.Id) else: vol=None return vertices,arcs,lineLoops,surfaces,surfaceLoop,vol def addCylinderByParameters(self,center,radius,z,height,volSize,plane="z",genLoops=True,genSurfaces=True,genSurfaceLoop=True,genVol=True,checkExist=True): """Adds cylinder to domain by given center and radius and height. Will create. * 2 new circles at ``z=z`` and ``z=z+height``, see :py:func:`pyfrp.modules.pyfrp_gmsh_geometry.domain.addCircleByParameters`. * 4 :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.line` objects connecting the two circles. If selected, will create: * 6 :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.lineLoop` objects around the 6 surfaces. * 6 corresponding :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.ruledSurface` objects. * 1 :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.surfaceLoop`. * 1 corresponding :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.volume`. For example: >>> d=pyfrp_gmsh_geometry.domain() >>> d.addCylinderByParameters([256,256],100,50,100,30.,plane="z",genLoops=True,genSurfaces=True,genVol=True) >>> d.draw() would return: .. image:: ../imgs/pyfrp_gmsh_geometry/addCylinderByParameters.png .. note:: Plane can be given as ``"x","y","z"``. See also :py:func:`pyfrp.modules.pyfrp_geometry_module.flipCoordinate`. Args: center (numpy.ndarray): Center of cylinder. radius (float): Radius of the cylinder. z (float): Height at which cylinder is placed. height (float): Height of cylinder. volSize (float): Mesh size of vertices. Keyword Args: plane (str): Plane in which cylinder is placed. genLoops (bool): Generate line loops. genSurfaces (bool): Generate surfaces. genSurfaceLoop (bool): Generate surface loop. genVol (bool): Generate volume. checkExist (bool): Checks if a vertex at same location already exists. Returns: tuple: Tuple containing: * vertices (list): List of vertices. * arcs (list): List of arcs. * lines (list): List of lines. * loops (list): List of loops. * surfaces (list): List of surfaces. * surfaceLoop (pyfrp.modules.pyfrp_gmsh_geometry.surfaceLoop): Generated surface loop. * vol (pyfrp.modules.pyfrp_gmsh_geometry.volume): Generated volume. """ # Check input if genVol and not genSurfaces: printError("Cannot create volume when there are no surfaces.") if genSurfaces and not genLoops: printError("Cannot create surfaces when there are no loops.") # Create circles vertices1,arcs1,ltemp,stemp=self.addCircleByParameters(center,radius,z,volSize,plane=plane) vertices2,arcs2,ltemp,stemp=self.addCircleByParameters(center,radius,z+height,volSize,plane=plane) # Create connecting lines lines=[] lines.append(self.addLine(vertices1[1],vertices2[1])) lines.append(self.addLine(vertices1[2],vertices2[2])) lines.append(self.addLine(vertices1[3],vertices2[3])) lines.append(self.addLine(vertices1[4],vertices2[4])) # Generate loops loops=[] if genLoops: loops.append(self.addLineLoop(edgeIDs=[arcs1[0].Id,arcs1[1].Id,arcs1[2].Id,arcs1[3].Id])) loops.append(self.addLineLoop(edgeIDs=[arcs2[0].Id,arcs2[1].Id,arcs2[2].Id,arcs2[3].Id])) loops.append(self.addLineLoop(edgeIDs=[-lines[0].Id,arcs1[0].Id,lines[1].Id,-arcs2[0].Id])) loops.append(self.addLineLoop(edgeIDs=[-lines[1].Id,arcs1[1].Id,lines[2].Id,-arcs2[1].Id])) loops.append(self.addLineLoop(edgeIDs=[-lines[2].Id,arcs1[2].Id,lines[3].Id,-arcs2[2].Id])) loops.append(self.addLineLoop(edgeIDs=[-lines[3].Id,arcs1[3].Id,lines[0].Id,-arcs2[3].Id])) # Generate surfaces surfaces=[] surfaceIds=[] if genSurfaces: for loop in loops: surfaces.append(self.addRuledSurface(lineLoopID=loop.Id)) surfaceIds.append(surfaces[-1].Id) # Generate surface loop and volume if genSurfaceLoop: surfaceLoop=self.addSurfaceLoop(surfaceIDs=surfaceIds) else: surfaceLoop=None if genVol: vol=self.addVolume(surfaceLoopID=surfaceLoop.Id) else: vol=None return [vertices1,vertices2],[arcs1,arcs2],lines,loops,surfaces,surfaceLoop,vol def insertVertex(self,obj,copy=False,strict=True,debug=False): """Inserts vertex into domain. See also :py:func:`pyfrp.modules.pyfrp_gmsh_geometry.domain.insertElement`. Args: obj (pyfrp.modules.pyfrp_gmsh_geometry.vertex): A vertex. Keyword Args: copy (bool): Inserts copy of object. strict (bool): Don't allow IDs to be assigned to multiple elements. debug (bool): Print debugging output. Returns: list: Updated edges list. """ if self.getVertexByX(obj.x)[0]!=False: if debug: printWarning("Vertex with x=" +str(obj.x) + " already exists.") return self.insertElement("vertices",obj,copy=copy,strict=strict,debug=debug) def insertEdge(self,obj,copy=False,strict=True,debug=False): """Inserts edge into domain. See also :py:func:`pyfrp.modules.pyfrp_gmsh_geometry.domain.insertElement`. Args: obj (pyfrp.modules.pyfrp_gmsh_geometry.edge): A edge. Keyword Args: copy (bool): Inserts copy of object. strict (bool): Don't allow IDs to be assigned to multiple elements. debug (bool): Print debugging output. Returns: list: Updated edges list. """ LOld=len(self.edges) l=self.insertElement("edges",obj,copy=copy,strict=strict,debug=debug) b=(LOld<len(self.edges)) if b: if obj.typ==0: self.lines.append(obj) if obj.typ==1: self.arcs.append(obj) if obj.typ==2: self.bSpline.append(obj) return l def insertLineLoop(self,obj,copy=False,strict=True,debug=False): """Inserts line loop into domain. See also :py:func:`pyfrp.modules.pyfrp_gmsh_geometry.domain.insertElement`. Args: obj (pyfrp.modules.pyfrp_gmsh_geometry.lineLoop): A line loop. Keyword Args: copy (bool): Inserts copy of object. strict (bool): Don't allow IDs to be assigned to multiple elements. debug (bool): Print debugging output. Returns: list: Updated lineLoops list. """ return self.insertElement("lineLoops",obj,copy=copy,strict=strict,debug=debug) def insertRuledSurface(self,obj,copy=False,strict=True,debug=False): """Inserts ruled surface into domain. See also :py:func:`pyfrp.modules.pyfrp_gmsh_geometry.domain.insertElement`. Args: obj (pyfrp.modules.pyfrp_gmsh_geometry.ruledSurface): A ruled surface. Keyword Args: copy (bool): Inserts copy of object. strict (bool): Don't allow IDs to be assigned to multiple elements. debug (bool): Print debugging output. Returns: list: Updated ruledSurfaces list. """ return self.insertElement("ruledSurfaces",obj,copy=copy,strict=strict,debug=debug) def insertSurfaceLoop(self,obj,copy=False,strict=True,debug=False): """Inserts surface loop into domain. See also :py:func:`pyfrp.modules.pyfrp_gmsh_geometry.domain.insertElement`. Args: obj (pyfrp.modules.pyfrp_gmsh_geometry.surfaceLoop): A surface loop. Keyword Args: copy (bool): Inserts copy of object. strict (bool): Don't allow IDs to be assigned to multiple elements. debug (bool): Print debugging output. Returns: list: Updated surfaceLoops list. """ return self.insertElement("ruledSurfaces",obj,copy=copy,strict=strict,debug=debug) def insertVolume(self,obj,copy=False,strict=True,debug=False): """Inserts volume into domain. See also :py:func:`pyfrp.modules.pyfrp_gmsh_geometry.domain.insertElement`. Args: obj (pyfrp.modules.pyfrp_gmsh_geometry.volume): A volume. Keyword Args: copy (bool): Inserts copy of object. strict (bool): Don't allow IDs to be assigned to multiple elements. debug (bool): Print debugging output. Returns: list: Updates volumes list. """ return self.insertElement("volumes",obj,copy=copy,strict=strict,debug=debug) def insertField(self,obj,copy=False,strict=True,debug=False): """Inserts field into domain. See also :py:func:`pyfrp.modules.pyfrp_gmsh_geometry.domain.insertElement`. Args: obj (pyfrp.modules.pyfrp_gmsh_geometry.field): A field. Keyword Args: copy (bool): Inserts copy of object. strict (bool): Don't allow IDs to be assigned to multiple elements. debug (bool): Print debugging output. Returns: list: Updates fields list. """ return self.insertElement("fields",obj,copy=copy,strict=strict,debug=debug) def insertElement(self,element,obj,copy=False,strict=True,debug=False): """Inserts gmshElement into domain. Checks if there is already a element with ID. .. note:: If ``copy=True``, will generate copy of element. This might mess with some connection between elements. Thus ``copy=False`` as default. Possible values for ``element`` are: * vertices * lines * arcs * lineLoops * bSplines * ruledSurfaces * surfaceLoops * volumes * fields * auto .. note:: ``element='auto'`` will automatically detect the type of element and insert it at the right point. Will automatically set ``self`` as element's domain. .. note:: If ``strict=True``, will not allow double IDs. Args: element (str): Name of element list where object belongs. obj (pyfrp.modules.pyfrp_gmsh_geometry.gmshElement): Element to insert. Keyword Args: copy (bool): Inserts copy of object. strict (bool): Don't allow IDs to be assigned to multiple elements. debug (bool): Print debugging output. Returns: list: Updated respective element list. """ if element=='auto': element = obj.getTypeListName() if element in ['edges','bSplines','arcs','lines']: return self.insertEdge(obj,strict=strict,copy=copy,debug=debug) if element=='vertices': return self.insertVertex(obj,strict=strict,copy=copy,debug=debug) if self.checkIdExists(obj.Id,getattr(self,element),debug=debug): if debug: printWarning(obj.getType() + " with Id=" +str(obj.getID()) + " already exits.") if strict: return getattr(self,element) if copy: e=obj.getCopy() else: e=obj e.domain=self getattr(self,element).append(e) return getattr(self,element) def getRuledSurfacesByNormal(self,direction,onlyAbs=True): """Returns all surfaces in domain that have given normal vector. The direction can be given in multiple ways: * A ``numpy.ndarray``: The method will look for all surfaces with same normal vector than array. * A ``str``: The method will first check if ``direction='all'`` is given. If so, return all surfaces. Otherwise the method will decode the string ("x"/"y","z") using :py:func:`pyfrp.modules.pyfrp_geometry_module.decodeEuclideanBase`, then proceed the same way as with the ``numpy.ndarray``. * A ``list`` of the previous options: Will find all surface matching each of them. .. note:: If ``onlyAbs=True``, will only look for matches in terms of absolute value. If a list of directions is given, then one can also specifiy a list of ``onlyAbs`` values. Args: direction (numpy.ndarray): Direction to be matched. Keyword Args: onlyAbs (bool): Only try to match in terms of absolute value. Returns: list: List of matching surfaces. """ # Check if we need to return all of them if direction=='all': return list(self.ruledSurfaces) # Result list sfs=[] # If list, call recursively if isinstance(direction,list): if not isinstance(onlyAbs,list): onlyAbs=len(direction)*[onlyAbs] for i,d in enumerate(direction): sfs=sfs+self.getRuledSurfacesByNormal(d,onlyAbs=onlyAbs[i]) return sfs # If given as string, decode if isinstance(direction,str): d=pyfrp_geometry_module.decodeEuclideanBase(direction) else: d=direction # Look for matching surfaces for sf in self.ruledSurfaces: if onlyAbs: if pyfrp_misc_module.compareVectors(abs(sf.getNormal().astype('float')),d.astype('float')): sfs.append(sf) else: if pyfrp_misc_module.compareVectors(sf.getNormal().astype('float'),d.astype('float')): sfs.append(sf) return sfs def checkIdExists(self,Id,objList,debug=False): """Checks if any object in ``objList`` already has ID ``Id``. Args: Id (int): ID to be checked. objList (list): List of objects, for example ``edges``. Keyword Args: debug (bool): Print debugging output. Returns: bool: True if any object has ID ``Id``. """ IdList=pyfrp_misc_module.objAttrToList(objList,'Id') if Id in IdList: if debug: printWarning("Object with Id " + str(Id) + " already exists.") return True return False def getNewId(self,objList,Id=None): """Returns free ID for object type. Args: objList (list): List of objects, for example ``edges``. Keyword Args: Id (int): ID to be checked. Returns: int: New free ID. """ if Id==None: newId=self.incrementID(objList) else: if self.checkIdExists(Id,objList): newId=self.incrementID(objList) else: newId=Id return newId def incrementID(self,objList): """Returns ID that is by one larger for a specific object type. Args: objList (list): List of objects, for example ``edges``. Returns: int: Incremented ID. """ if len(objList)==0: newId=1 else: IdList=pyfrp_misc_module.objAttrToList(objList,'Id') newId=max(IdList)+1 return newId def getEdgeById(self,ID): """Returns edge with ID ``ID``. Returns ``(False,False)`` if edge cannot be found. Args: ID (int): ID of edge. Returns: tuple: Tuple containing: * e (pyfrp.modules.pyfrp_gmsh_geometry.edge): Edge. * i (int): Position in ``edges`` list. """ for i,e in enumerate(self.edges): if e.Id==ID: return e,i return False,False def getEdgeByVertices(self,v1,v2): """Returns edge between vertex ``v1`` and ``v2``. Returns ``(False,False)`` if edge cannot be found. Args: v1 (pyfrp.modules.pyfrp_gmsh_geometry.vertex): Vertex 1. v2 (pyfrp.modules.pyfrp_gmsh_geometry.vertex): Vertex 2. Returns: tuple: Tuple containing: * e (pyfrp.modules.pyfrp_gmsh_geometry.edge): Edge. * i (int): Position in ``edges`` list. """ for i,e in enumerate(self.edges): vertices=[e.getFirstVertex(1),e.getLastVertex(1)] if v1 in vertices and v2 in vertices: return e,i return False,False def getLineLoopById(self,ID): """Returns lineLoop with ID ``ID``. Returns ``(False,False)`` if lineLoop cannot be found. Args: ID (int): ID of lineLoop. Returns: tuple: Tuple containing: * l (pyfrp.modules.pyfrp_gmsh_geometry.lineLoop): lineLoop. * i (int): Position in ``lineLoops`` list. """ for i,l in enumerate(self.lineLoops): if l.Id==ID: return l,i return False,False def getRuledSurfaceById(self,ID): """Returns ruledSurface with ID ``ID``. Returns ``(False,False)`` if ruledSurface cannot be found. Args: ID (int): ID of ruledSurface. Returns: tuple: Tuple containing: * l (pyfrp.modules.pyfrp_gmsh_geometry.ruledSurface): ruledSurface. * i (int): Position in ``ruledSurfaces`` list. """ for i,l in enumerate(self.ruledSurfaces): if l.Id==ID: return l,i return False,False def getSurfaceLoopById(self,ID): """Returns surfaceLoop with ID ``ID``. Returns ``(False,False)`` if surfaceLoop cannot be found. Args: ID (int): ID of surfaceLoop. Returns: tuple: Tuple containing: * l (pyfrp.modules.pyfrp_gmsh_geometry.surfaceLoop): surfaceLoop. * i (int): Position in ``surfaceLoops`` list. """ for i,l in enumerate(self.surfaceLoops): if l.Id==ID: return l,i return False,False def getVolumeById(self,ID): """Returns volume with ID ``ID``. Returns ``(False,False)`` if volume cannot be found. Args: ID (int): ID of volume. Returns: tuple: Tuple containing: * l (pyfrp.modules.pyfrp_gmsh_geometry.volume): volume. * i (int): Position in ``volumes`` list. """ for i,l in enumerate(self.volumes): if l.Id==ID: return l,i return False,False def getFieldById(self,ID): """Returns field with ID ``ID``. Returns ``(False,False)`` if field cannot be found. Args: ID (int): ID of field. Returns: tuple: Tuple containing: * f (pyfrp.modules.pyfrp_gmsh_geometry.field): Field. * i (int): Position in ``fields`` list. """ for i,f in enumerate(self.fields): if f.Id==ID: return f,i return False,False def getVertexById(self,ID): """Returns vertex with ID ``ID``. Returns ``(False,False)`` if vertex cannot be found. Args: ID (int): ID of vertex. Returns: tuple: Tuple containing: * v (pyfrp.modules.pyfrp_gmsh_geometry.vertex): Vertex. * i (int): Position in ``vertices`` list. """ for i,v in enumerate(self.vertices): if v.Id==ID: return v,i return False,False def getVertexByX(self,x): """Returns vertex at coordinate ``x``. Returns ``(False,False)`` if vertex cannot be found. Args: x (numpy.ndarry): Coordinate of vertex. Returns: tuple: Tuple containing: * v (pyfrp.modules.pyfrp_gmsh_geometry.vertex): Vertex. * i (int): Position in ``vertices`` list. """ for i,v in enumerate(self.vertices): if (np.array(x)==v.x).sum()==len(v.x): return v,i return False,False def draw(self,ax=None,color='k',ann=None,drawSurfaces=False,surfaceColor='b',alpha=0.2,backend='mpl',asSphere=True,size=5,annElements=[True,True,True],linewidth=1): """Draws complete domain. There are two different backends for drawing, namely * Matplotlib (``backend='mpl'``) * VTK (``backend='vtk'``) Matplotlib is easier to handle, but slower. VTK is faster for complex geometries. .. note:: If ``backend=mpl``, ``ax`` should be a ``matplotlib.axes``, if ``backend='vtk'``, ``ax`` should be a ``vtk.vtkRenderer`` object. .. note:: If no axes is given, will create new one, see also :py:func:`pyfrp.modules.pyfrp_plot_module.makeGeometryPlot` or :py:func:`pyfrp.modules.pyfrp_vtk_module.makeVTKCanvas`. .. warning:: Annotations are not properly working with ``backend='vtk'``. With ``annElements`` the user has the possibility to only annotate given elements. For example ``annElements=[False,True,False]`` only annotates edges. Keyword Args: ax (matplotlib.axes): Matplotlib axes to be plotted in. color (str): Color of domain. ann (bool): Show annotations. asSphere (bool): Draws vertex as sphere (only in vtk mode). size (float): Size of vertex (only in vtk mode). annElements (list): Only annotate some element types. linewidth (float): Line width. Returns: matplotlib.axes: Updated axes. """ if ann==None: ann=False for v in self.vertices: ax=v.draw(ax=ax,color=color,ann=ann*annElements[0],backend=backend,size=size,asSphere=asSphere,render=False) for e in self.edges: ax=e.draw(ax=ax,color=color,ann=ann*annElements[1],backend=backend,render=False,linewidth=linewidth) if drawSurfaces: for s in self.ruledSurfaces: ax=s.draw(ax=ax,color=surfaceColor,alpha=alpha,backend=backend,ann=ann*annElements[2]) if backend=="vtk": ax=pyfrp_vtk_module.renderVTK(ax,start=False) return ax def getExtend(self): """Returns extend of domain in all 3 dimensions. Returns: tuple: Tuple containing: * minx (float): Minimal x-coordinate. * maxx (float): Maximal x-coordinate. * miny (float): Minimal y-coordinate. * maxy (float): Maximal y-coordinate. * minz (float): Minimal z-coordinate. * maxz (float): Maximal z-coordinate. """ x=[] y=[] z=[] for v in self.vertices: x.append(v.x[0]) y.append(v.x[1]) z.append(v.x[2]) return min(x), max(x), min(y),max(y), min(z),max(z) def verticesCoordsToList(self): """Returns list of coordinates from all vertrices. Returns: list: List of (x,y,z) coordinates. """ l=[] for v in self.vertices: l.append(v.x) return l def setGlobalVolSize(self,volSize): """Sets volSize for all nodes in geometry. """ for v in self.vertices: v.volSize=volSize def addLineLoop(self,Id=None,edgeIDs=[]): """Adds new :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.lineLoop` instance with given edgeIDs. Keyword Args: edgeIDs (list): List of edge IDs included in line loop. Returns: pyfrp.modules.pyfrp_gmsh_geometry.lineLoop: New lineLoop instance. """ newId=self.getNewId(self.lineLoops,Id) l=lineLoop(self,edgeIDs,newId) self.lineLoops.append(l) return l def addAllSurfacesToLoop(self): """Adds all surfaces in domain to a single surfaceLoop. Returns: pyfrp.modules.pyfrp_gmsh_geometry.surfaceLoop: New surfaceLoop instance. """ surfaceIDs=pyfrp_misc_module.objAttrToList(self.ruledSurfaces,'Id') return self.addSurfaceLoop(surfaceIDs=surfaceIDs) def addEnclosingVolume(self): """Adds volume enclosing all surfaces. See also :py:func:`addAllSurfacesToLoop`. Returns: pyfrp.modules.pyfrp_gmsh_geometry.volume: New volume instance. """ s=self.addAllSurfacesToLoop() return self.addVolume(surfaceLoopID=s.Id) def addSurfaceLoop(self,Id=None,surfaceIDs=[]): """Adds new :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.surfaceLoop` instance with given surfaceIDs. Keyword Args: surfaceIDs (list): List of surface IDs included in surface loop. Returns: pyfrp.modules.pyfrp_gmsh_geometry.surfaceLoop: New surfaceLoop instance. """ newId=self.getNewId(self.surfaceLoops,Id) l=surfaceLoop(self,surfaceIDs,newId) self.surfaceLoops.append(l) return l def addRuledSurface(self,Id=None,lineLoopID=None): """Adds new :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.ruledSurface` instance with given lineLoop. Keyword Args: lineLoopID (ID): ID of line loop. Returns: pyfrp.modules.pyfrp_gmsh_geometry.ruledSurface: New ruledSurface instance. """ newId=self.getNewId(self.ruledSurfaces,Id) l=ruledSurface(self,lineLoopID,newId) self.ruledSurfaces.append(l) return l def addVolume(self,Id=None,surfaceLoopID=None): """Adds new :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.volume` instance with given surfaceLoop. Keyword Args: surfaceLoopID (ID): ID of surface loop. Returns: pyfrp.modules.pyfrp_gmsh_geometry.volume: New volume instance. """ newId=self.getNewId(self.volumes,Id) l=volume(self,surfaceLoopID,newId) self.volumes.append(l) return l def addBoxField(self,Id=None,volSizeIn=10.,volSizeOut=20.,xRange=[],yRange=[],zRange=[]): """Adds new :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.boxField` instance. Keyword Args: Id (int): ID of field. volSizeIn (float): Mesh element volume inside box. volSizeOut (float): Mesh element volume outside box. xRange (list): Range of box field in x-direction given as ``[minVal,maxVal]``. yRange (list): Range of box field in y-direction given as ``[minVal,maxVal]``. zRange (list): Range of box field in z-direction given as ``[minVal,maxVal]``. Returns: pyfrp.modules.pyfrp_gmsh_geometry.boxField: New boxField instance. """ newId=self.getNewId(self.fields,Id) l=boxField(self,newId,volSizeIn=volSizeIn,volSizeOut=volSizeOut,xRange=xRange,yRange=yRange,zRange=zRange) self.fields.append(l) return l def addThresholdField(self,Id=None,IField=None,LcMin=5.,LcMax=20.,DistMin=30.,DistMax=60.): """Adds new :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.thresholdField` instance. .. image:: ../imgs/pyfrp_gmsh_geometry/thresholdField.png Keyword Args: Id (int): ID of field. IField (int): ID of vertex that is center to threshold field. LcMin (float): Minimum volSize of threshold field. LcMax (float): Maximum volSize of threshold field. DistMin (float): Minimun density of field. DistMax (float): Maximum density of field. Returns: pyfrp.modules.pyfrp_gmsh_geometry.thresholdField: New thresholdField instance. """ newId=self.getNewId(self.fields,Id) l=thresholdField(self,newId,IField=IField,LcMin=LcMin,LcMax=LcMax,DistMin=DistMin,DistMax=DistMax) self.fields.append(l) return l def addAttractorField(self,Id=None,NodesList=[]): """Adds new :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.attractorField` instance. Keyword Args: Id (int): ID of field. NodesList (list): List of IDs of the Nodes that attractor field centers around. Returns: pyfrp.modules.pyfrp_gmsh_geometry.attractorField: New attractorField instance. """ newId=self.getNewId(self.fields,Id) l=attractorField(self,newId,NodesList=NodesList) self.fields.append(l) return l def addMinField(self,Id=None,FieldsList=[]): """Adds new :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.minField` instance. Keyword Args: Id (int): ID of field. NodesList (list): List of IDs of the Nodes that attractor field centers around. Returns: pyfrp.modules.pyfrp_gmsh_geometry.minField: New attractorField instance. """ newId=self.getNewId(self.fields,Id) l=minField(self,newId,FieldsList=FieldsList) self.fields.append(l) return l def addBoundaryLayerField(self,Id=None,AnisoMax=10000000000,hwall_n=1.,hwall_t=1,ratio=1.1,thickness=10.,hfar=1.,IntersectMetrics=1,Quads=0.): """Adds new :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.boundaryLayerField` instance. Keyword Args: Id (int): ID of field. AnisoMax (float): Threshold angle for creating a mesh fan in the boundary layer. IntersectMetrics (int): Intersect metrics of all faces. Quad (int): Generate recombined elements in the boundary layer. har (float): Element size far from the wall. hwall_n (float): Mesh Size Normal to the The Wall. hwall_t (float): Mesh Size Tangent to the Wall. ratio (float): Size Ratio Between Two Successive Layers. thickness (float): Maximal thickness of the boundary layer. List (list): List of field IDs. Returns: pyfrp.modules.pyfrp_gmsh_geometry.boundaryLayerField: New boundaryLayerField instance. """ newId=self.getNewId(self.fields,Id) l=boundaryLayerField(self,newId,AnisoMax=AnisoMax,hwall_n=hwall_n,hwall_t=hwall_t,ratio=ratio,thickness=thickness,hfar=hfar,IntersectMetrics=IntersectMetrics,Quads=Quads) self.fields.append(l) return l def setAnnOffset(self,offset): """Sets annotation offset for plotting. Args: offset (numpy.ndarray): New offset. """ self.annXOffset=offset[0] self.annYOffset=offset[1] self.annZOffset=offset[2] def writeToFile(self,fn): """Writes domain to file. Args: fn (str): File path to write to. """ with open(fn,'wb') as f: self.writeElements("vertices",f) self.writeElements("lines",f) self.writeElements("arcs",f) self.writeElements("bSplines",f) self.writeElements("lineLoops",f) self.writeElements("ruledSurfaces",f) self.writeElements("surfaceLoops",f) self.writeElements("volumes",f) self.writeElements("fields",f) def writeElements(self,element,f): """Writes all entities of a specific element type to file. Possible elements are: * vertices * lines * arcs * lineLoops * bSplines * ruledSurfaces * surfaceLoops * volumes * fields Args: element (str): Element type to write. f (file): File to write to. """ pyfrp_gmsh_IO_module.writeComment(f,element) for v in getattr(self,element): f=v.writeToFile(f) f.write("\n") def incrementAllIDs(self,offset): """Adds offset to all entity IDs. Args: offset (int): Offset to be added. """ self.incrementIDs(offset,"vertices") self.incrementIDs(offset,"lines") self.incrementIDs(offset,"arcs") self.incrementIDs(offset,"bSplines") self.incrementIDs(offset,"lineLoops") self.incrementIDs(offset,"ruledSurfaces") self.incrementIDs(offset,"surfaceLoops") self.incrementIDs(offset,"volumes") def incrementIDs(self,offset,element): """Adds offset to all entity IDs. Possible elements are: * vertices * lines * arcs * lineLoops * ruledSurfaces * surfaceLoops * volumes * fields Args: offset (int): Offset to be added. element (str): Element type to increment. """ for e in getattr(self,element): e.Id=e.Id+offset def setDomainGlobally(self): """Makes sure that ``self`` is domain for all elements. """ self.setDomainForElementType("vertices") self.setDomainForElementType("lines") self.setDomainForElementType("arcs") self.setDomainForElementType("bSplines") self.setDomainForElementType("lineLoops") self.setDomainForElementType("ruledSurfaces") self.setDomainForElementType("surfaceLoops") self.setDomainForElementType("volumes") self.setDomainForElementType("fields") def setDomainForElementType(self,element): """Makes sure that ``self`` is domain for all elements of given type. Possible elements are: * vertices * lines * arcs * lineLoops * ruledSurfaces * surfaceLoops * volumes * fields Args: offset (int): Offset to be added. element (str): Element type to increment. """ for e in getattr(self,element): e.domain=self def getMaxID(self,element): """Returns maximum ID for a specific element. Possible elements are: * vertices * lines * arcs * lineLoops * ruledSurfaces * surfaceLoops * volumes Args: element (str): Element type. Returns: int: Maximum ID. """ IDs=[] for e in getattr(self,element): IDs.append(e.Id) try: return max(IDs) except ValueError: 0. def getAllMaxID(self): """Returns maximum ID over all elements. Returns: int: Maximum ID. """ IDs=[] IDs.append(self.getMaxID("vertices")) IDs.append(self.getMaxID("lines")) IDs.append(self.getMaxID("arcs")) IDs.append(self.getMaxID("lineLoops")) IDs.append(self.getMaxID("ruledSurfaces")) IDs.append(self.getMaxID("surfaceLoops")) IDs.append(self.getMaxID("volumes")) return max(IDs) def getAllFieldsOfType(self,typ): """Returns all fields of domain with specific typ. Returns: list: List of :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.field` objects. """ fs=[] for f in self.fields: if f.typ==typ: fs.append(f) return fs def getBkgdField(self): """Returns background field of domain. Returns: pyfrp.modules.pyfrp_gmsh_geometry.field: Background field. """ return self.bkgdField def hasBkgdField(self): """Checks if domain already has a background field. Returns: bool: True if background field already exists. """ return self.bkgdField!=None def genMinBkgd(self,FieldsList=[]): """Generates minimum field as background field. If domain already has minimum field, will take it and set it as background field. If domain has multiple minimum fields, will take the first one that appears in ``fields`` list. Keyword Args: FieldsList (list): List of field IDs included in minField. Returns: pyfrp.modules.pyfrp_gmsh_geometry.minField: Minimum field. """ #Generate minField if not existent minFields=self.getAllFieldsOfType("min") if len(minFields)==0: if len(FieldsList)==0: FieldsList=pyfrp_misc_module.objAttrToList(self.fields,'Id') minField=self.addMinField(FieldsList=FieldsList) else: if self.hasBkgdField(): if self.getBkgdField() in minFields: minField=self.getBkgdField() else: minField=minFields[0] minField.setAsBkgdField() if not self.hasBkgdField(): minField.setAsBkgdField() return self.getBkgdField() def getAllObjectsWithProp(self,objName,attr,val): """Filters all objects of type objName given attribute value. Possible objects names are: * vertices * lines * arcs * lineLoops * ruledSurfaces * surfaceLoops * volumes * fields .. note:: ``val`` can have any datatype. Args: objName (str): Name of object list. attr (str): Name of attribute. val (str): Value of attribute. Returns: list: List of objects that fulfill requirement. """ objects=getattr(self,objName) filteredObjects=pyfrp_misc_module.getAllObjWithAttrVal(objects,attr,val) return filteredObjects def simplifySurfaces(self,iterations=3,triangIterations=2,addPoints=False,fixSurfaces=True,debug=False): """Tries to simplify surfaces inside the domain. Does this by: * For ``iterations`` iterations, do: * Find all surfaces with the same normal vector. * Try to fuse this surfaces, see also :py:func:`pyfrp.modules.pyfrp_geometry_module.ruledSurface.fuse`. * Clean up edges via :py:func:`pyfrp.modules.pyfrp_geometry_module.domain.cleanUpUnusedEdges`. * Fixing loops via :py:func:`pyfrp.modules.pyfrp_geometry_module.domain.fixAllLoops`. * Fixing surfaces via :py:func:`pyfrp.modules.pyfrp_geometry_module.domain.fixAllSurfaces`. Keyword Args: iterations (int): Number of iterations used for simplification. triangIterations (int): Number of iterations used for subdivision of surfaces. addPoints (bool): Allow adding points inside surface triangles. fixSurfaces (bool): Allow fixing of surfaces, making sure they are coherent with Gmsh requirements. debug (bool): Print debugging messages. """ #Remember the stats from the start x=len(self.ruledSurfaces) y=len(self.lineLoops) z=len(self.edges) #Compute the normal of all surfaces for surface in self.ruledSurfaces: surface.getNormal() #Loop through iterations for k in range(iterations): #Loop through surfaces for i,surface in enumerate(self.ruledSurfaces): #Get all surfaces with same normal vector sameNormal=self.getAllObjectsWithProp("ruledSurfaces","normal",surface.normal) sameNormal=sameNormal+self.getAllObjectsWithProp("ruledSurfaces","normal",-surface.normal) #Loop through all with same normal for j,sN in enumerate(sameNormal): if sN==surface: continue #Fuse if surface.fuse(sN,debug=debug): if debug: print "Successfully fused ", surface.Id, sN.Id #Clean up edges self.cleanUpUnusedEdges(debug=debug) #Print some final statistics if debug: print "Surfaces: Before =" , x , " After:" , len(self.ruledSurfaces) print "lineLoops: Before =" , y , " After:" , len(self.lineLoops) print "Edges: Before =" , z , " After:" , len(self.edges) #raw_input() #Fix loops and surfaces self.fixAllLoops(debug=debug) if fixSurfaces: self.fixAllSurfaces(iterations=triangIterations,addPoints=addPoints) def cleanUpUnusedEdges(self,debug=False): """Cleans up all unused edges in domain. See also: :py:func:`pyfrp.pyfrp_modules.pyfrp_gmsh_geometry.edge.delete`. Keyword Args: debug (bool): Print debugging output. """ for edge in self.edges: edge.delete(debug=debug) def fixAllLoops(self,debug=False): """Tries to fix all loops in domain. See also: :py:func:`pyfrp.pyfrp_modules.pyfrp_gmsh_geometry.lineLoop.fix`. Keyword Args: debug (bool): Print debugging output. """ for loop in self.lineLoops: loop.fix() def fixAllSurfaces(self,debug=False,iterations=2,addPoints=False): """Tries to fix all surfaces in domain. Does this by reiniating all ``lineLoop``. See also: :py:func:`pyfrp.pyfrp_modules.pyfrp_gmsh_geometry.ruledSurface.initLineLoop`. Keyword Args: iterations (int): Number of iterations used for subdivision of surfaces. addPoints (bool): Allow adding points inside surface triangles. debug (bool): Print debugging messages. """ for surface in self.ruledSurfaces: surface.initLineLoop(surface.lineLoop.Id,debug=debug,iterations=iterations,addPoints=addPoints) def save(self,fn): """Saves domain to pickle file. Args: fn (str): Output filename. """ pyfrp_IO_module.saveToPickle(self,fn=fn) def merge(self,d): """Merges domain d into this domain. Does this by: * Incrementing all IDs in ``d`` such that there is no overlap with ``self``. * Merging all element lists. * Making sure that all elements refer to ``self`` as domain. See also :py:func:`incrementAllIDs` and :py:func:`setDomainGlobally`. Args: d (pyfrp.modules.pyfrp_geometry_module.domain): Domain to merge. """ d.incrementAllIDs(self.getAllMaxID()+1) self.edges=self.edges+d.edges self.vertices=self.vertices+d.vertices self.arcs=self.arcs+d.arcs self.bSplines=self.bSplines+d.bSplines self.lines=self.lines+d.lines self.lineLoops=self.lineLoops+d.lineLoops self.ruledSurfaces=self.ruledSurfaces+d.ruledSurfaces self.surfaceLoops=self.surfaceLoops+d.surfaceLoops self.volumes=self.volumes+d.volumes self.fields=self.fields+d.fields self.setDomainGlobally() def removeDuplicates(self,debug=False): self.removeDuplicateEdgeIDs(debug=debug) self.removeDuplicateVerticesIDs() def removeDuplicateVerticesIDs(self): """Checks if multiple vertices have the same ID and tries to remove one of them. Checks if vertices with same ID have the same coordinate. If so, remove all but one. Otherwise fixes index. Returns: list: Updated vertices list. """ # Loop through edges for i,v in enumerate(self.vertices): for j in range(i+1,len(self.vertices)): # Check if same ID if self.vertices[j].Id==self.vertices[i].Id: # Check if same start/end vertex if pyfrp_misc_module.compareVectors(self.vertices[j].x,self.vertices[i].x): self.vertices.remove(self.vertices[j]) else: newId=self.getNewId(self.vertices,None) self.vertices[j].setID(newId) return self.vertices def removeDuplicateEdgeIDs(self,debug=False): """Checks if multiple edges have the same ID and tries to remove one of them. Checkss if edges with same ID have the same start and end vertex. If so, removes it all but one. Otherwise fixes index. Returns: list: Updated edges list. """ edgeIDs=pyfrp_misc_module.objAttrToList(self.edges,'Id') print edgeIDs # Loop through edges for i,e in enumerate(self.edges): for j in range(i+1,len(self.edges)): print i,j,self.edges[i].Id,self.edges[j].Id # Check if same ID if self.edges[j].Id==self.edges[i].Id: print "same id",self.edges[j].Id # Check if same start/end vertex if (self.edges[j].getFirstVertex()==self.edges[i].getFirstVertex()) and (self.edges[j].getLastVertex()==self.edges[i].getLastVertex()): self.edges[j].delete(debug=debug) else: newId=self.getNewId(self.edges,None) self.edges[j].setID(newId) return self.edges class gmshElement(object): def __init__(self,domain,Id): self.domain=domain self.Id=Id def getID(self): """Returns ID of element. Returns: int: ID of element. """ return self.Id def setID(self,Id): """Sets ID of element. Args: Id (int): New ID of element. Returns: int: New ID of element. """ self.Id=Id return self.Id def getCopy(self): """Returns copy of element. Uses `copy.copy` to generate copy. Returns: pyfrp.modules.pyfrp_gmsh_geometry.gmshElement: Copy of element. """ return cpy.copy(self) def getType(self): """Returns type of element. Returns: str: Type of element. """ t=str(type(self)) t=t.split("'")[1] t=t.replace("pyfrp.modules.pyfrp_gmsh_geometry.","") return t def getTypeListName(self): """Returns the element lists name. Returns: str: Name of element list. """ if self.getType()=="vertex": return "vertices" if self.getType()=="line": return "lines" if self.getType()=="arc": return "arcs" if self.getType()=="edge": return "edges" if self.getType()=="lineLoop": return "lineLoops" if self.getType()=="ruledSurface": return "ruledSurfaces" if self.getType()=="surfaceLoop": return "surfaceLoops" if self.getType()=="volume": return "volumes" if self.getType()=="field": return "fields" def getTypeList(self): """Returns the element list of domain for this element. Returns: list: Element list. """ return self.getDomain().getattr(self.getTypeListName) def getDomain(self): """Returns element's domain. Returns: pyfrp.modules.pyfrp_gmsh_geometry.domain: Element's domain. """ return self.domain def setDomain(self,d): """Sets element's domain. Args: d (pyfrp.modules.pyfrp_gmsh_geometry.domain): New domain Returns: pyfrp.modules.pyfrp_gmsh_geometry.domain: New domain. """ self.domain=d return self.domain def getSubElements(self): """Returns all elements that define this element. Returns: list: List of elements. """ return [] def getAllSubElements(self,elements=[]): """Finds all elements that are necessary to define this element recursively. Returns: list: List of elements. """ elements=list(elements) if len(self.getSubElements())==0: return elements else: for el in self.getSubElements(): elements.append(el) elements=el.getAllSubElements(elements=elements) return elements def extract(self,d=None,strict=True,copy=False,debug=False): """Extracts element and all elements necessary to define it. .. note:: If ``d`` is specified, then all extracted elements are inserted into ``d`` using :py:func:`insertElement`. Keyword Args: d (pyfrp.modules.pyfrp_gmsh_geometry.domain): Domain to insert element copy (bool): Inserts copy of object. strict (bool): Don't allow IDs to be assigned to multiple elements. debug (bool): Print debugging output. Returns: list: List of elements. """ elmts=[self]+self.getAllSubElements() if d!=None: for el in elmts: d.insertElement('auto',el,strict=strict,copy=copy,debug=debug) return elmts class vertex(gmshElement): """Vertex class storing information from gmsh .geo Points. .. note:: ``volSize`` does not have any effect on the geometry itself but is simply stored in the vertex object for further usage. Args: domain (pyfrp.modules.pyfrp_gmsh_geometry.domain): Domain vertex belongs to. x (numpy.ndarray): Coordinate of vertex. Id (int): ID of vertex. Keyword Args: volSize (float): Element size at vertex. """ def __init__(self,domain,x,Id,volSize=None): gmshElement.__init__(self,domain,Id) self.x=np.array(x) self.volSize=volSize def draw(self,ax=None,color=None,ann=None,backend="mpl",asSphere=True,size=10,render=False): """Draws vertex. There are two different backends for drawing, namely * Matplotlib (``backend='mpl'``) * VTK (``backend='vtk'``) Matplotlib is easier to handle, but slower. VTK is faster for complex geometries. .. note:: If ``backend=mpl``, ``ax`` should be a ``matplotlib.axes``, if ``backend='vtk'``, ``ax`` should be a ``vtk.vtkRenderer`` object. .. note:: If no axes is given, will create new one, see also :py:func:`pyfrp.modules.pyfrp_plot_module.makeGeometryPlot` or :py:func:`pyfrp.modules.pyfrp_vtk_module.makeVTKCanvas`. .. warning:: Annotations are not properly working with ``backend='vtk'``. Keyword Args: ax (matplotlib.axes): Matplotlib axes to be plotted in. color (str): Color of vertex. ann (bool): Show annotations. asSphere (bool): Draws vertex as sphere (only in vtk mode). size (float): Size of vertex (only in vtk mode). render (bool): Render in the end (only in vtk mode). Returns: matplotlib.axes: Updated axes. """ if backend=="mpl": ax=self.drawMPL(ax=ax,color=color,ann=ann) if backend=="vtk": ax=self.drawVTK(color=color,ann=ann,ax=ax,asSphere=asSphere,size=size,render=render) return ax def drawMPL(self,ax=None,color=None,ann=None): """Draws vertrex into matplotlib axes. .. note:: If ``ann=None``, will set ``ann=False``. .. note:: If no axes is given, will create new one, see also :py:func:`pyfrp.modules.pyfrp_plot_module.makeGeometryPlot`. Keyword Args: ax (matplotlib.axes): Matplotlib axes to be plotted in. color (str): Color of domain. ann (bool): Show annotations. Returns: matplotlib.axes: Axes. """ if ann==None: ann=False if ax==None: fig,axes = pyfrp_plot_module.makeGeometryPlot() ax=axes[0] ax.scatter(self.x[0],self.x[1],self.x[2],c=color) if ann: ax.text(self.x[0]+self.domain.annXOffset, self.x[1]+self.domain.annYOffset, self.x[2]+self.domain.annZOffset, "p"+str(self.Id), None) pyfrp_plot_module.redraw(ax) return ax def drawVTK(self,size=10,asSphere=True,ax=None,ann=None,color=[0,0,0],render=False): """Draws vertrex into VTK renderer. .. note:: If ``ann=None``, will set ``ann=False``. .. note:: If no axes is given, will create new ``vtkRenderer``, see also :py:func:`pyfrp.modules.pyfrp_vtk_module.makeVTKCanvas`. Keyword Args: ax (vtk.vtkRenderer): Renderer to draw in. color (str): Color of vertex. ann (bool): Show annotations. asSphere (bool): Draws vertex as sphere. size (float): Size of vertex. render (bool): Render in the end. Returns: vtk.vtkRenderer: Updated renderer. """ if ann==None: ann=False if ax==None: ax,renderWindow,renderWindowInteractor=pyfrp_vtk_module.makeVTKCanvas() pyfrp_vtk_module.drawVTKPoint(self.x,asSphere=asSphere,color=color,size=size,renderer=ax) if ann: printWarning("Annotations don't properly work with backend=vtk .") pyfrp_vtk_module.drawVTKText("p"+str(self.Id),[self.x[0]+self.domain.annXOffset, self.x[1]+self.domain.annYOffset, self.x[2]+self.domain.annZOffset],renderer=ax) if render: ax=pyfrp_vtk_module.renderVTK(ax,start=False) return ax def setX(self,x): """Sets coordinate if vertex to ``x``. Returns: numpy.ndarray: New vertex coordinate. """ self.x=x return self.x def writeToFile(self,f): """Writes vertex to file. Args: f (file): File to write to. Returns: file: File. """ f.write("Point("+str(self.Id)+")= {" + str(self.x[0]) + ","+ str(self.x[1])+ "," + str(self.x[2]) + ',' + str(self.volSize) + "};\n" ) return f def addToAttractor(self,attrField=None,LcMin=5.,LcMax=20.,DistMin=30.,DistMax=60.): """Adds vertex to a attractor field. If no field is given, will create new one with given parameters. Will also create a new threshhold field around attractor and add fields to minField. If no minField exists, will create a new one too and set it as background field. See also :py:func:`addAttractorField`, :py:func:`addThresholdField`, :py:func:`addMinField` and :py:func:`genMinBkgd`. Keyword Args: attrField (pyfrp.modules.pyfrp_gmsh_geometry.attractorField): Attractor field object. LcMin (float): Minimum volSize of threshold field. LcMax (float): Maximum volSize of threshold field. DistMin (float): Minimun density of field. DistMax (float): Maximum density of field. Returns: pyfrp.modules.pyfrp_gmsh_geometry.attractorField: Attractor field around vertex. """ #Generate attractor field if not given if attrField==None: attrField=self.domain.addAttractorField(NodesList=[self.Id]) else: attrField.addNodeByID(self.Id) #Generate threshhold field if not already existent threshFields=attrField.includedInThresholdField() if len(threshFields)==0: threshField=self.domain.addThresholdField(IField=attrField.Id,LcMin=LcMin,LcMax=LcMax,DistMin=DistMin,DistMax=DistMax) else: threshField=threshFields[0] self.domain.genMinBkgd(FieldsList=[threshField.Id]) return attrField def addToBoundaryLayer(self,boundField=None,**fieldOpts): """Adds vertex to a boundary layer field. If no field is given, will create new one with given parameters and add it to a minField. If no minField exists, will create a new one too and set it as background field. See also :py:func:`pyfrp.modules.pyfrp_gmsh_geometry.domain.addBoundaryLayerField` :py:func:`pyfrp.modules.pyfrp_gmsh_geometry.domain.addMinField` and :py:func:`pyfrp.modules.pyfrp_gmsh_geometry.domain.genMinBkgd`. Keyword Args: boundField (pyfrp.modules.pyfrp_gmsh_geometry.boundaryLayerField): Boundary layer field object. fieldOpts (dict): See documentation of boundary layer field of all available options. Returns: pyfrp.modules.pyfrp_gmsh_geometry.boundaryLayerField: Boundary layer field around vertex. """ #Generate attractor field if not given if boundField==None: boundField=self.domain.addBoundaryLayerField() #Add Vertex boundField.addNodeByID(self.Id) #Set options boundField.setFieldAttributes(**fieldOpts) #Generate background field self.domain.genMinBkgd(FieldsList=[boundField.Id]) return boundField class edge(gmshElement): """Edge class storing information from gmsh .geo circles and lines. Args: domain (pyfrp.modules.pyfrp_gmsh_geometry.domain): Domain vertex belongs to. Id (int): ID of edge. typ (int): Type of edge (1=arc/0=line). """ def __init__(self,domain,Id,typ): gmshElement.__init__(self,domain,Id) self.typ=typ def getDomain(self): """Returns domain edge belongs to.""" return self.domain def getTyp(self): """Returns Type of edge.""" return self.typ def decodeTyp(self): """Decodes type of edge into string.""" if typ==1: return "arc" elif typ==0: return "line" elif typ==2: return "bSpline" def addToBoundaryLayer(self,boundField=None,**fieldOpts): """Adds edge to a boundary layer field. If no field is given, will create new one with given parameters and add it to a minField. If no minField exists, will create a new one too and set it as background field. See also :py:func:`pyfrp.modules.pyfrp_gmsh_geometry.domain.addBoundaryLayerField` :py:func:`pyfrp.modules.pyfrp_gmsh_geometry.domain.addMinField` and :py:func:`pyfrp.modules.pyfrp_gmsh_geometry.domain.genMinBkgd`. Keyword Args: boundField (pyfrp.modules.pyfrp_gmsh_geometry.boundaryLayerField): Boundary layer field object. fieldOpts (dict): See documentation of boundary layer field of all available options. Returns: pyfrp.modules.pyfrp_gmsh_geometry.boundaryLayerField: Boundary layer field around edge. """ #Generate attractor field if not given if boundField==None: boundField=self.domain.addBoundaryLayerField() #Add Vertex boundField.addEdgeByID(self.Id) #Set options boundField.setFieldAttributes(**fieldOpts) #Generate background field self.domain.genMinBkgd(FieldsList=[boundField.Id]) return boundField def includedInLoop(self): """Checks if edge is included in a loop. Returns: tuple: Tuple containing: * included (bool): True if included. * loops (list): List of :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.lineLoop` objects that include edge. """ loops=[] for i,loop in enumerate(self.domain.lineLoops): if self in loop.edges: loops.append(loop) return len(loops)>0,loops def includedInField(self): """Checks if edge is included in a field. .. note:: Only checks for boundary layer fields, since they are the only ones who can evolve around edge. Returns: tuple: Tuple containing: * included (bool): True if included. * fields (list): List of :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.fields` objects that include edge. """ fields=[] for field in self.domain.fields: if field.typ=="boundaryLayer": if self in field.EdgesList: fields.append(fields) return len(fields)>0,fields def delete(self,debug=False): """Deletes edge if it is not used in any loop or field. Returns: bool: True if deletion was successful. """ incl,loops=self.includedInLoop() if incl: if debug: printWarning("Was not able to delete edge with ID " + str(self.Id) +". Still part of loops" + str(pyfrp_misc_module.objAttrToList(loops,'Id')) + " .") return False incl,fields=self.includedInField() if incl: if debug: printWarning("Was not able to delete edge with ID " + str(self.Id) +". Still part of field with ID " + str(pyfrp_misc_module.objAttrToList(fields,'Id')) ) return False try: if self.typ==0: self.domain.lines.remove(self) if self.typ==1: self.domain.arcs.remove(self) if self.typ==2: self.domain.bSplines.remove(self) self.domain.edges.remove(self) except ValueError: if debug: printWarning("Could not remove edge " + str(self.Id)+" from elements list. Already seems to be removed.") return False return True class line(edge): """Line class storing information from gmsh .geo lines. Args: domain (pyfrp.modules.pyfrp_gmsh_geometry.domain): Domain line belongs to. v1 (pyfrp.modules.pyfrp_gmsh_geometry.vertex): Start vertex. v2 (pyfrp.modules.pyfrp_gmsh_geometry.vertex): End vertex. Id (int): ID of line. """ def __init__(self,domain,v1,v2,Id): edge.__init__(self,domain,Id,0) self.v1=v1 self.v2=v2 def getMiddle(self): r"""Returns midpoint of line. .. math:: m = \frac{x(v_1) + x(v_2)}{2} Returns: numpy.ndarray: Midpoint. """ return (self.v1.x+self.v2.x)/2. def draw(self,ax=None,color=None,ann=None,backend="mpl",render=False,drawVertices=False,linewidth=1): """Draws line. There are two different backends for drawing, namely * Matplotlib (``backend='mpl'``) * VTK (``backend='vtk'``) Matplotlib is easier to handle, but slower. VTK is faster for complex geometries. .. note:: If ``backend=mpl``, ``ax`` should be a ``matplotlib.axes``, if ``backend='vtk'``, ``ax`` should be a ``vtk.vtkRenderer`` object. .. note:: If no axes is given, will create new one, see also :py:func:`pyfrp.modules.pyfrp_plot_module.makeGeometryPlot` or :py:func:`pyfrp.modules.pyfrp_vtk_module.makeVTKCanvas`. .. warning:: Annotations are not properly working with ``backend='vtk'``. Keyword Args: ax (matplotlib.axes): Matplotlib axes to be plotted in. color (str): Color of line. ann (bool): Show annotations. render (bool): Render in the end (only in vtk mode). drawVertices (bool): Also draw vertices. Returns: matplotlib.axes: Updated axes. """ if backend=="mpl": ax=self.drawMPL(ax=ax,color=color,ann=ann,linewidth=linewidth) if backend=="vtk": ax=self.drawVTK(color=color,ann=ann,ax=ax,render=render,linewidth=linewidth) if drawVertices: ax=self.v1.draw(ax=ax,color=color,ann=ann,backend=backend,render=render,asSphere=False) ax=self.v2.draw(ax=ax,color=color,ann=ann,backend=backend,render=render,asSphere=False) return ax def drawMPL(self,ax=None,color=None,ann=None,linewidth=1): """Draws line into matplotlib axes. .. note:: If ``ann=None``, will set ``ann=False``. .. note:: If no axes is given, will create new one, see also :py:func:`pyfrp.modules.pyfrp_plot_module.makeGeometryPlot`. Keyword Args: ax (matplotlib.axes): Matplotlib axes to be plotted in. color (str): Color of line. ann (bool): Show annotations. Returns: matplotlib.axes: Axes. """ if ann==None: ann=False if ax==None: fig,axes = pyfrp_plot_module.makeGeometryPlot() ax=axes[0] ax.plot([self.v1.x[0],self.v2.x[0]],[self.v1.x[1],self.v2.x[1]],zs=[self.v1.x[2],self.v2.x[2]],color=color,linestyle='-',linewidth=linewidth) if ann: m=self.getMiddle() ax.text(m[0]+self.domain.annXOffset, m[1]+self.domain.annYOffset, m[2]+self.domain.annZOffset, "l"+str(self.Id), None) pyfrp_plot_module.redraw(ax) return ax def drawVTK(self,ax=None,color=None,ann=None,render=False,linewidth=1): """Draws line into VTK renderer. .. note:: If ``ann=None``, will set ``ann=False``. .. note:: If no axes is given, will create new ``vtkRenderer``, see also :py:func:`pyfrp.modules.pyfrp_vtk_module.makeVTKCanvas`. See also :py:func:`pyfrp.modules.pyfrp_vtk_module.drawVTKLine`. Keyword Args: ax (vtk.vtkRenderer): Renderer to draw in. color (str): Color of line. ann (bool): Show annotations. render (bool): Render in the end. Returns: vtk.vtkRenderer: Updated renderer. """ if ann==None: ann=False if ax==None: ax,renderWindow,renderWindowInteractor=pyfrp_vtk_module.makeVTKCanvas() pyfrp_vtk_module.drawVTKLine(self.v1.x,self.v2.x,color=color,renderer=ax,linewidth=linewidth) if ann: printWarning("Annotations don't properly work with backend=vtk .") m=self.getMiddle() pyfrp_vtk_module.drawVTKText("p"+str(self.Id),[m[0]+self.domain.annXOffset, m[1]+self.domain.annYOffset, m[2]+self.domain.annZOffset],renderer=ax) if render: ax=pyfrp_vtk_module.renderVTK(ax,start=False) return ax def getLastVertex(self,orientation): """Returns last vertex of line given a orientation. Orientation can be either forward (1), or reverse (-1). Args: orientation (int): Orientation of line. Returns: pyfrp.pyfrp_gmsh_geometry.vertex: Vertex. """ if orientation==1: return self.v2 elif orientation==-1: return self.v1 else: printError("Cannot return last vertex. Orientation " + str(orientation) + " unknown.") return None def getFirstVertex(self,orientation): """Returns first vertex of line given a orientation. Orientation can be either forward (1), or reverse (-1). Args: orientation (int): Orientation of line. Returns: pyfrp.pyfrp_gmsh_geometry.vertex: Vertex. """ if orientation==1: return self.v1 elif orientation==-1: return self.v2 else: printError("Cannot return first vertex. Orientation " + str(orientation) + " unknown.") return None def writeToFile(self,f): """Writes line to file. Args: f (file): File to write to. Returns: file: File. """ f.write("Line("+str(self.Id)+")= {" + str(self.v1.Id) + "," + str(self.v2.Id) + "};\n" ) return f def getDirection(self,orientation): """Returns direction of line. Orientation can be either forward (1), or reverse (-1). Args: orientation (int): Orientation of line. Returns: numpy.ndarray: Direction of line. """ return self.getLastVertex(orientation).x-self.getFirstVertex(orientation).x def getSubElements(self): """Returns all elements that define this element. Returns: list: List of elements. """ return [self.getFirstVertex(1),self.getLastVertex(1)] class arc(edge): """Arc class storing information from gmsh .geo cicle. Will compute ``angleOffset``, ``angle`` and ``pOffset`` on creation. .. image:: ../imgs/pyfrp_gmsh_geometry/arc.png Args: domain (pyfrp.modules.pyfrp_gmsh_geometry.domain): Domain arc belongs to. vstart (pyfrp.modules.pyfrp_gmsh_geometry.vertex): Start vertex. vcenter (pyfrp.modules.pyfrp_gmsh_geometry.vertex): Center vertex. vend (pyfrp.modules.pyfrp_gmsh_geometry.vertex): End vertex. Id (int): ID of arc. """ def __init__(self,domain,vstart,vcenter,vend,Id): edge.__init__(self,domain,Id,1) self.vcenter=vcenter self.vstart=vstart self.vend=vend self.radius=self.computeRadius() self.pOffset=self.computePOffset() self.angleOffset=self.computeAngleOffset() self.angle=self.computeAngle() def computeAngleOffset(self): """Computes and returns offset angle of arc. """ self.angleOffset=pyfrp_geometry_module.getAngle(self.pOffset,self.vstart.x-self.vcenter.x) return self.angleOffset def computeAngle(self): """Computes and returns angle of arc. """ self.angle=pyfrp_geometry_module.getAngle(self.vstart.x-self.vcenter.x,self.vend.x-self.vcenter.x) return self.angle def computePOffset(self): """Computes and returns offset point of arc. """ v1n,v2nb = self.getNormVec() self.pOffset=self.radius*v2nb self.pOffset=self.pOffset/np.linalg.norm(self.pOffset) return self.pOffset def getNormVec(self): """Computes and returns vectors normal to arc. Returns: tuple: Tuple containing: * v1n (numpy.ndarray): Normal vector to ``vstart-vcenter``. * v2n (numpy.ndarray): Normal vector to ``vend-vcenter``. """ v1=self.vstart.x-self.vcenter.x v2=self.vend.x-self.vcenter.x self.v1n = v1/np.linalg.norm(v1) v2n = v2/np.linalg.norm(v2) v2nb = v2n-np.dot(v2n,self.v1n)*self.v1n self.v2nb = v2nb/np.linalg.norm(v2nb) return self.v1n,self.v2nb def getPlotVec(self): """Returns vectors for plotting arc. Returns: tuple: Tuple containing: * x (numpy.ndarray): x-array. * y (numpy.ndarray): y-array. * z (numpy.ndarray): z-array. """ self.getNormVec() if np.mod(self.angle,np.pi/2.)<0.01: a = np.linspace(0,self.angle,1000) else: a = np.linspace(self.angleOffset-self.angle,self.angleOffset,1000) x,y,z=self.getPointOnArc(a) return x,y,z def getPointOnArc(self,a): """Returns point on arc at angle ``a``. Returns: tuple: Tuple containing: * x (float): x-coordinate. * y (float): y-coordinate. * z (float): z-coordinate. """ x = self.vcenter.x[0]+np.sin(a)*self.radius*self.v1n[0]+np.cos(a)*self.radius*self.v2nb[0] y = self.vcenter.x[1]+np.sin(a)*self.radius*self.v1n[1]+np.cos(a)*self.radius*self.v2nb[1] z = self.vcenter.x[2]+np.sin(a)*self.radius*self.v1n[2]+np.cos(a)*self.radius*self.v2nb[2] return x,y,z def computeRadius(self): """Computes and returns radius of arc. Returns: float: Radius of arc. """ self.radius=np.linalg.norm(self.vstart.x-self.vcenter.x) return self.radius def inArc(self,x,debug=False): """Tells if coordinate ``x`` is on arc or not. Returns: bool: ``True`` if on arc, ``False`` otherwise. """ a=self.computeAngle(array([self.radius,0])-self.vcenter.x,x-self.vcenter.x) if np.mod(a,2*np.pi)<self.angle+self.angleOffset and self.angleOffset<=np.mod(a,2*np.pi): return True else: return False def getRadius(self): """Returns radius of arc.""" return self.radius def getAngle(self): """Returns angle of arc.""" return self.angle def getAngleOffset(self): """Returns offset angle of arc.""" return self.angleOffset def getVstart(self): """Returns start vertex of arc.""" return self.vstart def getVend(self): """Returns end vertex of arc.""" return self.vend def getXstart(self): """Returns start coordinate of arc.""" return self.vstart.x def getXend(self): """Returns end coordinate of arc.""" return self.vend.x def getVcenter(self): """Returns center vertex of arc.""" return self.vcenter def getXcenter(self): """Returns center coordinate of arc.""" return self.vcenter.x def draw(self,ax=None,color=None,ann=None,backend="mpl",render=False,drawVertices=True,linewidth=1): """Draws arc. There are two different backends for drawing, namely * Matplotlib (``backend='mpl'``) * VTK (``backend='vtk'``) Matplotlib is easier to handle, but slower. VTK is faster for complex geometries. .. note:: If ``backend=mpl``, ``ax`` should be a ``matplotlib.axes``, if ``backend='vtk'``, ``ax`` should be a ``vtk.vtkRenderer`` object. .. note:: If no axes is given, will create new one, see also :py:func:`pyfrp.modules.pyfrp_plot_module.makeGeometryPlot` or :py:func:`pyfrp.modules.pyfrp_vtk_module.makeVTKCanvas`. .. warning:: Annotations are not properly working with ``backend='vtk'``. Keyword Args: ax (matplotlib.axes): Matplotlib axes to be plotted in. color (str): Color of line. ann (bool): Show annotations. render (bool): Render in the end (only in vtk mode). drawVertices (bool): Also draw vertices. Returns: matplotlib.axes: Updated axes. """ if backend=="mpl": ax=self.drawMPL(ax=ax,color=color,ann=ann,linewidth=linewidth) if backend=="vtk": ax=self.drawVTK(color=color,ann=ann,ax=ax,render=render,linewidth=linewidth) if drawVertices: ax=self.vcenter.draw(ax=ax,color=color,ann=ann,backend=backend,render=render,asSphere=False) ax=self.vstart.draw(ax=ax,color=color,ann=ann,backend=backend,render=render,asSphere=False) ax=self.vend.draw(ax=ax,color=color,ann=ann,backend=backend,render=render,asSphere=False) return ax def drawMPL(self,ax=None,color=None,ann=None,render=False,linewidth=1): """Draws arc into matplotlib axes. .. note:: If ``ann=None``, will set ``ann=False``. .. note:: If no axes is given, will create new one, see also :py:func:`pyfrp.modules.pyfrp_plot_module.makeGeometryPlot`. Keyword Args: ax (matplotlib.axes): Matplotlib axes to be plotted in. color (str): Color of line. ann (bool): Show annotations. Returns: matplotlib.axes: Axes. """ if ann==None: ann=False if ax==None: fig,axes = pyfrp_plot_module.makeGeometryPlot() ax=axes[0] x,y,z=self.getPlotVec() ax.plot(x,y,zs=z,color=color,linestyle='-',linewidth=linewidth) if ann: x,y,z=self.getPointOnArc(self.angle/2.) ax.text(x+self.domain.annXOffset, y+self.domain.annYOffset, z+self.domain.annZOffset, "c"+str(self.Id), None) pyfrp_plot_module.redraw(ax) return ax def drawVTK(self,ax=None,color=None,ann=None,render=False,linewidth=1): """Draws arc into VTK renderer. .. note:: If ``ann=None``, will set ``ann=False``. .. note:: If no axes is given, will create new ``vtkRenderer``, see also :py:func:`pyfrp.modules.pyfrp_vtk_module.makeVTKCanvas`. See also :py:func:`pyfrp.modules.pyfrp_vtk_module.drawVTKArc`. Keyword Args: ax (vtk.vtkRenderer): Renderer to draw in. color (str): Color of line. ann (bool): Show annotations. render (bool): Render in the end. Returns: vtk.vtkRenderer: Updated renderer. """ if ann==None: ann=False if ax==None: ax,renderWindow,renderWindowInteractor=pyfrp_vtk_module.makeVTKCanvas() pyfrp_vtk_module.drawVTKArc(self.vstart.x,self.vcenter.x,self.vend.x,color=color,renderer=ax,linewidth=linewidth) if ann: printWarning("Annotations don't properly work with backend=vtk .") m=self.getMiddle() pyfrp_vtk_module.drawVTKText("p"+str(self.Id),[m[0]+self.domain.annXOffset, m[1]+self.domain.annYOffset, m[2]+self.domain.annZOffset],renderer=ax) if render: ax=pyfrp_vtk_module.renderVTK(ax,start=False) return ax def getLastVertex(self,orientation): """Returns last vertex of arc given a orientation. Orientation can be either forward (1), or reverse (-1). Args: orientation (int): Orientation of arc. Returns: pyfrp.pyfrp_gmsh_geometry.vertex: Vertex. """ if orientation==1: return self.getVend() elif orientation==-1: return self.getVstart() else: printError("Cannot return last vertex. Orientation " + str(orientation) + " unknown.") return None def getFirstVertex(self,orientation): """Returns first vertex of arc given a orientation. Orientation can be either forward (1), or reverse (-1). Args: orientation (int): Orientation of arc. Returns: pyfrp.pyfrp_gmsh_geometry.vertex: Vertex. """ if orientation==-1: return self.getVend() elif orientation==1: return self.getVstart() else: printError("Cannot return first vertex. Orientation " + str(orientation) + " unknown.") return None def writeToFile(self,f): """Writes arc to file. Args: f (file): File to write to. Returns: file: File. """ f.write("Circle("+str(self.Id)+")= {" + str(self.vstart.Id) + ","+ str(self.vcenter.Id)+ "," + str(self.vend.Id) + "};\n" ) return f def getSubElements(self): """Returns all elements that define this element. Returns: list: List of elements. """ return [self.vcenter,self.vstart,self.vend] class bSpline(edge): """Bspline class storing information from gmsh .geo BSpline. Args: domain (pyfrp.modules.pyfrp_gmsh_geometry.domain): Domain arc belongs to. vertices (list): List of vertex objects. Id (int): ID of spline. """ def __init__(self,domain,vertices,Id): edge.__init__(self,domain,Id,2) self.initVertices(vertices) def initVertices(self,vertices): """Initiates list of vertices. If vertex is given by Id, will use :py:func:`pyfrp.modules.pyfrp_gmsh_geometry.getVertexById` to identify vertex. Args: vertices (list): List of vertex objects. Returns: list: List of vertex objects. """ self.vertices=[] for v in vertices: if isinstance(v,int): self.vertices.append(self.domain.getVertexById(v)[0]) else: self.vertices.append(v) return self.vertices def writeToFile(self,f): """Writes bSpline to file. Args: f (file): File to write to. Returns: file: File. """ f.write("BSpline("+str(self.Id)+")= {" ) for i,v in enumerate(self.vertices): f.write(str(v.Id)) if i!=len(self.vertices)-1: f.write(",") else: f.write("};\n") return f def getMiddle(self): r"""Returns midpoint of bSpline. Midpoint in this case is defined as the coordinate of the mid vertex. Returns: numpy.ndarray: Midpoint. """ return self.vertices[int(np.floor(len(self.vertices)/2.))].x def draw(self,ax=None,color=None,ann=None,backend="mpl",render=False,drawVertices=False,linewidth=1): """Draws spline. There are two different backends for drawing, namely * Matplotlib (``backend='mpl'``) * VTK (``backend='vtk'``) Matplotlib is easier to handle, but slower. VTK is faster for complex geometries. .. note:: If ``backend=mpl``, ``ax`` should be a ``matplotlib.axes``, if ``backend='vtk'``, ``ax`` should be a ``vtk.vtkRenderer`` object. .. note:: If no axes is given, will create new one, see also :py:func:`pyfrp.modules.pyfrp_plot_module.makeGeometryPlot` or :py:func:`pyfrp.modules.pyfrp_vtk_module.makeVTKCanvas`. .. warning:: Annotations are not properly working with ``backend='vtk'``. Keyword Args: ax (matplotlib.axes): Matplotlib axes to be plotted in. color (str): Color of line. ann (bool): Show annotations. render (bool): Render in the end (only in vtk mode). drawVertices (bool): Also draw vertices. Returns: matplotlib.axes: Updated axes. """ printWarning("Spline drawing currently just draws lines inbetween interpolation points.") if backend=="mpl": ax=self.drawMPL(ax=ax,color=color,ann=ann,linewidth=linewidth) if backend=="vtk": ax=self.drawVTK(color=color,ann=ann,ax=ax,render=render,linewidth=linewidth) if drawVertices: for v in self.vertices: ax=v.draw(ax=ax,color=color,ann=ann,backend=backend,render=render,asSphere=False) return ax def drawMPL(self,ax=None,color=None,ann=None,linewidth=1): """Draws spline into matplotlib axes. .. note:: If ``ann=None``, will set ``ann=False``. .. note:: If no axes is given, will create new one, see also :py:func:`pyfrp.modules.pyfrp_plot_module.makeGeometryPlot`. Keyword Args: ax (matplotlib.axes): Matplotlib axes to be plotted in. color (str): Color of line. ann (bool): Show annotations. Returns: matplotlib.axes: Axes. """ if ann==None: ann=False if ax==None: fig,axes = pyfrp_plot_module.makeGeometryPlot() ax=axes[0] for i in range(len(self.vertices)-1): ax.plot([self.vertices[i].x[0],self.vertices[i+1].x[0]],[self.vertices[i].x[1],self.vertices[i+1].x[1]],zs=[self.vertices[i].x[2],self.vertices[i+1].x[2]],color=color,linestyle='-',linewidth=linewidth) if ann: m=self.getMiddle() ax.text(m[0]+self.domain.annXOffset, m[1]+self.domain.annYOffset, m[2]+self.domain.annZOffset, "l"+str(self.Id), None) pyfrp_plot_module.redraw(ax) return ax def drawVTK(self,ax=None,color=None,ann=None,render=False,linewidth=1): """Draws spline into VTK renderer. .. note:: If ``ann=None``, will set ``ann=False``. .. note:: If no axes is given, will create new ``vtkRenderer``, see also :py:func:`pyfrp.modules.pyfrp_vtk_module.makeVTKCanvas`. See also :py:func:`pyfrp.modules.pyfrp_vtk_module.drawVTKLine`. Keyword Args: ax (vtk.vtkRenderer): Renderer to draw in. color (str): Color of line. ann (bool): Show annotations. render (bool): Render in the end. Returns: vtk.vtkRenderer: Updated renderer. """ if ann==None: ann=False if ax==None: ax,renderWindow,renderWindowInteractor=pyfrp_vtk_module.makeVTKCanvas() pyfrp_vtk_module.drawVTKPolyLine(pyfrp_misc_module.objAttrToList(self.vertices,'x'),color=color,renderer=ax,linewidth=linewidth) if ann: printWarning("Annotations don't properly work with backend=vtk .") m=self.getMiddle() pyfrp_vtk_module.drawVTKText("p"+str(self.Id),[m[0]+self.domain.annXOffset, m[1]+self.domain.annYOffset, m[2]+self.domain.annZOffset],renderer=ax) if render: ax=pyfrp_vtk_module.renderVTK(ax,start=False) return ax def getLastVertex(self,orientation): """Returns last vertex of arc given a orientation. Orientation can be either forward (1), or reverse (-1). Args: orientation (int): Orientation of arc. Returns: pyfrp.pyfrp_gmsh_geometry.vertex: Vertex. """ if orientation==1: return self.vertices[-1] elif orientation==-1: return self.vertices[0] else: printError("Cannot return last vertex. Orientation " + str(orientation) + " unknown.") return None def getFirstVertex(self,orientation): """Returns first vertex of arc given a orientation. Orientation can be either forward (1), or reverse (-1). Args: orientation (int): Orientation of arc. Returns: pyfrp.pyfrp_gmsh_geometry.vertex: Vertex. """ if orientation==1: return self.vertices[0] elif orientation==-1: return self.vertices[-1] else: printError("Cannot return first vertex. Orientation " + str(orientation) + " unknown.") return None def getSubElements(self): """Returns all elements that define this element. Returns: list: List of elements. """ return self.vertices class lineLoop(gmshElement): """Lineloop class storing information from gmsh .geo. Object has two major attributes: * edges (list): List of pyfrp.moduels.pyfrp_gmsh_geometry.edge objects. * orientations (list): List of orientations of each element, either ``1`` or ``-1`` Args: domain (pyfrp.modules.pyfrp_gmsh_geometry.domain): Domain loop belongs to. edgeIDs (list): List of edge IDs. Id (int): ID of loop. """ def __init__(self,domain,edgeIDs,ID): gmshElement.__init__(self,domain,ID) self.edges,self.orientations=self.initEdges(edgeIDs) def initEdges(self,IDs): """Constructs ``edges`` and ``orientations`` list at object initiations from list of IDs. Args: IDs (list): List of IDs Returns: tuple: Tuple containing: * edges (list): List of pyfrp.moduels.pyfrp_gmsh_geometry.edge objects. * orientations (list): List of orientations of each element, either ``1`` or ``-1`` """ self.edges=[] self.orientations=[] for ID in IDs: self.addEdgeByID(ID) return self.edges,self.orientations def addEdgeByID(self,ID): """Adds edge to lineloop. Args: ID (int): ID of edge to be added. Returns: list: Updated edgeIDs list. """ self.edges.append(self.domain.getEdgeById(abs(ID))[0]) self.orientations.append(np.sign(ID)) return self.edges def insertEdgeByID(self,ID,pos): """Inserts edge to lineloop at position. Args: ID (int): ID of edge to be inserted. pos (int): Position at which ID to be inserted. Returns: list: Updated edgeIDs list. """ self.edges.insert(pos,self.domain.getEdgeById(abs(ID))[0]) self.orientations.insert(pos,np.sign(ID)) return self.edges def removeEdgeByID(self,ID): """Remove edge from lineloop. Args: ID (int): ID of edge to be removed. Returns: list: Updated edgeIDs list. """ idx=self.edges.index(abs(ID)) self.edges.remove(abs(ID)) self.orientations.pop(idx) return self.edges def reverseEdge(self,ID): """Reverses the orientation of an edge in the line loop. Args: ID (int): ID of edge to be reversed. Returns: list: Updated orientations list. """ e=self.domain.getEdgeById(abs(ID))[0] self.orientations[self.edges.index(e)]=-self.orientations[self.edges.index(e)] return self.orientations def draw(self,ax=None,color='k',ann=None,backend='mpl',drawVertices=False,linewidth=1): """Draws complete line loop. There are two different backends for drawing, namely * Matplotlib (``backend='mpl'``) * VTK (``backend='vtk'``) Matplotlib is easier to handle, but slower. VTK is faster for complex geometries. .. note:: If ``backend=mpl``, ``ax`` should be a ``matplotlib.axes``, if ``backend='vtk'``, ``ax`` should be a ``vtk.vtkRenderer`` object. .. note:: If no axes is given, will create new one, see also :py:func:`pyfrp.modules.pyfrp_plot_module.makeGeometryPlot` or :py:func:`pyfrp.modules.pyfrp_vtk_module.makeVTKCanvas`. .. warning:: Annotations are not properly working with ``backend='vtk'``. Keyword Args: ax (matplotlib.axes): Matplotlib axes to be plotted in. color (str): Color of line loop. ann (bool): Show annotations. drawVertices (bool): Also draw vertices. Returns: matplotlib.axes: Updated axes. """ for e in self.edges: ax=e.draw(ax=ax,color=color,ann=ann,backend=backend,drawVertices=drawVertices,linewidth=linewidth) return ax def printLoop(self): """Prints loop. """ ids=np.array(pyfrp_misc_module.objAttrToList(self.edges,"Id")) orients=np.array(self.orientations) print "Line Loop with ID = "+ str(self.Id)+": "+str(ids*orients) def fix(self): """Fixes loop. """ edgesNew=[self.edges[0]] orientationsNew=[self.orientations[0]] for i in range(1,len(self.edges)): lastEdge=edgesNew[i-1] vLast=lastEdge.getLastVertex(orientationsNew[i-1]) for j in range(len(self.edges)): currEdge=self.edges[j] currOrient=self.orientations[j] if currEdge==lastEdge: continue if vLast == currEdge.getFirstVertex(currOrient): edgesNew.append(currEdge) orientationsNew.append(currOrient) break elif vLast == currEdge.getLastVertex(currOrient): edgesNew.append(currEdge) orientationsNew.append(-currOrient) break if j==len(self.edges)-1: printWarning("Could not fix loop with ID" + str(self.Id)) print "Edge with ID " +str(lastEdge.Id) + " is not matching with any other edge." return False self.edges=edgesNew self.orientations=orientationsNew return True def checkClosed(self,fix=False,debug=False): """Checks if lineLoop is closed. Keyword Args: debug (bool): Print debugging messages. fix (bool): Close if necessary. Returns: bool: True if closed. """ b=True for i in range(len(self.edges)): #Get ID of edge edge1Temp=self.edges[i] orient1=self.orientations[i] #Get ID of next edge edge2Temp=self.edges[pyfrp_misc_module.modIdx(i+1,self.edges)] orient2=self.orientations[pyfrp_misc_module.modIdx(i+1,self.edges)] #Get ID of first/last vertex firstVertexId=edge1Temp.getFirstVertex(orient1).Id lastVertexId=edge2Temp.getLastVertex(orient2).Id #Check if vertices are matching if firstVertexId!=lastVertexId: b=False if fix: self.reverseEdge(edge2Temp.Id) b=True if debug: print "Edge with ID " +str(edge1Temp.Id) + " was not matching edge with ID " + str(edge2Temp.Id) + ". \n Fixed this." if debug: printWarning("lineLoop with ID " + str(self.Id) + " does not close." ) print "Edge with ID " +str(edge1Temp.Id) + " is not matching edge with ID " + str(edge2Temp.Id) return b def writeToFile(self,f): """Writes line loop to file. Args: f (file): File to write to. Returns: file: File. """ f.write("Line Loop("+str(self.Id)+")= {" ) for i,s in enumerate(self.edges): f.write(str(self.orientations[i]*s.Id)) if i!=len(self.edges)-1: f.write(",") else: f.write("};\n") return f def getVertices(self): """Returns all vertices included in loop.""" vertices=[] for i,edge in enumerate(self.edges): vertices.append(edge.getFirstVertex(self.orientations[i])) return vertices def hasCommonEdge(self,loop): """Checks if lineLoop has common edges with other lineLoop. Args: loop (pyfrp.modules.pyfrp_gmsh_geometry.lineLoop): lineLoop object. Returns: tuple: Tuple containing: * hasCommon (bool): True if loops have common edge. * edges (list): List of common edges. """ edges=[] for e in self.edges: if e in loop.edges: edges.append(e) return len(edges)>0,edges def fuse(self,loop,maxL=1000,debug=False,surface=None): """Fuses lineLoop with other loop. """ #Find common edge b,commonEdges=self.hasCommonEdge(loop) #print "commonEdges", pyfrp_misc_module.objAttrToList(commonEdges,'Id') if not b: printWarning("Cannot fuse lineLoop with ID " + str(self.Id) + " and lineLoop with ID "+ str(loop.Id) +" . Loops do not have common edge.") return False #Sort edges of loop and pop edges that are in common idx=loop.edges.index(commonEdges[0]) idxLast=loop.edges.index(commonEdges[-1])+1 edgeTemp1,loop.edges=pyfrp_misc_module.popRange(loop.edges,idx,idxLast) orientTemp1,loop.orientations=pyfrp_misc_module.popRange(loop.orientations,idx,idxLast) #print "popped ",pyfrp_misc_module.objAttrToList(edgeTemp1,'Id') #print "remain ",pyfrp_misc_module.objAttrToList(loop.edges,'Id') edges=list(np.roll(loop.edges,len(loop.edges)-idx)) orientations=list(np.roll(loop.orientations,len(loop.edges)-idx)) #Pop common edge out of this loop idx=self.edges.index(commonEdges[0]) idxLast=self.edges.index(commonEdges[-1])+1 edgeTemp2,self.edges=pyfrp_misc_module.popRange(self.edges,idx,idxLast) orientTemp2,self.orientations=pyfrp_misc_module.popRange(self.orientations,idx,idxLast) #print "popped 2 ",pyfrp_misc_module.objAttrToList(edgeTemp2,'Id') #print "remain ",pyfrp_misc_module.objAttrToList(self.edges,'Id') #Figure out if edges of other loop are in right order or need to be reversed if orientTemp1[0]==orientTemp2[0]: edges.reverse() orientations.reverse() if len(edges)>maxL: if debug: printWarning("Cannot fuse lineLoop with ID " + str(self.Id) + " and lineLoop with ID "+ str(loop.Id) +" . Resulting loop exceeds maxL.") return False #print "inserting ",pyfrp_misc_module.objAttrToList(edges,'Id') #Insert edges of second loop into loop self.edges[idx:idx]=edges self.orientations[idx:idx]=orientations #Check if closed in the end #self.checkClosed(fix=True,debug=False) self.fix() #Delete second lineLoop if surface!=None: loop.removeFromSurface(surface) b=loop.delete(debug=debug) bs=[] #Delete common edge for edge in edgeTemp1: bs.append(edge.delete(debug=debug)) return True def approxBySpline(self,angleThresh=0.314,debug=False): """Approximates parts of line loop by spline. Summarizes all consecutive lines in loop that have a small angle inbetween to a spline. .. note:: The choice of ``angleThresh`` is crucial for this function to work. It should be chosen on a by-case basis if necessary. Example: Load test file: >>> d,dd = pyfrp_gmsh_IO_module.readGeoFile("pyfrp/meshfiles/examples/splineTest.geo") Draw: >>> d.setAnnOffset([0.1,0.1,0.00]) >>> ax=d.draw(backend='mpl',asSphere=False,ann=True,annElements=[False,True,False]) returns the following .. image:: ../imgs/pyfrp_gmsh_geometry/approxBySpline1.png Approximate by spline and draw again >>> d.lineLoops[0].approxBySpline(angleThresh=0.1*np.pi) >>> ax=d.draw(backend='mpl',asSphere=False,ann=True,annElements=[False,True,False]) returns .. image:: ../imgs/pyfrp_gmsh_geometry/approxBySpline2.png And write to file >>> d.writeToFile("pyfrp/meshfiles/examples/approximated.geo") Keyword Args: angleThresh (float): Angular threshold in radians. debug (bool): Print debugging messages. Returns: bool: True if approximated. """ if len(self.edges)<=4: return False nEdges=len(self.edges) # Bookkeeping lists subst=[] edgesSubst=[] vertices=[] appending=False for i in range(len(self.edges)): # Get indices of edges idx1=pyfrp_misc_module.modIdx(i,self.edges) idx2=pyfrp_misc_module.modIdx(i+1,self.edges) # Get edges e1=self.edges[idx1] e2=self.edges[idx2] # If either e1 or e2 is not a line, skip right away. if e1.typ>0 or e2.typ>0: continue # Compute angle angle=pyfrp_geometry_module.getAngle(e1.getDirection(self.orientations[idx1]),e2.getDirection(self.orientations[idx2])) # If angle satisfies threshold criteria, append edge if angle<=angleThresh: vertices=vertices+[e1.getFirstVertex(self.orientations[idx1]),e1.getLastVertex(self.orientations[idx1])] edgesSubst.append(e1) appending=True # If angle is too large or its the end of the loop, close spline if angle>angleThresh or i==len(self.edges)-1: if appending==True: if e1 not in edgesSubst: edgesSubst.append(e1) """IDEA: Check that includedInLoop gives same return for all edges in edgesSubst. Then finally add spline. """ noSpline=False for j,e in enumerate(edgesSubst): inLoop,loops=e.includedInLoop() if j>0: if loops.sort()!=oldLoops.sort(): noSpline=True print "cannot turn into spline because ", edgesSubst[j-1].Id , " and ",edgesSubst[j].Id oldLoops=list(loops) if not noSpline: """ Check if e2 is already about to be substituted by a spline. Then we can simply add edges together to one spline. Otherwise, just create new spline. """ if len(subst)>0: if e2 in subst[0][0]: subst[0][0]=edgesSubst+subst[0][0] subst[0][2]=list(set(loops+subst[0][2])) subst[0][1].vertices=vertices+subst[0][1].vertices else: spline=self.domain.addBSpline(vertices+[e1.getLastVertex(self.orientations[i])]) subst.append([edgesSubst,spline,loops]) else: spline=self.domain.addBSpline(vertices+[e1.getLastVertex(self.orientations[i])]) subst.append([edgesSubst,spline,loops]) # Set back Bookkeeping variables appending=False edgesSubst=[] vertices=[] # Replace edges from loops with spline. for sub in subst: for loop in sub[2]: try: idx1=loop.edges.index(sub[0][0]) idx2=loop.edges.index(sub[0][-1]) except IndexError: printWarning("approxBySpline: Cannot find index of either first or last edge.") if idx1>idx2: idxInsert=idx2 else: idxInsert=idx1 for e in sub[0]: try: loop.edges.remove(e) except ValueError: printWarning("approxBySpline: Cannot remove edge "+str(e.Id)+" from loop"+loop.Id +".") loop.edges.insert(idxInsert,sub[1]) if debug: print "Substituted edges ", sub[0][0].Id , "-", sub[0][-1].Id, " with spline ", sub[1].Id # Remove edges from domain. for sub in subst: for e in sub[0]: e.delete(debug=debug) return nEdges>len(self.edges) def includedInSurface(self): """Checks if loop is included in a surface. Returns: tuple: Tuple containing: * included (bool): True if included. * loops (list): List of :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.ruledSurface` objects that include loop. """ surfaces=[] for surface in self.domain.ruledSurfaces: if self==surface.lineLoop: surfaces.append(surface) return len(surfaces)>0,surfaces def delete(self,debug=False): """Deletes loop if it is not used in any surface. Returns: bool: True if deletion was successful. """ incl,surfaces=self.includedInSurface() if incl: printWarning("Was not able to delete loop with ID " + str(self.Id) +". Still part of " + str(len(surfaces)) + " surfaces.") return False self.domain.lineLoops.remove(self) return True def removeFromSurface(self,surface): """Removes lineLoop from surface. """ if self==surface.lineLoop: surface.lineLoop=None def removeFromAllSurfaces(self): """Removes lineLoop from all surfaces. """ for surface in self.domain.ruledSurfaces: self.removeFromSurface(surface) def isCoplanar(self): """Returns if all edges lie in single plane. Does this by * picking the first two vertices as first vector ``vec1 = v1 - v0`` * looping through vertices and computung the normal vector between ``vec1`` and ``vec2=v[i]-v0``. * Checking if all normal vectors are colinear. Returns: bool: True if coplanar. """ #Get vertex coordinates coords=pyfrp_misc_module.objAttrToList(self.getVertices(),'x') #Compute normals normals=[] for i in range(2,len(coords)): n=pyfrp_geometry_module.computeNormal([coords[0],coords[1],coords[i]]) normals.append(n) #Check if normals are all colinear b=[] for i in range(1,len(normals)): # Make sure to skip normal vectors produced from colinear vectors if sum(normals[i])==0: continue b.append(pyfrp_geometry_module.checkColinear(normals[0],normals[i])) return sum(b)==len(b) def getCenterOfMass(self): """Computes center of mass of surface. Returns: numpy.ndarray: Center of mass. """ coords=np.array(pyfrp_misc_module.objAttrToList(self.getVertices(),'x')) return pyfrp_idx_module.getCenterOfMass(coords) def getEdges(self): """Returns list of edges included in lineLoop.""" return self.edges def getSubElements(self): """Returns all elements that define this element. Returns: list: List of elements. """ return self.getEdges() class ruledSurface(gmshElement): """ruledSurface class storing information from gmsh .geo. Args: domain (pyfrp.modules.pyfrp_gmsh_geometry.domain): Domain surface belongs to. loopID (int): ID of surrounding loop. Id (int): ID of surface. """ def __init__(self,domain,loopID,ID): gmshElement.__init__(self,domain,ID) self.initLineLoop(loopID) def initLineLoop(self,loopID,debug=False,addPoints=False,iterations=2): """Checks length of lineLoop and if length of lineLoop is greater than 4, will perform triangulation so Gmsh can handle surface.""" #Get lineLoop self.lineLoop=self.domain.getLineLoopById(loopID)[0] #Check if there is a line loop if self.lineLoop==False: return False,[] #Check length if len(self.lineLoop.edges)<=4: return False,[] #Compute normal vector oldNormal=self.getNormal() #Create triangulation rmat=self.rotateToPlane('xy') newNormal=self.getNormal() #Get vertices vertices=self.getVertices() coords=pyfrp_misc_module.objAttrToList(vertices,'x') #Get maximum volSize of vertices maxVolSize=max(pyfrp_misc_module.objAttrToList(vertices,'volSize')) #Get coordinates in plane coordsPlane=np.asarray(coords)[:,np.where(abs(self.normal)!=1)[0]] #Triangulate tri,coordsTri = pyfrp_idx_module.triangulatePoly(coordsPlane,addPoints=addPoints,iterations=iterations,debug=True) #Add 3D dimension to coordsTri coordsTri=np.concatenate((coordsTri,coords[0][2]*np.ones((coordsTri.shape[0],1))),axis=1) #Loop through each triangle surfacesCreated=[] vertices=[] for i in range(len(tri)): edges=[] #Loop through each vertex for j in range(len(tri[i])): #Get first vertex, create it if necessary v1=self.domain.getVertexByX(coordsTri[tri[i][j]])[0] if v1==False: v1=self.domain.addVertex(coordsTri[tri[i][j]],volSize=maxVolSize) #Get second vertex, create it if necessary v2=self.domain.getVertexByX(coordsTri[tri[i][pyfrp_misc_module.modIdx(j+1,tri[i])]])[0] if v2==False: v2=self.domain.addVertex(coordsTri[tri[i][pyfrp_misc_module.modIdx(j+1,tri[i])]],volSize=maxVolSize) #Check if edge already exists if not self.domain.getEdgeByVertices(v1,v2)[0]: edges.append(self.domain.addLine(v1,v2)) else: edges.append(self.domain.getEdgeByVertices(v1,v2)[0]) #Remember vertices so we can use them later for turning everything back. vertices=vertices+[v1,v2] #Add line loop edgeIDs=pyfrp_misc_module.objAttrToList(edges,"Id") loop=self.domain.addLineLoop(edgeIDs=edgeIDs) loop.checkClosed(fix=False,debug=False) loop.fix() #Add ruledSurface if necessary if i==0: self.lineLoop=loop else: snew=self.domain.addRuledSurface(lineLoopID=loop.Id) surfacesCreated.append(snew) #Delete original loop self.domain.lineLoops.remove(self.domain.getLineLoopById(loopID)[0]) #Remove duplicates in vertices list. vertices=pyfrp_misc_module.remRepeatsList(vertices) #Rotate back for v in vertices: v.x=np.dot(v.x,rmat.T) return True,surfacesCreated def normalToPlane(self): """Checks if surface lies within either x-y-/x-z-/y-z-plane. Does this by checking if ``1.`` is in the normal vector. Returns: bool: True if in plane. """ return 1. in self.normal def isCoplanar(self): """Returns if surface lies in single plane. Returns: bool: True if coplanar. """ return self.lineLoop.isCoplanar() def getCenterOfMass(self): """Computes center of mass of surface. Returns: numpy.ndarray: Center of mass. """ return self.lineLoop.getCenterOfMass() def getNormal(self,method='cross'): """Computes normal to surface. First checks if surface is coplanar using :py:func:`pyfrp.modules.pyfrp_gmsh_geometry.ruledSurface.isCoplanar`. Then finds two independent vectors that span surface and passes them on to :py:func:`pyfrp.modules.pyfrp_geometry_module.computeNormal`. Currently there are two methods available: * ``cross``, see also :py:func:`normalByCross`. * ``newells``, see also :py:func:`newells`. If method is unknown, will fall back to ``cross``. Keyword Args: method (str): Method of normal computation. Returns: numpy.ndarray: Normal vector to surface. """ if not self.isCoplanar(): printWarning("Surface " + str(self.Id) + " is not coplanar. The resulting normal vector might thus be not correct.") #Get vertices vertices=self.lineLoop.getVertices() #Find non-colinear vertices vec1=vertices[1].x-vertices[0].x idx=None for i in range(2,len(vertices)): tempVec=vertices[i].x-vertices[0].x if not pyfrp_geometry_module.checkColinear(vec1,tempVec): idx=i break if idx==None: printError("All points in surface "+str(self.Id) + " seem to be colinear. Will not be able to compute normal.") print self.Id self.draw(ann=True) print pyfrp_misc_module.objAttrToList(self.lineLoop.getVertices(),'Id') raw_input() return np.zeros((3,)) #Compute normal coords=[vertices[0].x,vertices[1].x,vertices[idx].x] self.normal=pyfrp_geometry_module.computeNormal(coords,method=method) return self.normal def writeToFile(self,f): """Writes ruled surface to file. Args: f (file): File to write to. Returns: file: File. """ f.write("Ruled Surface("+str(self.Id)+")= {"+str(self.lineLoop.Id)+ "};\n" ) return f def addToBoundaryLayer(self,boundField=None,**fieldOpts): """Adds surface to a boundary layer field. If no field is given, will create new one with given parameters and add it to a minField. If no minField exists, will create a new one too and set it as background field. See also :py:func:`pyfrp.modules.pyfrp_gmsh_geometry.domain.addBoundaryLayerField` :py:func:`pyfrp.modules.pyfrp_gmsh_geometry.domain.addMinField` and :py:func:`pyfrp.modules.pyfrp_gmsh_geometry.domain.genMinBkgd`. Keyword Args: boundField (pyfrp.modules.pyfrp_gmsh_geometry.boundaryLayerField): Boundary layer field object. fieldOpts (dict): See documentation of boundary layer field of all available options. Returns: pyfrp.modules.pyfrp_gmsh_geometry.boundaryLayerField: Boundary layer field around edge. """ #Generate boundary field if not given if boundField==None: boundField=self.domain.addBoundaryLayerField() #Add Vertex boundField.addFaceByID(self.Id) #Set options boundField.setFieldAttributes(**fieldOpts) #Generate background field self.domain.genMinBkgd(FieldsList=[boundField.Id]) return boundField def hasCommonEdge(self,surface): """Checks if surface has common edge with other surface. Args: surface (pyfrp.modules.pyfrp_gmsh_geometry.ruledSurface): Surface object. Returns: tuple: Tuple containing: * hasCommon (bool): True if loops have common edge. * e (pyfrp.modules.pyfrp_gmsh_geometry.edge): Edge that is in common. """ return self.lineLoop.hasCommonEdge(surface.lineLoop) def fuse(self,surface,maxL=1000,debug=False,sameNormal=False): """Fuses surface with another surface. Will not do anything if surfaces do not have an edge in common. """ if not self.hasCommonEdge(surface)[0]: if debug: printWarning("Cannot fuse surface with ID " + str(self.Id) + " and surface with ID "+ str(surface.Id) +" . Surfaces do not have common edge.") return False if not self.hasSameNormal(surface): if sameNormal: if debug: printWarning("Cannot fuse surface with ID " + str(self.Id) + " and surface with ID "+ str(surface.Id) +" . Not same normal, but sameNormal="+str(sameNormal)) return False if debug: printWarning("Fusing surface with ID " + str(self.Id) + " and surface with ID "+ str(surface.Id) +" will alter surface normal.") b=self.lineLoop.fuse(surface.lineLoop,maxL=maxL,debug=debug,surface=surface) if b: surface.removeFromAllLoops() surface.delete() return b def removeFromAllLoops(self): """Removes surface from all surface loops. """ for loop in self.domain.surfaceLoops: if self in loop.surfaces: loop.surfaces.remove(self) def hasSameNormal(self,surface,sameOrientation=False): """Checks if sufrace has the same normal vector as another surface. Args: surface (pyfrp.modules.pyfrp_gmsh_geometry.ruledSurface): Surface object. Keyword Args: sameOrientation (bool): Forces surfaces to also have same orientation. Returns: bool: True if same normal vector. """ # Compute Normals self.getNormal() surface.getNormal() if sameOrientation: if pyfrp_misc_module.compareVectors(self.normal,surface.normal): return True else: if pyfrp_misc_module.compareVectors(self.normal,surface.normal) or pyfrp_misc_module.compareVectors(self.normal,-surface.normal): return True return False def includedInLoop(self): """Checks if surface is included in a surfaceLoop. Returns: tuple: Tuple containing: * included (bool): True if included. * loops (list): List of :py:class:`pyfrp.modules.pyfrp_gmsh_geometry.surfaceLoops` objects that include surface. """ loops=[] for loop in self.domain.surfaceLoops: if self in loop.surfaces: loops.append(loop) return len(loops)>0,loops def delete(self): """Deletes surface if it is not used in any surfaceLoop. Returns: bool: True if deletion was successful. """ incl,loops=self.includedInLoop() if incl: printWarning("Was not able to delete loop with ID " + str(self.Id) +". Still part of " + str(len(loops)) + " loops.") return False self.domain.ruledSurfaces.remove(self) return True def draw(self,ax=None,color='b',edgeColor='k',drawLoop=True,ann=None,alpha=0.2,backend='mpl',linewidth=1): """Draws surface and fills it with color. .. note:: If ``ann=None``, will set ``ann=False``. .. note:: If no axes is given, will create new one. .. warning:: Does not work for surfaces surrounded by arcs yet. Keyword Args: ax (matplotlib.axes): Matplotlib axes to be plotted in. color (str): Color of surface. ann (bool): Show annotations. edgeColor (str): Color of lineLoop around. alpha (float): Transparency of surface. Returns: matplotlib.axes: Axes. """ if backend!='mpl': printError("Cannot draw surface with backend="+backend+". Currently not supported") return ax if ann==None: ann=False if ax==None: fig,axes = pyfrp_plot_module.makeGeometryPlot() ax=axes[0] if drawLoop: ax=self.lineLoop.draw(ax=ax,color=edgeColor,ann=False,linewidth=linewidth) for e in self.lineLoop.edges: if e in self.domain.arcs: printWarning("Cannot draw surface " + str(self.Id) + " yet. Surfaces including arcs are not supported yet.") return ax #Get Vertex coordinates in the form we want (this is probably unnecessarily complicated) vertices=self.lineLoop.getVertices() coords=pyfrp_misc_module.objAttrToList(vertices,'x') coords=np.asarray(coords) coords = zip(coords[:,0], coords[:,1], coords[:,2]) coordsNew=[] coordsNew.append(list(coords)) #Add collection coll=Poly3DCollection(coordsNew,alpha=alpha) coll.set_facecolor(color) ax.add_collection3d(coll) #annotation if ann: com=pyfrp_idx_module.getCenterOfMass(np.array(pyfrp_misc_module.objAttrToList(vertices,'x'))) ax.text(com[0],com[1],com[2], "s"+str(self.Id), None) #Redraw pyfrp_plot_module.redraw(ax) return ax def getVertices(self): """Returns all vertices included in surface.""" if self.lineLoop==None: return [] else: return self.lineLoop.getVertices() def getEdges(self): """Returns all edges included in surface.""" if self.lineLoop==None: return [] else: return self.lineLoop.getEdges() def rotateToNormal(self,normal,ownNormal=None): """Rotates surface such that it lies in the plane with normal vector ``normal``. See also :py:func:`pyfrp.modules.pyfrp_geometry_module.getRotMatrix`. Args: normal (numpy.ndarray): Normal vector. Returns: numpy.ndarray: Rotation matrix. """ if ownNormal==None: ownNormal=self.getNormal() if pyfrp_geometry_module.checkColinear(normal,ownNormal): rmat=np.identity(3) else: rmat=pyfrp_geometry_module.getRotMatrix(normal,ownNormal) # Rotate for v in self.getVertices(): v.x=np.dot(v.x,rmat) return rmat def rotateToSurface(self,s): """Rotates surface such that it lies in the same plane as a given surface. See also :py:func:`pyfrp.modules.pyfrp_geometry_module.getRotMatrix`. Args: s (pyfrp.modules.pyfrp_gmsh_geometry.ruledSurface): A surface. Returns: numpy.ndarray: Rotation matrix. """ return self.rotateToNormal(s.getNormal()) def rotateToPlane(self,plane): """Rotates surface such that it lies in plane. See also :py:func:`pyfrp.modules.pyfrp_geometry_module.getRotMatrix`. Possible planes are: * ``xy`` * ``xz`` * ``yz`` Args: plane (str): Plane to rotate to. Returns: numpy.ndarray: Rotation matrix. """ if plane=="xz": normal=np.array([0,0,1.]) elif plane=="yz": normal=np.array([1.,0,0]) elif plane=="xy": normal=np.array([0,0,1.]) else: printError("Do not know the plane " +plane +". Will not rotate plane") return return self.rotateToNormal(normal) def getSubElements(self): """Returns all elements that define this element. Returns: list: List of elements. """ return [self.lineLoop] class surfaceLoop(gmshElement): """surfaceLoop class storing information from gmsh .geo. Args: domain (pyfrp.modules.pyfrp_gmsh_geometry.domain): Domain loop belongs to. surfaceIDs (list): List of surfaces. Id (int): ID of loop. """ def __init__(self,domain,surfaceIDs,ID): gmshElement.__init__(self,domain,ID) self.surfaces=self.initSurfaces(surfaceIDs) def initSurfaces(self,IDs): """Constructs ``surfaces`` list at object initiations from list of IDs. Args: IDs (list): List of IDs. Returns: list: List of pyfrp.modules.pyfrp_gmsh_geometry.ruledSurface objects. """ self.surfaces=[] for ID in IDs: self.addSurfaceByID(ID) return self.surfaces def addSurfaceByID(self,ID): """Adds surface to surfaceloop. Args: ID (int): ID of surface to be added. Returns: list: Updated surfaceIDs list. """ self.surfaces.append(self.domain.getRuledSurfaceById(ID)[0]) return self.surfaces def insertSurfaceByID(self,ID,pos): """Inserts surface to surfaceloop at position. Args: ID (int): ID of surface to be inserted. pos (int): Position at which ID to be inserted. Returns: list: Updated surfaceIDs list. """ self.surfaces.insert(pos,self.domain.getRuledSurfaceById(ID)[0]) return self.surfaces def removeSurfaceByID(self,ID): """Remove surface from surfaceloop. Args: ID (int): ID of surface to be removed. Returns: list: Updated surfaceIDs list. """ self.surfaces.remove(self.domain.getRuledSurfaceById(ID)[0]) return self.surfaces def writeToFile(self,f): """Writes surface loop to file. Args: f (file): File to write to. Returns: file: File. """ f.write("Surface Loop("+str(self.Id)+")= {" ) for i,s in enumerate(self.surfaces): f.write(str(s.Id)) if i!=len(self.surfaces)-1: f.write(",") else: f.write("};\n") return f def getSubElements(self): """Returns all elements that define this element. Returns: list: List of elements. """ return self.surfaces class volume(gmshElement): """Volume class storing information from gmsh .geo. Args: domain (pyfrp.modules.pyfrp_gmsh_geometry.domain): Domain surface belongs to. surfaceLoopID (int): ID of surrounding surface loop. Id (int): ID of surface loop. """ def __init__(self,domain,surfaceLoopID,ID): gmshElement.__init__(self,domain,ID) self.surfaceLoop=self.domain.getSurfaceLoopById(surfaceLoopID)[0] def writeToFile(self,f): """Writes Volume to file. Args: f (file): File to write to. Returns: file: File. """ f.write("Volume("+str(self.Id)+")= {"+str(self.surfaceLoop.Id)+ "};\n" ) return f def getSubElements(self): """Returns all elements that define this element. Returns: list: List of elements. """ return [self.surfaceLoop] class field(gmshElement): """Field class storing information from gmsh .geo. Args: domain (pyfrp.modules.pyfrp_gmsh_geometry.domain): Domain surface belongs to. Id (int): ID of field. typ (str): Type of field. """ def __init__(self,domain,typ,Id): gmshElement.__init__(self,domain,Id) self.typ=typ def setAsBkgdField(self): """Sets this mesh as background field for the whole domain. """ self.domain.bkgdField=self def isBkgdField(self): """Returns true if field is background field. Returns: bool: True if background field. """ return self.domain.bkgdField==self def setFieldAttr(self,name,val): """Sets attribute of field. .. note:: Value can have any data type. Args: name (str): Name of attribute. val (str): Value. """ setattr(self,name,val) def setFieldAttributes(self,**kwargs): """Sets multiple field attributes. """ for key, value in kwargs.iteritems(): self.setFieldAttributes(key,value) def getSubElements(self): """Returns all elements that define this element. Returns: list: List of elements. """ return [] class boxField(field): """Box field class storing information from gmsh .geo. Subclasses from :py:class:`field`. Args: domain (pyfrp.modules.pyfrp_gmsh_geometry.domain): Domain surface belongs to. Id (int): ID of field. Keyword Args: volSizeIn (float): Mesh element volume inside box. volSizeOut (float): Mesh element volume outside box. xRange (list): Range of box field in x-direction given as ``[minVal,maxVal]``. yRange (list): Range of box field in y-direction given as ``[minVal,maxVal]``. zRange (list): Range of box field in z-direction given as ``[minVal,maxVal]``. """ def __init__(self,domain,Id,volSizeIn=10.,volSizeOut=20.,xRange=[],yRange=[],zRange=[]): field.__init__(self,domain,"box",Id) self.VOut=volSizeIn self.VIn=volSizeOut self.initBox(xRange,yRange,zRange) def initBox(self,xRange,yRange,zRange): """Initializes bounding box. """ self.setRange('X',xRange) self.setRange('Y',yRange) self.setRange('Z',zRange) def setRange(self,coord,vec): """Sets the bounding box range along a given axis. Args: coord (str): Axis along range is set (``"X","Y","Z"``) vec (list): Range of box ``[minVal,maxVal]`` Returns: tuple: Tuple containing: * coordMin (float): New minimum value. * coordMax (float): New maximum value. """ try: setattr(self,coord+"Min",vec[0]) setattr(self,coord+"Max",vec[1]) except IndexError: setattr(self,coord+"Min",None) setattr(self,coord+"Max",None) return getattr(self,coord+"Min"),getattr(self,coord+"Max") def writeToFile(self,f): """Writes box field to file. See also :py:func:`pyfrp.modules.pyfrp_gmsh_IO_module.writeBoxField`. Args: f (file): File to write to. Returns: file: File. """ f=pyfrp_gmsh_IO_module.writeBoxField(f,self.Id,self.VIn,self.VOut,[self.XMin,self.XMax],[self.YMin,self.YMax],[self.ZMin,self.ZMax]) if self.isBkgdField(): f=pyfrp_gmsh_IO_module.writeBackgroundField(f,self.Id) return f def getSubElements(self): """Returns all elements that define this element. Returns: list: List of elements. """ return [] class attractorField(field): """Attractor field class storing information from gmsh .geo. Subclasses from :py:class:`field`. Args: domain (pyfrp.modules.pyfrp_gmsh_geometry.domain): Domain surface belongs to. Id (int): ID of field. Keyword Args: NodesList (list): List of IDs of the Nodes that attractor field centers around. """ def __init__(self,domain,Id,NodesList=[]): field.__init__(self,domain,"attractor",Id) self.NodesList=self.initNodesList(NodesList) def initNodesList(self,NodesList): """Adds a list of vertices to NodesList. See also :py:func:`addNodeByID`. Args: NodesList (list): List of vertex IDs. Returns: list: Updated NodesList. """ self.NodesList=[] for Id in NodesList: self.addNodeByID(Id) return self.NodesList def addNodeByID(self,ID): """Adds vertex object to NodesList given the ID of the vertex. Args: ID (int): ID of vertex to be added. Returns: list: Updated NodesList. """ v,b=self.domain.getVertexById(ID) if isinstance(b,int): self.NodesList.append(v) return self.NodesList def setFieldAttr(self,name,val): """Sets field attribute. .. note:: Value can have any data type. Args: name (str): Name of attribute. val (float): Value of attribute. """ if name=="NodesList": self.initNodesList(val) else: setattr(self,name,val) def writeToFile(self,f): """Writes attractor field to file. See also :py:func:`pyfrp.modules.pyfrp_gmsh_IO_module.writeAttractorField`. Args: f (file): File to write to. Returns: file: File. """ f=pyfrp_gmsh_IO_module.writeAttractorField(f,self.Id,pyfrp_misc_module.objAttrToList(self.NodesList,'Id')) if self.isBkgdField(): f=pyfrp_gmsh_IO_module.writeBackgroundField(f,self.Id) return f def includedInThresholdField(self): """Returns all the threshholdFields where attractorField is included in. Returns: list: List of threshholdField objects. """ threshFields=self.domain.getAllFieldsOfType("threshold") included=[] for tField in threshFields: if tField.IField==self.Id: included.append(tField) return included def getSubElements(self): """Returns all elements that define this element. Returns: list: List of elements. """ return self.NodesList class thresholdField(field): """Threshold field class storing information from gmsh .geo. Subclasses from :py:class:`field`. Args: domain (pyfrp.modules.pyfrp_gmsh_geometry.domain): Domain surface belongs to. Id (int): ID of field. Keyword Args: IField (int): ID of vertex that is center to threshold field. LcMin (float): Minimum volSize of threshold field. LcMax (float): Maximum volSize of threshold field. DistMin (float): Minimun density of field. DistMax (float): Maximum density of field. """ def __init__(self,domain,Id,IField=None,LcMin=5.,LcMax=20.,DistMin=30.,DistMax=60.): field.__init__(self,domain,"threshold",Id) self.IField=IField self.LcMin=LcMin self.LcMax=LcMax self.DistMin=DistMin self.DistMax=DistMax def writeToFile(self,f): """Writes threshold field to file. See also :py:func:`pyfrp.modules.pyfrp_gmsh_IO_module.writeThresholdField`. Args: f (file): File to write to. Returns: file: File. """ f=pyfrp_gmsh_IO_module.writeThresholdField(f,self.Id,self.IField,self.LcMin,self.LcMax,self.DistMin,self.DistMax) if self.isBkgdField(): f=pyfrp_gmsh_IO_module.writeBackgroundField(f,self.Id) return f def getSubElements(self): """Returns all elements that define this element. Returns: list: List of elements. """ return [self.getDomain().getVertexById(self.IField)] class minField(field): """Minimum field class storing information from gmsh .geo. Subclasses from :py:class:`field`. Args: domain (pyfrp.modules.pyfrp_gmsh_geometry.domain): Domain surface belongs to. Id (int): ID of field. Keyword Args: FieldsList (list): List of field IDs. """ def __init__(self,domain,Id,FieldsList=[]): field.__init__(self,domain,"min",Id) self.FieldsList=self.initFieldsList(FieldsList) def setFieldAttr(self,name,val): if name=="FieldsList": self.initFieldsList(val) else: setattr(self,name,val) def initFieldsList(self,FieldsList): """Adds a list of vertices to NodesList. See also :py:func:`addNodeByID`. Args: FieldsList (list): List of field IDs. Returns: list: Updated FieldsList. """ self.FieldsList=[] for Id in FieldsList: self.addFieldByID(Id) return self.FieldsList def addFieldByID(self,ID): """Adds field object to FieldsList given the ID of the field. Args: ID (int): ID of field to be added. Returns: list: Updated FieldsList. """ f,b=self.domain.getFieldById(ID) if isinstance(b,int): self.FieldsList.append(f) return self.FieldsList def writeToFile(self,f): """Writes minimum field to file. See also :py:func:`pyfrp.modules.pyfrp_gmsh_IO_module.writeMinField`. Args: f (file): File to write to. Returns: file: File. """ f=pyfrp_gmsh_IO_module.writeMinField(f,self.Id,pyfrp_misc_module.objAttrToList(self.FieldsList,'Id')) if self.isBkgdField(): f=pyfrp_gmsh_IO_module.writeBackgroundField(f,self.Id) return f def addAllFields(self): """Adds all fields in domain to FieldsList if not already in there. Returns: list: Updated FieldsList. """ for f in self.domain.fields: if f not in self.FieldsList and f!=self: self.FieldsList.append(f) return self.FieldsList def getSubElements(self): """Returns all elements that define this element. Returns: list: List of elements. """ return self.FieldsList class boundaryLayerField(field): r"""Boundary Layer field class storing information from gmsh .geo. Creates boundary layer mesh around vertices, edges or surfacesin geometry. Boundary layer density is given by .. math:: h_{wall} * ratio^{(dist/h_{wall})}. Subclasses from :py:class:`field`. Example: Adding a box surrounded with a boundary layer to a geometry: >>> vertices,lines,loops,surfaces,sloops,vols=d.addCuboidByParameters([256-50,256-50,-160],100,100,120,10,genVol=False) Adjust volSize: >>> d.setGlobalVolSize(30.) Add boundary layer: >>> volSizeLayer=10. >>> blf=d.addBoundaryLayerField(hfar=volSizeLayer,hwall_n=volSizeLayer,hwall_t=volSizeLayer,thickness=30.,Quads=0.) >>> blf.addFaceListByID(pyfrp_misc_module.objAttrToList(surfaces,'Id')) >>> blf.setAsBkgdField() >>> d.draw() .. image:: ../imgs/pyfrp_gmsh_geometry/boundaryLayerField_geometry.png Write to file: >>> d.writeToFile("dome_boundary.geo") Generate mesh: >>> fnMesh=pyfrp_gmsh_module.runGmsh("dome_boundary.geo") >>> m=pyfrp_mesh.mesh(None) >>> m.setFnMesh(fnMesh) >>> m.plotMesh() .. image:: ../imgs/pyfrp_gmsh_geometry/boundaryLayerField_mesh.png See also http://gmsh.info/doc/texinfo/gmsh.html#Specifying-mesh-element-sizes . Args: domain (pyfrp.modules.pyfrp_gmsh_geometry.domain): Domain surface belongs to. Id (int): ID of field. Keyword Args: AnisoMax (float): Threshold angle for creating a mesh fan in the boundary layer. IntersectMetrics (int): Intersect metrics of all faces. Quad (int): Generate recombined elements in the boundary layer. har (float): Element size far from the wall. hwall_n (float): Mesh Size Normal to the The Wall. hwall_t (float): Mesh Size Tangent to the Wall. ratio (float): Size Ratio Between Two Successive Layers. thickness (float): Maximal thickness of the boundary layer. List (list): List of field IDs. """ def __init__(self,domain,Id,AnisoMax=10000000000,hwall_n=1.,hwall_t=1,ratio=1.1,thickness=10.,hfar=1.,IntersectMetrics=1,Quads=0.): field.__init__(self,domain,"boundaryLayer",Id) self.AnisoMax=AnisoMax self.Quads=Quads self.hfar=hfar self.hwall_n=hwall_n self.hwall_t=hwall_t self.IntersectMetrics=IntersectMetrics self.ratio=ratio self.thickness=thickness self.EdgesList=[] self.FacesList=[] self.FanNodesList=[] self.FansList=[] self.NodesList=[] def addEdgeListByID(self,IDs): """Adds a list of edge objects to EdgesList given the ID of the edges. Args: IDs (list): List of IDs of edges to be added. Returns: list: Updated EgesList. """ for ID in IDs: self.addEdgeByID(ID) return self.EdgesList def addFaceListByID(self,IDs): """Adds a list of surfaces objects to FacesList given the ID of the surfaces. Args: IDs (list): List of IDs of surfaces to be added. Returns: list: Updated FacesList. """ for ID in IDs: self.addFaceByID(ID) return self.FacesList def addNodeListByID(self,IDs): """Adds a list of vertex objects to NodesList given the ID of the vertex. Args: IDs (list): List of IDs of vertices to be added. Returns: list: Updated NodesList. """ for ID in IDs: self.addNodeByID(ID) return self.NodesList def addEdgeByID(self,ID): """Adds edge object to EdgesList given the ID of the edge. Args: ID (int): ID of edge to be added. Returns: list: Updated EgesList. """ v,b=self.domain.getEdgeById(ID) if isinstance(b,int): self.EdgesList.append(v) return self.EdgesList def addFaceByID(self,ID): """Adds surface object to FacesList given the ID of the surface. Args: ID (int): ID of surface to be added. Returns: list: Updated FacesList. """ v,b=self.domain.getRuledSurfaceById(ID) if isinstance(b,int): self.FacesList.append(v) return self.FacesList def addNodeByID(self,ID): """Adds vertex object to NodesList given the ID of the vertex. Args: ID (int): ID of vertex to be added. Returns: list: Updated NodesList. """ v,b=self.domain.getVertexById(ID) if isinstance(b,int): self.NodesList.append(v) return self.NodesList def buildElementDict(self): """Builds element dictionary for writing to file. """ elements={} for elmnt in ["EdgesList","FacesList","NodesList"]: if len(getattr(self,elmnt))>0: elements[elmnt]=pyfrp_misc_module.objAttrToList(getattr(self,elmnt),'Id') return elements def writeToFile(self,f): """Writes boundaryLayerField to file. See also :py:func:`pyfrp.modules.pyfrp_gmsh_IO_module.writeBoundaryLayerField`. Args: f (file): File to write to. Returns: file: File. """ #elements=pyfrp_misc_module.objAttr2Dict(self,attr=["EdgesList","FacesList","NodesList"]) elements=self.buildElementDict() fieldOpts=pyfrp_misc_module.objAttr2Dict(self,attr=["AnisoMax","hwall_n","hwall_t","ratio","thickness","hfar","IntersectMetrics","Quads"]) f=pyfrp_gmsh_IO_module.writeBoundaryLayerField(f,self.Id,elements,fieldOpts) if self.isBkgdField(): f=pyfrp_gmsh_IO_module.writeBackgroundField(f,self.Id) return f def getSubElements(self): """Returns all elements that define this element. Returns: list: List of elements. """ return [self.FacesList,self.EdgesList,self.NodesList] def setFieldAttr(self,name,val): """Sets field attribute. .. note:: Value can have any data type. Args: name (str): Name of attribute. val (float): Value of attribute. """ self.EdgesList=[] self.FacesList=[] self.FanNodesList=[] self.FansList=[] self.NodesList=[] if name=="NodesList": self.addNodeListByID(val) elif name=="FacesList": self.addFaceListByID(val) elif name=="EdgesList": self.addEdgeListByID(val) else: setattr(self,name,val)
gpl-3.0
ivoflipse/devide
testing/matplotlib_tests.py
7
2426
"""Module to test basic matplotlib functionality. """ import os import unittest import tempfile class MPLTest(unittest.TestCase): def test_figure_output(self): """Test if matplotlib figure can be generated and wrote to disc. """ # make sure the pythonshell is running self._devide_app.get_interface()._handler_menu_python_shell(None) # create new figure python_shell = self._devide_app.get_interface()._python_shell f = python_shell.mpl_new_figure() import pylab # unfortunately, it's almost impossible to get pixel-identical # rendering on all platforms, so we can only check that the plot # itself is correct (all font-rendering is disabled) # make sure we hardcode the font! (previous experiment) #pylab.rcParams['font.sans-serif'] = ['Bitstream Vera Sans'] #pylab.rc('font', family='sans-serif') from pylab import arange, plot, sin, cos, legend, grid, xlabel, ylabel a = arange(-30, 30, 0.01) plot(a, sin(a) / a, label='sinc(x)') plot(a, cos(a), label='cos(x)') #legend() grid() #xlabel('x') #ylabel('f(x)') # disable x and y ticks (no fonts allowed, remember) pylab.xticks([]) pylab.yticks([]) # width and height in inches f.set_figwidth(7.9) f.set_figheight(5.28) # and save it to disc filename1 = tempfile.mktemp(suffix='.png', prefix='tmp', dir=None) f.savefig(filename1, dpi=100) # get rid of the figure python_shell.mpl_close_figure(f) # now compare the bugger test_fn = os.path.join(self._devide_testing.get_images_dir(), 'mpl_test_figure_output.png') err = self._devide_testing.compare_png_images(test_fn, filename1) self.failUnless(err == 0, '%s differs from %s, err = %.2f' % (filename1, test_fn, err)) def get_suite(devide_testing): devide_app = devide_testing.devide_app # both of these tests require wx mm = devide_app.get_module_manager() mpl_suite = unittest.TestSuite() if 'matplotlib_kit' in mm.module_kits.module_kit_list: t = MPLTest('test_figure_output') t._devide_app = devide_app t._devide_testing = devide_testing mpl_suite.addTest(t) return mpl_suite
bsd-3-clause
ua-snap/downscale
snap_scripts/epscor_sc/older_epscor_sc_scripts_archive/cru_cl20_1961_1990_climatology_preprocess.py
1
12525
import numpy as np # hack to solve a lib issue in the function args of xyztogrid def cru_xyz_to_shp( in_xyz, lon_col, lat_col, crs, output_filename ): ''' convert the cru cl2.0 1961-1990 Climatology data to a shapefile. *can handle the .dat format even if compressed with .gzip extension. PARAMETERS: ----------- in_xyz = path to the .dat or .dat.gz downloaded cru cl2.0 file from UK Met Office site lon_col = string name of column storing longitudes lat_col = string name of column storing latitudes crs = proj4string or epsg code output_filename = string path to the output filename to be created RETURNS ------- output_filename as string ''' colnames = ['lat', 'lon', '01', '02', '03', '04', '05', '06', '07', '08', '09', '10', '11', '12'] from shapely.geometry import Point import pandas as pd import geopandas as gpd import os if os.path.splitext( in_xyz )[1] == '.gz': cru_df = pd.read_csv( in_xyz, delim_whitespace=True, compression='gzip', header=None, names=colnames ) else: cru_df = pd.read_csv( in_xyz, delim_whitespace=True, header=None, names=colnames ) # create a column named geometry with shapely geometry objects for each row def f( x ): ''' return a Point shapely object for each x,y pair''' return Point( x.lon, x.lat ) cru_df[ 'geometry' ] = cru_df.apply( f, axis=1 ) cru_df = gpd.GeoDataFrame( cru_df ) # convert to GeoDataFrame cru_df.to_file( output_filename, 'ESRI Shapefile' ) return output_filename def bounds_to_extent( bounds ): ''' take input rasterio bounds object and return an extent ''' l,b,r,t = bounds return [ (l,b), (r,b), (r,t), (l,t), (l,b) ] def extent_to_shapefile( extent, output_shapefile, proj4string ): ''' convert an extent to a shapefile using its proj4string ''' import geopandas as gpd from shapely.geometry import Polygon gpd.GeoDataFrame( {'extent_id':1, 'geometry':Polygon( extent )}, index=[1], crs=proj4string ).to_file( output_shapefile, 'ESRI Shapefile' ) return output_shapefile def pad_bounds( rst, npixels, crs, output_shapefile ): ''' convert the extents of 2 overlapping rasters to a shapefile with an expansion of the intersection of the rasters extents by npixels rst1: rasterio raster object rst2: rasterio raster object npixels: tuple of 4 (left(-),bottom(-),right(+),top(+)) number of pixels to expand in each direction. for 5 pixels in each direction it would look like this: (-5. -5. 5, 5) or just in the right and top directions like this: (0,0,5,5). crs: epsg code or proj4string defining the geospatial reference system output_shapefile: string full path to the newly created output shapefile ''' import rasterio, os, sys from shapely.geometry import Polygon resolution = rst.res[0] new_bounds = [ bound+(expand*resolution) for bound, expand in zip( rst.bounds, npixels ) ] new_ext = bounds_to_extent( new_bounds ) return extent_to_shapefile( new_ext, output_shapefile, crs ) def xyz_to_grid( x, y, z, grid, method='cubic', output_dtype=np.float32 ): ''' interpolate points to a grid. simple wrapper around scipy.interpolate.griddata. Points and grid must be in the same coordinate system x = 1-D np.array of x coordinates / x,y,z must be same length y = 1-D np.array of y coordinates / x,y,z must be same length z = 1-D np.array of z coordinates / x,y,z must be same length grid = tuple of meshgrid as made using numpy.meshgrid() order (xi, yi) method = one of 'cubic', 'near', linear ''' import numpy as np from scipy.interpolate import griddata zi = griddata( (x, y), z, grid, method=method ) zi = np.flipud( zi.astype( output_dtype ) ) return zi def crop_to_bounds2( rasterio_rst, bounds, output_filename, mask=None, mask_value=None ): ''' take a rasterio raster object and crop it to a smaller bounding box masking is supported where masked values are 0 and unmasked values are 1 PARAMETERS ---------- rasterio_rst = rasterio raster object bounds = rasterio style bounds (left, bottom, right, top) output_filename = string path to the raster file to be created mask = a 2d numpy array of the same shape as rasterio_rst with masked values = 0 and unmasked = 1 RETURNS ------- file path to the newly created file -- essentially the value of output_filename ''' from rasterio import Affine as A window = rasterio_rst.window( *bounds ) xmin, ymin, xmax, ymax = rasterio_rst.window_bounds( window ) row_res, col_res = rasterio_rst.res arr = rasterio_rst.read( 1, window=window ) if mask: arr[ mask != 1 ] = mask_value nodata = mask_value else: nodata = rasterio_rst.meta[ 'nodata' ] meta = {} meta.update( compress='lzw', affine=A( col_res, 0.0, xmin, 0.0, -row_res, ymax ), height=row_res, width=col_res, transform=[xmin, col_res, 0.0, ymax, 0.0, -row_res], crs=rasterio_rst.meta, nodata=nodata, dtype=rasterio_rst.meta[ 'dtype' ], count=1, driver=u'GTiff' ) with rasterio.open( output_filename, 'w', **meta ) as out: out.write_band( 1, arr ) return output_filename def crop_to_bounds( rasterio_rst, bounds ): ''' crop a raster by a window made from bounds of another domain ''' window = rasterio_rst.window( *bounds ) return rasterio_rst.read( 1, window=window ) def interpolate_akcan( x, y, z, grid, expanded_meta, template_rst, output_filename, method='cubic', output_dtype=np.float32 ): ''' interpolate across the alaska canada domains and crop / mask to that extent ''' cru_interp = xyz_to_grid( x, y, z, grid, method='cubic', output_dtype=np.float32 ) cru_interp = np.nan_to_num( cru_interp ) # convert to in memory rasterio object expanded_meta.update( driver='MEM' ) cru_interpolated = rasterio.open( '', mode='w', **expanded_meta ) cru_interpolated.write_band( 1, cru_interp ) akcan = crop_to_bounds( cru_interpolated, template_rst.bounds ) meta = template_rst.meta meta.update( compress='lzw' ) with rasterio.open( output_filename, 'w', **meta ) as out: mask = template_rst.read_masks( 1 ) akcan[ mask == 0 ] = meta[ 'nodata' ] akcan = np.ma.masked_where( mask == 0, akcan ) akcan.fill_value = meta[ 'nodata' ] out.write_band( 1, akcan ) return output_filename def run( args ): return interpolate_akcan( **args ) if __name__ == '__main__': import os, rasterio, glob, fiona import numpy as np import pandas as pd import geopandas as gpd from rasterio import Affine as A from pathos import multiprocessing as mp import argparse # parse the commandline arguments parser = argparse.ArgumentParser( description='preprocess CRU CL2.0 data to the AKCAN extent required by SNAP' ) parser.add_argument( "-p", "--base_path", action='store', dest='base_path', type=str, help="path to parent directory with a subdirector(ies)y storing the data" ) parser.add_argument( "-cru", "--cru_filename", action='store', dest='cru_filename', type=str, help="string path to the .tar.gz file location, downloaded from the CRU site" ) parser.add_argument( "-v", "--variable", action='store', dest='variable', type=str, help="string abbreviated name of the variable being processed." ) parser.add_argument( "-tr", "--template_raster_fn", action='store', dest='template_raster_fn', type=str, help="string path to a template raster dataset to match the CRU CL2.0 to." ) # base_path = '/workspace/Shared/Tech_Projects/ALFRESCO_Inputs/project_data/TEM_Data' # # open the Climatic Research Unit (CRU) CL2.0 data downloaded from: # # http://www.cru.uea.ac.uk/cru/data/hrg/tmc/ # # cru_filename = os.path.join( cru_folder, 'grid_10min_tmp.dat.gz' # cru_filename = os.path.join( cru_folder, 'grid_10min_sunp.dat.gz' # variable = 'sunp' # parse and unpack the args args = parser.parse_args() base_path = args.base_path cru_filename = args.cru_filename variable = args.variable template_raster_fn = args.template_raster_fn # build an output path to store the data generated with this script cru_path = os.path.join( base_path, 'cru_ts20', variable ) if not os.path.exists( cru_path ): os.makedirs( cru_path ) # read in the gzipped .dat file downloaded from the MET Office UK colnames = [ 'lat', 'lon', '01', '02', '03', '04', '05', '06', '07', '08', '09', '10', '11', '12' ] cru_df = pd.read_csv( cru_filename, delim_whitespace=True, compression='gzip', header=None, names=colnames ) # convert to point shapefile cru_shp_fn = os.path.join( cru_path, 'cru_'+variable+'_ts20_1961_1990_climatology.shp' ) cru_xyz_to_shp( cru_filename, 'lon', 'lat', {'init':'epsg:4326'}, cru_shp_fn ) # template dataset template_raster = rasterio.open( template_raster_fn ) resolution = template_raster.res template_meta = template_raster.meta # pad the bounds of the akcan template dataset crs = { 'init':'epsg:3338' } extent_path = os.path.join( cru_path, 'extents' ) if not os.path.exists( extent_path ): os.makedirs( extent_path ) new_ext_fn = os.path.join( extent_path, 'akcan_extent.shp' ) npixels = ( -200, -2000, 200, 200 ) pad_bounds( template_raster, npixels, crs, new_ext_fn ) # filename for a newly clipped and reprojected shapefile using the above padded bounds shape intermediate_path = os.path.join( cru_path, 'intermediate' ) if not os.path.exists( intermediate_path ): os.makedirs( intermediate_path ) expanded_ext_fn = os.path.join( intermediate_path, variable + '_cru_ts20_1961_1990_climatology_3338_akcan_expanded.shp' ) # reproject / crop to the AKCAN extent, the cru shapefile built above using ogr2ogr os.system( "ogr2ogr -overwrite -f 'ESRI Shapefile' -clipdst " + new_ext_fn + " -s_srs 'EPSG:4326' -t_srs 'EPSG:3338' " + expanded_ext_fn + " " + cru_shp_fn ) # -wrapdateline -- removed since it is not a geog srs output # generate metadata for the expanded extent to interpolate to xmin, ymin, xmax, ymax = fiona.open( new_ext_fn ).bounds cols = (xmax - xmin) / resolution[1] rows = (ymax - ymin) / resolution[0] # copy/update metadata to expanded extent expanded_meta = template_meta expanded_meta[ 'affine' ] = A( resolution[0], 0.0, xmin, 0.0, -resolution[1], ymax ) expanded_meta[ 'crs' ] = { 'init':'epsg:3338' } expanded_meta[ 'height' ] = rows expanded_meta[ 'width' ] = cols expanded_meta[ 'transform' ] = expanded_meta[ 'affine' ].to_gdal() # read in the clipped and reprojected cru shapefile using geopandas cru_gdf = gpd.read_file( expanded_ext_fn ) # update lon and lat to the 3338 cru_gdf.lon = cru_gdf.geometry.apply( lambda x: x.x ) cru_gdf.lat = cru_gdf.geometry.apply( lambda x: x.y ) # build the interpolation input values x = np.array(cru_gdf.lon.tolist()) y = np.array(cru_gdf.lat.tolist()) # build the output grid xi = np.linspace( xmin, xmax, cols ) yi = np.linspace( ymin, ymax, rows ) xi, yi = np.meshgrid( xi, yi ) akcan_path = os.path.join( cru_path, 'akcan' ) if not os.path.exists( akcan_path ): os.makedirs( akcan_path ) # build some args months = ['01','02','03','04','05','06','07','08','09','10','11','12'] output_filenames = [ os.path.join( akcan_path, variable+'_cru_cl20_akcan_'+month+'_1961_1990.tif' ) for month in months ] # run it in parallel -- the pool is not working currently! switching to serial args_list = [ { 'x':x, 'y':y, 'z':np.array(cru_gdf[ month ]), 'grid':(xi,yi), 'expanded_meta':expanded_meta, 'template_rst':template_raster, 'output_filename':out_fn } for month, out_fn in zip( months, output_filenames ) ] # pool = mp.Pool( 4 ) out = map( lambda x: run( x ), args_list ) # out = pool.map( lambda x: run( x ), args_list ) # pool.close() # # # EXAMPLE OF USE # # # # import os # os.chdir( '/workspace/Shared/Tech_Projects/ALFRESCO_Inputs/project_data/CODE/tem_ar5_inputs/downscale_cmip5/bin' ) # cru_folder = '/Data/Base_Data/Climate/World/CRU_grids/CRU_TS20' # # var_fn_dict = { 'hur':os.path.join( cru_folder, 'grid_10min_reh.dat.gz'),'tas':os.path.join( cru_folder, 'grid_10min_tmp.dat.gz'), 'sunp':os.path.join( cru_folder, 'grid_10min_sunp.dat.gz' ) } # var_fn_dict = { 'pre':os.path.join( cru_folder, 'grid_10min_pre.dat.gz' ) } # just a test. # base_path = '/workspace/Shared/Tech_Projects/ALFRESCO_Inputs/project_data/TEM_Data/CRU_TEM_2016' #cru_october_final' # template_raster_fn = '/workspace/Shared/Tech_Projects/ALFRESCO_Inputs/project_data/TEM_Data/templates/tas_mean_C_AR5_GFDL-CM3_historical_01_1860.tif' # for variable, cru_filename in var_fn_dict.iteritems(): # # print 'working on : %s' % variable # os.system( 'ipython -- cru_cl20_1961_1990_climatology_preprocess.py -p ' + base_path + ' -cru ' + cru_filename + ' -v ' + variable + ' -tr ' + template_raster_fn )
mit
yanyuchka/infovisproj-temp
crash_cleaner.py
1
3255
#!/user/bin/python # this python script cleans raw crash data and subsets the last n days of observations import pandas as pd import numpy as np import datetime as dt import re import os import logging dpath = './' def date_parser(ds): if type(ds) == str: return dt.datetime.date(dt.datetime.strptime(ds, "%m/%d/%Y")) else: return np.nan def time_parser(ts): if type(ts) == str: return dt.datetime.time(dt.datetime.strptime(ts, "%H:%M")) else: return np.nan #zip-s war by [email protected] def zip_cleaner(s): if type(s) != str: return np.nan elif re.match('^\d\d\d\d\d$', s): return s elif re.match('^\d\d\d\d\d-\d*$', s): return re.sub('-\d*$', '', s) else: return np.nan def test_zip_cleaner(): assert '12345' == zip_cleaner('12345') assert '12345' == zip_cleaner('12345-1234') assert np.isnan( zip_cleaner(np.nan) ) assert np.isnan( zip_cleaner('1234') ) assert np.isnan( zip_cleaner('0') ) assert np.isnan( zip_cleaner('UNKNOWN')) # read raw crash data def read_crash_csv(data): df = pd.read_csv(data, dtype={ 'DATE' : str, 'TIME' : str, 'BOROUGH': str, 'ZIP CODE': str, 'LATITUDE': np.floating, 'LONGITUDE': np.floating, 'LOCATION' : str, # derived type 'ON STREET NAME' : str, 'CROSS STREET NAME': str, 'OFF STREET NAME' : str, 'NUMBER OF PERSONS INJURED' : np.integer, 'NUMBER OF PERSONS KILLED' : np.integer, 'NUMBER OF PEDESTRIANS INJURED' : np.integer, 'NUMBER OF PEDESTRIANS KILLED' : np.integer, 'NUMBER OF CYCLIST INJURED' : np.integer, 'NUMBER OF CYCLIST KILLED' : np.integer, 'NUMBER OF MOTORIST INJURED' : np.integer, 'NUMBER OF MOTORIST KILLED' : np.integer, 'CONTRIBUTING FACTOR VEHICLE 1' : str, 'CONTRIBUTING FACTOR VEHICLE 2' : str, 'CONTRIBUTING FACTOR VEHICLE 3' : str, 'CONTRIBUTING FACTOR VEHICLE 4' : str, 'CONTRIBUTING FACTOR VEHICLE 5' : str, 'UNIQUE KEY' : np.integer, 'VEHICLE TYPE CODE 1' : str, 'VEHICLE TYPE CODE 2' : str, 'VEHICLE TYPE CODE 3' : str, 'VEHICLE TYPE CODE 4' : str, 'VEHICLE TYPE CODE 5' : str}) df['DATE'] = map(date_parser, df['DATE']) df['TIME'] = map(time_parser, df['TIME']) df['LOCATION'] = zip(df.LATITUDE,df.LONGITUDE) df['ZIP CODE'] = map(zip_cleaner,df['ZIP CODE']) df.columns = [field.replace(" ","_") for field in df.columns] return(df) #subset last n days of crash data and log number of records in data sets def sample_crash_data(n,path,folders): df = read_crash_csv(os.path.join(path,folders[0],'crashdata.csv')) logging.basicConfig(filename=os.path.join(path,folders[1],'sample.log'),level=logging.DEBUG) start = dt.date.today() logging.info('As for %s raw data set contains %s records ...' % (dt.datetime.strftime(start,"%m/%d/%Y %H:%M:%S") ,df.shape[0])) end = dt.date.today()-dt.timedelta(days=n) df_new = df[(df.DATE >= end) & (df.DATE <= start)] df_new.to_csv(os.path.join(path,folders[1],'%sdays_crashdata.csv' %(n)), index=False) logging.info('Raw data set for the last %s days contains %s records' % (n, df_new.shape[0])) # n = 150 days if __name__ == "__main__": sample_crash_data(150,dpath,['rawdata','data'])
mit
typpo/asterank
data/pipeline/run/00_deltav/deltav.py
1
3826
""" Calculates delta-v for asteroids according to Shoemaker and Helin (1978) See http://echo.jpl.nasa.gov/~lance/delta_v/delta_v.rendezvous.html http://echo.jpl.nasa.gov/~lance/delta_v/deltav.13.pl as well """ import sys import numpy as np import operator import pandas as pp if len(sys.argv) < 3: DATA_PATH = 'data/latest_sbdb.csv' DV_TEST_PATH = 'data/deltav/db.csv' OUTPUT_PATH = 'data/deltav/db2.csv' else: DATA_PATH = sys.argv[1] DV_TEST_PATH = sys.argv[2] OUTPUT_PATH = sys.argv[3] print 'Reading', DATA_PATH, '...' df = pp.read_csv(DATA_PATH, index_col='pdes') df.i = df.i * np.pi / 180 # inclination in radians df['Q'] = df.a * (1.0 + df.e) # aphelion def AtensDeltaV(df): """Delta V calculation for Atens asteroids, where a < 1.""" df['ut2'] = 2 - 2*np.cos(df.i/2)*np.sqrt(2*df.Q - df.Q**2) df['uc2'] = 3/df.Q - 1 - (2/df.Q)*np.sqrt(2 - df.Q) df['ur2'] = 3/df.Q - 1/df.a - ( (2/df.Q)*np.cos(df.i/2)*np.sqrt(df.a*(1-df.e**2)/df.Q)) return df def ApollosDeltaV(df): """Delta V calculation for Apollo asteroids, where q <= 1, a >= 1.""" df['ut2'] = 3 - 2/(df.Q + 1) - 2*np.cos(df.i/2)*np.sqrt(2*df.Q/(df.Q+1)) df['uc2'] = 3/df.Q - 2/(df.Q+1) - (2/df.Q)*np.sqrt(2/(df.Q+1)) df['ur2'] = 3/df.Q - 1/df.a - ( (2/df.Q)*np.cos(df.i/2)*np.sqrt((df.a/df.Q)*(1-df.e**2))) return df def AmorsDeltaV(df): """Delta V calculation for Amors asteroids, where q > 1 and a >= 1.""" df['ut2'] = 3 - 2/(df.Q+1) - 2*np.cos(df.i/2)*np.sqrt(2*df.Q/(df.Q+1)) df['uc2'] = 3/df.Q - 2/(df.Q+1) - ( (2/df.Q)*np.cos(df.i/2)*np.sqrt(2/(df.Q+1))) df['ur2'] = 3/df.Q - 1/df.a - (2/df.Q)*np.sqrt(df.a*(1-df.e**2)/df.Q) return df atens = AtensDeltaV(df[df.a < 1]) apollos = ApollosDeltaV(df[(df.q <= 1) & (df.a >= 1)]) amors = AmorsDeltaV(df[(df.q > 1) & (df.a >= 1)]) df = pp.concat((atens, apollos, amors)) v_earth = 29.784 # earth orbital velocity U0 = 7.727 / v_earth; # Normalized LEO velocity @ 300km S = np.sqrt(2) * U0 # Normalied escape velocity from LEO # Impulse for leaving LEO. df['ul'] = np.sqrt(df.ut2 + S**2) - U0 # Impulse for rendevouzing at asteroid. df['ur'] = np.sqrt(df.uc2 - ( 2*np.sqrt(df.ur2*df.uc2)*np.cos(df.i/2)) + df.ur2) # Figure of merit, from Shoemaker and Helin. df['F'] = df.ul + df.ur # Delta V. df['dv'] = (30*df.F) + .5 # Import Benner's delta v calculations. print 'Reading', DV_TEST_PATH, '...' df_test = pp.read_csv(DV_TEST_PATH, index_col='pdes') results = df.join(df_test, how='inner', rsuffix='_benner') results['dv_diff'] = (np.abs(results.dv - results.dv_benner) / results.dv_benner) print('\n\n% deviation from known delta-vs:') print(results.dv_diff.describe()) print('\n\n% deviation for Atens:') print(results[results.a < 1].dv_diff.describe()) print('\n\n% deviation for Apollos:') print(results[(results.q <= 1) & (results.a >= 1)].dv_diff.describe()) print('\n\n% deviation for Amors:') print(results[(results.q > 1) & (results.a >= 1)].dv_diff.describe()) print('\n\n30 asteroids with highest error:') outliers = results.sort_values(by=['dv_diff'])[-30:] for pdes, row in outliers.iterrows(): print('%s \t %.3f km/s (expected %.3f km/s) (error %%%.2f)' % ( pdes, row['dv'], row['dv_benner'], row['dv_diff']*100)) df = df.sort_values(by=['dv']) print('\n\n30 asteroids with lowest delta-v:') for pdes, row in df[:30].iterrows(): print('%s \t%.3f km/s' % (pdes, row['dv'])) print '\nWriting results to', OUTPUT_PATH #df.to_csv(OUTPUT_PATH, cols=('dv',)) f = open(OUTPUT_PATH, 'w') f.write('pdes,dv\n') for pdes, row in df.iterrows(): f.write('%s,%f\n' % (pdes, row['dv'])) """ if full_name.find('Klio') > -1: print full_name print row name = row['pdes'] if row['pdes'] != '' else full_name f.write('%s,%f\n' % (name, row['dv'])) """ f.close()
mit
Diviyan-Kalainathan/causal-humans
Cause-effect/model_comparison/generate_test_set.py
1
2620
""" Generation of the test set, w/ permuted vals Author : Diviyan Kalainathan Date : 11/10/2016 """ #ToDo Multiprocess program? import os,sys import pandas as pd from random import randint from random import shuffle import csv from multiprocessing import Pool import numpy from sklearn import metrics inputdata='../output/obj8/pca_var/cluster_5/pairs_c_5.csv' outputfolder='../output/test/' info='../output/obj8/pca_var/cluster_5/publicinfo_c_5.csv' max_proc=int(sys.argv[1]) max_gen=10 if not os.path.exists(outputfolder): os.makedirs(outputfolder) def chunk_job(chunk,part_no): chunk = pd.merge(chunk, publicinfo, on='SampleID') chunk.dropna(how='all') chunk['Pairtype'] = 'O' # Drop flags: chunk = chunk[chunk.SampleID.str.contains('flag')==False] to_add = [] for index, row in chunk.iterrows(): var1 = row['A'] var2 = row['B'] for i in range(max_gen): mode = randint(1, 3) if mode == 1: var1 = var1.split() shuffle(var1) var1 = " ".join(str(j) for j in var1) elif mode == 2: var2 = var2.split() shuffle(var2) var2 = " ".join(str(j) for j in var2) elif mode == 3: var1 = var1.split() shuffle(var1) var1 = " ".join(str(j) for j in var1) var2 = var2.split() shuffle(var2) var2 = " ".join(str(j) for j in var2) to_add.append([row['SampleID'] + '_Probe' + str(i), var1, var2, row['A-Type'], row['B-Type'], 'P']) df2 = pd.DataFrame(to_add, columns=['SampleID', 'A', 'B', 'A-Type', 'B-Type', 'Pairtype']) chunk=pd.concat([chunk,df2],ignore_index=True) sys.stdout.write('Finishing chunk '+str(part_no)+'\n') sys.stdout.flush() # chunk= chunk.iloc[numpy.random.permutation(len(chunk))] #No need to shuffle # chunk.reset_index(drop=True) chunk.to_csv(outputfolder + 'test_crit_p' + str(part_no) + '.csv', sep=';',index=False) outputfile = open(outputfolder + 'test_crit_.csv', 'wb') # Create file writer = csv.writer(outputfile, delimiter=';', lineterminator='\n') writer.writerow(['SampleID', 'A', 'B', 'Pairtype']) outputfile.close() publicinfo=pd.read_csv(info,sep=';') publicinfo.columns=['SampleID','A-Type','B-Type'] chunksize=10**4 data=pd.read_csv(inputdata,sep=';', chunksize=chunksize) print(chunksize) pool=Pool(processes=max_proc) partno=0 for chunk in data: partno+=1 pool.apply_async(chunk_job,args=(chunk,partno,)) pool.close() pool.join()
mit
evanbiederstedt/RRBSfun
scripts/repeat_finder_scripts/faster_repeats/temp_all.py
1
1358
import glob import pandas as pd import numpy as np df1 = pd.read_csv("repeats_hg19.csv") RRBS_files = glob.glob("RRBS*") df_dict = {group : df for group, df in df1.groupby(by="chr")} # In[11]: from numpy import nan def between_range(row, group_dict): # get sub dataframe from dictionary, if key not found return nan subset = group_dict.get(row['chr'], None) if subset is None: return '' # slice subset to get even smaller group subset = subset.loc[subset['start'] <= row['start'], :] # check if subset has any values if subset.empty: return '' # now slice the second time and return only a series of 'labels' subset = subset.loc[subset['end'] >= row['start'], 'repeat_class'] # now you need to decide what to do if there are more than one labels, i have only taken here the first one # return the first label, if empty return nan if subset.empty: return '' else: return subset.iloc[0] # In[12]: from functools import partial from time import time between_range_partial = partial(between_range, group_dict=df_dict) cols = ['chr', 'start'] for filename in RRBS_files: df2 = pd.read_csv(filename, sep="\t") labels = df2.loc[:, cols].apply(between_range_partial, axis=1) df2["repeat_class"] = labels df2.to_csv(filename, sep='\t', index=False)
mit
NMTHydro/Recharge
utils/raster_stacker_jan.py
1
8631
# =============================================================================== # Copyright 2016 gabe-parrish # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # =============================================================================== # ============= standard library imports ======================== import os import rasterio from rasterio import windows import numpy as np from numpy import meshgrid, arange from affine import Affine from pyproj import Proj, transform from utils.pixel_coord_finder import coord_getter from recharge.raster_tools import convert_raster_to_array, convert_array_to_raster import seaborn as sns import matplotlib.pyplot as plt import multiprocessing as mp from utils.tracker_plot import grapher, get_columns import pandas as pd # ============= local library imports =========================== def data_frame_formatter(raster_dictionary): """ :param raster_dictionary: :return: saved csvs Each raster will get written into a dict with certain info, then the dict will get turned into a dataframe and the dataframes will all get merged into one. This will then be exported and saved as a csv. Cool? Cool. dict = {column heading : [list of values]} cols = x(easting), y(northing), nlcd, ETrF, NDVI """ ras_dict = {} print "x, y is done. Starting k, v loop" for k, v in raster_dictionary.iteritems(): #======= #print v[0] #index = np.argwhere(v[0]==0) #non_zero_vals = v[0][v[0] != 0] #v[0].delete(0, index) #print y #======== ras_dict["{}".format(k)] = v[0].ravel().tolist() #v[0].tolist() print "Done wi kv loop" # col_list = ["x", "y"] col_list = [] for key in ras_dict.keys(): col_list.append(key) df = pd.DataFrame(ras_dict, columns=col_list) print "Done with main Dataframe" # AGRICULTURE # This way you get rid of the zero values associated with the unmasked areas. df_ag = df[df['jan_ag_mask_from_maskjanaoi_20110818']>0] # Filter out slope values greater than three df_ag = df_ag[df_ag['slope_degree_20110818']<3] df_ag.to_csv("/Volumes/SeagateExpansionDrive/jan_metric/jan_comparison_ag.csv") print "Done writing ag data frame" # NATURAL AREAS # This way you get rid of the zero values associated with the unmasked areas. df_nat = df[df['jan_natural_mask_from_naturalareasmask_20110818']>0] # Filter out slope values greater than three df_nat = df_nat[df_nat['slope_degree_20110818']<3] df_nat.to_csv("/Volumes/SeagateExpansionDrive/jan_metric/jan_comparison_nat.csv") print "Done writing natural data frame" #============================ # TODO - Fix hard-coding here # df_filter = df.loc[df['nlcd_align_path35_dixon_wy'].isin([81, 80])] # df_filter.to_csv("/Volumes/SeagateExpansionDrive/jan_metric/for_stacking/stack_csv.csv") # TODO - and here # y = df_filter.ix[:, 'LT50350312011166PAC01_ETrF'] # x = df_filter.ix[:, "LT50350312011166PAC01_NDVI"] ### IF doing at-large NLCD filtering # df = df[df['aligned_nlcd_full_warp_near_clip_3336']>80 | df['aligned_nlcd_full_warp_near_clip_3336']< 81] # ============================ # TODO - comment out if using nlcd filter at-large # AGRICULTURAL ETrF_ag = df_ag.ix[:, "etrf24_20110818"] ETa_ag = df_ag.ix[:, "et24_20110818"] # NATURAL ETrF_nat = df_nat.ix[:, "etrf24_20110818"] ETa_nat = df_nat.ix[:, "et24_20110818"] # =======GRAPHING PORTION======= # AGRICULTURAL ETrF_ag_hist = plt.figure() aa = ETrF_ag_hist.add_subplot(111) aa.set_title('Jan Metric 2011 August 18 - ETrF Agricultural Pixels', fontweight='bold') aa.set_xlabel('ETrF', style='italic') aa.set_ylabel('Frequency', style='italic') aa.hist(ETrF_ag, bins=20) plt.tight_layout() plt.savefig( "/Volumes/SeagateExpansionDrive/jan_metric/plots/non_aligned_plots/Histograms/janmetric/ETrF_ag_hist_janmetric.pdf") ETa_ag_hist = plt.figure() aa = ETa_ag_hist.add_subplot(111) aa.set_title('Jan Metric 2011 August 18 - ETa_ag_hist Agricultural Pixels', fontweight='bold') aa.set_xlabel('ETa', style='italic') aa.set_ylabel('Frequency', style='italic') aa.hist(ETa_ag, bins=20) plt.tight_layout() plt.savefig( "/Volumes/SeagateExpansionDrive/jan_metric/plots/non_aligned_plots/Histograms/janmetric/ETa_ag_hist_janmetric.pdf") # NATURAL ETrF_nat_hist = plt.figure() aa = ETrF_nat_hist.add_subplot(111) aa.set_title('Jan Metric 2011 August 18 - ETrF Natural Pixels', fontweight='bold') aa.set_xlabel('ETrF', style='italic') aa.set_ylabel('Frequency', style='italic') aa.hist(ETrF_nat, bins=20) plt.tight_layout() plt.savefig( "/Volumes/SeagateExpansionDrive/jan_metric/plots/non_aligned_plots/Histograms/janmetric/ETrF_nat_hist_janmetric.pdf") ETa_nat_hist = plt.figure() aa = ETa_nat_hist.add_subplot(111) aa.set_title('Jan Metric 2011 August 18 - ETa_nat_hist Natural Pixels', fontweight='bold') aa.set_xlabel('ETa', style='italic') aa.set_ylabel('Frequency', style='italic') aa.hist(ETa_nat, bins=20) plt.tight_layout() plt.savefig( "/Volumes/SeagateExpansionDrive/jan_metric/plots/non_aligned_plots/Histograms/janmetric/ETa_nat_hist_janmetric.pdf") def run(): # TODO - update at each use drive_path = os.path.join('/', 'Volumes', 'SeagateExpansionDrive', ) #tiff_path = os.path.join(drive_path, "jan_metric", 'for_stacking', 'aligned_nlcd_full_warp_near_clip_3336.tif') stack_location = os.path.join(drive_path, "jan_metric", 'stacking_histogram_jan') #x, y = coord_getter(tiff_path) # print "x", x # # print "y", y #### find the right window to use. # First get the minimum raster extent. comparison_list = [] comparison_dict = {} for directory_path, subdir, file in os.walk(stack_location, topdown=False): for tf in file: if tf.endswith(".tif"): tiff_path = os.path.join(directory_path, tf) with rasterio.open(tiff_path) as src: ras = src.read(1) # raster.shape -> (###,###) # # raster.shape[1] raster.shape[0] comparison_list.append(ras.shape[0]*ras.shape[1]) comparison_dict["{}".format(ras.shape[0]*ras.shape[1])] = tiff_path # get the minimum dimensions raster. val = min(comparison_list) min_raster_path = comparison_dict["{}".format(val)] print (min_raster_path) with rasterio.open(min_raster_path) as raster: ras = raster.read(1) print 'ras shape 0', ras.shape[0] print 'ras shape 1', ras.shape[1] window = ((0, ras.shape[0]), (0, ras.shape[1])) print "WINDOW", window bounds = raster.window_bounds(window) print "BOUNDS", bounds # Take the bounds from the minimum raster and for each raster in the dir, # get the correct window to be read in for the dict using the bounds from the min raster. raster_dict = {} window_lst = [] for directory_path, subdir, file in os.walk(stack_location, topdown=False): for tf in file: if tf.endswith(".tif") or tf.endswith(".img"): tiff_path = os.path.join(directory_path, tf) #print 'path', tiff_path with rasterio.open(tiff_path) as r: T0 = r.affine # upper-left pixel corner affine transform print T0 window = r.window(*bounds) print "edited window", window A = r.read(1, window=window) print "A", A print "A shape", A.shape print 'path', tiff_path raster_dict['{}'.format(tf.split(".")[0])] = (A, tiff_path) print 'raster dict', raster_dict print "Starting the formatter" data_frame_formatter(raster_dict) if __name__ == "__main__": run()
apache-2.0
Karuntg/SDSS_SSC
analysis/processLCs.py
1
6459
# Given a file with directory and LC file information, # loop over LCs and do some computations. # Libraries import os, sys, math import numpy as np from astropy.table import Table from astropy.io import ascii from matplotlib import pyplot as plt from astroML.plotting import scatter_contour from astroML.plotting import hist as histML def processLC(LCfile): # read into astropy Table data = ascii.read(LCfile) rmag = data['col31'] rerr = data['col36'] tai = data['col51'] + data['col56'] Ndata = rmag.size ### compute and return # dT = taiMax - taiMin # min, max, rms, and chi2 for the r band dT = np.max(tai) - np.min(tai) rmed = np.median(rmag) # robust standard deviation rms = 0.7413*(np.percentile(rmag, 75)-np.percentile(rmag, 25)) # robust chi2dof chi = (rmag-rmed)/rerr chi2 = 0.7413*(np.percentile(chi, 75)-np.percentile(chi, 25)) ### eventualy, run Lomb-Scargle here # bestPeriods = LombScargle(tai, rmag) return np.min(tai), dT, Ndata, rmed, rms, chi2 def getLCdata(LCfile): # read into astropy Table data = ascii.read(LCfile) rmag = data['col31'] rerr = data['col36'] tai = data['col51'] + data['col56'] return rmag, rerr # given vectors x and y, fit medians in bins from xMin to xMax, with Nbin steps, # and return xBin, medianBin, medianErrBin def fitMedians(x, y, xMin, xMax, Nbin, verbose=1): # first generate bins xEdge = np.linspace(xMin, xMax, (Nbin+1)) xBin = np.linspace(0, 1, Nbin) nPts = 0*np.linspace(0, 1, Nbin) medianBin = 0*np.linspace(0, 1, Nbin) sigGbin = -1+0*np.linspace(0, 1, Nbin) for i in range(0, Nbin): xBin[i] = 0.5*(xEdge[i]+xEdge[i+1]) yAux = y[(x>xEdge[i])&(x<=xEdge[i+1])] if (yAux.size > 0): nPts[i] = yAux.size medianBin[i] = np.median(yAux) # robust estimate of standard deviation: 0.741*(q75-q25) sigmaG = 0.741*(np.percentile(yAux,75)-np.percentile(yAux,25)) # uncertainty of the median: sqrt(pi/2)*st.dev/sqrt(N) sigGbin[i] = np.sqrt(np.pi/2)*sigmaG/np.sqrt(nPts[i]) else: nPts[i], medianBin[i], sigGBin[i] = 0 if (verbose): print('median:', np.median(medianBin[Npts>0])) return xBin, nPts, medianBin, sigGbin def analyzeSTATSfile(statsFile, outdir): """Make a 4-panel plot illustrating basic stats""" # Ndata histogram # rchi2 histogram # rrms vs. rmed # rchi2 vs. rmed # <TAImin dT Ndata rmed rrms rchi2> dataT = np.loadtxt(statsFile, skiprows=1, usecols = (0,1,2,3,4,5)) data = dataT.transpose(1,0) TAImin = data[0] dT = data[1] Ndata = data[2] rmag = data[3] rrms = data[4] rchi2 = data[5] ### PLOTTING ### plot_kwargs = dict(color='k', linestyle='none', marker='.', markersize=1) plt.subplots_adjust(bottom=0.10, top=0.92, left=0.11, right=0.9, wspace=0.41, hspace=0.32) ax1 = plt.subplot(2,2,1) hist, bins = np.histogram(Ndata, bins=60) center = (bins[:-1]+bins[1:])/2 ax1.plot(center, hist, drawstyle='steps') #histML(Ndata, bins='knuth', ax=ax1, histtype='stepfilled', ec='k', fc='#AAAAAA') ax1.set_xlim(0, 60) ax1.set_ylim(0, 1.1*np.max(hist)) ax1.set_xlabel(r'$\mathrm{Ndata}$') ax1.set_ylabel(r'$\mathrm{dN/dNdata}$') ax1.set_title('Standard stars from SDSS Stripe 82') rchi2ok = rchi2[rchi2<3.0] hist, bins = np.histogram(rchi2ok, bins=50) center = (bins[:-1]+bins[1:])/2 ax2 = plt.subplot(2,2,2) ax2.plot(center, hist, drawstyle='steps') ax2.set_xlim(0, 3.0) ax2.set_ylim(0, 1.1*np.max(hist)) ax2.set_xlabel(r'$\mathrm{\chi^2_{dof}(r)}$') ax2.set_ylabel(r'$\mathrm{dN/d\chi^2_{dof}}$') ax3 = plt.subplot(2,2,3) ax3.set_xlim(13, 23) ax3.set_ylim(0, 0.1) ax3.set_xlabel(r'$\mathrm{rMag}$') ax3.set_ylabel(r'$\mathrm{rRms}$') if (0): ax3.scatter(rmag, rrms, s=3, alpha=0.5) else: col0 = rmag col1 = rrms # 2D-histogram im3 = ax3.hexbin(col0, col1, bins='log', cmap=plt.cm.viridis, mincnt=1, extent=(13, 22.0, 0, 0.1)) # color bar # cb = plt.colorbar(im,label='log(N)') ax4 = plt.subplot(2,2,4) ax4.set_xlim(13, 22) ax4.set_ylim(0, 3.0) ax4.set_xlabel(r'$\mathrm{rMag}$') ax4.set_ylabel(r'$\mathrm{\chi^2_{dof}(r)}$') if (0): ax4.scatter(rmag, rchi2, s=6, alpha=0.5) else: col0 = rmag[rchi2<3.0] col1 = rchi2ok # 2D-histogram im4 = ax4.hexbin(col0, col1, bins='log', cmap=plt.cm.viridis, mincnt=1, extent=(13, 22.0, 0, 3.0)) # color bar # cb = plt.colorbar(im,label='log(N)') outfile = outdir + "/statsFile.png" plt.savefig(outfile) # plt.show() return def processLCs(LCdir): # Read Karun's file with LC data filein = LCdir + "/LC_dirs_fils.lst" fileout = LCdir + "/LC_dirs_fils.stats" Nlines = 0 NlineMin = 2 NlineMax = 2000001 EpochSum = 0 mssgStep = 1000 fout = open(fileout, "w") fout.write(" TAImin dT Ndata rmed rrms rchi2 LCfile\n") with open(filein, "r") as f: for line in f: Nlines += 1 if (Nlines == Nlines/mssgStep*mssgStep): print Nlines lineS = line.split() if ((Nlines >= NlineMin) and (Nlines <= NlineMax)): RAdir = lineS[3] DECdir = lineS[4] LCfile = lineS[5] Nepoch = int(lineS[6]) EpochSum += Nepoch LCpath = RAdir + "/" + DECdir + "/" + LCfile LCfullpath = LCdir + "/" + LCpath # test that it's not a file without data (i.e. only 2 header lines) lcf = open(LCfullpath, "r") lines = lcf.readlines() if (len(lines)>2): r1, r2, r3, r4, r5, r6 = processLC(LCfullpath) s = str("%.4f " % r1) + str("%.2f " % r2) + str("%3.0f " % r3) + str("%.3f " % r4) s = s + str("%.3f " % r5) + str("%6.2f " % r6) + LCpath + "\n" fout.write(s) else: print 'EMPTY FILE: ', LCpath fout.close() print 'EpochSum = ', EpochSum return if(0): LCdir = "/Users/ivezic/Work/Science/CalibrationV2/Data/testLCdir" processLCs(LCdir) statsfile = LCdir + "/LC_dirs_fils.stats" analyzeSTATSfile(statsfile, LCdir) # plot in statsFile_r.png # 481,000 with 15<r<20 and Ndata>10 (162,000 with Ndata>20)
gpl-3.0
jakeown/GAS
GAS/gauss_fit.py
1
9175
from spectral_cube import SpectralCube from astropy.io import fits import matplotlib.pyplot as plt import astropy.units as u import numpy as np from scipy.optimize import curve_fit from scipy import * import time import pprocess from astropy.convolution import convolve import radio_beam import sys def gauss_fitter(region = 'Cepheus_L1251', snr_min = 3.0, mol = 'C2S', vmin = 5.0, vmax=10.0, convolve=False, use_old_conv=False, multicore = 1, file_extension = None): """ Fit a Gaussian to non-NH3 emission lines from GAS. It creates a cube for the best-fit Gaussian, a cube for the best-fit Gaussian with noise added back into the spectrum, and a parameter map of Tpeak, Vlsr, and FWHM Parameters ---------- region : str Name of region to reduce snr_min : float Lowest signal-to-noise pixels to include in the line-fitting mol : str name of molecule to fit vmin : numpy.float Minimum centroid velocity, in km/s. vmax : numpy.float Maximum centroid velocity, in km/s. convolve : bool or float If not False, specifies the beam-size to convolve the original map with Beam-size must be given in arcseconds use_old_conv : bool If True, use an already convolved map with name: region + '_' + mol + file_extension + '_conv.fits' This convolved map must be in units of km/s multicore : int Maximum number of simultaneous processes desired file_extension: str filename extension """ if file_extension: root = file_extension else: # root = 'base{0}'.format(blorder) root = 'all' molecules = ['C2S', 'HC7N_22_21', 'HC7N_21_20', 'HC5N'] MolFile = '{0}/{0}_{2}_{1}.fits'.format(region,root,mol) ConvFile = '{0}/{0}_{2}_{1}_conv.fits'.format(region,root,mol) GaussOut = '{0}/{0}_{2}_{1}_gauss_cube.fits'.format(region,root,mol) GaussNoiseOut = '{0}/{0}_{2}_{1}_gauss_cube_noise.fits'.format(region,root,mol) ParamOut = '{0}/{0}_{2}_{1}_param_cube.fits'.format(region,root,mol) # Load the spectral cube and convert to velocity units cube = SpectralCube.read(MolFile) cube_km = cube.with_spectral_unit(u.km / u.s, velocity_convention='radio') # If desired, convolve map with larger beam # or load previously created convolved cube if convolve: cube = SpectralCube.read(MolFile) cube_km_1 = cube.with_spectral_unit(u.km / u.s, velocity_convention='radio') beam = radio_beam.Beam(major=convolve*u.arcsec, minor=convolve*u.arcsec, pa=0*u.deg) cube_km = cube_km_1.convolve_to(beam) cube_km.write(ConvFile, format='fits', overwrite=True) if use_old_conv: cube_km = SpectralCube.read(ConvFile) # Define the spectral axis in km/s spectra_x_axis_kms = np.array(cube_km.spectral_axis) # Find the channel range corresponding to vmin and vmax # -- This is a hold-over from when I originally set up the code to # use a channel range rather than velocity range. # Can change later, but this should work for now. low_channel = np.where(spectra_x_axis_kms<=vmax)[0][0]+1 # Add ones to change index to channel high_channel = np.where(spectra_x_axis_kms>=vmin)[0][-1]+1 # Again, hold-over from older setup peak_channels = [low_channel, high_channel] # Create cubes for storing the fitted Gaussian profiles # and the Gaussians with noise added back into the spectrum header = cube_km.header cube_gauss = np.array(cube_km.unmasked_data[:,:,:]) cube_gauss_noise = np.array(cube_km.unmasked_data[:,:,:]) shape = np.shape(cube_gauss) # Set up a cube for storing fitted parameters param_cube = np.zeros(6, shape[1], shape[2]) param_header = cube_km.header # Define the Gaussian profile def p_eval(x, a, x0, sigma): return a*np.exp(-(x-x0)**2/(2*sigma**2)) # Create some arrays full of NANs # To be used in output cubes if fits fail nan_array=np.empty(shape[0]) # For gauss cubes nan_array[:] = np.NAN nan_array2=np.empty(param_cube.shape[0]) # For param cubes nan_array2[:] = np.NAN # Loop through each pixel and find those # with SNR above snr_min x = [] y = [] pixels = 0 for (i,j), value in np.ndenumerate(cube_gauss[0]): spectra=np.array(cube_km.unmasked_data[:,i,j]) if (False in np.isnan(spectra)): rms = np.nanstd(np.append(spectra[0:(peak_channels[0]-1)], spectra[(peak_channels[1]+1):len(spectra)])) if (max(spectra[peak_channels[0]:peak_channels[1]]) / rms) > snr_min: pixels+=1 x.append(i) y.append(j) else: cube_gauss[:,i,j]=nan_array param_cube[:,i,j]=nan_array2 cube_gauss_noise[:,i,j]=nan_array print str(pixels) + ' Pixels above SNR=' + str(snr_min) # Define a Gaussian fitting function for each pixel # i, j are the x,y coordinates of the pixel being fit def pix_fit(i,j): spectra = np.array(cube_km.unmasked_data[:,i,j]) # Use the peak brightness Temp within specified channel # range as the initial guess for Gaussian height max_ch = np.argmax(spectra[peak_channels[0]:peak_channels[1]]) Tpeak = spectra[peak_channels[0]:peak_channels[1]][max_ch] # Use the velocity of the brightness Temp peak as # initial guess for Gaussian mean vpeak = spectra_x_axis_kms[peak_channels[0]:peak_channels[1]][max_ch] rms = np.std(np.append(spectra[0:(peak_channels[0]-1)], spectra[(peak_channels[1]+1):len(spectra)])) err1 = np.zeros(shape[0])+rms # Create a noise spectrum based on rms of off-line channels # This will be added to best-fit Gaussian to obtain a noisy Gaussian noise=np.random.normal(0.,rms,len(spectra_x_axis_kms)) # Define initial guesses for Gaussian fit guess = [Tpeak, vpeak, 0.3] # [height, mean, sigma] try: coeffs, covar_mat = curve_fit(p_eval, xdata=spectra_x_axis_kms, ydata=spectra, p0=guess, sigma=err1, maxfev=500) gauss = np.array(p_eval(spectra_x_axis_kms,coeffs[0], coeffs[1], coeffs[2])) noisy_gauss = np.array(p_eval(spectra_x_axis_kms,coeffs[0], coeffs[1], coeffs[2]))+noise params = np.append(coeffs, (covar_mat[0][0]**0.5, covar_mat[1][1]**0.5, covar_mat[2][2]**0.5)) # params = ['Tpeak', 'VLSR','sigma','Tpeak_err','VLSR_err','sigma_err'] # Don't accept fit if fitted parameters are non-physical or too uncertain if (params[0] < 0.01) or (params[3] > 1.0) or (params[2] < 0.05) or (params[5] > 0.5) or (params[4] > 0.75): noisy_gauss = nan_array gauss = nan_array params = nan_array2 # Don't accept fit if the SNR for fitted spectrum is less than SNR threshold #if max(gauss)/rms < snr_min: # noisy_gauss = nan_array # gauss = nan_array # params = nan_array2 except RuntimeError: noisy_gauss = nan_array gauss = nan_array params = nan_array2 return i, j, gauss, params, noisy_gauss # Parallel computation: nproc = multicore # maximum number of simultaneous processes desired queue = pprocess.Queue(limit=nproc) calc = queue.manage(pprocess.MakeParallel(pix_fit)) tic=time.time() counter = 0 # Uncomment to see some plots of the fitted spectra #for i,j in zip(x,y): #pix_fit(i,j) #plt.plot(spectra_x_axis_kms, spectra, color='blue', drawstyle='steps') #plt.plot(spectra_x_axis_kms, gauss, color='red') #plt.show() #plt.close() # Begin parallel computations # Store the best-fit Gaussians and parameters # in their correct positions in the previously created cubes for i,j in zip(x,y): calc(i,j) for i,j,gauss_spec,parameters,noisy_gauss_spec in queue: cube_gauss[:,i,j]=gauss_spec param_cube[:,i,j]=parameters cube_gauss_noise[:,i,j]=noisy_gauss_spec counter+=1 print str(counter) + ' of ' + str(pixels) + ' pixels completed \r', sys.stdout.flush() print "\n %f s for parallel computation." % (time.time() - tic) # Save final cubes # These will be in km/s units. # Spectra will have larger values to the left, lower values to right cube_final_gauss = SpectralCube(data=cube_gauss, wcs=cube_km.wcs, header=cube_km.header) cube_final_gauss.write(GaussOut, format='fits', overwrite=True) cube_final_gauss_noise = SpectralCube(data=cube_gauss_noise, wcs=cube_km.wcs, header=cube_km.header) cube_final_gauss_noise.write(GaussNoiseOut, format='fits', overwrite=True) # Construct appropriate header for param_cube param_header['NAXIS3'] = len(nan_array2) param_header['WCSAXES'] = 3 param_header['CRPIX3'] = 1 param_header['CDELT3'] = 1 param_header['CRVAL3'] = 0 param_header['PLANE1'] = 'Tpeak' param_header['PLANE2'] = 'VLSR' param_header['PLANE3'] = 'sigma' param_header['PLANE5'] = 'Tpeak_err' param_header['PLANE6'] = 'VLSR_err' param_header['PLANE7'] = 'sigma_err' fits.writeto(ParamOut, param_cube, header=param_header, clobber=True) ### Examples ### # Fit the HC5N data in Cepheus_L1251, without convolution #gauss_fitter(region = 'Cepheus_L1251', snr_min = 7.0, mol = 'HC5N', vmin=-6.3, vmax=-2.2, multicore=3) # Convolve the HC5N data in Cepheus_L1251 to a spatial resolution of 64 arcseconds, # then fit a Gaussian to all pixels above SNR=3 #gauss_fitter(region = 'Cepheus_L1251', direct = '/Users/jkeown/Desktop/GAS_dendro/', snr_min = 3.0, mol = 'HC5N', peak_channels = [402,460], convolve=64., use_old_conv=False)
mit
facebookresearch/ParlAI
parlai/crowdsourcing/tasks/turn_annotations_static/analysis/compile_results.py
1
23052
#!/usr/bin/env python3 # Copyright (c) Facebook, Inc. and its affiliates. # This source code is licensed under the MIT license found in the # LICENSE file in the root directory of this source tree. import copy import json import os from datetime import datetime from typing import Any, Dict, Optional, Tuple import numpy as np import pandas as pd from parlai.crowdsourcing.utils.analysis import AbstractTurnAnnotationResultsCompiler class TurnAnnotationsStaticResultsCompiler(AbstractTurnAnnotationResultsCompiler): """ Class to compile results from static turn annotations. Change PROBLEM_BUCKETS in task_config/annotation_buckets.json to be the buckets that you are asking crowdsource workers to annotate with. """ NUM_SUBTASKS = 7 LIVE_ONBOARDING_IS_LAST_SUBTASK = True LIVE_ONBOARDING_THRESHOLD = 0.5 INFLIGHT_ONBOARDING_DATA = None NUM_ANNOTATIONS = 5 FILENAME_STUB = 'results' CALCULATE_STATS_INTERANNOTATOR_AGREEMENT = True @classmethod def setup_args(cls): parser = super().setup_args() parser.add_argument( '--onboarding-in-flight-data-file', type=str, help='Path to JSONL file containing onboarding in-flight conversations', ) parser.add_argument( '--gold-annotations-file', type=str, default=None, help='Path to a JSON file mapping utterance IDs to the gold annotations', ) return parser def __init__(self, opt: Dict[str, Any]): super().__init__(opt) self.onboarding_in_flight_data_file = opt.get('onboarding_in_flight_data_file') self.gold_annotations_file = opt.get('gold_annotations_file') def get_data_paths_mephisto(self, task_run_id_folder): """ Get all the individual folders with data from the <task_run_id> path we are given as input. In Mephisto the structure is: /<project_id>/<task_run_id>/<assignment_id>/<agent_id>/ Side note: assignment_id == HIT ID """ # TODO: replace direct folder access with a call to # mephisto.tools.data_browser.DataBrowser read_folders = [] for assignment_id in os.listdir(task_run_id_folder): if assignment_id in ['onboarding', 'reservations', 'build', '.', '..']: continue assignment_folder = os.path.join(task_run_id_folder, assignment_id) if os.path.isdir(assignment_folder): if len(os.listdir(assignment_folder)) > 2: print( f'Had more than one HIT in folder: {assignment_folder}, had {len(os.listdir(assignment_folder))} folders.' ) for agent_id in os.listdir(assignment_folder): if os.path.isdir(os.path.join(assignment_folder, agent_id)): full_path = os.path.join( task_run_id_folder, assignment_id, agent_id, 'agent_data.json', ) read_folders.append(full_path) return read_folders def get_results_path_base(self) -> str: now = datetime.now() return os.path.join( self.output_folder, f'{self.FILENAME_STUB}_{now.strftime("%Y%m%d_%H%M%S")}' ) def compile_results(self) -> pd.DataFrame: # Loads data from files and gets rid of incomplete or malformed convos conversations = self.compile_initial_results(self.results_folders) master_dataframe = self.process_data_into_dataframe(conversations) self.calculate_basic_interannotator_agreement(master_dataframe) if self.gold_annotations_file is not None: with open(self.gold_annotations_file, 'r') as gold_f: gold_annotations = json.loads(gold_f.read()) self.calculate_agreement_with_gold_annotations( gold_annotations, master_dataframe ) if self.CALCULATE_STATS_INTERANNOTATOR_AGREEMENT: self.calculate_stats_interannotator_agreement(master_dataframe) return master_dataframe def _validate_hit(self, hit_data) -> Tuple[bool, Optional[str]]: """ Validate an entire HIT. :return: tuple (is_valid, reason) """ if 'outputs' not in hit_data or hit_data['outputs'] is None: return False, 'Malformed HIT' subtasks = hit_data['outputs']['final_data'] if len(subtasks) != self.NUM_SUBTASKS: return False, f'Incomplete HIT with subtask length {len(subtasks)}.' return True, None def _validate_subtask(self, subtask_data) -> Tuple[bool, Optional[str]]: """ Validate a conversation subtask within the HIT. :return: tuple (is_valid, reason) """ # Check that the conversation consists of pairs of comments between # agents 0 and 1, with 0 speaking first try: assert all( [ utterance_data['agent_idx'] == turn_idx % 2 for turn_idx, utterance_data in enumerate(subtask_data) ] ) messages_0 = [utt for utt in subtask_data if utt['agent_idx'] == 0] messages_1 = [utt for utt in subtask_data if utt['agent_idx'] == 1] assert len(messages_0) + len(messages_1) == len(subtask_data) except Exception: return False, f'Data not in form expected. Length is: {len(subtask_data)}' for utterance_data in subtask_data: if ( utterance_data['agent_idx'] == 1 and self.problem_buckets[0] not in utterance_data ): return ( False, f'Bot utterance was malformed and had no problem annotation fields (Failed to find key: {self.problem_buckets[0]}).', ) return True, None def _get_inflight_onboarding_success_from_subtask(self, subtask): if self.INFLIGHT_ONBOARDING_DATA is None: self.INFLIGHT_ONBOARDING_DATA = self.setup_inflight_onboarding_data() onboarding_utterance = subtask['data'][-1] num_answers = 0 num_correct = 0 num_incorrect = 0 for d in self.INFLIGHT_ONBOARDING_DATA: if d['dialog'][-1][-1]['text'] == onboarding_utterance['text']: num_answers = len(d['answers']) for pb in self.problem_buckets: if pb in d['answers'] and onboarding_utterance[pb]: num_correct += 1 if onboarding_utterance[pb] and pb not in d['answers']: num_incorrect += 1 return num_correct / num_answers def compile_initial_results(self, results_folders) -> list: """ Do initial loading and processing of crowdsource data Loads data from all the worker ID files and gets rid of incomplete or malformed convos. Also adds fields such as worker_id, assignment_id, etc for convenience :return: list of JSON objects which represent a conversation with annotations d["data"] of each has an array of utterance level data """ print('Starting compile_initial_results...') all_data_paths = [] for f in results_folders: # Each one is a HIT completed by a given worker (so if # units-per-assignment > 1), then will include the same conversations # multiple times annotated by different workers data_paths = self.get_data_paths_mephisto(f) all_data_paths.extend(data_paths) print(f'Got {len(all_data_paths)} folders to read.') conversations = [] task_completion_times = [] for dp in all_data_paths: # Read in file with open(os.path.join(dp), 'rb') as f: data = json.load(f) worker_id = dp.split('/')[-2] hit_id = dp.split('/')[-3] _ = dp.split('/')[-4] # Task run (is_valid_hit, reason) = self._validate_hit(data) if not is_valid_hit: print( f'Skipping invalid HIT {hit_id}, worker_id: {worker_id} for reason: {reason}.' ) continue # HIT-level metric of HIT completion time has to be done here for now task_completion_time_seconds = ( data['times']['task_end'] - data['times']['task_start'] ) print(task_completion_time_seconds) subtasks = data['outputs']['final_data'] if self.LIVE_ONBOARDING_IS_LAST_SUBTASK: qc_success_pct = self._get_inflight_onboarding_success_from_subtask( subtasks[-1] ) else: qc_success_pct = 0.0 for subtask_idx, d in enumerate(subtasks): if ( subtask_idx == (len(subtasks) - 1) and self.LIVE_ONBOARDING_IS_LAST_SUBTASK ): # Last subtask is inflight onboarding; don't include it continue subtask_data = copy.deepcopy(d) # Structure of each subtask is {'subtask_index': XX, 'data': [...]} (is_valid_subtask, reason) = self._validate_subtask(d['data']) if not is_valid_subtask: print( f'Skipping invalid subtask within HIT: {hit_id}, worker_id: {worker_id} for reason: {reason}.' ) continue subtask_data['worker_id'] = worker_id subtask_data['hit_id'] = hit_id subtask_data['folder'] = dp subtask_data['subtask_idx'] = subtask_idx experimental_design = 'self_chat' subtask_data['model_nickname'] = experimental_design + '/' + 'TODO' subtask_data['qc_success_pct'] = qc_success_pct conversations.append(subtask_data) task_completion_times.append(task_completion_time_seconds) if len(task_completion_times) > 0: print( f'Average task completion time (seconds) was: ' f'{np.average(task_completion_times):0.1f}' ) if len(conversations) == 0: raise ValueError('No conversations found!') return conversations def process_data_into_dataframe(self, conversations) -> pd.DataFrame: """ Return one big dataframe of all conversations where a row is an utterance and its problem annotations. """ print('Starting process_data_into_dataframe...') rows = [] for _, convo in enumerate(conversations): for turn_idx, utt in enumerate(convo['data']): row = { 'annotation_id': f'{convo["hit_id"]}_{convo["subtask_idx"]}_{turn_idx}_{convo["worker_id"]}', 'conversation_id': f'{convo["hit_id"]}_{convo["subtask_idx"]}', 'utterance_id': f'{convo["hit_id"]}_{convo["subtask_idx"]}_{turn_idx}', 'turn_idx': turn_idx, 'agent_idx': utt['agent_idx'], 'folder': convo['folder'], 'worker_id': convo['worker_id'], 'hit_id': convo['hit_id'], 'model_nickname': convo['model_nickname'], 'qc_success_pct': convo['qc_success_pct'], 'text': utt['text'], } row = self._add_additional_columns(row=row, utt=utt) for k in self.problem_buckets: row[k] = utt[k] if utt['agent_idx'] == 1 else '' rows.append(row) df = pd.DataFrame(rows) print(f'Returning master dataframe with {len(df)} annotations.') return df def _add_additional_columns(self, row: Dict[str, Any], utt: dict) -> Dict[str, Any]: """ Add additional columns to the results dataframe. If you wish to add additional columns to the results dataframe, use the input utterance dict `utt` to define new keys in `row`, which will form one row in the final results dataframe. """ _ = utt # The utt dict isn't used here, but may be used in subclasses. return row def calculate_basic_interannotator_agreement(self, df: pd.DataFrame) -> None: print('Starting calculate_interannotator_agreement...') # Drops the human utterances which don't have problem buckets bot_only_df = df.replace('', np.nan) # Get rid of the None's, which occur if there were no checkboxes (so if # last utterance only option selected) bot_only_df = bot_only_df.fillna(value=np.nan) bot_only_df = bot_only_df.dropna() bot_only_df = self._problem_bucket_specific_filtering(bot_only_df) # Group at the utterance level (summing across workers) bot_only_df = bot_only_df.replace(True, 1) bot_only_df = bot_only_df.replace(False, 0) all_bot_annotations_count = len(bot_only_df) # Remove utterances that don't have self.NUM_ANNOTATIONS annotations counted_df = bot_only_df.groupby(['utterance_id']).count() counted_df = counted_df[counted_df == self.NUM_ANNOTATIONS].dropna() bot_only_df = bot_only_df[bot_only_df['utterance_id'].isin(counted_df.index)] print( f'Removed {all_bot_annotations_count - len(bot_only_df)} that did not have annotations by {self.NUM_ANNOTATIONS} workers. {len(bot_only_df)} annotations remaining.' ) if self.LIVE_ONBOARDING_IS_LAST_SUBTASK: # Remove those that didn't get enough right on live onboarding bot_only_df = bot_only_df[ bot_only_df['qc_success_pct'] >= self.LIVE_ONBOARDING_THRESHOLD ] summed_df = bot_only_df.groupby(['utterance_id']).sum() print(f'summed_df has length {len(summed_df)}; bot_only_df: {len(bot_only_df)}') utterance_ids = bot_only_df['utterance_id'].unique() print(f'Number of unique utterance_ids: {len(utterance_ids)}.') if 'any_problem' in summed_df: # We've computed a column marking if any problem exists, so include this extended_problem_buckets = self.problem_buckets + ['any_problem'] else: extended_problem_buckets = self.problem_buckets for k in extended_problem_buckets: one_annotator = len(summed_df[summed_df[k] == 1]) two_annotators = len(summed_df[summed_df[k] == 2]) three_annotators = len(summed_df[summed_df[k] >= 3]) total_problem_annotations = ( one_annotator + two_annotators + three_annotators ) total_utterances = len(summed_df[k]) if total_problem_annotations > 0: print( f'Bucket: {k}, total unique problem utterances: {total_problem_annotations} ({total_problem_annotations/total_utterances:.1%} of all), one annotator: {one_annotator} ({one_annotator/total_problem_annotations:.1%}), two_annotators: {two_annotators} ({two_annotators/total_problem_annotations:.1%}), three+ annotators: {three_annotators} ({three_annotators/total_problem_annotations:.1%})' ) def _problem_bucket_specific_filtering( self, bot_only_df: pd.DataFrame ) -> pd.DataFrame: """ Filter the bot responses given the specific problem buckets being used. """ non_none_problem_buckets = [ bucket for bucket in self.problem_buckets if bucket != 'none_all_good' ] assert len(set(non_none_problem_buckets)) + 1 == len(self.problem_buckets) # Make sure problem buckets are all unique utterance_count_total = len(bot_only_df) # Select which columns are consistent is_consistent = ( bot_only_df[non_none_problem_buckets[0]] + bot_only_df['none_all_good'] ) < 2 for bucket in non_none_problem_buckets[1:]: is_consistent = is_consistent & ( (bot_only_df[bucket] + bot_only_df['none_all_good']) < 2 ) bot_only_df['is_consistent'] = is_consistent bot_only_df = bot_only_df[bot_only_df['is_consistent']] # If any of the problem buckets have marked True any_problem = bot_only_df[non_none_problem_buckets[0]] for bucket in non_none_problem_buckets[1:]: any_problem = any_problem | bot_only_df[bucket] bot_only_df['any_problem'] = any_problem print( f'Dropped {utterance_count_total - len(bot_only_df)} inconsistently annotated utterances (none_all_good and a problem bucket). Now have {len(bot_only_df)} utterances.' ) return bot_only_df def calculate_agreement_with_gold_annotations( self, gold_annotations, df: pd.DataFrame ) -> None: """ Assume gold_annotations are a dictionary of the form {utterance_id : {bucket_i: true/false}} where utterance_id is taken from the compile_initial_results (i.e. mephistohitid_subtaskindex_utteranceidx) """ print('Starting calculate_agreement_with_gold_annotations...') # Drops the human utterances which don't have problem buckets bot_only_df = df.replace('', np.nan) # Get rid of the None's, which occur if there were no checkboxes (so if # last utterance only option selected) bot_only_df = bot_only_df.fillna(value=np.nan) bot_only_df = bot_only_df.dropna() # Include only utterances that have gold_annotations bot_only_df = bot_only_df[ bot_only_df['utterance_id'].isin(gold_annotations.keys()) ] print( f'Got {len(gold_annotations.keys())} utterances with gold annotations. Found {len(bot_only_df)} utterances matching gold annotations from DataFrame.' ) agreement_map = {pb: [] for pb in self.problem_buckets} agreement_map_problem_only = {pb: [] for pb in self.problem_buckets} problem_counts = {pb: 0 for pb in self.problem_buckets} for utterance_id, gold in gold_annotations.items(): utterance_df = bot_only_df[bot_only_df['utterance_id'] == utterance_id] count_workers = len(utterance_df) for pb in self.problem_buckets: gold_annotation = gold[pb] match_count = utterance_df[utterance_df[pb] == gold[pb]].count()[pb] a = float(match_count / count_workers) agreement_map[pb].append(a) if gold_annotation: agreement_map_problem_only[pb].append(a) problem_counts[pb] += 1 print( f'------------------------\nAverage agreement with {len(gold_annotations)} total gold utterances annotated was:' ) for pb in self.problem_buckets: print( f'{pb}: {np.average(agreement_map[pb]):.1%} ({problem_counts[pb]} gold problem samples)' ) print('------------------------') print( f'------------------------\nAverage agreement problem samples only with {len(gold_annotations)} total gold utterances annotated was:' ) for pb in self.problem_buckets: print( f'{pb}: {np.average(agreement_map_problem_only[pb]):.1%} ({problem_counts[pb]} gold problem samples)' ) print('------------------------') def calculate_stats_interannotator_agreement(self, df: pd.DataFrame): print('Starting calculate_stats_interannotator_agreement...') # Get rid of the human utterances (non-annotated) bot_only_df = df.replace('', np.nan) # Get rid of the None's, which occur if there were no checkboxes (so if # last utterance only option selected) bot_only_df = bot_only_df.fillna(value=np.nan) bot_only_df = bot_only_df.dropna() print(f'Calculating agreement on {len(bot_only_df)} annotations.') for pb in self.problem_buckets: # Expects a df of rater_id, item_id and "data" column kappa_df = df[['annotation_id', 'worker_id', 'utterance_id', pb]] kappa_df = kappa_df.rename( columns={'worker_id': 'rater_id', 'utterance_id': 'item_id', pb: 'data'} ) try: fleiss_kappa = self.compute_fleiss_kappa( kappa_df, [True, False], self.NUM_ANNOTATIONS ) except Exception as exc: print(f'Exception calculating Fleiss Kappa: {exc}. Skipping.') continue print(f'Fleiss\' kappa for {pb} is: {fleiss_kappa:0.3f}.') def compute_fleiss_kappa( self, df: pd.DataFrame, categories: list, number_of_raters: int ) -> float: """ Expects a df of index, rater_id, item_id and "data" column with each row a label of one of the categories. """ # categories are "True" and "False" # As per wikipedia definition: https://en.wikipedia.org/wiki/Fleiss%27_kappa items_list = df.drop_duplicates(subset=['item_id'])['item_id'].to_list() N = len(items_list) p_j = np.zeros(len(categories)) P_bar_sum_term = 0.0 for item in items_list: df_item_annotations = df[df['item_id'] == item] if len(df_item_annotations) != number_of_raters: continue for j, c in enumerate(categories): try: n_ij = df_item_annotations['data'].value_counts()[c] except Exception: n_ij = 0.0 p_j[j] += n_ij P_bar_sum_term += n_ij ** 2 p_j = [tmp / (N * number_of_raters) for tmp in p_j] P_e_bar = sum([tmp ** 2 for tmp in p_j]) P_bar = (P_bar_sum_term - N * number_of_raters) / ( N * number_of_raters * (number_of_raters - 1) ) kappa = (P_bar - P_e_bar) / (1 - P_e_bar) return kappa def setup_inflight_onboarding_data(self): print('setup_inflight_onboarding_data') raw_qc_convos = [] with open(self.onboarding_in_flight_data_file, "r") as f: line = f.readline() while line: qc_convo = json.loads(line) raw_qc_convos.append(qc_convo) line = f.readline() return raw_qc_convos if __name__ == '__main__': parser_ = TurnAnnotationsStaticResultsCompiler.setup_args() args = parser_.parse_args() TurnAnnotationsStaticResultsCompiler(vars(args)).compile_and_save_results()
mit
PDuckworth/strands_qsr_lib
qsr_lib/dbg/dbg_rcc3.py
8
5041
#!/usr/bin/python # import numpy as np from matplotlib import pyplot as plt from matplotlib.patches import Rectangle def return_bounding_box_2d(x, y, xsize, ysize): """Return the bounding box :param x: x center :param y: y center :param xsize: x size :param ysize: y size :return: list(x1, y1, x2, y2) where (x1, y1) and (x2, y2) are the coordinates of the diagonal points of the bounding box depending on your coordinates frame """ if xsize <= 0 or ysize <= 0: print("ERROR: can't compute bounding box, xsize or height has no positive value") return [] return [x-xsize/2, y-ysize/2, x+xsize/2, y+ysize/2] def compute_qsr(bb1, bb2): """Return symmetrical RCC3 relation :param bb1: first bounding box (x_bottom_left, y_bottom_left, x_top_right, y_top_right) :param bb2: second bounding box (x_bottom_left, y_bottom_left, x_top_right, y_top_right) :return: an RCC3 relation from the following: 'dc':disconnected, 'po':partial overlap, 'o': occluded/part of """ bboxes_intercept_v, rabx, raxPrbx, raby, rayPrby = bboxes_intercept(bb1, bb2) if bboxes_intercept_v: if rabx > 0.0 or raby > 0: return "po", -1 else: occluded_points = count_occluded_points(bb1, bb2) if occluded_points >= 4: return "o", occluded_points else: return "po", occluded_points else: return "dc", 0 def count_occluded_points(bb1, bb2): occluded_points = 0 bb1_4corners = ((bb1[0], bb1[1]), (bb1[2], bb1[1]), (bb1[2], bb1[3]), (bb1[0], bb1[3])) bb2_4corners = ((bb2[0], bb2[1]), (bb2[2], bb2[1]), (bb2[2], bb2[3]), (bb2[0], bb2[3])) for p in bb1_4corners: if is_point_in_rectangle(p, bb2): occluded_points += 1 for p in bb2_4corners: if is_point_in_rectangle(p, bb1): occluded_points += 1 return occluded_points # function does not return correctly if the bounding boxes in count_occluded points are the ones below, still doesn't matter # o1 = (.0, .0, 1., 1.) # o2 = (.0, .0, 1.5, .5) def is_point_in_rectangle(p, r, d=0.): return p[0] >= r[0]-d and p[0] <= r[2]+d and p[1] >= r[0]-d and p[1] <= r[3]+d def bboxes_intercept(bb1, bb2): """ https://rbrundritt.wordpress.com/2009/10/03/determining-if-two-bounding-boxes-overlap/ :param bb1: first bounding box (x_bottom_left, y_bottom_left, x_top_right, y_top_right) :param bb2: second bounding box (x_bottom_left, y_bottom_left, x_top_right, y_top_right) :return: """ # First bounding box, top left corner, bottom right corner ATLx = bb1[0] ATLy = bb1[3] ABRx = bb1[2] ABRy = bb1[1] # Second bounding box, top left corner, bottom right corner BTLx = bb2[0] BTLy = bb2[3] BBRx = bb2[2] BBRy = bb2[1] rabx = abs(ATLx + ABRx - BTLx - BBRx) raby = abs(ATLy + ABRy - BTLy - BBRy) # rAx + rBx raxPrbx = ABRx - ATLx + BBRx - BTLx # rAy + rBy rayPrby = ATLy - ABRy + BTLy - BBRy if(rabx <= raxPrbx) and (raby <= rayPrby): return True, rabx, raxPrbx, raby, rayPrby else: return False, rabx, raxPrbx, raby, rayPrby def plot_bbs(bb1, bb2): plt.figure() ax = plt.gca() # ax.invert_yaxis() ax.add_patch(Rectangle((bb1[0], bb1[1]), bb1[2]-bb1[0], bb1[3]-bb1[1], alpha=1, facecolor="blue")) ax.add_patch(Rectangle((bb2[0], bb2[1]), bb2[2]-bb2[0], bb2[3]-bb2[1], alpha=1, facecolor="red")) h = 6 l = 0 # ax.set_xlim(l, h) # ax.set_ylim(l, h) ax.set_xlim(l, h) ax.set_ylim(h, l) plt.show() # o1 = [Object_State(name="o1", timestamp=0, x=1., y=1., xsize=5., ysize=8.), # Object_State(name="o1", timestamp=1, x=1., y=2., xsize=5., ysize=8.), # Object_State(name="o1", timestamp=2, x=1., y=3., xsize=5., ysize=8.)] # # o2 = [Object_State(name="o2", timestamp=0, x=11., y=1., xsize=5., ysize=8.), # Object_State(name="o2", timestamp=1, x=11., y=2., xsize=5., ysize=8.), # Object_State(name="o2", timestamp=2, x=11., y=3., xsize=5., ysize=8.), # Object_State(name="o2", timestamp=3, x=11., y=4., xsize=5., ysize=8.)] # # o3 = [Object_State(name="o3", timestamp=0, x=1., y=11., xsize=5., ysize=8.), # Object_State(name="o3", timestamp=1, x=2., y=11., xsize=5., ysize=8.), # Object_State(name="o3", timestamp=2, x=3., y=11., xsize=5., ysize=8.)] o1 = (2.0, 2.0, 2., 2.) o2 = (4.0, 3.0, 1., 1.) o1 = return_bounding_box_2d(o1[0], o1[1], o1[2], o1[3]) o2 = return_bounding_box_2d(o2[0], o2[1], o2[2], o2[3]) print("o1o2:", bboxes_intercept(o1, o2)) print("o2o1:", bboxes_intercept(o2, o1)) # print("o1:", o1) # print("o2:", o2) print("o1o2:", compute_qsr(o1, o2)) print("o2o1:", compute_qsr(o2, o1)) plot_bbs(o1, o2)
mit
nmartensen/pandas
pandas/io/sas/sas7bdat.py
5
27243
""" Read SAS7BDAT files Based on code written by Jared Hobbs: https://bitbucket.org/jaredhobbs/sas7bdat See also: https://github.com/BioStatMatt/sas7bdat Partial documentation of the file format: https://cran.r-project.org/web/packages/sas7bdat/vignettes/sas7bdat.pdf Reference for binary data compression: http://collaboration.cmc.ec.gc.ca/science/rpn/biblio/ddj/Website/articles/CUJ/1992/9210/ross/ross.htm """ import pandas as pd from pandas import compat from pandas.io.common import get_filepath_or_buffer, BaseIterator import numpy as np import struct import pandas.io.sas.sas_constants as const from pandas.io.sas._sas import Parser class _subheader_pointer(object): pass class _column(object): pass # SAS7BDAT represents a SAS data file in SAS7BDAT format. class SAS7BDATReader(BaseIterator): """ Read SAS files in SAS7BDAT format. Parameters ---------- path_or_buf : path name or buffer Name of SAS file or file-like object pointing to SAS file contents. index : column identifier, defaults to None Column to use as index. convert_dates : boolean, defaults to True Attempt to convert dates to Pandas datetime values. Note that some rarely used SAS date formats may be unsupported. blank_missing : boolean, defaults to True Convert empty strings to missing values (SAS uses blanks to indicate missing character variables). chunksize : int, defaults to None Return SAS7BDATReader object for iterations, returns chunks with given number of lines. encoding : string, defaults to None String encoding. convert_text : bool, defaults to True If False, text variables are left as raw bytes. convert_header_text : bool, defaults to True If False, header text, including column names, are left as raw bytes. """ def __init__(self, path_or_buf, index=None, convert_dates=True, blank_missing=True, chunksize=None, encoding=None, convert_text=True, convert_header_text=True): self.index = index self.convert_dates = convert_dates self.blank_missing = blank_missing self.chunksize = chunksize self.encoding = encoding self.convert_text = convert_text self.convert_header_text = convert_header_text self.default_encoding = "latin-1" self.compression = "" self.column_names_strings = [] self.column_names = [] self.column_types = [] self.column_formats = [] self.columns = [] self._current_page_data_subheader_pointers = [] self._cached_page = None self._column_data_lengths = [] self._column_data_offsets = [] self._current_row_in_file_index = 0 self._current_row_on_page_index = 0 self._current_row_in_file_index = 0 self._path_or_buf, _, _ = get_filepath_or_buffer(path_or_buf) if isinstance(self._path_or_buf, compat.string_types): self._path_or_buf = open(self._path_or_buf, 'rb') self.handle = self._path_or_buf self._get_properties() self._parse_metadata() def close(self): try: self.handle.close() except AttributeError: pass def _get_properties(self): # Check magic number self._path_or_buf.seek(0) self._cached_page = self._path_or_buf.read(288) if self._cached_page[0:len(const.magic)] != const.magic: self.close() raise ValueError("magic number mismatch (not a SAS file?)") # Get alignment information align1, align2 = 0, 0 buf = self._read_bytes(const.align_1_offset, const.align_1_length) if buf == const.u64_byte_checker_value: align2 = const.align_2_value self.U64 = True self._int_length = 8 self._page_bit_offset = const.page_bit_offset_x64 self._subheader_pointer_length = const.subheader_pointer_length_x64 else: self.U64 = False self._page_bit_offset = const.page_bit_offset_x86 self._subheader_pointer_length = const.subheader_pointer_length_x86 self._int_length = 4 buf = self._read_bytes(const.align_2_offset, const.align_2_length) if buf == const.align_1_checker_value: align1 = const.align_2_value total_align = align1 + align2 # Get endianness information buf = self._read_bytes(const.endianness_offset, const.endianness_length) if buf == b'\x01': self.byte_order = "<" else: self.byte_order = ">" # Get encoding information buf = self._read_bytes(const.encoding_offset, const.encoding_length)[0] if buf in const.encoding_names: self.file_encoding = const.encoding_names[buf] else: self.file_encoding = "unknown (code=%s)" % str(buf) # Get platform information buf = self._read_bytes(const.platform_offset, const.platform_length) if buf == b'1': self.platform = "unix" elif buf == b'2': self.platform = "windows" else: self.platform = "unknown" buf = self._read_bytes(const.dataset_offset, const.dataset_length) self.name = buf.rstrip(b'\x00 ') if self.convert_header_text: self.name = self.name.decode( self.encoding or self.default_encoding) buf = self._read_bytes(const.file_type_offset, const.file_type_length) self.file_type = buf.rstrip(b'\x00 ') if self.convert_header_text: self.file_type = self.file_type.decode( self.encoding or self.default_encoding) # Timestamp is epoch 01/01/1960 epoch = pd.datetime(1960, 1, 1) x = self._read_float(const.date_created_offset + align1, const.date_created_length) self.date_created = epoch + pd.to_timedelta(x, unit='s') x = self._read_float(const.date_modified_offset + align1, const.date_modified_length) self.date_modified = epoch + pd.to_timedelta(x, unit='s') self.header_length = self._read_int(const.header_size_offset + align1, const.header_size_length) # Read the rest of the header into cached_page. buf = self._path_or_buf.read(self.header_length - 288) self._cached_page += buf if len(self._cached_page) != self.header_length: self.close() raise ValueError("The SAS7BDAT file appears to be truncated.") self._page_length = self._read_int(const.page_size_offset + align1, const.page_size_length) self._page_count = self._read_int(const.page_count_offset + align1, const.page_count_length) buf = self._read_bytes(const.sas_release_offset + total_align, const.sas_release_length) self.sas_release = buf.rstrip(b'\x00 ') if self.convert_header_text: self.sas_release = self.sas_release.decode( self.encoding or self.default_encoding) buf = self._read_bytes(const.sas_server_type_offset + total_align, const.sas_server_type_length) self.server_type = buf.rstrip(b'\x00 ') if self.convert_header_text: self.server_type = self.server_type.decode( self.encoding or self.default_encoding) buf = self._read_bytes(const.os_version_number_offset + total_align, const.os_version_number_length) self.os_version = buf.rstrip(b'\x00 ') if self.convert_header_text: self.os_version = self.os_version.decode( self.encoding or self.default_encoding) buf = self._read_bytes(const.os_name_offset + total_align, const.os_name_length) buf = buf.rstrip(b'\x00 ') if len(buf) > 0: self.os_name = buf.decode(self.encoding or self.default_encoding) else: buf = self._read_bytes(const.os_maker_offset + total_align, const.os_maker_length) self.os_name = buf.rstrip(b'\x00 ') if self.convert_header_text: self.os_name = self.os_name.decode( self.encoding or self.default_encoding) def __next__(self): da = self.read(nrows=self.chunksize or 1) if da is None: raise StopIteration return da # Read a single float of the given width (4 or 8). def _read_float(self, offset, width): if width not in (4, 8): self.close() raise ValueError("invalid float width") buf = self._read_bytes(offset, width) fd = "f" if width == 4 else "d" return struct.unpack(self.byte_order + fd, buf)[0] # Read a single signed integer of the given width (1, 2, 4 or 8). def _read_int(self, offset, width): if width not in (1, 2, 4, 8): self.close() raise ValueError("invalid int width") buf = self._read_bytes(offset, width) it = {1: "b", 2: "h", 4: "l", 8: "q"}[width] iv = struct.unpack(self.byte_order + it, buf)[0] return iv def _read_bytes(self, offset, length): if self._cached_page is None: self._path_or_buf.seek(offset) buf = self._path_or_buf.read(length) if len(buf) < length: self.close() msg = "Unable to read {:d} bytes from file position {:d}." raise ValueError(msg.format(length, offset)) return buf else: if offset + length > len(self._cached_page): self.close() raise ValueError("The cached page is too small.") return self._cached_page[offset:offset + length] def _parse_metadata(self): done = False while not done: self._cached_page = self._path_or_buf.read(self._page_length) if len(self._cached_page) <= 0: break if len(self._cached_page) != self._page_length: self.close() raise ValueError( "Failed to read a meta data page from the SAS file.") done = self._process_page_meta() def _process_page_meta(self): self._read_page_header() pt = [const.page_meta_type, const.page_amd_type] + const.page_mix_types if self._current_page_type in pt: self._process_page_metadata() return ((self._current_page_type in [256] + const.page_mix_types) or (self._current_page_data_subheader_pointers is not None)) def _read_page_header(self): bit_offset = self._page_bit_offset tx = const.page_type_offset + bit_offset self._current_page_type = self._read_int(tx, const.page_type_length) tx = const.block_count_offset + bit_offset self._current_page_block_count = self._read_int( tx, const.block_count_length) tx = const.subheader_count_offset + bit_offset self._current_page_subheaders_count = ( self._read_int(tx, const.subheader_count_length)) def _process_page_metadata(self): bit_offset = self._page_bit_offset for i in range(self._current_page_subheaders_count): pointer = self._process_subheader_pointers( const.subheader_pointers_offset + bit_offset, i) if pointer.length == 0: continue if pointer.compression == const.truncated_subheader_id: continue subheader_signature = self._read_subheader_signature( pointer.offset) subheader_index = ( self._get_subheader_index(subheader_signature, pointer.compression, pointer.ptype)) self._process_subheader(subheader_index, pointer) def _get_subheader_index(self, signature, compression, ptype): index = const.subheader_signature_to_index.get(signature) if index is None: f1 = ((compression == const.compressed_subheader_id) or (compression == 0)) f2 = (ptype == const.compressed_subheader_type) if (self.compression != "") and f1 and f2: index = const.index.dataSubheaderIndex else: self.close() raise ValueError("Unknown subheader signature") return index def _process_subheader_pointers(self, offset, subheader_pointer_index): subheader_pointer_length = self._subheader_pointer_length total_offset = (offset + subheader_pointer_length * subheader_pointer_index) subheader_offset = self._read_int(total_offset, self._int_length) total_offset += self._int_length subheader_length = self._read_int(total_offset, self._int_length) total_offset += self._int_length subheader_compression = self._read_int(total_offset, 1) total_offset += 1 subheader_type = self._read_int(total_offset, 1) x = _subheader_pointer() x.offset = subheader_offset x.length = subheader_length x.compression = subheader_compression x.ptype = subheader_type return x def _read_subheader_signature(self, offset): subheader_signature = self._read_bytes(offset, self._int_length) return subheader_signature def _process_subheader(self, subheader_index, pointer): offset = pointer.offset length = pointer.length if subheader_index == const.index.rowSizeIndex: processor = self._process_rowsize_subheader elif subheader_index == const.index.columnSizeIndex: processor = self._process_columnsize_subheader elif subheader_index == const.index.columnTextIndex: processor = self._process_columntext_subheader elif subheader_index == const.index.columnNameIndex: processor = self._process_columnname_subheader elif subheader_index == const.index.columnAttributesIndex: processor = self._process_columnattributes_subheader elif subheader_index == const.index.formatAndLabelIndex: processor = self._process_format_subheader elif subheader_index == const.index.columnListIndex: processor = self._process_columnlist_subheader elif subheader_index == const.index.subheaderCountsIndex: processor = self._process_subheader_counts elif subheader_index == const.index.dataSubheaderIndex: self._current_page_data_subheader_pointers.append(pointer) return else: raise ValueError("unknown subheader index") processor(offset, length) def _process_rowsize_subheader(self, offset, length): int_len = self._int_length lcs_offset = offset lcp_offset = offset if self.U64: lcs_offset += 682 lcp_offset += 706 else: lcs_offset += 354 lcp_offset += 378 self.row_length = self._read_int( offset + const.row_length_offset_multiplier * int_len, int_len) self.row_count = self._read_int( offset + const.row_count_offset_multiplier * int_len, int_len) self.col_count_p1 = self._read_int( offset + const.col_count_p1_multiplier * int_len, int_len) self.col_count_p2 = self._read_int( offset + const.col_count_p2_multiplier * int_len, int_len) mx = const.row_count_on_mix_page_offset_multiplier * int_len self._mix_page_row_count = self._read_int(offset + mx, int_len) self._lcs = self._read_int(lcs_offset, 2) self._lcp = self._read_int(lcp_offset, 2) def _process_columnsize_subheader(self, offset, length): int_len = self._int_length offset += int_len self.column_count = self._read_int(offset, int_len) if (self.col_count_p1 + self.col_count_p2 != self.column_count): print("Warning: column count mismatch (%d + %d != %d)\n", self.col_count_p1, self.col_count_p2, self.column_count) # Unknown purpose def _process_subheader_counts(self, offset, length): pass def _process_columntext_subheader(self, offset, length): offset += self._int_length text_block_size = self._read_int(offset, const.text_block_size_length) buf = self._read_bytes(offset, text_block_size) cname_raw = buf[0:text_block_size].rstrip(b"\x00 ") cname = cname_raw if self.convert_header_text: cname = cname.decode(self.encoding or self.default_encoding) self.column_names_strings.append(cname) if len(self.column_names_strings) == 1: compression_literal = "" for cl in const.compression_literals: if cl in cname_raw: compression_literal = cl self.compression = compression_literal offset -= self._int_length offset1 = offset + 16 if self.U64: offset1 += 4 buf = self._read_bytes(offset1, self._lcp) compression_literal = buf.rstrip(b"\x00") if compression_literal == "": self._lcs = 0 offset1 = offset + 32 if self.U64: offset1 += 4 buf = self._read_bytes(offset1, self._lcp) self.creator_proc = buf[0:self._lcp] elif compression_literal == const.rle_compression: offset1 = offset + 40 if self.U64: offset1 += 4 buf = self._read_bytes(offset1, self._lcp) self.creator_proc = buf[0:self._lcp] elif self._lcs > 0: self._lcp = 0 offset1 = offset + 16 if self.U64: offset1 += 4 buf = self._read_bytes(offset1, self._lcs) self.creator_proc = buf[0:self._lcp] if self.convert_header_text: if hasattr(self, "creator_proc"): self.creator_proc = self.creator_proc.decode( self.encoding or self.default_encoding) def _process_columnname_subheader(self, offset, length): int_len = self._int_length offset += int_len column_name_pointers_count = (length - 2 * int_len - 12) // 8 for i in range(column_name_pointers_count): text_subheader = offset + const.column_name_pointer_length * \ (i + 1) + const.column_name_text_subheader_offset col_name_offset = offset + const.column_name_pointer_length * \ (i + 1) + const.column_name_offset_offset col_name_length = offset + const.column_name_pointer_length * \ (i + 1) + const.column_name_length_offset idx = self._read_int( text_subheader, const.column_name_text_subheader_length) col_offset = self._read_int( col_name_offset, const.column_name_offset_length) col_len = self._read_int( col_name_length, const.column_name_length_length) name_str = self.column_names_strings[idx] self.column_names.append(name_str[col_offset:col_offset + col_len]) def _process_columnattributes_subheader(self, offset, length): int_len = self._int_length column_attributes_vectors_count = ( length - 2 * int_len - 12) // (int_len + 8) self.column_types = np.empty( column_attributes_vectors_count, dtype=np.dtype('S1')) self._column_data_lengths = np.empty( column_attributes_vectors_count, dtype=np.int64) self._column_data_offsets = np.empty( column_attributes_vectors_count, dtype=np.int64) for i in range(column_attributes_vectors_count): col_data_offset = (offset + int_len + const.column_data_offset_offset + i * (int_len + 8)) col_data_len = (offset + 2 * int_len + const.column_data_length_offset + i * (int_len + 8)) col_types = (offset + 2 * int_len + const.column_type_offset + i * (int_len + 8)) x = self._read_int(col_data_offset, int_len) self._column_data_offsets[i] = x x = self._read_int(col_data_len, const.column_data_length_length) self._column_data_lengths[i] = x x = self._read_int(col_types, const.column_type_length) if x == 1: self.column_types[i] = b'd' else: self.column_types[i] = b's' def _process_columnlist_subheader(self, offset, length): # unknown purpose pass def _process_format_subheader(self, offset, length): int_len = self._int_length text_subheader_format = ( offset + const.column_format_text_subheader_index_offset + 3 * int_len) col_format_offset = (offset + const.column_format_offset_offset + 3 * int_len) col_format_len = (offset + const.column_format_length_offset + 3 * int_len) text_subheader_label = ( offset + const.column_label_text_subheader_index_offset + 3 * int_len) col_label_offset = (offset + const.column_label_offset_offset + 3 * int_len) col_label_len = offset + const.column_label_length_offset + 3 * int_len x = self._read_int(text_subheader_format, const.column_format_text_subheader_index_length) format_idx = min(x, len(self.column_names_strings) - 1) format_start = self._read_int( col_format_offset, const.column_format_offset_length) format_len = self._read_int( col_format_len, const.column_format_length_length) label_idx = self._read_int( text_subheader_label, const.column_label_text_subheader_index_length) label_idx = min(label_idx, len(self.column_names_strings) - 1) label_start = self._read_int( col_label_offset, const.column_label_offset_length) label_len = self._read_int(col_label_len, const.column_label_length_length) label_names = self.column_names_strings[label_idx] column_label = label_names[label_start: label_start + label_len] format_names = self.column_names_strings[format_idx] column_format = format_names[format_start: format_start + format_len] current_column_number = len(self.columns) col = _column() col.col_id = current_column_number col.name = self.column_names[current_column_number] col.label = column_label col.format = column_format col.ctype = self.column_types[current_column_number] col.length = self._column_data_lengths[current_column_number] self.column_formats.append(column_format) self.columns.append(col) def read(self, nrows=None): if (nrows is None) and (self.chunksize is not None): nrows = self.chunksize elif nrows is None: nrows = self.row_count if self._current_row_in_file_index >= self.row_count: return None m = self.row_count - self._current_row_in_file_index if nrows > m: nrows = m nd = (self.column_types == b'd').sum() ns = (self.column_types == b's').sum() self._string_chunk = np.empty((ns, nrows), dtype=np.object) self._byte_chunk = np.empty((nd, 8 * nrows), dtype=np.uint8) self._current_row_in_chunk_index = 0 p = Parser(self) p.read(nrows) rslt = self._chunk_to_dataframe() if self.index is not None: rslt = rslt.set_index(self.index) return rslt def _read_next_page(self): self._current_page_data_subheader_pointers = [] self._cached_page = self._path_or_buf.read(self._page_length) if len(self._cached_page) <= 0: return True elif len(self._cached_page) != self._page_length: self.close() msg = ("failed to read complete page from file " "(read {:d} of {:d} bytes)") raise ValueError(msg.format(len(self._cached_page), self._page_length)) self._read_page_header() if self._current_page_type == const.page_meta_type: self._process_page_metadata() pt = [const.page_meta_type, const.page_data_type] pt += [const.page_mix_types] if self._current_page_type not in pt: return self._read_next_page() return False def _chunk_to_dataframe(self): n = self._current_row_in_chunk_index m = self._current_row_in_file_index ix = range(m - n, m) rslt = pd.DataFrame(index=ix) js, jb = 0, 0 for j in range(self.column_count): name = self.column_names[j] if self.column_types[j] == b'd': rslt[name] = self._byte_chunk[jb, :].view( dtype=self.byte_order + 'd') rslt[name] = np.asarray(rslt[name], dtype=np.float64) if self.convert_dates: unit = None if self.column_formats[j] in const.sas_date_formats: unit = 'd' elif self.column_formats[j] in const.sas_datetime_formats: unit = 's' if unit: rslt[name] = pd.to_datetime(rslt[name], unit=unit, origin="1960-01-01") jb += 1 elif self.column_types[j] == b's': rslt[name] = self._string_chunk[js, :] if self.convert_text and (self.encoding is not None): rslt[name] = rslt[name].str.decode( self.encoding or self.default_encoding) if self.blank_missing: ii = rslt[name].str.len() == 0 rslt.loc[ii, name] = np.nan js += 1 else: self.close() raise ValueError("unknown column type %s" % self.column_types[j]) return rslt
bsd-3-clause
cbertinato/pandas
pandas/io/json/normalize.py
1
9424
# --------------------------------------------------------------------- # JSON normalization routines from collections import defaultdict import copy import numpy as np from pandas._libs.writers import convert_json_to_lines from pandas import DataFrame def _convert_to_line_delimits(s): """ Helper function that converts JSON lists to line delimited JSON. """ # Determine we have a JSON list to turn to lines otherwise just return the # json object, only lists can if not s[0] == '[' and s[-1] == ']': return s s = s[1:-1] return convert_json_to_lines(s) def nested_to_record(ds, prefix="", sep=".", level=0): """ A simplified json_normalize. Converts a nested dict into a flat dict ("record"), unlike json_normalize, it does not attempt to extract a subset of the data. Parameters ---------- ds : dict or list of dicts prefix: the prefix, optional, default: "" sep : string, default '.' Nested records will generate names separated by sep, e.g., for sep='.', { 'foo' : { 'bar' : 0 } } -> foo.bar .. versionadded:: 0.20.0 level: the number of levels in the jason string, optional, default: 0 Returns ------- d - dict or list of dicts, matching `ds` Examples -------- IN[52]: nested_to_record(dict(flat1=1,dict1=dict(c=1,d=2), nested=dict(e=dict(c=1,d=2),d=2))) Out[52]: {'dict1.c': 1, 'dict1.d': 2, 'flat1': 1, 'nested.d': 2, 'nested.e.c': 1, 'nested.e.d': 2} """ singleton = False if isinstance(ds, dict): ds = [ds] singleton = True new_ds = [] for d in ds: new_d = copy.deepcopy(d) for k, v in d.items(): # each key gets renamed with prefix if not isinstance(k, str): k = str(k) if level == 0: newkey = k else: newkey = prefix + sep + k # only dicts gets recurse-flattened # only at level>1 do we rename the rest of the keys if not isinstance(v, dict): if level != 0: # so we skip copying for top level, common case v = new_d.pop(k) new_d[newkey] = v continue else: v = new_d.pop(k) new_d.update(nested_to_record(v, newkey, sep, level + 1)) new_ds.append(new_d) if singleton: return new_ds[0] return new_ds def json_normalize(data, record_path=None, meta=None, meta_prefix=None, record_prefix=None, errors='raise', sep='.'): """ Normalize semi-structured JSON data into a flat table. Parameters ---------- data : dict or list of dicts Unserialized JSON objects record_path : string or list of strings, default None Path in each object to list of records. If not passed, data will be assumed to be an array of records meta : list of paths (string or list of strings), default None Fields to use as metadata for each record in resulting table meta_prefix : string, default None record_prefix : string, default None If True, prefix records with dotted (?) path, e.g. foo.bar.field if path to records is ['foo', 'bar'] errors : {'raise', 'ignore'}, default 'raise' * 'ignore' : will ignore KeyError if keys listed in meta are not always present * 'raise' : will raise KeyError if keys listed in meta are not always present .. versionadded:: 0.20.0 sep : string, default '.' Nested records will generate names separated by sep, e.g., for sep='.', { 'foo' : { 'bar' : 0 } } -> foo.bar .. versionadded:: 0.20.0 Returns ------- frame : DataFrame Examples -------- >>> from pandas.io.json import json_normalize >>> data = [{'id': 1, 'name': {'first': 'Coleen', 'last': 'Volk'}}, ... {'name': {'given': 'Mose', 'family': 'Regner'}}, ... {'id': 2, 'name': 'Faye Raker'}] >>> json_normalize(data) id name name.family name.first name.given name.last 0 1.0 NaN NaN Coleen NaN Volk 1 NaN NaN Regner NaN Mose NaN 2 2.0 Faye Raker NaN NaN NaN NaN >>> data = [{'state': 'Florida', ... 'shortname': 'FL', ... 'info': { ... 'governor': 'Rick Scott' ... }, ... 'counties': [{'name': 'Dade', 'population': 12345}, ... {'name': 'Broward', 'population': 40000}, ... {'name': 'Palm Beach', 'population': 60000}]}, ... {'state': 'Ohio', ... 'shortname': 'OH', ... 'info': { ... 'governor': 'John Kasich' ... }, ... 'counties': [{'name': 'Summit', 'population': 1234}, ... {'name': 'Cuyahoga', 'population': 1337}]}] >>> result = json_normalize(data, 'counties', ['state', 'shortname', ... ['info', 'governor']]) >>> result name population info.governor state shortname 0 Dade 12345 Rick Scott Florida FL 1 Broward 40000 Rick Scott Florida FL 2 Palm Beach 60000 Rick Scott Florida FL 3 Summit 1234 John Kasich Ohio OH 4 Cuyahoga 1337 John Kasich Ohio OH >>> data = {'A': [1, 2]} >>> json_normalize(data, 'A', record_prefix='Prefix.') Prefix.0 0 1 1 2 """ def _pull_field(js, spec): result = js if isinstance(spec, list): for field in spec: result = result[field] else: result = result[spec] return result if isinstance(data, list) and not data: return DataFrame() # A bit of a hackjob if isinstance(data, dict): data = [data] if record_path is None: if any([isinstance(x, dict) for x in y.values()] for y in data): # naive normalization, this is idempotent for flat records # and potentially will inflate the data considerably for # deeply nested structures: # {VeryLong: { b: 1,c:2}} -> {VeryLong.b:1 ,VeryLong.c:@} # # TODO: handle record value which are lists, at least error # reasonably data = nested_to_record(data, sep=sep) return DataFrame(data) elif not isinstance(record_path, list): record_path = [record_path] if meta is None: meta = [] elif not isinstance(meta, list): meta = [meta] meta = [m if isinstance(m, list) else [m] for m in meta] # Disastrously inefficient for now records = [] lengths = [] meta_vals = defaultdict(list) if not isinstance(sep, str): sep = str(sep) meta_keys = [sep.join(val) for val in meta] def _recursive_extract(data, path, seen_meta, level=0): if isinstance(data, dict): data = [data] if len(path) > 1: for obj in data: for val, key in zip(meta, meta_keys): if level + 1 == len(val): seen_meta[key] = _pull_field(obj, val[-1]) _recursive_extract(obj[path[0]], path[1:], seen_meta, level=level + 1) else: for obj in data: recs = _pull_field(obj, path[0]) # For repeating the metadata later lengths.append(len(recs)) for val, key in zip(meta, meta_keys): if level + 1 > len(val): meta_val = seen_meta[key] else: try: meta_val = _pull_field(obj, val[level:]) except KeyError as e: if errors == 'ignore': meta_val = np.nan else: raise KeyError("Try running with " "errors='ignore' as key " "{err} is not always present" .format(err=e)) meta_vals[key].append(meta_val) records.extend(recs) _recursive_extract(data, record_path, {}, level=0) result = DataFrame(records) if record_prefix is not None: result = result.rename( columns=lambda x: "{p}{c}".format(p=record_prefix, c=x)) # Data types, a problem for k, v in meta_vals.items(): if meta_prefix is not None: k = meta_prefix + k if k in result: raise ValueError('Conflicting metadata name {name}, ' 'need distinguishing prefix '.format(name=k)) # forcing dtype to object to avoid the metadata being casted to string result[k] = np.array(v, dtype=object).repeat(lengths) return result
bsd-3-clause
Nikea/pyXPCS
pyxpcs/minimize.py
1
5523
# Licensed as BSD by Yuriy Chushkin of the ESRF on 2014-08-06 ################################################################################ # Copyright (c) 2014, the European Synchrotron Radiation Facility # # All rights reserved. # # # # Redistribution and use in source and binary forms, with or without # # modification, are permitted provided that the following conditions are met: # # # # * Redistributions of source code must retain the above copyright notice, # # this list of conditions and the following disclaimer. # # # # * Redistributions in binary form must reproduce the above copyright notice, # # this list of conditions and the following disclaimer in the documentation # # and/or other materials provided with the distribution. # # # # * Neither the name of the European Synchrotron Radiation Facility nor the # # names of its contributors may be used to endorse or promote products # # derived from this software without specific prior written permission. # # # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" # # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # # ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE # # LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # # CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # # SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # # CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE # # POSSIBILITY OF SUCH DAMAGE. # ################################################################################ from array import * #from scipy import * from scipy.optimize import leastsq import scipy.io.array_import from scipy import factorial from numpy import * import matplotlib.pylab as pyl def residuals(p,y,x,yerr): err = (y-peval(x,p))/yerr return err ######################################################### def residuals_duri_global(p, y, x,yerr,qval): print p #not the squared ones, squaring will be handled by leastsq err = 0 xplot=pyl.array(x,typecode='d') for i,q in enumerate(qval): q= float(q) y_calc=peval_duri_global(x,p,q) # y_calcplot=pyl.array(y_calc,typecode='d') err+=(y[i,:]-y_calc)**2 # err+=y[i,:]-y_calc # pyl.figure(2) # yplot=pyl.array(y[i,:],typecode='d') # pyl.subplot(211) # pyl.semilogx(xplot,y_calcplot-yplot,'-') # pyl.hold(False) # pyl.subplot(212) # pyl.semilogx(xplot,yplot,'o',xplot,y_calcplot,'-') # pyl.hold(False) err = sqrt(err) return err ######################################################### def peval_duri_global(x,p,q): global func return eval(func) ######################################################### def peval(x,p): global func return eval(func) ######################################################### def def_func(npar,c0): global func for i in range(npar): par_old='p'+str(i) par_new='p['+str(i)+']' func= func.replace(par_old,par_new) nconst=len(c0) for i in range(nconst): name='c'+str(i) value=str(c0[i]) func=func.replace(name,value) print func return func ######################################################### def fitting(x,y,f,p0,c0,yerr='none',qval='none'): if yerr=='none': yerr=y*0+y/y global func func=f npar=len(p0) func=def_func(npar,c0) print 'fitting with funcion: ', func print 'no of parameters: ', len(p0) # plsq = leastsq(residuals, p0, args=(y,x,yerr), col_deriv=1, maxfev=20000) if 'duri' in func: plsq= leastsq(residuals_duri_global, p0, args=(y,x,yerr,qval), col_deriv=0, ftol=1e-4, maxfev=2000000) else: plsq = leastsq(residuals, p0, args=(y,x,yerr), col_deriv=0, maxfev=20000) if npar==1: final_par = array([plsq[0]]) else: final_par = plsq[0] if 'duri' in func: yfit=0*y for i,q in enumerate(qval): q=float(q) yfit[i,:]=pyl.array(peval_duri_global(x,final_par,q),typecode='d') else: yfit=pyl.array(peval(x,final_par),typecode='d') return yfit, final_par, func def func_duri(x,q,gamma0,delta,alfa,n=101): gn=resize(0*x,[n,len(x)]) alfa=abs(cos(alfa)) for k in range(n): P_k=(exp(-abs(gamma0)*x)*(abs(gamma0)*x)**k)/factorial(k) gn[k,:]= P_k*exp(-(q*abs(delta)*k**abs(alfa))**2) g1=sum(gn,axis=0) return g1 #####from yuriy #out=leastsq(errfunc,p0,args=(xdata,ydata,b),full_output=1) # p1[i,1:]=out[0] # covar=out[1] # err[i,:]=sqrt(diag(covar,k=0))
bsd-3-clause
michaelaye/planet4
planet4/io.py
1
17380
import configparser import datetime as dt import logging import os import shutil from pathlib import Path from urllib.error import URLError import matplotlib.image as mplimg import pandas as pd import pkg_resources as pr from . import stats from .exceptions import NoFilesFoundError try: from urllib import urlretrieve except ImportError: from urllib.request import urlretrieve pkg_name = __name__.split('.')[0] configpath = Path.home() / ".{}.ini".format(pkg_name) LOGGER = logging.getLogger(__name__) def get_config(): """Read the configfile and return config dict. Returns ------- dict Dictionary with the content of the configpath file. """ if not configpath.exists(): raise IOError("Config file {} not found.".format(str(configpath))) else: config = configparser.ConfigParser() config.read(str(configpath)) return config def set_database_path(dbfolder): """Use to write the database path into the config. Parameters ---------- dbfolder : str or pathlib.Path Path to where planet4 will store clustering results by default. """ try: d = get_config() except IOError: d = configparser.ConfigParser() d['planet4_db'] = {} d['planet4_db']['path'] = dbfolder with configpath.open('w') as f: d.write(f) print("Saved database path into {}.".format(configpath)) def get_data_root(): d = get_config() data_root = Path(d['planet4_db']['path']).expanduser() data_root.mkdir(exist_ok=True, parents=True) return data_root def get_ground_projection_root(): d = get_config() gp_root = Path(d['ground_projection']['path']) gp_root.mkdir(exist_ok=True) return gp_root if not configpath.exists(): print("No configuration file {} found.\n".format(configpath)) savepath = input( "Please provide the path where you want to store planet4 results:") set_database_path(savepath) else: data_root = get_data_root() def dropbox(): return Path.home() / 'Dropbox' def p4data(): return dropbox() / 'data' / 'planet4' def analysis_folder(): name = 'p4_analysis' if p4data().exists(): path = p4data() / name else: path = dropbox() / name return path def check_and_pad_id(imgid): "Does NOT work with pd.Series item." if imgid is None: return None imgid_template = "APF0000000" if len(imgid) < len(imgid_template): imgid = imgid_template[:-len(imgid)] + imgid return imgid def get_subframe(url): """Download image if not there yet and return numpy array. Takes a data record (called 'line'), picks out the image_url. First checks if the name of that image is already stored in the image path. If not, it grabs it from the server. Then uses matplotlib.image to read the image into a numpy-array and finally returns it. """ targetpath = data_root / 'images' / os.path.basename(url) targetpath.parent.mkdir(exist_ok=True) if not targetpath.exists(): LOGGER.info("Did not find image in cache. Downloading ...") try: path = urlretrieve(url)[0] except URLError: msg = "Cannot receive subframe image. No internet?" LOGGER.error(msg) return None LOGGER.debug("Done.") shutil.move(path, str(targetpath)) else: LOGGER.debug("Found image in cache.") im = mplimg.imread(targetpath) return im class P4DBName(object): def __init__(self, fname): self.p = Path(fname) date = str(self.name)[:10] self.date = dt.datetime(*[int(i) for i in date.split('-')]) def __getattr__(self, name): "looking up things in the Path object if not in `self`." return getattr(self.p, name) def get_latest_file(filenames): fnames = list(filenames) if len(fnames) == 0: raise NoFilesFoundError retval = P4DBName(fnames[0]) dtnow = retval.date for fname in fnames[1:]: dt_to_check = P4DBName(fname).date if dt_to_check > dtnow: dtnow = dt_to_check retval = P4DBName(fname) return retval.p def get_latest_cleaned_db(datadir=None): datadir = data_root if datadir is None else Path(datadir) h5files = list(datadir.glob('201*_queryable_cleaned*.h5')) if len(h5files) == 0: LOGGER.error("No files found. Searching in %s", str(datadir)) raise NoFilesFoundError(f"No files found. Searching in {str(datadir)}") return get_latest_file(h5files) def get_latest_season23_dbase(datadir=None): if datadir is None: datadir = data_root h5files = list(datadir.glob('201*_queryable_cleaned_seasons2and3.h5')) return get_latest_file(h5files) def get_test_database(): fname = pr.resource_filename('planet4', 'data/test_db.csv') return pd.read_csv(fname) def get_latest_tutorial_data(datadir=None): if datadir is None: datadir = data_root tut_files = datadir.glob('/*_tutorials.h5') tut_files = [i for i in tut_files if i.parent[:4].isdigit()] if not tut_files: raise NoFilesFoundError return pd.read_hdf(str(get_latest_file(tut_files)), 'df') def common_gold_ids(): # read the common gold_ids to check with open('../data/gold_standard_commons.txt') as f: gold_ids = f.read() gold_ids = gold_ids.split('\n') del gold_ids[-1] # last one is empty return gold_ids def get_image_names_from_db(dbfname): """Return arrary of HiRISE image_names from database file. Parameters ---------- dbfname : pathlib.Path or str Path to database file to be used. Returns ------- numpy.ndarray Array of unique image names. """ path = Path(dbfname) if path.suffix in ['.hdf', '.h5']: with pd.HDFStore(str(dbfname)) as store: return store.select_column('df', 'image_name').unique() elif path.suffix == '.csv': return pd.read_csv(dbfname).image_id.unique() def get_latest_marked(): return pd.read_hdf(str(get_latest_cleaned_db()), 'df', where='marking!=None') def get_image_id_from_fname(fname): "Return image_id from beginning of Path(fname).name" fname = Path(fname) name = fname.name return name.split('_')[0] def get_image_ids_in_folder(folder, extension='.csv'): fnames = Path(folder).glob('*' + extension) return [get_image_id_from_fname(i) for i in fnames] class PathManager(object): """Manage file paths and folders related to the analysis pipeline. Level definitions: * L0 : Raw output of Planet Four * L1A : Clustering of Blotches and Fans on their own * L1B : Clustered blotches and fans combined into final fans, final blotches, and fnotches that need to have a cut applied for the decision between fans or blotches. * L1C : Derived database where a cut has been applied for fnotches to become either fan or blotch. Parameters ---------- id_ : str, optional The data item id that is used to determine sub-paths. Can be set after init. datapath : str or pathlib.Path, optional the base path from where to manage all derived paths. No default assumed to prevent errors. suffix : {'.hdf', '.h5', '.csv'} The suffix that controls the reader function to be used. obsid : str, optional HiRISE obsid (i.e. P4 image_name), added as a folder inside path. Can be set after init. extra_path : str, pathlib.Path, optional Any extra path element that needs to be added to the standard path. Attributes ---------- cut_dir : pathlib.Path Defined in `get_cut_folder`. """ def __init__(self, id_='', datapath='clustering', suffix='.csv', obsid='', cut=0.5, extra_path=''): self.id = id_ self.cut = cut self._obsid = obsid self.extra_path = extra_path if datapath is None: # take default path if none given self._datapath = Path(data_root) / 'clustering' elif Path(datapath).is_absolute(): # if given datapath is absolute, take only that: self._datapath = Path(datapath) else: # if it is relative, add it to data_root self._datapath = Path(data_root) / datapath self.suffix = suffix # point reader to correct function depending on required suffix if suffix in ['.hdf', '.h5']: self.reader = pd.read_hdf elif suffix == '.csv': self.reader = pd.read_csv # making sure to warn the user here if the data isn't where it's expected to be if id_ != '': if not self.path_so_far.exists(): raise FileNotFoundError(f"{self.path_so_far} does not exist.") @property def id(self): return self._id @id.setter def id(self, value): if value is not None: self._id = check_and_pad_id(value) @property def clustering_logfile(self): return self.fanfile.parent / 'clustering_settings.yaml' @property def obsid(self): if self._obsid is '': if self.id is not '': LOGGER.debug("Entering obsid search for known image_id.") db = DBManager() data = db.get_image_id_markings(self.id) try: obsid = data.image_name.iloc[0] except IndexError: raise IndexError("obsid access broken. Did you forget to use the `obsid` keyword" " at initialization?") LOGGER.debug("obsid found: %s", obsid) self._obsid = obsid return self._obsid @obsid.setter def obsid(self, value): self._obsid = value @property def obsid_results_savefolder(self): subfolder = 'p4_catalog' if self.datapath is None else self.datapath savefolder = analysis_folder() / subfolder savefolder.mkdir(exist_ok=True, parents=True) return savefolder @property def obsid_final_fans_path(self): return self.obsid_results_savefolder / f"{self.obsid}_fans.csv" @property def obsid_final_blotches_path(self): return self.obsid_results_savefolder / f"{self.obsid}_blotches.csv" @property def datapath(self): return self._datapath @property def path_so_far(self): p = self.datapath p /= self.extra_path p /= self.obsid return p @property def L1A_folder(self): "Subfolder name for the clustered data before fnotching." return 'L1A' @property def L1B_folder(self): "Subfolder name for the fnotched data, before cut is applied." return 'L1B' @property def L1C_folder(self): "subfolder name for the final catalog after applying `cut`." return 'L1C_cut_{:.1f}'.format(self.cut) def get_path(self, marking, specific=''): p = self.path_so_far # now add the image_id try: p /= self.id except TypeError: logging.warning("self.id not set. Storing in obsid level.") id_ = self.id if self.id != '' else self.obsid # add the specific sub folder p /= specific if specific != '': p /= f"{id_}_{specific}_{marking}{self.suffix}" else: # prepend the data level to file name if given. p /= f"{id_}_{marking}{self.suffix}" return p def get_obsid_paths(self, level): """get all existing paths for a given data level. Parameters ---------- level : {'L1A', 'L1B', 'L1C'} """ folder = self.path_so_far # cast to upper case for the lazy... ;) level = level.upper() image_id_paths = [item for item in folder.glob('*') if item.is_dir()] bucket = [] for p in image_id_paths: try: bucket.append(next(p.glob(f"{level}*"))) except StopIteration: continue return bucket def get_df(self, fpath): return self.reader(str(fpath)) @property def fanfile(self): return self.get_path('fans', self.L1A_folder) @property def fandf(self): return self.get_df(self.fanfile) @property def reduced_fanfile(self): return self.get_path('fans', self.L1B_folder) @property def reduced_fandf(self): return self.get_df(self.reduced_fanfile) @property def final_fanfile(self): return self.get_path('fans', self.L1C_folder) @property def final_fandf(self): return self.get_df(self.final_fanfile) @property def blotchfile(self): return self.get_path('blotches', self.L1A_folder) @property def blotchdf(self): return self.get_df(self.blotchfile) @property def reduced_blotchfile(self): return self.get_path('blotches', self.L1B_folder) @property def reduced_blotchdf(self): return self.get_df(self.reduced_blotchfile) @property def final_blotchfile(self): return self.get_path('blotches', self.L1C_folder) @property def final_blotchdf(self): return self.get_df(self.final_blotchfile) @property def fnotchfile(self): return self.get_path('fnotches', self.L1B_folder) @property def fnotchdf(self): # the fnotchfile has an index, so i need to read that here: return pd.read_csv(self.fnotchfile, index_col=0) class DBManager(object): """Access class for database activities. Provides easy access to often used data items. Parameters ---------- dbname : str, optional Path to database file to be used. Default: use get_latest_cleaned_db() to find it. Attributes ---------- image_names image_ids n_image_ids n_image_names obsids : Alias to image_ids season2and3_image_names """ def __init__(self, dbname=None): """Initialize DBManager class. Parameters ---------- dbname : <str> Filename of database file to use. Default: Latest produced full database. """ if dbname is None: self.dbname = str(get_latest_cleaned_db()) else: self.dbname = str(dbname) def __repr__(self): s = "Database root: {}\n".format(Path(self.dbname).parent) s += "Database name: {}\n".format(Path(self.dbname).name) return s @property def orig_csv(self): p = Path(self.dbname) return p.parent / (p.name[:38] + '.csv') def set_latest_with_dupes_db(self, datadir=None): datadir = data_root if datadir is None else Path(datadir) h5files = datadir.glob('201*_queryable.h5') dbname = get_latest_file(h5files) print("Setting {} as dbname.".format(dbname.name)) self.dbname = str(dbname) @property def image_names(self): """Return list of unique obsids used in database. See also -------- get_image_names_from_db """ return get_image_names_from_db(self.dbname) @property def image_ids(self): "Return list of unique image_ids in database." with pd.HDFStore(self.dbname) as store: return store.select_column('df', 'image_id').unique() @property def n_image_ids(self): return len(self.image_ids) @property def n_image_names(self): return len(self.image_names) @property def obsids(self): "Alias to self.image_names." return self.image_names def get_all(self, datadir=None): return pd.read_hdf(str(self.dbname), 'df') def get_obsid_markings(self, obsid): "Return marking data for given HiRISE obsid." return pd.read_hdf(self.dbname, 'df', where='image_name=' + obsid) def get_image_name_markings(self, image_name): "Alias for get_obsid_markings." return self.get_obsid_markings(image_name) def get_image_id_markings(self, image_id): "Return marking data for one Planet4 image_id" image_id = check_and_pad_id(image_id) return pd.read_hdf(self.dbname, 'df', where='image_id=' + image_id) def get_data_for_obsids(self, obsids): bucket = [] for obsid in obsids: bucket.append(self.get_obsid_markings(obsid)) return pd.concat(bucket, ignore_index=True) def get_classification_id_data(self, class_id): "Return data for one classification_id" return pd.read_hdf(self.dbname, 'df', where="classification_id=='{}'".format(class_id)) @property def season2and3_image_names(self): "numpy.array : List of image_names for season 2 and 3." image_names = self.image_names metadf = pd.DataFrame(pd.Series(image_names).astype( 'str'), columns=['image_name']) stats.define_season_column(metadf) return metadf[(metadf.season > 1) & (metadf.season < 4)].image_name.unique() def get_general_filter(self, f): return pd.read_hdf(self.dbname, 'df', where=f)
isc
juancq/shape-deform
gplib.py
1
47610
# This file is part of DEAP. # # DEAP is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as # published by the Free Software Foundation, either version 3 of # the License, or (at your option) any later version. # # DEAP is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with DEAP. If not, see <http://www.gnu.org/licenses/>. """The :mod:`gp` module provides the methods and classes to perform Genetic Programming with DEAP. It essentially contains the classes to build a Genetic Program Tree, and the functions to evaluate it. This module support both strongly and loosely typed GP. """ import copy import math import random import re import sys import warnings from collections import defaultdict, deque from functools import partial, wraps from inspect import isclass from operator import eq, lt from deap import tools # Needed by HARM-GP ###################################### # GP Data structure # ###################################### # Define the name of type for any types. __type__ = object class PrimitiveTree(list): """Tree specifically formatted for optimization of genetic programming operations. The tree is represented with a list where the nodes are appended in a depth-first order. The nodes appended to the tree are required to have an attribute *arity* which defines the arity of the primitive. An arity of 0 is expected from terminals nodes. """ def __init__(self, content): list.__init__(self, content) def __deepcopy__(self, memo): new = self.__class__(self) new.__dict__.update(copy.deepcopy(self.__dict__, memo)) return new def __setitem__(self, key, val): # Check for most common errors # Does NOT check for STGP constraints if isinstance(key, slice): if key.start >= len(self): raise IndexError("Invalid slice object (try to assign a %s" " in a tree of size %d). Even if this is allowed by the" " list object slice setter, this should not be done in" " the PrimitiveTree context, as this may lead to an" " unpredictable behavior for searchSubtree or evaluate." % (key, len(self))) total = val[0].arity for node in val[1:]: total += node.arity - 1 if total != 0: raise ValueError("Invalid slice assignation : insertion of" " an incomplete subtree is not allowed in PrimitiveTree." " A tree is defined as incomplete when some nodes cannot" " be mapped to any position in the tree, considering the" " primitives' arity. For instance, the tree [sub, 4, 5," " 6] is incomplete if the arity of sub is 2, because it" " would produce an orphan node (the 6).") elif val.arity != self[key].arity: raise ValueError("Invalid node replacement with a node of a" " different arity.") list.__setitem__(self, key, val) def js_str(self): """Return the expression in a human readable string. """ string = "" stack = [] for node in self: stack.append((node, [])) while len(stack[-1][1]) == stack[-1][0].arity: prim, args = stack.pop() if type(prim) is Primitive: string = prim.d_format(*args) else: string = prim.format(*args) if len(stack) == 0: break # If stack is empty, all nodes should have been seen stack[-1][1].append(string) return string def __str__(self): """Return the expression in a human readable string. """ string = "" stack = [] for node in self: stack.append((node, [])) while len(stack[-1][1]) == stack[-1][0].arity: prim, args = stack.pop() string = prim.format(*args) if len(stack) == 0: break # If stack is empty, all nodes should have been seen stack[-1][1].append(string) return string @classmethod def from_string(cls, string, pset): """Try to convert a string expression into a PrimitiveTree given a PrimitiveSet *pset*. The primitive set needs to contain every primitive present in the expression. :param string: String representation of a Python expression. :param pset: Primitive set from which primitives are selected. :returns: PrimitiveTree populated with the deserialized primitives. """ tokens = re.split("[ \t\n\r\f\v(),]", string) expr = [] ret_types = deque() for token in tokens: if token == '': continue if len(ret_types) != 0: type_ = ret_types.popleft() else: type_ = None if token in pset.mapping: primitive = pset.mapping[token] if type_ is not None and not issubclass(primitive.ret, type_): raise TypeError("Primitive {} return type {} does not " "match the expected one: {}." .format(primitive, primitive.ret, type_)) expr.append(primitive) if isinstance(primitive, Primitive): ret_types.extendleft(reversed(primitive.args)) else: try: token = eval(token) except NameError: raise TypeError("Unable to evaluate terminal: {}.".format(token)) if type_ is None: type_ = type(token) if not issubclass(type(token), type_): raise TypeError("Terminal {} type {} does not " "match the expected one: {}." .format(token, type(token), type_)) expr.append(Terminal(token, False, type_)) return cls(expr) @property def height(self): """Return the height of the tree, or the depth of the deepest node. """ stack = [0] max_depth = 0 for elem in self: depth = stack.pop() max_depth = max(max_depth, depth) stack.extend([depth + 1] * elem.arity) return max_depth @property def root(self): """Root of the tree, the element 0 of the list. """ return self[0] def searchSubtree(self, begin): """Return a slice object that corresponds to the range of values that defines the subtree which has the element with index *begin* as its root. """ end = begin + 1 total = self[begin].arity while total > 0: total += self[end].arity - 1 end += 1 return slice(begin, end) class Primitive(object): """Class that encapsulates a primitive and when called with arguments it returns the Python code to call the primitive with the arguments. >>> pr = Primitive("mul", (int, int), int) >>> pr.format(1, 2) 'mul(1, 2)' """ __slots__ = ('name', 'arity', 'args', 'ret', 'seq') def __init__(self, name, args, ret): self.name = name self.arity = len(args) self.args = args self.ret = ret args = ", ".join(map("{{{0}}}".format, range(self.arity))) self.seq = "{name}({args})".format(name=self.name, args=args) def format(self, *args): return self.seq.format(*args) def d_format(self, *args): if self.arity == 2: return "({arg1} {name} {arg2})".format(name=self.name, arg1=args[0], arg2=args[1]) else: return self.seq.format(*args) def __eq__(self, other): if type(self) is type(other): return all(getattr(self, slot) == getattr(other, slot) for slot in self.__slots__) else: return NotImplemented class Terminal(object): """Class that encapsulates terminal primitive in expression. Terminals can be values or 0-arity functions. """ __slots__ = ('name', 'value', 'ret', 'conv_fct') def __init__(self, terminal, symbolic, ret): self.ret = ret self.value = terminal self.name = str(terminal) self.conv_fct = str if symbolic else repr @property def arity(self): return 0 def format(self): return self.conv_fct(self.value) def __eq__(self, other): if type(self) is type(other): return all(getattr(self, slot) == getattr(other, slot) for slot in self.__slots__) else: return NotImplemented class Ephemeral(Terminal): """Class that encapsulates a terminal which value is set when the object is created. To mutate the value, a new object has to be generated. This is an abstract base class. When subclassing, a staticmethod 'func' must be defined. """ def __init__(self): Terminal.__init__(self, self.func(), symbolic=False, ret=self.ret) @staticmethod def func(): """Return a random value used to define the ephemeral state. """ raise NotImplementedError class PrimitiveSetTyped(object): """Class that contains the primitives that can be used to solve a Strongly Typed GP problem. The set also defined the researched function return type, and input arguments type and number. """ def __init__(self, name, in_types, ret_type, prefix="ARG"): self.terminals = defaultdict(list) self.primitives = defaultdict(list) self.arguments = [] # setting "__builtins__" to None avoid the context # being polluted by builtins function when evaluating # GP expression. self.context = {"__builtins__": None} self.mapping = dict() self.terms_count = 0 self.prims_count = 0 self.name = name self.ret = ret_type self.ins = in_types for i, type_ in enumerate(in_types): arg_str = "{prefix}{index}".format(prefix=prefix, index=i) self.arguments.append(arg_str) term = Terminal(arg_str, True, type_) self._add(term) self.terms_count += 1 def renameArguments(self, **kargs): """Rename function arguments with new names from *kargs*. """ for i, old_name in enumerate(self.arguments): if old_name in kargs: new_name = kargs[old_name] self.arguments[i] = new_name self.mapping[new_name] = self.mapping[old_name] self.mapping[new_name].value = new_name del self.mapping[old_name] def _add(self, prim): def addType(dict_, ret_type): if not ret_type in dict_: new_list = [] for type_, list_ in dict_.items(): if issubclass(type_, ret_type): for item in list_: if not item in new_list: new_list.append(item) dict_[ret_type] = new_list addType(self.primitives, prim.ret) addType(self.terminals, prim.ret) self.mapping[prim.name] = prim if isinstance(prim, Primitive): for type_ in prim.args: addType(self.primitives, type_) addType(self.terminals, type_) dict_ = self.primitives else: dict_ = self.terminals for type_ in dict_: if issubclass(prim.ret, type_): dict_[type_].append(prim) def addPrimitive(self, primitive, in_types, ret_type, name=None): """Add a primitive to the set. :param primitive: callable object or a function. :parma in_types: list of primitives arguments' type :param ret_type: type returned by the primitive. :param name: alternative name for the primitive instead of its __name__ attribute. """ if name is None: name = primitive.__name__ prim = Primitive(name, in_types, ret_type) assert name not in self.context or \ self.context[name] is primitive, \ "Primitives are required to have a unique name. " \ "Consider using the argument 'name' to rename your "\ "second '%s' primitive." % (name,) self._add(prim) self.context[prim.name] = primitive self.prims_count += 1 def addTerminal(self, terminal, ret_type, name=None): """Add a terminal to the set. Terminals can be named using the optional *name* argument. This should be used : to define named constant (i.e.: pi); to speed the evaluation time when the object is long to build; when the object does not have a __repr__ functions that returns the code to build the object; when the object class is not a Python built-in. :param terminal: Object, or a function with no arguments. :param ret_type: Type of the terminal. :param name: defines the name of the terminal in the expression. """ symbolic = False if name is None and callable(terminal): name = terminal.__name__ assert name not in self.context, \ "Terminals are required to have a unique name. " \ "Consider using the argument 'name' to rename your "\ "second %s terminal." % (name,) if name is not None: self.context[name] = terminal terminal = name symbolic = True elif terminal in (True, False): # To support True and False terminals with Python 2. self.context[str(terminal)] = terminal prim = Terminal(terminal, symbolic, ret_type) self._add(prim) self.terms_count += 1 def addEphemeralConstant(self, name, ephemeral, ret_type): """Add an ephemeral constant to the set. An ephemeral constant is a no argument function that returns a random value. The value of the constant is constant for a Tree, but may differ from one Tree to another. :param name: name used to refers to this ephemeral type. :param ephemeral: function with no arguments returning a random value. :param ret_type: type of the object returned by *ephemeral*. """ module_gp = globals() if not name in module_gp: class_ = type(name, (Ephemeral,), {'func': staticmethod(ephemeral), 'ret': ret_type}) module_gp[name] = class_ else: class_ = module_gp[name] if issubclass(class_, Ephemeral): if class_.func is not ephemeral: raise Exception("Ephemerals with different functions should " "be named differently, even between psets.") elif class_.ret is not ret_type: raise Exception("Ephemerals with the same name and function " "should have the same type, even between psets.") else: raise Exception("Ephemerals should be named differently " "than classes defined in the gp module.") self._add(class_) self.terms_count += 1 def addADF(self, adfset): """Add an Automatically Defined Function (ADF) to the set. :param adfset: PrimitiveSetTyped containing the primitives with which the ADF can be built. """ prim = Primitive(adfset.name, adfset.ins, adfset.ret) self._add(prim) self.prims_count += 1 @property def terminalRatio(self): """Return the ratio of the number of terminals on the number of all kind of primitives. """ return self.terms_count / float(self.terms_count + self.prims_count) class PrimitiveSet(PrimitiveSetTyped): """Class same as :class:`~deap.gp.PrimitiveSetTyped`, except there is no definition of type. """ def __init__(self, name, arity, prefix="ARG"): args = [__type__] * arity PrimitiveSetTyped.__init__(self, name, args, __type__, prefix) self.js = None def addPrimitive(self, primitive, arity, name=None, js=None): """Add primitive *primitive* with arity *arity* to the set. If a name *name* is provided, it will replace the attribute __name__ attribute to represent/identify the primitive. """ assert arity > 0, "arity should be >= 1" args = [__type__] * arity self.js = js PrimitiveSetTyped.addPrimitive(self, primitive, args, __type__, name) def addTerminal(self, terminal, name=None): """Add a terminal to the set.""" PrimitiveSetTyped.addTerminal(self, terminal, __type__, name) def addEphemeralConstant(self, name, ephemeral): """Add an ephemeral constant to the set.""" PrimitiveSetTyped.addEphemeralConstant(self, name, ephemeral, __type__) ###################################### # GP Tree compilation functions # ###################################### def compile(expr, pset): """Compile the expression *expr*. :param expr: Expression to compile. It can either be a PrimitiveTree, a string of Python code or any object that when converted into string produced a valid Python code expression. :param pset: Primitive set against which the expression is compile. :returns: a function if the primitive set has 1 or more arguments, or return the results produced by evaluating the tree. """ code = str(expr) if len(pset.arguments) > 0: # This section is a stripped version of the lambdify # function of SymPy 0.6.6. args = ",".join(arg for arg in pset.arguments) code = "lambda {args}: {code}".format(args=args, code=code) try: return eval(code, pset.context, {}) except MemoryError: _, _, traceback = sys.exc_info() raise MemoryError, ("DEAP : Error in tree evaluation :" " Python cannot evaluate a tree higher than 90. " "To avoid this problem, you should use bloat control on your " "operators. See the DEAP documentation for more information. " "DEAP will now abort."), traceback def compileADF(expr, psets): """Compile the expression represented by a list of trees. The first element of the list is the main tree, and the following elements are automatically defined functions (ADF) that can be called by the first tree. :param expr: Expression to compile. It can either be a PrimitiveTree, a string of Python code or any object that when converted into string produced a valid Python code expression. :param psets: List of primitive sets. Each set corresponds to an ADF while the last set is associated with the expression and should contain reference to the preceding ADFs. :returns: a function if the main primitive set has 1 or more arguments, or return the results produced by evaluating the tree. """ adfdict = {} func = None for pset, subexpr in reversed(zip(psets, expr)): pset.context.update(adfdict) func = compile(subexpr, pset) adfdict.update({pset.name: func}) return func ###################################### # GP Program generation functions # ###################################### def genFull(pset, min_, max_, type_=None): """Generate an expression where each leaf has a the same depth between *min* and *max*. :param pset: Primitive set from which primitives are selected. :param min_: Minimum height of the produced trees. :param max_: Maximum Height of the produced trees. :param type_: The type that should return the tree when called, when :obj:`None` (default) the type of :pset: (pset.ret) is assumed. :returns: A full tree with all leaves at the same depth. """ def condition(height, depth): """Expression generation stops when the depth is equal to height.""" return depth == height return generate(pset, min_, max_, condition, type_) def genGrow(pset, min_, max_, type_=None): """Generate an expression where each leaf might have a different depth between *min* and *max*. :param pset: Primitive set from which primitives are selected. :param min_: Minimum height of the produced trees. :param max_: Maximum Height of the produced trees. :param type_: The type that should return the tree when called, when :obj:`None` (default) the type of :pset: (pset.ret) is assumed. :returns: A grown tree with leaves at possibly different depths. """ def condition(height, depth): """Expression generation stops when the depth is equal to height or when it is randomly determined that a a node should be a terminal. """ return depth == height or \ (depth >= min_ and random.random() < pset.terminalRatio) return generate(pset, min_, max_, condition, type_) def genHalfAndHalf(pset, min_, max_, type_=None): """Generate an expression with a PrimitiveSet *pset*. Half the time, the expression is generated with :func:`~deap.gp.genGrow`, the other half, the expression is generated with :func:`~deap.gp.genFull`. :param pset: Primitive set from which primitives are selected. :param min_: Minimum height of the produced trees. :param max_: Maximum Height of the produced trees. :param type_: The type that should return the tree when called, when :obj:`None` (default) the type of :pset: (pset.ret) is assumed. :returns: Either, a full or a grown tree. """ method = random.choice((genGrow, genFull)) return method(pset, min_, max_, type_) def genRamped(pset, min_, max_, type_=None): """ .. deprecated:: 1.0 The function has been renamed. Use :func:`~deap.gp.genHalfAndHalf` instead. """ warnings.warn("gp.genRamped has been renamed. Use genHalfAndHalf instead.", FutureWarning) return genHalfAndHalf(pset, min_, max_, type_) def generate(pset, min_, max_, condition, type_=None): """Generate a Tree as a list of list. The tree is build from the root to the leaves, and it stop growing when the condition is fulfilled. :param pset: Primitive set from which primitives are selected. :param min_: Minimum height of the produced trees. :param max_: Maximum Height of the produced trees. :param condition: The condition is a function that takes two arguments, the height of the tree to build and the current depth in the tree. :param type_: The type that should return the tree when called, when :obj:`None` (default) the type of :pset: (pset.ret) is assumed. :returns: A grown tree with leaves at possibly different depths dependending on the condition function. """ if type_ is None: type_ = pset.ret expr = [] height = random.randint(min_, max_) stack = [(0, type_)] while len(stack) != 0: depth, type_ = stack.pop() if condition(height, depth): try: term = random.choice(pset.terminals[type_]) except IndexError: _, _, traceback = sys.exc_info() raise IndexError, "The gp.generate function tried to add "\ "a terminal of type '%s', but there is "\ "none available." % (type_,), traceback if isclass(term): term = term() expr.append(term) else: try: prim = random.choice(pset.primitives[type_]) except IndexError: _, _, traceback = sys.exc_info() raise IndexError, "The gp.generate function tried to add "\ "a primitive of type '%s', but there is "\ "none available." % (type_,), traceback expr.append(prim) for arg in reversed(prim.args): stack.append((depth + 1, arg)) print 'in gen: ', expr return expr ###################################### # GP Crossovers # ###################################### def cxOnePoint(ind1, ind2): """Randomly select in each individual and exchange each subtree with the point as root between each individual. :param ind1: First tree participating in the crossover. :param ind2: Second tree participating in the crossover. :returns: A tuple of two trees. """ if len(ind1) < 2 or len(ind2) < 2: # No crossover on single node tree return ind1, ind2 # List all available primitive types in each individual types1 = defaultdict(list) types2 = defaultdict(list) if ind1.root.ret == __type__: # Not STGP optimization types1[__type__] = xrange(1, len(ind1)) types2[__type__] = xrange(1, len(ind2)) common_types = [__type__] else: for idx, node in enumerate(ind1[1:], 1): types1[node.ret].append(idx) for idx, node in enumerate(ind2[1:], 1): types2[node.ret].append(idx) common_types = set(types1.keys()).intersection(set(types2.keys())) if len(common_types) > 0: type_ = random.choice(list(common_types)) index1 = random.choice(types1[type_]) index2 = random.choice(types2[type_]) slice1 = ind1.searchSubtree(index1) slice2 = ind2.searchSubtree(index2) ind1[slice1], ind2[slice2] = ind2[slice2], ind1[slice1] return ind1, ind2 def cxOnePointLeafBiased(ind1, ind2, termpb): """Randomly select crossover point in each individual and exchange each subtree with the point as root between each individual. :param ind1: First typed tree participating in the crossover. :param ind2: Second typed tree participating in the crossover. :param termpb: The probability of chosing a terminal node (leaf). :returns: A tuple of two typed trees. When the nodes are strongly typed, the operator makes sure the second node type corresponds to the first node type. The parameter *termpb* sets the probability to choose between a terminal or non-terminal crossover point. For instance, as defined by Koza, non- terminal primitives are selected for 90% of the crossover points, and terminals for 10%, so *termpb* should be set to 0.1. """ if len(ind1) < 2 or len(ind2) < 2: # No crossover on single node tree return ind1, ind2 # Determine wether we keep terminals or primitives for each individual terminal_op = partial(eq, 0) primitive_op = partial(lt, 0) arity_op1 = terminal_op if random.random() < termpb else primitive_op arity_op2 = terminal_op if random.random() < termpb else primitive_op # List all available primitive or terminal types in each individual types1 = defaultdict(list) types2 = defaultdict(list) for idx, node in enumerate(ind1[1:], 1): if arity_op1(node.arity): types1[node.ret].append(idx) for idx, node in enumerate(ind2[1:], 1): if arity_op2(node.arity): types2[node.ret].append(idx) common_types = set(types1.keys()).intersection(set(types2.keys())) if len(common_types) > 0: # Set does not support indexing type_ = random.sample(common_types, 1)[0] index1 = random.choice(types1[type_]) index2 = random.choice(types2[type_]) slice1 = ind1.searchSubtree(index1) slice2 = ind2.searchSubtree(index2) ind1[slice1], ind2[slice2] = ind2[slice2], ind1[slice1] return ind1, ind2 ###################################### # GP Mutations # ###################################### def mutUniform(individual, expr, pset): """Randomly select a point in the tree *individual*, then replace the subtree at that point as a root by the expression generated using method :func:`expr`. :param individual: The tree to be mutated. :param expr: A function object that can generate an expression when called. :returns: A tuple of one tree. """ index = random.randrange(len(individual)) slice_ = individual.searchSubtree(index) type_ = individual[index].ret individual[slice_] = expr(pset=pset, type_=type_) return individual, def mutNodeReplacement(individual, pset): """Replaces a randomly chosen primitive from *individual* by a randomly chosen primitive with the same number of arguments from the :attr:`pset` attribute of the individual. :param individual: The normal or typed tree to be mutated. :returns: A tuple of one tree. """ if len(individual) < 2: return individual, index = random.randrange(1, len(individual)) node = individual[index] if node.arity == 0: # Terminal term = random.choice(pset.terminals[node.ret]) if isclass(term): term = term() individual[index] = term else: # Primitive prims = [p for p in pset.primitives[node.ret] if p.args == node.args] individual[index] = random.choice(prims) return individual, def mutEphemeral(individual, mode): """This operator works on the constants of the tree *individual*. In *mode* ``"one"``, it will change the value of one of the individual ephemeral constants by calling its generator function. In *mode* ``"all"``, it will change the value of **all** the ephemeral constants. :param individual: The normal or typed tree to be mutated. :param mode: A string to indicate to change ``"one"`` or ``"all"`` ephemeral constants. :returns: A tuple of one tree. """ if mode not in ["one", "all"]: raise ValueError("Mode must be one of \"one\" or \"all\"") ephemerals_idx = [index for index, node in enumerate(individual) if isinstance(node, Ephemeral)] if len(ephemerals_idx) > 0: if mode == "one": ephemerals_idx = (random.choice(ephemerals_idx),) for i in ephemerals_idx: individual[i] = type(individual[i])() return individual, def mutInsert(individual, pset): """Inserts a new branch at a random position in *individual*. The subtree at the chosen position is used as child node of the created subtree, in that way, it is really an insertion rather than a replacement. Note that the original subtree will become one of the children of the new primitive inserted, but not perforce the first (its position is randomly selected if the new primitive has more than one child). :param individual: The normal or typed tree to be mutated. :returns: A tuple of one tree. """ index = random.randrange(len(individual)) node = individual[index] slice_ = individual.searchSubtree(index) choice = random.choice # As we want to keep the current node as children of the new one, # it must accept the return value of the current node primitives = [p for p in pset.primitives[node.ret] if node.ret in p.args] if len(primitives) == 0: return individual, new_node = choice(primitives) new_subtree = [None] * len(new_node.args) position = choice([i for i, a in enumerate(new_node.args) if a == node.ret]) for i, arg_type in enumerate(new_node.args): if i != position: term = choice(pset.terminals[arg_type]) if isclass(term): term = term() new_subtree[i] = term new_subtree[position:position + 1] = individual[slice_] new_subtree.insert(0, new_node) individual[slice_] = new_subtree return individual, def mutShrink(individual): """This operator shrinks the *individual* by chosing randomly a branch and replacing it with one of the branch's arguments (also randomly chosen). :param individual: The tree to be shrinked. :returns: A tuple of one tree. """ # We don't want to "shrink" the root if len(individual) < 3 or individual.height <= 1: return individual, iprims = [] for i, node in enumerate(individual[1:], 1): if isinstance(node, Primitive) and node.ret in node.args: iprims.append((i, node)) if len(iprims) != 0: index, prim = random.choice(iprims) arg_idx = random.choice([i for i, type_ in enumerate(prim.args) if type_ == prim.ret]) rindex = index + 1 for _ in range(arg_idx + 1): rslice = individual.searchSubtree(rindex) subtree = individual[rslice] rindex += len(subtree) slice_ = individual.searchSubtree(index) individual[slice_] = subtree return individual, ###################################### # GP bloat control decorators # ###################################### def staticLimit(key, max_value): """Implement a static limit on some measurement on a GP tree, as defined by Koza in [Koza1989]. It may be used to decorate both crossover and mutation operators. When an invalid (over the limit) child is generated, it is simply replaced by one of its parents, randomly selected. This operator can be used to avoid memory errors occuring when the tree gets higher than 90 levels (as Python puts a limit on the call stack depth), because it can ensure that no tree higher than this limit will ever be accepted in the population, except if it was generated at initialization time. :param key: The function to use in order the get the wanted value. For instance, on a GP tree, ``operator.attrgetter('height')`` may be used to set a depth limit, and ``len`` to set a size limit. :param max_value: The maximum value allowed for the given measurement. :returns: A decorator that can be applied to a GP operator using \ :func:`~deap.base.Toolbox.decorate` .. note:: If you want to reproduce the exact behavior intended by Koza, set *key* to ``operator.attrgetter('height')`` and *max_value* to 17. .. [Koza1989] J.R. Koza, Genetic Programming - On the Programming of Computers by Means of Natural Selection (MIT Press, Cambridge, MA, 1992) """ def decorator(func): @wraps(func) def wrapper(*args, **kwargs): keep_inds = [copy.deepcopy(ind) for ind in args] new_inds = list(func(*args, **kwargs)) for i, ind in enumerate(new_inds): if key(ind) > max_value: new_inds[i] = random.choice(keep_inds) return new_inds return wrapper return decorator ###################################### # GP bloat control algorithms # ###################################### def harm(population, toolbox, cxpb, mutpb, ngen, alpha, beta, gamma, rho, nbrindsmodel=-1, mincutoff=20, stats=None, halloffame=None, verbose=__debug__): """Implement bloat control on a GP evolution using HARM-GP, as defined in [Gardner2015]. It is implemented in the form of an evolution algorithm (similar to :func:`~deap.algorithms.eaSimple`). :param population: A list of individuals. :param toolbox: A :class:`~deap.base.Toolbox` that contains the evolution operators. :param cxpb: The probability of mating two individuals. :param mutpb: The probability of mutating an individual. :param ngen: The number of generation. :param alpha: The HARM *alpha* parameter. :param beta: The HARM *beta* parameter. :param gamma: The HARM *gamma* parameter. :param rho: The HARM *rho* parameter. :param nbrindsmodel: The number of individuals to generate in order to model the natural distribution. -1 is a special value which uses the equation proposed in [Gardner2015] to set the value of this parameter : max(2000, len(population)) :param mincutoff: The absolute minimum value for the cutoff point. It is used to ensure that HARM does not shrink the population too much at the beginning of the evolution. The default value is usually fine. :param stats: A :class:`~deap.tools.Statistics` object that is updated inplace, optional. :param halloffame: A :class:`~deap.tools.HallOfFame` object that will contain the best individuals, optional. :param verbose: Whether or not to log the statistics. :returns: The final population :returns: A class:`~deap.tools.Logbook` with the statistics of the evolution This function expects the :meth:`toolbox.mate`, :meth:`toolbox.mutate`, :meth:`toolbox.select` and :meth:`toolbox.evaluate` aliases to be registered in the toolbox. .. note:: The recommended values for the HARM-GP parameters are *alpha=0.05*, *beta=10*, *gamma=0.25*, *rho=0.9*. However, these parameters can be adjusted to perform better on a specific problem (see the relevant paper for tuning information). The number of individuals used to model the natural distribution and the minimum cutoff point are less important, their default value being effective in most cases. .. [Gardner2015] M.-A. Gardner, C. Gagne, and M. Parizeau, Controlling Code Growth by Dynamically Shaping the Genotype Size Distribution, Genetic Programming and Evolvable Machines, 2015, DOI 10.1007/s10710-015-9242-8 """ def _genpop(n, pickfrom=[], acceptfunc=lambda s: True, producesizes=False): # Generate a population of n individuals, using individuals in # *pickfrom* if possible, with a *acceptfunc* acceptance function. # If *producesizes* is true, also return a list of the produced # individuals sizes. # This function is used 1) to generate the natural distribution # (in this case, pickfrom and acceptfunc should be let at their # default values) and 2) to generate the final population, in which # case pickfrom should be the natural population previously generated # and acceptfunc a function implementing the HARM-GP algorithm. producedpop = [] producedpopsizes = [] while len(producedpop) < n: if len(pickfrom) > 0: # If possible, use the already generated # individuals (more efficient) aspirant = pickfrom.pop() if acceptfunc(len(aspirant)): producedpop.append(aspirant) if producesizes: producedpopsizes.append(len(aspirant)) else: opRandom = random.random() if opRandom < cxpb: # Crossover aspirant1, aspirant2 = toolbox.mate(*map(toolbox.clone, toolbox.select(population, 2))) del aspirant1.fitness.values, aspirant2.fitness.values if acceptfunc(len(aspirant1)): producedpop.append(aspirant1) if producesizes: producedpopsizes.append(len(aspirant1)) if len(producedpop) < n and acceptfunc(len(aspirant2)): producedpop.append(aspirant2) if producesizes: producedpopsizes.append(len(aspirant2)) else: aspirant = toolbox.clone(toolbox.select(population, 1)[0]) if opRandom - cxpb < mutpb: # Mutation aspirant = toolbox.mutate(aspirant)[0] del aspirant.fitness.values if acceptfunc(len(aspirant)): producedpop.append(aspirant) if producesizes: producedpopsizes.append(len(aspirant)) if producesizes: return producedpop, producedpopsizes else: return producedpop halflifefunc = lambda x: (x * float(alpha) + beta) if nbrindsmodel == -1: nbrindsmodel = max(2000, len(population)) logbook = tools.Logbook() logbook.header = ['gen', 'nevals'] + (stats.fields if stats else []) # Evaluate the individuals with an invalid fitness invalid_ind = [ind for ind in population if not ind.fitness.valid] fitnesses = toolbox.map(toolbox.evaluate, invalid_ind) for ind, fit in zip(invalid_ind, fitnesses): ind.fitness.values = fit if halloffame is not None: halloffame.update(population) record = stats.compile(population) if stats else {} logbook.record(gen=0, nevals=len(invalid_ind), **record) if verbose: print logbook.stream # Begin the generational process for gen in range(1, ngen + 1): # Estimation population natural distribution of sizes naturalpop, naturalpopsizes = _genpop(nbrindsmodel, producesizes=True) naturalhist = [0] * (max(naturalpopsizes) + 3) for indsize in naturalpopsizes: # Kernel density estimation application naturalhist[indsize] += 0.4 naturalhist[indsize - 1] += 0.2 naturalhist[indsize + 1] += 0.2 naturalhist[indsize + 2] += 0.1 if indsize - 2 >= 0: naturalhist[indsize - 2] += 0.1 # Normalization naturalhist = [val * len(population) / nbrindsmodel for val in naturalhist] # Cutoff point selection sortednatural = sorted(naturalpop, key=lambda ind: ind.fitness) cutoffcandidates = sortednatural[int(len(population) * rho - 1):] # Select the cutoff point, with an absolute minimum applied # to avoid weird cases in the first generations cutoffsize = max(mincutoff, len(min(cutoffcandidates, key=len))) # Compute the target distribution targetfunc = lambda x: (gamma * len(population) * math.log(2) / halflifefunc(x)) * math.exp(-math.log(2) * (x - cutoffsize) / halflifefunc(x)) targethist = [naturalhist[binidx] if binidx <= cutoffsize else targetfunc(binidx) for binidx in range(len(naturalhist))] # Compute the probabilities distribution probhist = [t / n if n > 0 else t for n, t in zip(naturalhist, targethist)] probfunc = lambda s: probhist[s] if s < len(probhist) else targetfunc(s) acceptfunc = lambda s: random.random() <= probfunc(s) # Generate offspring using the acceptance probabilities # previously computed offspring = _genpop(len(population), pickfrom=naturalpop, acceptfunc=acceptfunc, producesizes=False) # Evaluate the individuals with an invalid fitness invalid_ind = [ind for ind in offspring if not ind.fitness.valid] fitnesses = toolbox.map(toolbox.evaluate, invalid_ind) for ind, fit in zip(invalid_ind, fitnesses): ind.fitness.values = fit # Update the hall of fame with the generated individuals if halloffame is not None: halloffame.update(offspring) # Replace the current population by the offspring population[:] = offspring # Append the current generation statistics to the logbook record = stats.compile(population) if stats else {} logbook.record(gen=gen, nevals=len(invalid_ind), **record) if verbose: print logbook.stream return population, logbook def graph(expr): """Construct the graph of a tree expression. The tree expression must be valid. It returns in order a node list, an edge list, and a dictionary of the per node labels. The node are represented by numbers, the edges are tuples connecting two nodes (number), and the labels are values of a dictionary for which keys are the node numbers. :param expr: A tree expression to convert into a graph. :returns: A node list, an edge list, and a dictionary of labels. The returned objects can be used directly to populate a `pygraphviz <http://networkx.lanl.gov/pygraphviz/>`_ graph:: import pygraphviz as pgv # [...] Execution of code that produce a tree expression nodes, edges, labels = graph(expr) g = pgv.AGraph() g.add_nodes_from(nodes) g.add_edges_from(edges) g.layout(prog="dot") for i in nodes: n = g.get_node(i) n.attr["label"] = labels[i] g.draw("tree.pdf") or a `NetworX <http://networkx.github.com/>`_ graph:: import matplotlib.pyplot as plt import networkx as nx # [...] Execution of code that produce a tree expression nodes, edges, labels = graph(expr) g = nx.Graph() g.add_nodes_from(nodes) g.add_edges_from(edges) pos = nx.graphviz_layout(g, prog="dot") nx.draw_networkx_nodes(g, pos) nx.draw_networkx_edges(g, pos) nx.draw_networkx_labels(g, pos, labels) plt.show() .. note:: We encourage you to use `pygraphviz <http://networkx.lanl.gov/pygraphviz/>`_ as the nodes might be plotted out of order when using `NetworX <http://networkx.github.com/>`_. """ nodes = range(len(expr)) edges = list() labels = dict() stack = [] for i, node in enumerate(expr): if stack: edges.append((stack[-1][0], i)) stack[-1][1] -= 1 labels[i] = node.name if isinstance(node, Primitive) else node.value stack.append([i, node.arity]) while stack and stack[-1][1] == 0: stack.pop() return nodes, edges, labels if __name__ == "__main__": import doctest doctest.testmod()
mit
devanshdalal/scikit-learn
sklearn/ensemble/tests/test_bagging.py
43
28175
""" Testing for the bagging ensemble module (sklearn.ensemble.bagging). """ # Author: Gilles Louppe # License: BSD 3 clause import numpy as np from sklearn.base import BaseEstimator from sklearn.utils.testing import assert_array_equal from sklearn.utils.testing import assert_array_almost_equal from sklearn.utils.testing import assert_equal from sklearn.utils.testing import assert_raises from sklearn.utils.testing import assert_greater from sklearn.utils.testing import assert_less from sklearn.utils.testing import assert_true from sklearn.utils.testing import assert_false from sklearn.utils.testing import assert_warns from sklearn.utils.testing import assert_warns_message from sklearn.dummy import DummyClassifier, DummyRegressor from sklearn.model_selection import GridSearchCV, ParameterGrid from sklearn.ensemble import BaggingClassifier, BaggingRegressor from sklearn.linear_model import Perceptron, LogisticRegression from sklearn.neighbors import KNeighborsClassifier, KNeighborsRegressor from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor from sklearn.svm import SVC, SVR from sklearn.pipeline import make_pipeline from sklearn.feature_selection import SelectKBest from sklearn.model_selection import train_test_split from sklearn.datasets import load_boston, load_iris, make_hastie_10_2 from sklearn.utils import check_random_state from scipy.sparse import csc_matrix, csr_matrix rng = check_random_state(0) # also load the iris dataset # and randomly permute it iris = load_iris() perm = rng.permutation(iris.target.size) iris.data = iris.data[perm] iris.target = iris.target[perm] # also load the boston dataset # and randomly permute it boston = load_boston() perm = rng.permutation(boston.target.size) boston.data = boston.data[perm] boston.target = boston.target[perm] def test_classification(): # Check classification for various parameter settings. rng = check_random_state(0) X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=rng) grid = ParameterGrid({"max_samples": [0.5, 1.0], "max_features": [1, 2, 4], "bootstrap": [True, False], "bootstrap_features": [True, False]}) for base_estimator in [None, DummyClassifier(), Perceptron(), DecisionTreeClassifier(), KNeighborsClassifier(), SVC()]: for params in grid: BaggingClassifier(base_estimator=base_estimator, random_state=rng, **params).fit(X_train, y_train).predict(X_test) def test_sparse_classification(): # Check classification for various parameter settings on sparse input. class CustomSVC(SVC): """SVC variant that records the nature of the training set""" def fit(self, X, y): super(CustomSVC, self).fit(X, y) self.data_type_ = type(X) return self rng = check_random_state(0) X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=rng) parameter_sets = [ {"max_samples": 0.5, "max_features": 2, "bootstrap": True, "bootstrap_features": True}, {"max_samples": 1.0, "max_features": 4, "bootstrap": True, "bootstrap_features": True}, {"max_features": 2, "bootstrap": False, "bootstrap_features": True}, {"max_samples": 0.5, "bootstrap": True, "bootstrap_features": False}, ] for sparse_format in [csc_matrix, csr_matrix]: X_train_sparse = sparse_format(X_train) X_test_sparse = sparse_format(X_test) for params in parameter_sets: for f in ['predict', 'predict_proba', 'predict_log_proba', 'decision_function']: # Trained on sparse format sparse_classifier = BaggingClassifier( base_estimator=CustomSVC(decision_function_shape='ovr'), random_state=1, **params ).fit(X_train_sparse, y_train) sparse_results = getattr(sparse_classifier, f)(X_test_sparse) # Trained on dense format dense_classifier = BaggingClassifier( base_estimator=CustomSVC(decision_function_shape='ovr'), random_state=1, **params ).fit(X_train, y_train) dense_results = getattr(dense_classifier, f)(X_test) assert_array_equal(sparse_results, dense_results) sparse_type = type(X_train_sparse) types = [i.data_type_ for i in sparse_classifier.estimators_] assert all([t == sparse_type for t in types]) def test_regression(): # Check regression for various parameter settings. rng = check_random_state(0) X_train, X_test, y_train, y_test = train_test_split(boston.data[:50], boston.target[:50], random_state=rng) grid = ParameterGrid({"max_samples": [0.5, 1.0], "max_features": [0.5, 1.0], "bootstrap": [True, False], "bootstrap_features": [True, False]}) for base_estimator in [None, DummyRegressor(), DecisionTreeRegressor(), KNeighborsRegressor(), SVR()]: for params in grid: BaggingRegressor(base_estimator=base_estimator, random_state=rng, **params).fit(X_train, y_train).predict(X_test) def test_sparse_regression(): # Check regression for various parameter settings on sparse input. rng = check_random_state(0) X_train, X_test, y_train, y_test = train_test_split(boston.data[:50], boston.target[:50], random_state=rng) class CustomSVR(SVR): """SVC variant that records the nature of the training set""" def fit(self, X, y): super(CustomSVR, self).fit(X, y) self.data_type_ = type(X) return self parameter_sets = [ {"max_samples": 0.5, "max_features": 2, "bootstrap": True, "bootstrap_features": True}, {"max_samples": 1.0, "max_features": 4, "bootstrap": True, "bootstrap_features": True}, {"max_features": 2, "bootstrap": False, "bootstrap_features": True}, {"max_samples": 0.5, "bootstrap": True, "bootstrap_features": False}, ] for sparse_format in [csc_matrix, csr_matrix]: X_train_sparse = sparse_format(X_train) X_test_sparse = sparse_format(X_test) for params in parameter_sets: # Trained on sparse format sparse_classifier = BaggingRegressor( base_estimator=CustomSVR(), random_state=1, **params ).fit(X_train_sparse, y_train) sparse_results = sparse_classifier.predict(X_test_sparse) # Trained on dense format dense_results = BaggingRegressor( base_estimator=CustomSVR(), random_state=1, **params ).fit(X_train, y_train).predict(X_test) sparse_type = type(X_train_sparse) types = [i.data_type_ for i in sparse_classifier.estimators_] assert_array_equal(sparse_results, dense_results) assert all([t == sparse_type for t in types]) assert_array_equal(sparse_results, dense_results) def test_bootstrap_samples(): # Test that bootstrapping samples generate non-perfect base estimators. rng = check_random_state(0) X_train, X_test, y_train, y_test = train_test_split(boston.data, boston.target, random_state=rng) base_estimator = DecisionTreeRegressor().fit(X_train, y_train) # without bootstrap, all trees are perfect on the training set ensemble = BaggingRegressor(base_estimator=DecisionTreeRegressor(), max_samples=1.0, bootstrap=False, random_state=rng).fit(X_train, y_train) assert_equal(base_estimator.score(X_train, y_train), ensemble.score(X_train, y_train)) # with bootstrap, trees are no longer perfect on the training set ensemble = BaggingRegressor(base_estimator=DecisionTreeRegressor(), max_samples=1.0, bootstrap=True, random_state=rng).fit(X_train, y_train) assert_greater(base_estimator.score(X_train, y_train), ensemble.score(X_train, y_train)) def test_bootstrap_features(): # Test that bootstrapping features may generate duplicate features. rng = check_random_state(0) X_train, X_test, y_train, y_test = train_test_split(boston.data, boston.target, random_state=rng) ensemble = BaggingRegressor(base_estimator=DecisionTreeRegressor(), max_features=1.0, bootstrap_features=False, random_state=rng).fit(X_train, y_train) for features in ensemble.estimators_features_: assert_equal(boston.data.shape[1], np.unique(features).shape[0]) ensemble = BaggingRegressor(base_estimator=DecisionTreeRegressor(), max_features=1.0, bootstrap_features=True, random_state=rng).fit(X_train, y_train) for features in ensemble.estimators_features_: assert_greater(boston.data.shape[1], np.unique(features).shape[0]) def test_probability(): # Predict probabilities. rng = check_random_state(0) X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=rng) with np.errstate(divide="ignore", invalid="ignore"): # Normal case ensemble = BaggingClassifier(base_estimator=DecisionTreeClassifier(), random_state=rng).fit(X_train, y_train) assert_array_almost_equal(np.sum(ensemble.predict_proba(X_test), axis=1), np.ones(len(X_test))) assert_array_almost_equal(ensemble.predict_proba(X_test), np.exp(ensemble.predict_log_proba(X_test))) # Degenerate case, where some classes are missing ensemble = BaggingClassifier(base_estimator=LogisticRegression(), random_state=rng, max_samples=5).fit(X_train, y_train) assert_array_almost_equal(np.sum(ensemble.predict_proba(X_test), axis=1), np.ones(len(X_test))) assert_array_almost_equal(ensemble.predict_proba(X_test), np.exp(ensemble.predict_log_proba(X_test))) def test_oob_score_classification(): # Check that oob prediction is a good estimation of the generalization # error. rng = check_random_state(0) X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=rng) for base_estimator in [DecisionTreeClassifier(), SVC()]: clf = BaggingClassifier(base_estimator=base_estimator, n_estimators=100, bootstrap=True, oob_score=True, random_state=rng).fit(X_train, y_train) test_score = clf.score(X_test, y_test) assert_less(abs(test_score - clf.oob_score_), 0.1) # Test with few estimators assert_warns(UserWarning, BaggingClassifier(base_estimator=base_estimator, n_estimators=1, bootstrap=True, oob_score=True, random_state=rng).fit, X_train, y_train) def test_oob_score_regression(): # Check that oob prediction is a good estimation of the generalization # error. rng = check_random_state(0) X_train, X_test, y_train, y_test = train_test_split(boston.data, boston.target, random_state=rng) clf = BaggingRegressor(base_estimator=DecisionTreeRegressor(), n_estimators=50, bootstrap=True, oob_score=True, random_state=rng).fit(X_train, y_train) test_score = clf.score(X_test, y_test) assert_less(abs(test_score - clf.oob_score_), 0.1) # Test with few estimators assert_warns(UserWarning, BaggingRegressor(base_estimator=DecisionTreeRegressor(), n_estimators=1, bootstrap=True, oob_score=True, random_state=rng).fit, X_train, y_train) def test_single_estimator(): # Check singleton ensembles. rng = check_random_state(0) X_train, X_test, y_train, y_test = train_test_split(boston.data, boston.target, random_state=rng) clf1 = BaggingRegressor(base_estimator=KNeighborsRegressor(), n_estimators=1, bootstrap=False, bootstrap_features=False, random_state=rng).fit(X_train, y_train) clf2 = KNeighborsRegressor().fit(X_train, y_train) assert_array_equal(clf1.predict(X_test), clf2.predict(X_test)) def test_error(): # Test that it gives proper exception on deficient input. X, y = iris.data, iris.target base = DecisionTreeClassifier() # Test max_samples assert_raises(ValueError, BaggingClassifier(base, max_samples=-1).fit, X, y) assert_raises(ValueError, BaggingClassifier(base, max_samples=0.0).fit, X, y) assert_raises(ValueError, BaggingClassifier(base, max_samples=2.0).fit, X, y) assert_raises(ValueError, BaggingClassifier(base, max_samples=1000).fit, X, y) assert_raises(ValueError, BaggingClassifier(base, max_samples="foobar").fit, X, y) # Test max_features assert_raises(ValueError, BaggingClassifier(base, max_features=-1).fit, X, y) assert_raises(ValueError, BaggingClassifier(base, max_features=0.0).fit, X, y) assert_raises(ValueError, BaggingClassifier(base, max_features=2.0).fit, X, y) assert_raises(ValueError, BaggingClassifier(base, max_features=5).fit, X, y) assert_raises(ValueError, BaggingClassifier(base, max_features="foobar").fit, X, y) # Test support of decision_function assert_false(hasattr(BaggingClassifier(base).fit(X, y), 'decision_function')) def test_parallel_classification(): # Check parallel classification. rng = check_random_state(0) # Classification X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=rng) ensemble = BaggingClassifier(DecisionTreeClassifier(), n_jobs=3, random_state=0).fit(X_train, y_train) # predict_proba ensemble.set_params(n_jobs=1) y1 = ensemble.predict_proba(X_test) ensemble.set_params(n_jobs=2) y2 = ensemble.predict_proba(X_test) assert_array_almost_equal(y1, y2) ensemble = BaggingClassifier(DecisionTreeClassifier(), n_jobs=1, random_state=0).fit(X_train, y_train) y3 = ensemble.predict_proba(X_test) assert_array_almost_equal(y1, y3) # decision_function ensemble = BaggingClassifier(SVC(decision_function_shape='ovr'), n_jobs=3, random_state=0).fit(X_train, y_train) ensemble.set_params(n_jobs=1) decisions1 = ensemble.decision_function(X_test) ensemble.set_params(n_jobs=2) decisions2 = ensemble.decision_function(X_test) assert_array_almost_equal(decisions1, decisions2) ensemble = BaggingClassifier(SVC(decision_function_shape='ovr'), n_jobs=1, random_state=0).fit(X_train, y_train) decisions3 = ensemble.decision_function(X_test) assert_array_almost_equal(decisions1, decisions3) def test_parallel_regression(): # Check parallel regression. rng = check_random_state(0) X_train, X_test, y_train, y_test = train_test_split(boston.data, boston.target, random_state=rng) ensemble = BaggingRegressor(DecisionTreeRegressor(), n_jobs=3, random_state=0).fit(X_train, y_train) ensemble.set_params(n_jobs=1) y1 = ensemble.predict(X_test) ensemble.set_params(n_jobs=2) y2 = ensemble.predict(X_test) assert_array_almost_equal(y1, y2) ensemble = BaggingRegressor(DecisionTreeRegressor(), n_jobs=1, random_state=0).fit(X_train, y_train) y3 = ensemble.predict(X_test) assert_array_almost_equal(y1, y3) def test_gridsearch(): # Check that bagging ensembles can be grid-searched. # Transform iris into a binary classification task X, y = iris.data, iris.target y[y == 2] = 1 # Grid search with scoring based on decision_function parameters = {'n_estimators': (1, 2), 'base_estimator__C': (1, 2)} GridSearchCV(BaggingClassifier(SVC()), parameters, scoring="roc_auc").fit(X, y) def test_base_estimator(): # Check base_estimator and its default values. rng = check_random_state(0) # Classification X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=rng) ensemble = BaggingClassifier(None, n_jobs=3, random_state=0).fit(X_train, y_train) assert_true(isinstance(ensemble.base_estimator_, DecisionTreeClassifier)) ensemble = BaggingClassifier(DecisionTreeClassifier(), n_jobs=3, random_state=0).fit(X_train, y_train) assert_true(isinstance(ensemble.base_estimator_, DecisionTreeClassifier)) ensemble = BaggingClassifier(Perceptron(), n_jobs=3, random_state=0).fit(X_train, y_train) assert_true(isinstance(ensemble.base_estimator_, Perceptron)) # Regression X_train, X_test, y_train, y_test = train_test_split(boston.data, boston.target, random_state=rng) ensemble = BaggingRegressor(None, n_jobs=3, random_state=0).fit(X_train, y_train) assert_true(isinstance(ensemble.base_estimator_, DecisionTreeRegressor)) ensemble = BaggingRegressor(DecisionTreeRegressor(), n_jobs=3, random_state=0).fit(X_train, y_train) assert_true(isinstance(ensemble.base_estimator_, DecisionTreeRegressor)) ensemble = BaggingRegressor(SVR(), n_jobs=3, random_state=0).fit(X_train, y_train) assert_true(isinstance(ensemble.base_estimator_, SVR)) def test_bagging_with_pipeline(): estimator = BaggingClassifier(make_pipeline(SelectKBest(k=1), DecisionTreeClassifier()), max_features=2) estimator.fit(iris.data, iris.target) assert_true(isinstance(estimator[0].steps[-1][1].random_state, int)) class DummyZeroEstimator(BaseEstimator): def fit(self, X, y): self.classes_ = np.unique(y) return self def predict(self, X): return self.classes_[np.zeros(X.shape[0], dtype=int)] def test_bagging_sample_weight_unsupported_but_passed(): estimator = BaggingClassifier(DummyZeroEstimator()) rng = check_random_state(0) estimator.fit(iris.data, iris.target).predict(iris.data) assert_raises(ValueError, estimator.fit, iris.data, iris.target, sample_weight=rng.randint(10, size=(iris.data.shape[0]))) def test_warm_start(random_state=42): # Test if fitting incrementally with warm start gives a forest of the # right size and the same results as a normal fit. X, y = make_hastie_10_2(n_samples=20, random_state=1) clf_ws = None for n_estimators in [5, 10]: if clf_ws is None: clf_ws = BaggingClassifier(n_estimators=n_estimators, random_state=random_state, warm_start=True) else: clf_ws.set_params(n_estimators=n_estimators) clf_ws.fit(X, y) assert_equal(len(clf_ws), n_estimators) clf_no_ws = BaggingClassifier(n_estimators=10, random_state=random_state, warm_start=False) clf_no_ws.fit(X, y) assert_equal(set([tree.random_state for tree in clf_ws]), set([tree.random_state for tree in clf_no_ws])) def test_warm_start_smaller_n_estimators(): # Test if warm start'ed second fit with smaller n_estimators raises error. X, y = make_hastie_10_2(n_samples=20, random_state=1) clf = BaggingClassifier(n_estimators=5, warm_start=True) clf.fit(X, y) clf.set_params(n_estimators=4) assert_raises(ValueError, clf.fit, X, y) def test_warm_start_equal_n_estimators(): # Test that nothing happens when fitting without increasing n_estimators X, y = make_hastie_10_2(n_samples=20, random_state=1) X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=43) clf = BaggingClassifier(n_estimators=5, warm_start=True, random_state=83) clf.fit(X_train, y_train) y_pred = clf.predict(X_test) # modify X to nonsense values, this should not change anything X_train += 1. assert_warns_message(UserWarning, "Warm-start fitting without increasing n_estimators does not", clf.fit, X_train, y_train) assert_array_equal(y_pred, clf.predict(X_test)) def test_warm_start_equivalence(): # warm started classifier with 5+5 estimators should be equivalent to # one classifier with 10 estimators X, y = make_hastie_10_2(n_samples=20, random_state=1) X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=43) clf_ws = BaggingClassifier(n_estimators=5, warm_start=True, random_state=3141) clf_ws.fit(X_train, y_train) clf_ws.set_params(n_estimators=10) clf_ws.fit(X_train, y_train) y1 = clf_ws.predict(X_test) clf = BaggingClassifier(n_estimators=10, warm_start=False, random_state=3141) clf.fit(X_train, y_train) y2 = clf.predict(X_test) assert_array_almost_equal(y1, y2) def test_warm_start_with_oob_score_fails(): # Check using oob_score and warm_start simultaneously fails X, y = make_hastie_10_2(n_samples=20, random_state=1) clf = BaggingClassifier(n_estimators=5, warm_start=True, oob_score=True) assert_raises(ValueError, clf.fit, X, y) def test_oob_score_removed_on_warm_start(): X, y = make_hastie_10_2(n_samples=2000, random_state=1) clf = BaggingClassifier(n_estimators=50, oob_score=True) clf.fit(X, y) clf.set_params(warm_start=True, oob_score=False, n_estimators=100) clf.fit(X, y) assert_raises(AttributeError, getattr, clf, "oob_score_") def test_oob_score_consistency(): # Make sure OOB scores are identical when random_state, estimator, and # training data are fixed and fitting is done twice X, y = make_hastie_10_2(n_samples=200, random_state=1) bagging = BaggingClassifier(KNeighborsClassifier(), max_samples=0.5, max_features=0.5, oob_score=True, random_state=1) assert_equal(bagging.fit(X, y).oob_score_, bagging.fit(X, y).oob_score_) def test_estimators_samples(): # Check that format of estimators_samples_ is correct and that results # generated at fit time can be identically reproduced at a later time # using data saved in object attributes. X, y = make_hastie_10_2(n_samples=200, random_state=1) bagging = BaggingClassifier(LogisticRegression(), max_samples=0.5, max_features=0.5, random_state=1, bootstrap=False) bagging.fit(X, y) # Get relevant attributes estimators_samples = bagging.estimators_samples_ estimators_features = bagging.estimators_features_ estimators = bagging.estimators_ # Test for correct formatting assert_equal(len(estimators_samples), len(estimators)) assert_equal(len(estimators_samples[0]), len(X)) assert_equal(estimators_samples[0].dtype.kind, 'b') # Re-fit single estimator to test for consistent sampling estimator_index = 0 estimator_samples = estimators_samples[estimator_index] estimator_features = estimators_features[estimator_index] estimator = estimators[estimator_index] X_train = (X[estimator_samples])[:, estimator_features] y_train = y[estimator_samples] orig_coefs = estimator.coef_ estimator.fit(X_train, y_train) new_coefs = estimator.coef_ assert_array_almost_equal(orig_coefs, new_coefs) def test_max_samples_consistency(): # Make sure validated max_samples and original max_samples are identical # when valid integer max_samples supplied by user max_samples = 100 X, y = make_hastie_10_2(n_samples=2*max_samples, random_state=1) bagging = BaggingClassifier(KNeighborsClassifier(), max_samples=max_samples, max_features=0.5, random_state=1) bagging.fit(X, y) assert_equal(bagging._max_samples, max_samples)
bsd-3-clause
rmcgibbo/mdtraj
mdtraj/formats/mol2.py
5
9925
############################################################################## # MDTraj: A Python Library for Loading, Saving, and Manipulating # Molecular Dynamics Trajectories. # Copyright 2012-2013 Stanford University and the Authors # # Authors: Kyle A. Beauchamp # Contributors: Robert McGibbon, John D. Chodera # # MDTraj is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as # published by the Free Software Foundation, either version 2.1 # of the License, or (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with MDTraj. If not, see <http://www.gnu.org/licenses/>. # # Portions of this code originate from the OpenMM molecular simulation # toolkit, copyright (c) 2012 Stanford University and Peter Eastman. Those # portions are distributed under the following terms: # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL # THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, # DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE # USE OR OTHER DEALINGS IN THE SOFTWARE. ############################################################################## """Load an md.Topology from tripos mol2 files. """ ############################################################################## # Imports ############################################################################## from __future__ import print_function, division import numpy as np import itertools import re from mdtraj.utils import import_ from mdtraj.utils.six.moves import cStringIO as StringIO from mdtraj.formats.registry import FormatRegistry from mdtraj.core import element as elem __all__ = ['load_mol2', "mol2_to_dataframes"] @FormatRegistry.register_loader('.mol2') def load_mol2(filename): """Load a TRIPOS mol2 file from disk. Parameters ---------- filename : str Path to the prmtop file on disk. Returns ------- traj : md.Trajectory The resulting topology, as an md.Topology object. Notes ----- This function should work on GAFF and sybyl style MOL2 files, but has been primarily tested on GAFF mol2 files. This function does NOT accept multi-structure MOL2 files!!! The elements are guessed using GAFF atom types or via the atype string. Examples -------- >>> traj = md.load_mol2('mysystem.mol2') """ from mdtraj.core.trajectory import Trajectory from mdtraj.core.topology import Topology, Single, Double, Triple, Aromatic, Amide atoms, bonds = mol2_to_dataframes(filename) atoms_mdtraj = atoms[["name", "resName"]].copy() atoms_mdtraj["serial"] = atoms.index #Figure out 1 letter element names # IF this is a GAFF mol2, this line should work without issues atoms_mdtraj["element"] = atoms.atype.map(gaff_elements) # If this is a sybyl mol2, there should be NAN (null) values if atoms_mdtraj.element.isnull().any(): # If this is a sybyl mol2, I think this works generally. # Argument x is being passed as a list with only one element. def to_element(x): if isinstance(x, (list, tuple)): assert len(x) == 1 x = x[0] if '.' in x: # orbital-hybridizations in SYBL return x.split('.')[0] try: # check if we can convert the whole str to an Element, # if not, we only pass the first letter. from mdtraj.core.element import Element Element.getBySymbol(x) except KeyError: return x[0] return x atoms_mdtraj["element"] = atoms.atype.apply(to_element) # Check if elements inferred from atoms.atype are valid # If not, try to infer elements from atoms.name try: atoms_mdtraj['element'].apply(elem.get_by_symbol) except KeyError: try: atoms_mdtraj["element"] = atoms.name.apply(to_element) atoms_mdtraj['element'].apply(elem.get_by_symbol) except KeyError: raise KeyError('Invalid element passed to atoms DataFrame') atoms_mdtraj['resSeq'] = atoms['code'] atoms_mdtraj["chainID"] = np.ones(len(atoms), 'int') bond_type_map = { '1': Single, '2': Double, '3': Triple, 'am': Amide, 'ar': Aromatic } if bonds is not None: bonds_mdtraj = bonds[["id0", "id1"]].values offset = bonds_mdtraj.min() # Should this just be 1??? bonds_mdtraj -= offset # Create the bond augment information n_bonds = bonds_mdtraj.shape[0] bond_augment = np.zeros([n_bonds, 2], dtype=float) # Add bond type information bond_augment[:, 0] = [float(bond_type_map[str(bond_value)]) for bond_value in bonds["bond_type"].values] # Add Bond "order" information, this is not known from Mol2 files bond_augment[:, 1] = [0.0 for _ in range(n_bonds)] # Augment array, dtype is cast to minimal representation of float bonds_mdtraj = np.append(bonds_mdtraj, bond_augment, axis=-1) else: bonds_mdtraj = None top = Topology.from_dataframe(atoms_mdtraj, bonds_mdtraj) xyzlist = np.array([atoms[["x", "y", "z"]].values]) xyzlist /= 10.0 # Convert from angstrom to nanometer traj = Trajectory(xyzlist, top) return traj def mol2_to_dataframes(filename): """Convert a GAFF (or sybyl) mol2 file to a pair of pandas dataframes. Parameters ---------- filename : str Name of mol2 filename Returns ------- atoms_frame : pd.DataFrame DataFrame containing atom information bonds_frame : pd.DataFrame DataFrame containing bond information Notes ----- These dataframes may contain force field information as well as the information necessary for constructing the coordinates and molecular topology. This function has been tested for GAFF and sybyl-style mol2 files but has been primarily tested on GAFF mol2 files. This function does NOT accept multi-structure MOL2 files!!! See Also -------- If you just need the coordinates and bonds, use load_mol2(filename) to get a Trajectory object. """ pd = import_('pandas') with open(filename) as f: data = dict((key, list(grp)) for key, grp in itertools.groupby(f, _parse_mol2_sections)) # Mol2 can have "status bits" at the end of the bond lines. We don't care # about these, but they interfere with using pd_read_table because it looks # like one line has too many columns. So we just regex out the offending # text. status_bit_regex = r"BACKBONE|DICT|INTERRES|\|" data["@<TRIPOS>BOND\n"] = [re.sub(status_bit_regex, lambda _: "", s) for s in data["@<TRIPOS>BOND\n"]] if len(data["@<TRIPOS>BOND\n"]) > 1: csv = StringIO() csv.writelines(data["@<TRIPOS>BOND\n"][1:]) csv.seek(0) bonds_frame = pd.read_table(csv, names=["bond_id", "id0", "id1", "bond_type"], index_col=0, header=None, sep="\s+", engine='python') else: bonds_frame = None csv = StringIO() csv.writelines(data["@<TRIPOS>ATOM\n"][1:]) csv.seek(0) atoms_frame = pd.read_csv(csv, sep="\s+", engine='python', header=None) ncols = atoms_frame.shape[1] names=["serial", "name", "x", "y", "z", "atype", "code", "resName", "charge", "status"] atoms_frame.columns = names[:ncols] return atoms_frame, bonds_frame def _parse_mol2_sections(x): """Helper function for parsing a section in a MOL2 file.""" if x.startswith('@<TRIPOS>'): _parse_mol2_sections.key = x return _parse_mol2_sections.key gaff_elements = { 'br': 'Br', 'c': 'C', 'c1': 'C', 'c2': 'C', 'c3': 'C', 'ca': 'C', 'cc': 'C', 'cd': 'C', 'ce': 'C', 'cf': 'C', 'cg': 'C', 'ch': 'C', 'cl': 'Cl', 'cp': 'C', 'cq': 'C', 'cu': 'C', 'cv': 'C', 'cx': 'C', 'cy': 'C', 'cz': 'C', 'f': 'F', 'h1': 'H', 'h2': 'H', 'h3': 'H', 'h4': 'H', 'h5': 'H', 'ha': 'H', 'hc': 'H', 'hn': 'H', 'ho': 'H', 'hp': 'H', 'hs': 'H', 'hw': 'H', 'hx': 'H', 'i': 'I', 'n': 'N', 'n1': 'N', 'n2': 'N', 'n3': 'N', 'n4': 'N', 'na': 'N', 'nb': 'N', 'nc': 'N', 'nd': 'N', 'ne': 'N', 'nf': 'N', 'nh': 'N', 'no': 'N', 'o': 'O', 'oh': 'O', 'os': 'O', 'ow': 'O', 'p2': 'P', 'p3': 'P', 'p4': 'P', 'p5': 'P', 'pb': 'P', 'px': 'P', 'py': 'P', 's': 'S', 's2': 'S', 's4': 'S', 's6': 'S', 'sh': 'S', 'ss': 'S', 'sx': 'S', 'sy': 'S'}
lgpl-2.1
alvarofierroclavero/scikit-learn
sklearn/preprocessing/tests/test_function_transformer.py
176
2169
from nose.tools import assert_equal import numpy as np from sklearn.preprocessing import FunctionTransformer def _make_func(args_store, kwargs_store, func=lambda X, *a, **k: X): def _func(X, *args, **kwargs): args_store.append(X) args_store.extend(args) kwargs_store.update(kwargs) return func(X) return _func def test_delegate_to_func(): # (args|kwargs)_store will hold the positional and keyword arguments # passed to the function inside the FunctionTransformer. args_store = [] kwargs_store = {} X = np.arange(10).reshape((5, 2)) np.testing.assert_array_equal( FunctionTransformer(_make_func(args_store, kwargs_store)).transform(X), X, 'transform should have returned X unchanged', ) # The function should only have recieved X. assert_equal( args_store, [X], 'Incorrect positional arguments passed to func: {args}'.format( args=args_store, ), ) assert_equal( kwargs_store, {}, 'Unexpected keyword arguments passed to func: {args}'.format( args=kwargs_store, ), ) # reset the argument stores. args_store[:] = [] # python2 compatible inplace list clear. kwargs_store.clear() y = object() np.testing.assert_array_equal( FunctionTransformer( _make_func(args_store, kwargs_store), pass_y=True, ).transform(X, y), X, 'transform should have returned X unchanged', ) # The function should have recieved X and y. assert_equal( args_store, [X, y], 'Incorrect positional arguments passed to func: {args}'.format( args=args_store, ), ) assert_equal( kwargs_store, {}, 'Unexpected keyword arguments passed to func: {args}'.format( args=kwargs_store, ), ) def test_np_log(): X = np.arange(10).reshape((5, 2)) # Test that the numpy.log example still works. np.testing.assert_array_equal( FunctionTransformer(np.log1p).transform(X), np.log1p(X), )
bsd-3-clause
AlexanderFabisch/scikit-learn
examples/svm/plot_separating_hyperplane_unbalanced.py
329
1850
""" ================================================= SVM: Separating hyperplane for unbalanced classes ================================================= Find the optimal separating hyperplane using an SVC for classes that are unbalanced. We first find the separating plane with a plain SVC and then plot (dashed) the separating hyperplane with automatically correction for unbalanced classes. .. currentmodule:: sklearn.linear_model .. note:: This example will also work by replacing ``SVC(kernel="linear")`` with ``SGDClassifier(loss="hinge")``. Setting the ``loss`` parameter of the :class:`SGDClassifier` equal to ``hinge`` will yield behaviour such as that of a SVC with a linear kernel. For example try instead of the ``SVC``:: clf = SGDClassifier(n_iter=100, alpha=0.01) """ print(__doc__) import numpy as np import matplotlib.pyplot as plt from sklearn import svm #from sklearn.linear_model import SGDClassifier # we create 40 separable points rng = np.random.RandomState(0) n_samples_1 = 1000 n_samples_2 = 100 X = np.r_[1.5 * rng.randn(n_samples_1, 2), 0.5 * rng.randn(n_samples_2, 2) + [2, 2]] y = [0] * (n_samples_1) + [1] * (n_samples_2) # fit the model and get the separating hyperplane clf = svm.SVC(kernel='linear', C=1.0) clf.fit(X, y) w = clf.coef_[0] a = -w[0] / w[1] xx = np.linspace(-5, 5) yy = a * xx - clf.intercept_[0] / w[1] # get the separating hyperplane using weighted classes wclf = svm.SVC(kernel='linear', class_weight={1: 10}) wclf.fit(X, y) ww = wclf.coef_[0] wa = -ww[0] / ww[1] wyy = wa * xx - wclf.intercept_[0] / ww[1] # plot separating hyperplanes and samples h0 = plt.plot(xx, yy, 'k-', label='no weights') h1 = plt.plot(xx, wyy, 'k--', label='with weights') plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Paired) plt.legend() plt.axis('tight') plt.show()
bsd-3-clause
etkirsch/scikit-learn
sklearn/preprocessing/label.py
137
27165
# Authors: Alexandre Gramfort <[email protected]> # Mathieu Blondel <[email protected]> # Olivier Grisel <[email protected]> # Andreas Mueller <[email protected]> # Joel Nothman <[email protected]> # Hamzeh Alsalhi <[email protected]> # License: BSD 3 clause from collections import defaultdict import itertools import array import numpy as np import scipy.sparse as sp from ..base import BaseEstimator, TransformerMixin from ..utils.fixes import np_version from ..utils.fixes import sparse_min_max from ..utils.fixes import astype from ..utils.fixes import in1d from ..utils import column_or_1d from ..utils.validation import check_array from ..utils.validation import check_is_fitted from ..utils.validation import _num_samples from ..utils.multiclass import unique_labels from ..utils.multiclass import type_of_target from ..externals import six zip = six.moves.zip map = six.moves.map __all__ = [ 'label_binarize', 'LabelBinarizer', 'LabelEncoder', 'MultiLabelBinarizer', ] def _check_numpy_unicode_bug(labels): """Check that user is not subject to an old numpy bug Fixed in master before 1.7.0: https://github.com/numpy/numpy/pull/243 """ if np_version[:3] < (1, 7, 0) and labels.dtype.kind == 'U': raise RuntimeError("NumPy < 1.7.0 does not implement searchsorted" " on unicode data correctly. Please upgrade" " NumPy to use LabelEncoder with unicode inputs.") class LabelEncoder(BaseEstimator, TransformerMixin): """Encode labels with value between 0 and n_classes-1. Read more in the :ref:`User Guide <preprocessing_targets>`. Attributes ---------- classes_ : array of shape (n_class,) Holds the label for each class. Examples -------- `LabelEncoder` can be used to normalize labels. >>> from sklearn import preprocessing >>> le = preprocessing.LabelEncoder() >>> le.fit([1, 2, 2, 6]) LabelEncoder() >>> le.classes_ array([1, 2, 6]) >>> le.transform([1, 1, 2, 6]) #doctest: +ELLIPSIS array([0, 0, 1, 2]...) >>> le.inverse_transform([0, 0, 1, 2]) array([1, 1, 2, 6]) It can also be used to transform non-numerical labels (as long as they are hashable and comparable) to numerical labels. >>> le = preprocessing.LabelEncoder() >>> le.fit(["paris", "paris", "tokyo", "amsterdam"]) LabelEncoder() >>> list(le.classes_) ['amsterdam', 'paris', 'tokyo'] >>> le.transform(["tokyo", "tokyo", "paris"]) #doctest: +ELLIPSIS array([2, 2, 1]...) >>> list(le.inverse_transform([2, 2, 1])) ['tokyo', 'tokyo', 'paris'] """ def fit(self, y): """Fit label encoder Parameters ---------- y : array-like of shape (n_samples,) Target values. Returns ------- self : returns an instance of self. """ y = column_or_1d(y, warn=True) _check_numpy_unicode_bug(y) self.classes_ = np.unique(y) return self def fit_transform(self, y): """Fit label encoder and return encoded labels Parameters ---------- y : array-like of shape [n_samples] Target values. Returns ------- y : array-like of shape [n_samples] """ y = column_or_1d(y, warn=True) _check_numpy_unicode_bug(y) self.classes_, y = np.unique(y, return_inverse=True) return y def transform(self, y): """Transform labels to normalized encoding. Parameters ---------- y : array-like of shape [n_samples] Target values. Returns ------- y : array-like of shape [n_samples] """ check_is_fitted(self, 'classes_') classes = np.unique(y) _check_numpy_unicode_bug(classes) if len(np.intersect1d(classes, self.classes_)) < len(classes): diff = np.setdiff1d(classes, self.classes_) raise ValueError("y contains new labels: %s" % str(diff)) return np.searchsorted(self.classes_, y) def inverse_transform(self, y): """Transform labels back to original encoding. Parameters ---------- y : numpy array of shape [n_samples] Target values. Returns ------- y : numpy array of shape [n_samples] """ check_is_fitted(self, 'classes_') diff = np.setdiff1d(y, np.arange(len(self.classes_))) if diff: raise ValueError("y contains new labels: %s" % str(diff)) y = np.asarray(y) return self.classes_[y] class LabelBinarizer(BaseEstimator, TransformerMixin): """Binarize labels in a one-vs-all fashion Several regression and binary classification algorithms are available in the scikit. A simple way to extend these algorithms to the multi-class classification case is to use the so-called one-vs-all scheme. At learning time, this simply consists in learning one regressor or binary classifier per class. In doing so, one needs to convert multi-class labels to binary labels (belong or does not belong to the class). LabelBinarizer makes this process easy with the transform method. At prediction time, one assigns the class for which the corresponding model gave the greatest confidence. LabelBinarizer makes this easy with the inverse_transform method. Read more in the :ref:`User Guide <preprocessing_targets>`. Parameters ---------- neg_label : int (default: 0) Value with which negative labels must be encoded. pos_label : int (default: 1) Value with which positive labels must be encoded. sparse_output : boolean (default: False) True if the returned array from transform is desired to be in sparse CSR format. Attributes ---------- classes_ : array of shape [n_class] Holds the label for each class. y_type_ : str, Represents the type of the target data as evaluated by utils.multiclass.type_of_target. Possible type are 'continuous', 'continuous-multioutput', 'binary', 'multiclass', 'mutliclass-multioutput', 'multilabel-indicator', and 'unknown'. multilabel_ : boolean True if the transformer was fitted on a multilabel rather than a multiclass set of labels. The ``multilabel_`` attribute is deprecated and will be removed in 0.18 sparse_input_ : boolean, True if the input data to transform is given as a sparse matrix, False otherwise. indicator_matrix_ : str 'sparse' when the input data to tansform is a multilable-indicator and is sparse, None otherwise. The ``indicator_matrix_`` attribute is deprecated as of version 0.16 and will be removed in 0.18 Examples -------- >>> from sklearn import preprocessing >>> lb = preprocessing.LabelBinarizer() >>> lb.fit([1, 2, 6, 4, 2]) LabelBinarizer(neg_label=0, pos_label=1, sparse_output=False) >>> lb.classes_ array([1, 2, 4, 6]) >>> lb.transform([1, 6]) array([[1, 0, 0, 0], [0, 0, 0, 1]]) Binary targets transform to a column vector >>> lb = preprocessing.LabelBinarizer() >>> lb.fit_transform(['yes', 'no', 'no', 'yes']) array([[1], [0], [0], [1]]) Passing a 2D matrix for multilabel classification >>> import numpy as np >>> lb.fit(np.array([[0, 1, 1], [1, 0, 0]])) LabelBinarizer(neg_label=0, pos_label=1, sparse_output=False) >>> lb.classes_ array([0, 1, 2]) >>> lb.transform([0, 1, 2, 1]) array([[1, 0, 0], [0, 1, 0], [0, 0, 1], [0, 1, 0]]) See also -------- label_binarize : function to perform the transform operation of LabelBinarizer with fixed classes. """ def __init__(self, neg_label=0, pos_label=1, sparse_output=False): if neg_label >= pos_label: raise ValueError("neg_label={0} must be strictly less than " "pos_label={1}.".format(neg_label, pos_label)) if sparse_output and (pos_label == 0 or neg_label != 0): raise ValueError("Sparse binarization is only supported with non " "zero pos_label and zero neg_label, got " "pos_label={0} and neg_label={1}" "".format(pos_label, neg_label)) self.neg_label = neg_label self.pos_label = pos_label self.sparse_output = sparse_output def fit(self, y): """Fit label binarizer Parameters ---------- y : numpy array of shape (n_samples,) or (n_samples, n_classes) Target values. The 2-d matrix should only contain 0 and 1, represents multilabel classification. Returns ------- self : returns an instance of self. """ self.y_type_ = type_of_target(y) if 'multioutput' in self.y_type_: raise ValueError("Multioutput target data is not supported with " "label binarization") if _num_samples(y) == 0: raise ValueError('y has 0 samples: %r' % y) self.sparse_input_ = sp.issparse(y) self.classes_ = unique_labels(y) return self def transform(self, y): """Transform multi-class labels to binary labels The output of transform is sometimes referred to by some authors as the 1-of-K coding scheme. Parameters ---------- y : numpy array or sparse matrix of shape (n_samples,) or (n_samples, n_classes) Target values. The 2-d matrix should only contain 0 and 1, represents multilabel classification. Sparse matrix can be CSR, CSC, COO, DOK, or LIL. Returns ------- Y : numpy array or CSR matrix of shape [n_samples, n_classes] Shape will be [n_samples, 1] for binary problems. """ check_is_fitted(self, 'classes_') y_is_multilabel = type_of_target(y).startswith('multilabel') if y_is_multilabel and not self.y_type_.startswith('multilabel'): raise ValueError("The object was not fitted with multilabel" " input.") return label_binarize(y, self.classes_, pos_label=self.pos_label, neg_label=self.neg_label, sparse_output=self.sparse_output) def inverse_transform(self, Y, threshold=None): """Transform binary labels back to multi-class labels Parameters ---------- Y : numpy array or sparse matrix with shape [n_samples, n_classes] Target values. All sparse matrices are converted to CSR before inverse transformation. threshold : float or None Threshold used in the binary and multi-label cases. Use 0 when: - Y contains the output of decision_function (classifier) Use 0.5 when: - Y contains the output of predict_proba If None, the threshold is assumed to be half way between neg_label and pos_label. Returns ------- y : numpy array or CSR matrix of shape [n_samples] Target values. Notes ----- In the case when the binary labels are fractional (probabilistic), inverse_transform chooses the class with the greatest value. Typically, this allows to use the output of a linear model's decision_function method directly as the input of inverse_transform. """ check_is_fitted(self, 'classes_') if threshold is None: threshold = (self.pos_label + self.neg_label) / 2. if self.y_type_ == "multiclass": y_inv = _inverse_binarize_multiclass(Y, self.classes_) else: y_inv = _inverse_binarize_thresholding(Y, self.y_type_, self.classes_, threshold) if self.sparse_input_: y_inv = sp.csr_matrix(y_inv) elif sp.issparse(y_inv): y_inv = y_inv.toarray() return y_inv def label_binarize(y, classes, neg_label=0, pos_label=1, sparse_output=False): """Binarize labels in a one-vs-all fashion Several regression and binary classification algorithms are available in the scikit. A simple way to extend these algorithms to the multi-class classification case is to use the so-called one-vs-all scheme. This function makes it possible to compute this transformation for a fixed set of class labels known ahead of time. Parameters ---------- y : array-like Sequence of integer labels or multilabel data to encode. classes : array-like of shape [n_classes] Uniquely holds the label for each class. neg_label : int (default: 0) Value with which negative labels must be encoded. pos_label : int (default: 1) Value with which positive labels must be encoded. sparse_output : boolean (default: False), Set to true if output binary array is desired in CSR sparse format Returns ------- Y : numpy array or CSR matrix of shape [n_samples, n_classes] Shape will be [n_samples, 1] for binary problems. Examples -------- >>> from sklearn.preprocessing import label_binarize >>> label_binarize([1, 6], classes=[1, 2, 4, 6]) array([[1, 0, 0, 0], [0, 0, 0, 1]]) The class ordering is preserved: >>> label_binarize([1, 6], classes=[1, 6, 4, 2]) array([[1, 0, 0, 0], [0, 1, 0, 0]]) Binary targets transform to a column vector >>> label_binarize(['yes', 'no', 'no', 'yes'], classes=['no', 'yes']) array([[1], [0], [0], [1]]) See also -------- LabelBinarizer : class used to wrap the functionality of label_binarize and allow for fitting to classes independently of the transform operation """ if not isinstance(y, list): # XXX Workaround that will be removed when list of list format is # dropped y = check_array(y, accept_sparse='csr', ensure_2d=False, dtype=None) else: if _num_samples(y) == 0: raise ValueError('y has 0 samples: %r' % y) if neg_label >= pos_label: raise ValueError("neg_label={0} must be strictly less than " "pos_label={1}.".format(neg_label, pos_label)) if (sparse_output and (pos_label == 0 or neg_label != 0)): raise ValueError("Sparse binarization is only supported with non " "zero pos_label and zero neg_label, got " "pos_label={0} and neg_label={1}" "".format(pos_label, neg_label)) # To account for pos_label == 0 in the dense case pos_switch = pos_label == 0 if pos_switch: pos_label = -neg_label y_type = type_of_target(y) if 'multioutput' in y_type: raise ValueError("Multioutput target data is not supported with label " "binarization") if y_type == 'unknown': raise ValueError("The type of target data is not known") n_samples = y.shape[0] if sp.issparse(y) else len(y) n_classes = len(classes) classes = np.asarray(classes) if y_type == "binary": if len(classes) == 1: Y = np.zeros((len(y), 1), dtype=np.int) Y += neg_label return Y elif len(classes) >= 3: y_type = "multiclass" sorted_class = np.sort(classes) if (y_type == "multilabel-indicator" and classes.size != y.shape[1]): raise ValueError("classes {0} missmatch with the labels {1}" "found in the data".format(classes, unique_labels(y))) if y_type in ("binary", "multiclass"): y = column_or_1d(y) # pick out the known labels from y y_in_classes = in1d(y, classes) y_seen = y[y_in_classes] indices = np.searchsorted(sorted_class, y_seen) indptr = np.hstack((0, np.cumsum(y_in_classes))) data = np.empty_like(indices) data.fill(pos_label) Y = sp.csr_matrix((data, indices, indptr), shape=(n_samples, n_classes)) elif y_type == "multilabel-indicator": Y = sp.csr_matrix(y) if pos_label != 1: data = np.empty_like(Y.data) data.fill(pos_label) Y.data = data else: raise ValueError("%s target data is not supported with label " "binarization" % y_type) if not sparse_output: Y = Y.toarray() Y = astype(Y, int, copy=False) if neg_label != 0: Y[Y == 0] = neg_label if pos_switch: Y[Y == pos_label] = 0 else: Y.data = astype(Y.data, int, copy=False) # preserve label ordering if np.any(classes != sorted_class): indices = np.searchsorted(sorted_class, classes) Y = Y[:, indices] if y_type == "binary": if sparse_output: Y = Y.getcol(-1) else: Y = Y[:, -1].reshape((-1, 1)) return Y def _inverse_binarize_multiclass(y, classes): """Inverse label binarization transformation for multiclass. Multiclass uses the maximal score instead of a threshold. """ classes = np.asarray(classes) if sp.issparse(y): # Find the argmax for each row in y where y is a CSR matrix y = y.tocsr() n_samples, n_outputs = y.shape outputs = np.arange(n_outputs) row_max = sparse_min_max(y, 1)[1] row_nnz = np.diff(y.indptr) y_data_repeated_max = np.repeat(row_max, row_nnz) # picks out all indices obtaining the maximum per row y_i_all_argmax = np.flatnonzero(y_data_repeated_max == y.data) # For corner case where last row has a max of 0 if row_max[-1] == 0: y_i_all_argmax = np.append(y_i_all_argmax, [len(y.data)]) # Gets the index of the first argmax in each row from y_i_all_argmax index_first_argmax = np.searchsorted(y_i_all_argmax, y.indptr[:-1]) # first argmax of each row y_ind_ext = np.append(y.indices, [0]) y_i_argmax = y_ind_ext[y_i_all_argmax[index_first_argmax]] # Handle rows of all 0 y_i_argmax[np.where(row_nnz == 0)[0]] = 0 # Handles rows with max of 0 that contain negative numbers samples = np.arange(n_samples)[(row_nnz > 0) & (row_max.ravel() == 0)] for i in samples: ind = y.indices[y.indptr[i]:y.indptr[i + 1]] y_i_argmax[i] = classes[np.setdiff1d(outputs, ind)][0] return classes[y_i_argmax] else: return classes.take(y.argmax(axis=1), mode="clip") def _inverse_binarize_thresholding(y, output_type, classes, threshold): """Inverse label binarization transformation using thresholding.""" if output_type == "binary" and y.ndim == 2 and y.shape[1] > 2: raise ValueError("output_type='binary', but y.shape = {0}". format(y.shape)) if output_type != "binary" and y.shape[1] != len(classes): raise ValueError("The number of class is not equal to the number of " "dimension of y.") classes = np.asarray(classes) # Perform thresholding if sp.issparse(y): if threshold > 0: if y.format not in ('csr', 'csc'): y = y.tocsr() y.data = np.array(y.data > threshold, dtype=np.int) y.eliminate_zeros() else: y = np.array(y.toarray() > threshold, dtype=np.int) else: y = np.array(y > threshold, dtype=np.int) # Inverse transform data if output_type == "binary": if sp.issparse(y): y = y.toarray() if y.ndim == 2 and y.shape[1] == 2: return classes[y[:, 1]] else: if len(classes) == 1: y = np.empty(len(y), dtype=classes.dtype) y.fill(classes[0]) return y else: return classes[y.ravel()] elif output_type == "multilabel-indicator": return y else: raise ValueError("{0} format is not supported".format(output_type)) class MultiLabelBinarizer(BaseEstimator, TransformerMixin): """Transform between iterable of iterables and a multilabel format Although a list of sets or tuples is a very intuitive format for multilabel data, it is unwieldy to process. This transformer converts between this intuitive format and the supported multilabel format: a (samples x classes) binary matrix indicating the presence of a class label. Parameters ---------- classes : array-like of shape [n_classes] (optional) Indicates an ordering for the class labels sparse_output : boolean (default: False), Set to true if output binary array is desired in CSR sparse format Attributes ---------- classes_ : array of labels A copy of the `classes` parameter where provided, or otherwise, the sorted set of classes found when fitting. Examples -------- >>> mlb = MultiLabelBinarizer() >>> mlb.fit_transform([(1, 2), (3,)]) array([[1, 1, 0], [0, 0, 1]]) >>> mlb.classes_ array([1, 2, 3]) >>> mlb.fit_transform([set(['sci-fi', 'thriller']), set(['comedy'])]) array([[0, 1, 1], [1, 0, 0]]) >>> list(mlb.classes_) ['comedy', 'sci-fi', 'thriller'] """ def __init__(self, classes=None, sparse_output=False): self.classes = classes self.sparse_output = sparse_output def fit(self, y): """Fit the label sets binarizer, storing `classes_` Parameters ---------- y : iterable of iterables A set of labels (any orderable and hashable object) for each sample. If the `classes` parameter is set, `y` will not be iterated. Returns ------- self : returns this MultiLabelBinarizer instance """ if self.classes is None: classes = sorted(set(itertools.chain.from_iterable(y))) else: classes = self.classes dtype = np.int if all(isinstance(c, int) for c in classes) else object self.classes_ = np.empty(len(classes), dtype=dtype) self.classes_[:] = classes return self def fit_transform(self, y): """Fit the label sets binarizer and transform the given label sets Parameters ---------- y : iterable of iterables A set of labels (any orderable and hashable object) for each sample. If the `classes` parameter is set, `y` will not be iterated. Returns ------- y_indicator : array or CSR matrix, shape (n_samples, n_classes) A matrix such that `y_indicator[i, j] = 1` iff `classes_[j]` is in `y[i]`, and 0 otherwise. """ if self.classes is not None: return self.fit(y).transform(y) # Automatically increment on new class class_mapping = defaultdict(int) class_mapping.default_factory = class_mapping.__len__ yt = self._transform(y, class_mapping) # sort classes and reorder columns tmp = sorted(class_mapping, key=class_mapping.get) # (make safe for tuples) dtype = np.int if all(isinstance(c, int) for c in tmp) else object class_mapping = np.empty(len(tmp), dtype=dtype) class_mapping[:] = tmp self.classes_, inverse = np.unique(class_mapping, return_inverse=True) yt.indices = np.take(inverse, yt.indices) if not self.sparse_output: yt = yt.toarray() return yt def transform(self, y): """Transform the given label sets Parameters ---------- y : iterable of iterables A set of labels (any orderable and hashable object) for each sample. If the `classes` parameter is set, `y` will not be iterated. Returns ------- y_indicator : array or CSR matrix, shape (n_samples, n_classes) A matrix such that `y_indicator[i, j] = 1` iff `classes_[j]` is in `y[i]`, and 0 otherwise. """ class_to_index = dict(zip(self.classes_, range(len(self.classes_)))) yt = self._transform(y, class_to_index) if not self.sparse_output: yt = yt.toarray() return yt def _transform(self, y, class_mapping): """Transforms the label sets with a given mapping Parameters ---------- y : iterable of iterables class_mapping : Mapping Maps from label to column index in label indicator matrix Returns ------- y_indicator : sparse CSR matrix, shape (n_samples, n_classes) Label indicator matrix """ indices = array.array('i') indptr = array.array('i', [0]) for labels in y: indices.extend(set(class_mapping[label] for label in labels)) indptr.append(len(indices)) data = np.ones(len(indices), dtype=int) return sp.csr_matrix((data, indices, indptr), shape=(len(indptr) - 1, len(class_mapping))) def inverse_transform(self, yt): """Transform the given indicator matrix into label sets Parameters ---------- yt : array or sparse matrix of shape (n_samples, n_classes) A matrix containing only 1s ands 0s. Returns ------- y : list of tuples The set of labels for each sample such that `y[i]` consists of `classes_[j]` for each `yt[i, j] == 1`. """ if yt.shape[1] != len(self.classes_): raise ValueError('Expected indicator for {0} classes, but got {1}' .format(len(self.classes_), yt.shape[1])) if sp.issparse(yt): yt = yt.tocsr() if len(yt.data) != 0 and len(np.setdiff1d(yt.data, [0, 1])) > 0: raise ValueError('Expected only 0s and 1s in label indicator.') return [tuple(self.classes_.take(yt.indices[start:end])) for start, end in zip(yt.indptr[:-1], yt.indptr[1:])] else: unexpected = np.setdiff1d(yt, [0, 1]) if len(unexpected) > 0: raise ValueError('Expected only 0s and 1s in label indicator. ' 'Also got {0}'.format(unexpected)) return [tuple(self.classes_.compress(indicators)) for indicators in yt]
bsd-3-clause
mingwpy/scipy
scipy/stats/_multivariate.py
35
69253
# # Author: Joris Vankerschaver 2013 # from __future__ import division, print_function, absolute_import import numpy as np import scipy.linalg from scipy.misc import doccer from scipy.special import gammaln, psi, multigammaln from scipy._lib._util import check_random_state __all__ = ['multivariate_normal', 'dirichlet', 'wishart', 'invwishart'] _LOG_2PI = np.log(2 * np.pi) _LOG_2 = np.log(2) _LOG_PI = np.log(np.pi) def _process_parameters(dim, mean, cov): """ Infer dimensionality from mean or covariance matrix, ensure that mean and covariance are full vector resp. matrix. """ # Try to infer dimensionality if dim is None: if mean is None: if cov is None: dim = 1 else: cov = np.asarray(cov, dtype=float) if cov.ndim < 2: dim = 1 else: dim = cov.shape[0] else: mean = np.asarray(mean, dtype=float) dim = mean.size else: if not np.isscalar(dim): raise ValueError("Dimension of random variable must be a scalar.") # Check input sizes and return full arrays for mean and cov if necessary if mean is None: mean = np.zeros(dim) mean = np.asarray(mean, dtype=float) if cov is None: cov = 1.0 cov = np.asarray(cov, dtype=float) if dim == 1: mean.shape = (1,) cov.shape = (1, 1) if mean.ndim != 1 or mean.shape[0] != dim: raise ValueError("Array 'mean' must be a vector of length %d." % dim) if cov.ndim == 0: cov = cov * np.eye(dim) elif cov.ndim == 1: cov = np.diag(cov) elif cov.ndim == 2 and cov.shape != (dim, dim): rows, cols = cov.shape if rows != cols: msg = ("Array 'cov' must be square if it is two dimensional," " but cov.shape = %s." % str(cov.shape)) else: msg = ("Dimension mismatch: array 'cov' is of shape %s," " but 'mean' is a vector of length %d.") msg = msg % (str(cov.shape), len(mean)) raise ValueError(msg) elif cov.ndim > 2: raise ValueError("Array 'cov' must be at most two-dimensional," " but cov.ndim = %d" % cov.ndim) return dim, mean, cov def _process_quantiles(x, dim): """ Adjust quantiles array so that last axis labels the components of each data point. """ x = np.asarray(x, dtype=float) if x.ndim == 0: x = x[np.newaxis] elif x.ndim == 1: if dim == 1: x = x[:, np.newaxis] else: x = x[np.newaxis, :] return x def _squeeze_output(out): """ Remove single-dimensional entries from array and convert to scalar, if necessary. """ out = out.squeeze() if out.ndim == 0: out = out[()] return out def _eigvalsh_to_eps(spectrum, cond=None, rcond=None): """ Determine which eigenvalues are "small" given the spectrum. This is for compatibility across various linear algebra functions that should agree about whether or not a Hermitian matrix is numerically singular and what is its numerical matrix rank. This is designed to be compatible with scipy.linalg.pinvh. Parameters ---------- spectrum : 1d ndarray Array of eigenvalues of a Hermitian matrix. cond, rcond : float, optional Cutoff for small eigenvalues. Singular values smaller than rcond * largest_eigenvalue are considered zero. If None or -1, suitable machine precision is used. Returns ------- eps : float Magnitude cutoff for numerical negligibility. """ if rcond is not None: cond = rcond if cond in [None, -1]: t = spectrum.dtype.char.lower() factor = {'f': 1E3, 'd': 1E6} cond = factor[t] * np.finfo(t).eps eps = cond * np.max(abs(spectrum)) return eps def _pinv_1d(v, eps=1e-5): """ A helper function for computing the pseudoinverse. Parameters ---------- v : iterable of numbers This may be thought of as a vector of eigenvalues or singular values. eps : float Values with magnitude no greater than eps are considered negligible. Returns ------- v_pinv : 1d float ndarray A vector of pseudo-inverted numbers. """ return np.array([0 if abs(x) <= eps else 1/x for x in v], dtype=float) class _PSD(object): """ Compute coordinated functions of a symmetric positive semidefinite matrix. This class addresses two issues. Firstly it allows the pseudoinverse, the logarithm of the pseudo-determinant, and the rank of the matrix to be computed using one call to eigh instead of three. Secondly it allows these functions to be computed in a way that gives mutually compatible results. All of the functions are computed with a common understanding as to which of the eigenvalues are to be considered negligibly small. The functions are designed to coordinate with scipy.linalg.pinvh() but not necessarily with np.linalg.det() or with np.linalg.matrix_rank(). Parameters ---------- M : array_like Symmetric positive semidefinite matrix (2-D). cond, rcond : float, optional Cutoff for small eigenvalues. Singular values smaller than rcond * largest_eigenvalue are considered zero. If None or -1, suitable machine precision is used. lower : bool, optional Whether the pertinent array data is taken from the lower or upper triangle of M. (Default: lower) check_finite : bool, optional Whether to check that the input matrices contain only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs. allow_singular : bool, optional Whether to allow a singular matrix. (Default: True) Notes ----- The arguments are similar to those of scipy.linalg.pinvh(). """ def __init__(self, M, cond=None, rcond=None, lower=True, check_finite=True, allow_singular=True): # Compute the symmetric eigendecomposition. # Note that eigh takes care of array conversion, chkfinite, # and assertion that the matrix is square. s, u = scipy.linalg.eigh(M, lower=lower, check_finite=check_finite) eps = _eigvalsh_to_eps(s, cond, rcond) if np.min(s) < -eps: raise ValueError('the input matrix must be positive semidefinite') d = s[s > eps] if len(d) < len(s) and not allow_singular: raise np.linalg.LinAlgError('singular matrix') s_pinv = _pinv_1d(s, eps) U = np.multiply(u, np.sqrt(s_pinv)) # Initialize the eagerly precomputed attributes. self.rank = len(d) self.U = U self.log_pdet = np.sum(np.log(d)) # Initialize an attribute to be lazily computed. self._pinv = None @property def pinv(self): if self._pinv is None: self._pinv = np.dot(self.U, self.U.T) return self._pinv _doc_default_callparams = """\ mean : array_like, optional Mean of the distribution (default zero) cov : array_like, optional Covariance matrix of the distribution (default one) allow_singular : bool, optional Whether to allow a singular covariance matrix. (Default: False) """ _doc_callparams_note = \ """Setting the parameter `mean` to `None` is equivalent to having `mean` be the zero-vector. The parameter `cov` can be a scalar, in which case the covariance matrix is the identity times that value, a vector of diagonal entries for the covariance matrix, or a two-dimensional array_like. """ _doc_random_state = """\ random_state : None or int or np.random.RandomState instance, optional If int or RandomState, use it for drawing the random variates. If None (or np.random), the global np.random state is used. Default is None. """ _doc_frozen_callparams = "" _doc_frozen_callparams_note = \ """See class definition for a detailed description of parameters.""" docdict_params = { '_doc_default_callparams': _doc_default_callparams, '_doc_callparams_note': _doc_callparams_note, '_doc_random_state': _doc_random_state } docdict_noparams = { '_doc_default_callparams': _doc_frozen_callparams, '_doc_callparams_note': _doc_frozen_callparams_note, '_doc_random_state': _doc_random_state } class multi_rv_generic(object): """ Class which encapsulates common functionality between all multivariate distributions. """ def __init__(self, seed=None): super(multi_rv_generic, self).__init__() self._random_state = check_random_state(seed) @property def random_state(self): """ Get or set the RandomState object for generating random variates. This can be either None or an existing RandomState object. If None (or np.random), use the RandomState singleton used by np.random. If already a RandomState instance, use it. If an int, use a new RandomState instance seeded with seed. """ return self._random_state @random_state.setter def random_state(self, seed): self._random_state = check_random_state(seed) def _get_random_state(self, random_state): if random_state is not None: return check_random_state(random_state) else: return self._random_state class multi_rv_frozen(object): """ Class which encapsulates common functionality between all frozen multivariate distributions. """ @property def random_state(self): return self._dist._random_state @random_state.setter def random_state(self, seed): self._dist._random_state = check_random_state(seed) class multivariate_normal_gen(multi_rv_generic): r""" A multivariate normal random variable. The `mean` keyword specifies the mean. The `cov` keyword specifies the covariance matrix. Methods ------- ``pdf(x, mean=None, cov=1, allow_singular=False)`` Probability density function. ``logpdf(x, mean=None, cov=1, allow_singular=False)`` Log of the probability density function. ``rvs(mean=None, cov=1, size=1, random_state=None)`` Draw random samples from a multivariate normal distribution. ``entropy()`` Compute the differential entropy of the multivariate normal. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. %(_doc_default_callparams)s %(_doc_random_state)s Alternatively, the object may be called (as a function) to fix the mean and covariance parameters, returning a "frozen" multivariate normal random variable: rv = multivariate_normal(mean=None, cov=1, allow_singular=False) - Frozen object with the same methods but holding the given mean and covariance fixed. Notes ----- %(_doc_callparams_note)s The covariance matrix `cov` must be a (symmetric) positive semi-definite matrix. The determinant and inverse of `cov` are computed as the pseudo-determinant and pseudo-inverse, respectively, so that `cov` does not need to have full rank. The probability density function for `multivariate_normal` is .. math:: f(x) = \frac{1}{\sqrt{(2 \pi)^k \det \Sigma}} \exp\left( -\frac{1}{2} (x - \mu)^T \Sigma^{-1} (x - \mu) \right), where :math:`\mu` is the mean, :math:`\Sigma` the covariance matrix, and :math:`k` is the dimension of the space where :math:`x` takes values. .. versionadded:: 0.14.0 Examples -------- >>> import matplotlib.pyplot as plt >>> from scipy.stats import multivariate_normal >>> x = np.linspace(0, 5, 10, endpoint=False) >>> y = multivariate_normal.pdf(x, mean=2.5, cov=0.5); y array([ 0.00108914, 0.01033349, 0.05946514, 0.20755375, 0.43939129, 0.56418958, 0.43939129, 0.20755375, 0.05946514, 0.01033349]) >>> fig1 = plt.figure() >>> ax = fig1.add_subplot(111) >>> ax.plot(x, y) The input quantiles can be any shape of array, as long as the last axis labels the components. This allows us for instance to display the frozen pdf for a non-isotropic random variable in 2D as follows: >>> x, y = np.mgrid[-1:1:.01, -1:1:.01] >>> pos = np.dstack((x, y)) >>> rv = multivariate_normal([0.5, -0.2], [[2.0, 0.3], [0.3, 0.5]]) >>> fig2 = plt.figure() >>> ax2 = fig2.add_subplot(111) >>> ax2.contourf(x, y, rv.pdf(pos)) """ def __init__(self, seed=None): super(multivariate_normal_gen, self).__init__(seed) self.__doc__ = doccer.docformat(self.__doc__, docdict_params) def __call__(self, mean=None, cov=1, allow_singular=False, seed=None): """ Create a frozen multivariate normal distribution. See `multivariate_normal_frozen` for more information. """ return multivariate_normal_frozen(mean, cov, allow_singular=allow_singular, seed=seed) def _logpdf(self, x, mean, prec_U, log_det_cov, rank): """ Parameters ---------- x : ndarray Points at which to evaluate the log of the probability density function mean : ndarray Mean of the distribution prec_U : ndarray A decomposition such that np.dot(prec_U, prec_U.T) is the precision matrix, i.e. inverse of the covariance matrix. log_det_cov : float Logarithm of the determinant of the covariance matrix rank : int Rank of the covariance matrix. Notes ----- As this function does no argument checking, it should not be called directly; use 'logpdf' instead. """ dev = x - mean maha = np.sum(np.square(np.dot(dev, prec_U)), axis=-1) return -0.5 * (rank * _LOG_2PI + log_det_cov + maha) def logpdf(self, x, mean, cov, allow_singular=False): """ Log of the multivariate normal probability density function. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. %(_doc_default_callparams)s Returns ------- pdf : ndarray Log of the probability density function evaluated at `x` Notes ----- %(_doc_callparams_note)s """ dim, mean, cov = _process_parameters(None, mean, cov) x = _process_quantiles(x, dim) psd = _PSD(cov, allow_singular=allow_singular) out = self._logpdf(x, mean, psd.U, psd.log_pdet, psd.rank) return _squeeze_output(out) def pdf(self, x, mean, cov, allow_singular=False): """ Multivariate normal probability density function. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. %(_doc_default_callparams)s Returns ------- pdf : ndarray Probability density function evaluated at `x` Notes ----- %(_doc_callparams_note)s """ dim, mean, cov = _process_parameters(None, mean, cov) x = _process_quantiles(x, dim) psd = _PSD(cov, allow_singular=allow_singular) out = np.exp(self._logpdf(x, mean, psd.U, psd.log_pdet, psd.rank)) return _squeeze_output(out) def rvs(self, mean=None, cov=1, size=1, random_state=None): """ Draw random samples from a multivariate normal distribution. Parameters ---------- %(_doc_default_callparams)s size : integer, optional Number of samples to draw (default 1). %(_doc_random_state)s Returns ------- rvs : ndarray or scalar Random variates of size (`size`, `N`), where `N` is the dimension of the random variable. Notes ----- %(_doc_callparams_note)s """ dim, mean, cov = _process_parameters(None, mean, cov) random_state = self._get_random_state(random_state) out = random_state.multivariate_normal(mean, cov, size) return _squeeze_output(out) def entropy(self, mean=None, cov=1): """ Compute the differential entropy of the multivariate normal. Parameters ---------- %(_doc_default_callparams)s Returns ------- h : scalar Entropy of the multivariate normal distribution Notes ----- %(_doc_callparams_note)s """ dim, mean, cov = _process_parameters(None, mean, cov) _, logdet = np.linalg.slogdet(2 * np.pi * np.e * cov) return 0.5 * logdet multivariate_normal = multivariate_normal_gen() class multivariate_normal_frozen(multi_rv_frozen): def __init__(self, mean=None, cov=1, allow_singular=False, seed=None): """ Create a frozen multivariate normal distribution. Parameters ---------- mean : array_like, optional Mean of the distribution (default zero) cov : array_like, optional Covariance matrix of the distribution (default one) allow_singular : bool, optional If this flag is True then tolerate a singular covariance matrix (default False). seed : None or int or np.random.RandomState instance, optional This parameter defines the RandomState object to use for drawing random variates. If None (or np.random), the global np.random state is used. If integer, it is used to seed the local RandomState instance Default is None. Examples -------- When called with the default parameters, this will create a 1D random variable with mean 0 and covariance 1: >>> from scipy.stats import multivariate_normal >>> r = multivariate_normal() >>> r.mean array([ 0.]) >>> r.cov array([[1.]]) """ self.dim, self.mean, self.cov = _process_parameters(None, mean, cov) self.cov_info = _PSD(self.cov, allow_singular=allow_singular) self._dist = multivariate_normal_gen(seed) def logpdf(self, x): x = _process_quantiles(x, self.dim) out = self._dist._logpdf(x, self.mean, self.cov_info.U, self.cov_info.log_pdet, self.cov_info.rank) return _squeeze_output(out) def pdf(self, x): return np.exp(self.logpdf(x)) def rvs(self, size=1, random_state=None): return self._dist.rvs(self.mean, self.cov, size, random_state) def entropy(self): """ Computes the differential entropy of the multivariate normal. Returns ------- h : scalar Entropy of the multivariate normal distribution """ log_pdet = self.cov_info.log_pdet rank = self.cov_info.rank return 0.5 * (rank * (_LOG_2PI + 1) + log_pdet) # Set frozen generator docstrings from corresponding docstrings in # multivariate_normal_gen and fill in default strings in class docstrings for name in ['logpdf', 'pdf', 'rvs']: method = multivariate_normal_gen.__dict__[name] method_frozen = multivariate_normal_frozen.__dict__[name] method_frozen.__doc__ = doccer.docformat(method.__doc__, docdict_noparams) method.__doc__ = doccer.docformat(method.__doc__, docdict_params) _dirichlet_doc_default_callparams = """\ alpha : array_like The concentration parameters. The number of entries determines the dimensionality of the distribution. """ _dirichlet_doc_frozen_callparams = "" _dirichlet_doc_frozen_callparams_note = \ """See class definition for a detailed description of parameters.""" dirichlet_docdict_params = { '_dirichlet_doc_default_callparams': _dirichlet_doc_default_callparams, '_doc_random_state': _doc_random_state } dirichlet_docdict_noparams = { '_dirichlet_doc_default_callparams': _dirichlet_doc_frozen_callparams, '_doc_random_state': _doc_random_state } def _dirichlet_check_parameters(alpha): alpha = np.asarray(alpha) if np.min(alpha) <= 0: raise ValueError("All parameters must be greater than 0") elif alpha.ndim != 1: raise ValueError("Parameter vector 'a' must be one dimensional, " "but a.shape = %s." % (alpha.shape, )) return alpha def _dirichlet_check_input(alpha, x): x = np.asarray(x) if x.shape[0] + 1 != alpha.shape[0] and x.shape[0] != alpha.shape[0]: raise ValueError("Vector 'x' must have either the same number " "of entries as, or one entry fewer than, " "parameter vector 'a', but alpha.shape = %s " "and x.shape = %s." % (alpha.shape, x.shape)) if x.shape[0] != alpha.shape[0]: xk = np.array([1 - np.sum(x, 0)]) if xk.ndim == 1: x = np.append(x, xk) elif xk.ndim == 2: x = np.vstack((x, xk)) else: raise ValueError("The input must be one dimensional or a two " "dimensional matrix containing the entries.") if np.min(x) <= 0: raise ValueError("Each entry in 'x' must be greater than zero.") if np.max(x) > 1: raise ValueError("Each entry in 'x' must be smaller or equal one.") if (np.abs(np.sum(x, 0) - 1.0) > 10e-10).any(): raise ValueError("The input vector 'x' must lie within the normal " "simplex. but np.sum(x, 0) = %s." % np.sum(x, 0)) return x def _lnB(alpha): r""" Internal helper function to compute the log of the useful quotient .. math:: B(\alpha) = \frac{\prod_{i=1}{K}\Gamma(\alpha_i)}{\Gamma\left(\sum_{i=1}^{K}\alpha_i\right)} Parameters ---------- %(_dirichlet_doc_default_callparams)s Returns ------- B : scalar Helper quotient, internal use only """ return np.sum(gammaln(alpha)) - gammaln(np.sum(alpha)) class dirichlet_gen(multi_rv_generic): r""" A Dirichlet random variable. The `alpha` keyword specifies the concentration parameters of the distribution. .. versionadded:: 0.15.0 Methods ------- ``pdf(x, alpha)`` Probability density function. ``logpdf(x, alpha)`` Log of the probability density function. ``rvs(alpha, size=1, random_state=None)`` Draw random samples from a Dirichlet distribution. ``mean(alpha)`` The mean of the Dirichlet distribution ``var(alpha)`` The variance of the Dirichlet distribution ``entropy(alpha)`` Compute the differential entropy of the multivariate normal. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. %(_dirichlet_doc_default_callparams)s %(_doc_random_state)s Alternatively, the object may be called (as a function) to fix concentration parameters, returning a "frozen" Dirichlet random variable: rv = dirichlet(alpha) - Frozen object with the same methods but holding the given concentration parameters fixed. Notes ----- Each :math:`\alpha` entry must be positive. The distribution has only support on the simplex defined by .. math:: \sum_{i=1}^{K} x_i \le 1 The probability density function for `dirichlet` is .. math:: f(x) = \frac{1}{\mathrm{B}(\boldsymbol\alpha)} \prod_{i=1}^K x_i^{\alpha_i - 1} where .. math:: \mathrm{B}(\boldsymbol\alpha) = \frac{\prod_{i=1}^K \Gamma(\alpha_i)} {\Gamma\bigl(\sum_{i=1}^K \alpha_i\bigr)} and :math:`\boldsymbol\alpha=(\alpha_1,\ldots,\alpha_K)`, the concentration parameters and :math:`K` is the dimension of the space where :math:`x` takes values. Note that the dirichlet interface is somewhat inconsistent. The array returned by the rvs function is transposed with respect to the format expected by the pdf and logpdf. """ def __init__(self, seed=None): super(dirichlet_gen, self).__init__(seed) self.__doc__ = doccer.docformat(self.__doc__, dirichlet_docdict_params) def __call__(self, alpha, seed=None): return dirichlet_frozen(alpha, seed=seed) def _logpdf(self, x, alpha): """ Parameters ---------- x : ndarray Points at which to evaluate the log of the probability density function %(_dirichlet_doc_default_callparams)s Notes ----- As this function does no argument checking, it should not be called directly; use 'logpdf' instead. """ lnB = _lnB(alpha) return - lnB + np.sum((np.log(x.T) * (alpha - 1)).T, 0) def logpdf(self, x, alpha): """ Log of the Dirichlet probability density function. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. %(_dirichlet_doc_default_callparams)s Returns ------- pdf : ndarray Log of the probability density function evaluated at `x`. """ alpha = _dirichlet_check_parameters(alpha) x = _dirichlet_check_input(alpha, x) out = self._logpdf(x, alpha) return _squeeze_output(out) def pdf(self, x, alpha): """ The Dirichlet probability density function. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. %(_dirichlet_doc_default_callparams)s Returns ------- pdf : ndarray The probability density function evaluated at `x`. """ alpha = _dirichlet_check_parameters(alpha) x = _dirichlet_check_input(alpha, x) out = np.exp(self._logpdf(x, alpha)) return _squeeze_output(out) def mean(self, alpha): """ Compute the mean of the dirichlet distribution. Parameters ---------- %(_dirichlet_doc_default_callparams)s Returns ------- mu : scalar Mean of the Dirichlet distribution """ alpha = _dirichlet_check_parameters(alpha) out = alpha / (np.sum(alpha)) return _squeeze_output(out) def var(self, alpha): """ Compute the variance of the dirichlet distribution. Parameters ---------- %(_dirichlet_doc_default_callparams)s Returns ------- v : scalar Variance of the Dirichlet distribution """ alpha = _dirichlet_check_parameters(alpha) alpha0 = np.sum(alpha) out = (alpha * (alpha0 - alpha)) / ((alpha0 * alpha0) * (alpha0 + 1)) return out def entropy(self, alpha): """ Compute the differential entropy of the dirichlet distribution. Parameters ---------- %(_dirichlet_doc_default_callparams)s Returns ------- h : scalar Entropy of the Dirichlet distribution """ alpha = _dirichlet_check_parameters(alpha) alpha0 = np.sum(alpha) lnB = _lnB(alpha) K = alpha.shape[0] out = lnB + (alpha0 - K) * scipy.special.psi(alpha0) - np.sum( (alpha - 1) * scipy.special.psi(alpha)) return _squeeze_output(out) def rvs(self, alpha, size=1, random_state=None): """ Draw random samples from a Dirichlet distribution. Parameters ---------- %(_dirichlet_doc_default_callparams)s size : int, optional Number of samples to draw (default 1). %(_doc_random_state)s Returns ------- rvs : ndarray or scalar Random variates of size (`size`, `N`), where `N` is the dimension of the random variable. """ alpha = _dirichlet_check_parameters(alpha) random_state = self._get_random_state(random_state) return random_state.dirichlet(alpha, size=size) dirichlet = dirichlet_gen() class dirichlet_frozen(multi_rv_frozen): def __init__(self, alpha, seed=None): self.alpha = _dirichlet_check_parameters(alpha) self._dist = dirichlet_gen(seed) def logpdf(self, x): return self._dist.logpdf(x, self.alpha) def pdf(self, x): return self._dist.pdf(x, self.alpha) def mean(self): return self._dist.mean(self.alpha) def var(self): return self._dist.var(self.alpha) def entropy(self): return self._dist.entropy(self.alpha) def rvs(self, size=1, random_state=None): return self._dist.rvs(self.alpha, size, random_state) # Set frozen generator docstrings from corresponding docstrings in # multivariate_normal_gen and fill in default strings in class docstrings for name in ['logpdf', 'pdf', 'rvs', 'mean', 'var', 'entropy']: method = dirichlet_gen.__dict__[name] method_frozen = dirichlet_frozen.__dict__[name] method_frozen.__doc__ = doccer.docformat( method.__doc__, dirichlet_docdict_noparams) method.__doc__ = doccer.docformat(method.__doc__, dirichlet_docdict_params) _wishart_doc_default_callparams = """\ df : int Degrees of freedom, must be greater than or equal to dimension of the scale matrix scale : array_like Symmetric positive definite scale matrix of the distribution """ _wishart_doc_callparams_note = "" _wishart_doc_frozen_callparams = "" _wishart_doc_frozen_callparams_note = \ """See class definition for a detailed description of parameters.""" wishart_docdict_params = { '_doc_default_callparams': _wishart_doc_default_callparams, '_doc_callparams_note': _wishart_doc_callparams_note, '_doc_random_state': _doc_random_state } wishart_docdict_noparams = { '_doc_default_callparams': _wishart_doc_frozen_callparams, '_doc_callparams_note': _wishart_doc_frozen_callparams_note, '_doc_random_state': _doc_random_state } class wishart_gen(multi_rv_generic): r""" A Wishart random variable. The `df` keyword specifies the degrees of freedom. The `scale` keyword specifies the scale matrix, which must be symmetric and positive definite. In this context, the scale matrix is often interpreted in terms of a multivariate normal precision matrix (the inverse of the covariance matrix). Methods ------- ``pdf(x, df, scale)`` Probability density function. ``logpdf(x, df, scale)`` Log of the probability density function. ``rvs(df, scale, size=1, random_state=None)`` Draw random samples from a Wishart distribution. ``entropy()`` Compute the differential entropy of the Wishart distribution. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. %(_doc_default_callparams)s %(_doc_random_state)s Alternatively, the object may be called (as a function) to fix the degrees of freedom and scale parameters, returning a "frozen" Wishart random variable: rv = wishart(df=1, scale=1) - Frozen object with the same methods but holding the given degrees of freedom and scale fixed. See Also -------- invwishart, chi2 Notes ----- %(_doc_callparams_note)s The scale matrix `scale` must be a symmetric positive definite matrix. Singular matrices, including the symmetric positive semi-definite case, are not supported. The Wishart distribution is often denoted .. math:: W_p(\nu, \Sigma) where :math:`\nu` is the degrees of freedom and :math:`\Sigma` is the :math:`p \times p` scale matrix. The probability density function for `wishart` has support over positive definite matrices :math:`S`; if :math:`S \sim W_p(\nu, \Sigma)`, then its PDF is given by: .. math:: f(S) = \frac{|S|^{\frac{\nu - p - 1}{2}}}{2^{ \frac{\nu p}{2} } |\Sigma|^\frac{\nu}{2} \Gamma_p \left ( \frac{\nu}{2} \right )} \exp\left( -tr(\Sigma^{-1} S) / 2 \right) If :math:`S \sim W_p(\nu, \Sigma)` (Wishart) then :math:`S^{-1} \sim W_p^{-1}(\nu, \Sigma^{-1})` (inverse Wishart). If the scale matrix is 1-dimensional and equal to one, then the Wishart distribution :math:`W_1(\nu, 1)` collapses to the :math:`\chi^2(\nu)` distribution. .. versionadded:: 0.16.0 References ---------- .. [1] M.L. Eaton, "Multivariate Statistics: A Vector Space Approach", Wiley, 1983. .. [2] W.B. Smith and R.R. Hocking, "Algorithm AS 53: Wishart Variate Generator", Applied Statistics, vol. 21, pp. 341-345, 1972. Examples -------- >>> import matplotlib.pyplot as plt >>> from scipy.stats import wishart, chi2 >>> x = np.linspace(1e-5, 8, 100) >>> w = wishart.pdf(x, df=3, scale=1); w[:5] array([ 0.00126156, 0.10892176, 0.14793434, 0.17400548, 0.1929669 ]) >>> c = chi2.pdf(x, 3); c[:5] array([ 0.00126156, 0.10892176, 0.14793434, 0.17400548, 0.1929669 ]) >>> plt.plot(x, w) The input quantiles can be any shape of array, as long as the last axis labels the components. """ def __init__(self, seed=None): super(wishart_gen, self).__init__(seed) self.__doc__ = doccer.docformat(self.__doc__, wishart_docdict_params) def __call__(self, df=None, scale=None, seed=None): """ Create a frozen Wishart distribution. See `wishart_frozen` for more information. """ return wishart_frozen(df, scale, seed) def _process_parameters(self, df, scale): if scale is None: scale = 1.0 scale = np.asarray(scale, dtype=float) if scale.ndim == 0: scale = scale[np.newaxis,np.newaxis] elif scale.ndim == 1: scale = np.diag(scale) elif scale.ndim == 2 and not scale.shape[0] == scale.shape[1]: raise ValueError("Array 'scale' must be square if it is two" " dimensional, but scale.scale = %s." % str(scale.shape)) elif scale.ndim > 2: raise ValueError("Array 'scale' must be at most two-dimensional," " but scale.ndim = %d" % scale.ndim) dim = scale.shape[0] if df is None: df = dim elif not np.isscalar(df): raise ValueError("Degrees of freedom must be a scalar.") elif df < dim: raise ValueError("Degrees of freedom cannot be less than dimension" " of scale matrix, but df = %d" % df) return dim, df, scale def _process_quantiles(self, x, dim): """ Adjust quantiles array so that last axis labels the components of each data point. """ x = np.asarray(x, dtype=float) if x.ndim == 0: x = x * np.eye(dim)[:, :, np.newaxis] if x.ndim == 1: if dim == 1: x = x[np.newaxis, np.newaxis, :] else: x = np.diag(x)[:, :, np.newaxis] elif x.ndim == 2: if not x.shape[0] == x.shape[1]: raise ValueError("Quantiles must be square if they are two" " dimensional, but x.shape = %s." % str(x.shape)) x = x[:, :, np.newaxis] elif x.ndim == 3: if not x.shape[0] == x.shape[1]: raise ValueError("Quantiles must be square in the first two" " dimensions if they are three dimensional" ", but x.shape = %s." % str(x.shape)) elif x.ndim > 3: raise ValueError("Quantiles must be at most two-dimensional with" " an additional dimension for multiple" "components, but x.ndim = %d" % x.ndim) # Now we have 3-dim array; should have shape [dim, dim, *] if not x.shape[0:2] == (dim, dim): raise ValueError('Quantiles have incompatible dimensions: should' ' be %s, got %s.' % ((dim, dim), x.shape[0:2])) return x def _process_size(self, size): size = np.asarray(size) if size.ndim == 0: size = size[np.newaxis] elif size.ndim > 1: raise ValueError('Size must be an integer or tuple of integers;' ' thus must have dimension <= 1.' ' Got size.ndim = %s' % str(tuple(size))) n = size.prod() shape = tuple(size) return n, shape def _logpdf(self, x, dim, df, scale, log_det_scale, C): """ Parameters ---------- x : ndarray Points at which to evaluate the log of the probability density function dim : int Dimension of the scale matrix df : int Degrees of freedom scale : ndarray Scale matrix log_det_scale : float Logarithm of the determinant of the scale matrix C : ndarray Cholesky factorization of the scale matrix, lower triagular. Notes ----- As this function does no argument checking, it should not be called directly; use 'logpdf' instead. """ # log determinant of x # Note: x has components along the last axis, so that x.T has # components alone the 0-th axis. Then since det(A) = det(A'), this # gives us a 1-dim vector of determinants # Retrieve tr(scale^{-1} x) log_det_x = np.zeros(x.shape[-1]) scale_inv_x = np.zeros(x.shape) tr_scale_inv_x = np.zeros(x.shape[-1]) for i in range(x.shape[-1]): _, log_det_x[i] = self._cholesky_logdet(x[:,:,i]) scale_inv_x[:,:,i] = scipy.linalg.cho_solve((C, True), x[:,:,i]) tr_scale_inv_x[i] = scale_inv_x[:,:,i].trace() # Log PDF out = ((0.5 * (df - dim - 1) * log_det_x - 0.5 * tr_scale_inv_x) - (0.5 * df * dim * _LOG_2 + 0.5 * df * log_det_scale + multigammaln(0.5*df, dim))) return out def logpdf(self, x, df, scale): """ Log of the Wishart probability density function. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. Each quantile must be a symmetric positive definite matrix. %(_doc_default_callparams)s Returns ------- pdf : ndarray Log of the probability density function evaluated at `x` Notes ----- %(_doc_callparams_note)s """ dim, df, scale = self._process_parameters(df, scale) x = self._process_quantiles(x, dim) # Cholesky decomposition of scale, get log(det(scale)) C, log_det_scale = self._cholesky_logdet(scale) out = self._logpdf(x, dim, df, scale, log_det_scale, C) return _squeeze_output(out) def pdf(self, x, df, scale): """ Wishart probability density function. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. Each quantile must be a symmetric positive definite matrix. %(_doc_default_callparams)s Returns ------- pdf : ndarray Probability density function evaluated at `x` Notes ----- %(_doc_callparams_note)s """ return np.exp(self.logpdf(x, df, scale)) def _mean(self, dim, df, scale): """ Parameters ---------- dim : int Dimension of the scale matrix %(_doc_default_callparams)s Notes ----- As this function does no argument checking, it should not be called directly; use 'mean' instead. """ return df * scale def mean(self, df, scale): """ Mean of the Wishart distribution Parameters ---------- %(_doc_default_callparams)s Returns ------- mean : float The mean of the distribution """ dim, df, scale = self._process_parameters(df, scale) out = self._mean(dim, df, scale) return _squeeze_output(out) def _mode(self, dim, df, scale): """ Parameters ---------- dim : int Dimension of the scale matrix %(_doc_default_callparams)s Notes ----- As this function does no argument checking, it should not be called directly; use 'mode' instead. """ if df >= dim + 1: out = (df-dim-1) * scale else: out = None return out def mode(self, df, scale): """ Mode of the Wishart distribution Only valid if the degrees of freedom are greater than the dimension of the scale matrix. Parameters ---------- %(_doc_default_callparams)s Returns ------- mode : float or None The Mode of the distribution """ dim, df, scale = self._process_parameters(df, scale) out = self._mode(dim, df, scale) return _squeeze_output(out) if out is not None else out def _var(self, dim, df, scale): """ Parameters ---------- dim : int Dimension of the scale matrix %(_doc_default_callparams)s Notes ----- As this function does no argument checking, it should not be called directly; use 'var' instead. """ var = scale**2 diag = scale.diagonal() # 1 x dim array var += np.outer(diag, diag) var *= df return var def var(self, df, scale): """ Variance of the Wishart distribution Parameters ---------- %(_doc_default_callparams)s Returns ------- var : float The variance of the distribution """ dim, df, scale = self._process_parameters(df, scale) out = self._var(dim, df, scale) return _squeeze_output(out) def _standard_rvs(self, n, shape, dim, df, random_state): """ Parameters ---------- n : integer Number of variates to generate shape : iterable Shape of the variates to generate dim : int Dimension of the scale matrix df : int Degrees of freedom random_state : np.random.RandomState instance RandomState used for drawing the random variates. Notes ----- As this function does no argument checking, it should not be called directly; use 'rvs' instead. """ # Random normal variates for off-diagonal elements n_tril = dim * (dim-1) // 2 covariances = random_state.normal( size=n*n_tril).reshape(shape+(n_tril,)) # Random chi-square variates for diagonal elements variances = np.r_[[random_state.chisquare(df-(i+1)+1, size=n)**0.5 for i in range(dim)]].reshape((dim,) + shape[::-1]).T # Create the A matri(ces) - lower triangular A = np.zeros(shape + (dim, dim)) # Input the covariances size_idx = tuple([slice(None,None,None)]*len(shape)) tril_idx = np.tril_indices(dim, k=-1) A[size_idx + tril_idx] = covariances # Input the variances diag_idx = np.diag_indices(dim) A[size_idx + diag_idx] = variances return A def _rvs(self, n, shape, dim, df, C, random_state): """ Parameters ---------- n : integer Number of variates to generate shape : iterable Shape of the variates to generate dim : int Dimension of the scale matrix df : int Degrees of freedom scale : ndarray Scale matrix C : ndarray Cholesky factorization of the scale matrix, lower triangular. %(_doc_random_state)s Notes ----- As this function does no argument checking, it should not be called directly; use 'rvs' instead. """ random_state = self._get_random_state(random_state) # Calculate the matrices A, which are actually lower triangular # Cholesky factorizations of a matrix B such that B ~ W(df, I) A = self._standard_rvs(n, shape, dim, df, random_state) # Calculate SA = C A A' C', where SA ~ W(df, scale) # Note: this is the product of a (lower) (lower) (lower)' (lower)' # or, denoting B = AA', it is C B C' where C is the lower # triangular Cholesky factorization of the scale matrix. # this appears to conflict with the instructions in [1]_, which # suggest that it should be D' B D where D is the lower # triangular factorization of the scale matrix. However, it is # meant to refer to the Bartlett (1933) representation of a # Wishart random variate as L A A' L' where L is lower triangular # so it appears that understanding D' to be upper triangular # is either a typo in or misreading of [1]_. for index in np.ndindex(shape): CA = np.dot(C, A[index]) A[index] = np.dot(CA, CA.T) return A def rvs(self, df, scale, size=1, random_state=None): """ Draw random samples from a Wishart distribution. Parameters ---------- %(_doc_default_callparams)s size : integer or iterable of integers, optional Number of samples to draw (default 1). %(_doc_random_state)s Returns ------- rvs : ndarray Random variates of shape (`size`) + (`dim`, `dim), where `dim` is the dimension of the scale matrix. Notes ----- %(_doc_callparams_note)s """ n, shape = self._process_size(size) dim, df, scale = self._process_parameters(df, scale) # Cholesky decomposition of scale C = scipy.linalg.cholesky(scale, lower=True) out = self._rvs(n, shape, dim, df, C, random_state) return _squeeze_output(out) def _entropy(self, dim, df, log_det_scale): """ Parameters ---------- dim : int Dimension of the scale matrix df : int Degrees of freedom log_det_scale : float Logarithm of the determinant of the scale matrix Notes ----- As this function does no argument checking, it should not be called directly; use 'entropy' instead. """ return ( 0.5 * (dim+1) * log_det_scale + 0.5 * dim * (dim+1) * _LOG_2 + multigammaln(0.5*df, dim) - 0.5 * (df - dim - 1) * np.sum( [psi(0.5*(df + 1 - (i+1))) for i in range(dim)] ) + 0.5 * df * dim ) def entropy(self, df, scale): """ Compute the differential entropy of the Wishart. Parameters ---------- %(_doc_default_callparams)s Returns ------- h : scalar Entropy of the Wishart distribution Notes ----- %(_doc_callparams_note)s """ dim, df, scale = self._process_parameters(df, scale) _, log_det_scale = self._cholesky_logdet(scale) return self._entropy(dim, df, log_det_scale) def _cholesky_logdet(self, scale): """ Compute Cholesky decomposition and determine (log(det(scale)). Parameters ---------- scale : ndarray Scale matrix. Returns ------- c_decomp : ndarray The Cholesky decomposition of `scale`. logdet : scalar The log of the determinant of `scale`. Notes ----- This computation of ``logdet`` is equivalent to ``np.linalg.slogdet(scale)``. It is ~2x faster though. """ c_decomp = scipy.linalg.cholesky(scale, lower=True) logdet = 2 * np.sum(np.log(c_decomp.diagonal())) return c_decomp, logdet wishart = wishart_gen() class wishart_frozen(multi_rv_frozen): """ Create a frozen Wishart distribution. Parameters ---------- df : array_like Degrees of freedom of the distribution scale : array_like Scale matrix of the distribution seed : None or int or np.random.RandomState instance, optional This parameter defines the RandomState object to use for drawing random variates. If None (or np.random), the global np.random state is used. If integer, it is used to seed the local RandomState instance Default is None. """ def __init__(self, df, scale, seed=None): self._dist = wishart_gen(seed) self.dim, self.df, self.scale = self._dist._process_parameters( df, scale) self.C, self.log_det_scale = self._dist._cholesky_logdet(self.scale) def logpdf(self, x): x = self._dist._process_quantiles(x, self.dim) out = self._dist._logpdf(x, self.dim, self.df, self.scale, self.log_det_scale, self.C) return _squeeze_output(out) def pdf(self, x): return np.exp(self.logpdf(x)) def mean(self): out = self._dist._mean(self.dim, self.df, self.scale) return _squeeze_output(out) def mode(self): out = self._dist._mode(self.dim, self.df, self.scale) return _squeeze_output(out) if out is not None else out def var(self): out = self._dist._var(self.dim, self.df, self.scale) return _squeeze_output(out) def rvs(self, size=1, random_state=None): n, shape = self._dist._process_size(size) out = self._dist._rvs(n, shape, self.dim, self.df, self.C, random_state) return _squeeze_output(out) def entropy(self): return self._dist._entropy(self.dim, self.df, self.log_det_scale) # Set frozen generator docstrings from corresponding docstrings in # Wishart and fill in default strings in class docstrings for name in ['logpdf', 'pdf', 'mean', 'mode', 'var', 'rvs', 'entropy']: method = wishart_gen.__dict__[name] method_frozen = wishart_frozen.__dict__[name] method_frozen.__doc__ = doccer.docformat( method.__doc__, wishart_docdict_noparams) method.__doc__ = doccer.docformat(method.__doc__, wishart_docdict_params) from numpy import asarray_chkfinite, asarray from scipy.linalg.misc import LinAlgError from scipy.linalg.lapack import get_lapack_funcs def _cho_inv_batch(a, check_finite=True): """ Invert the matrices a_i, using a Cholesky factorization of A, where a_i resides in the last two dimensions of a and the other indices describe the index i. Overwrites the data in a. Parameters ---------- a : array Array of matrices to invert, where the matrices themselves are stored in the last two dimensions. check_finite : bool, optional Whether to check that the input matrices contain only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs. Returns ------- x : array Array of inverses of the matrices ``a_i``. See also -------- scipy.linalg.cholesky : Cholesky factorization of a matrix """ if check_finite: a1 = asarray_chkfinite(a) else: a1 = asarray(a) if len(a1.shape) < 2 or a1.shape[-2] != a1.shape[-1]: raise ValueError('expected square matrix in last two dimensions') potrf, potri = get_lapack_funcs(('potrf','potri'), (a1,)) tril_idx = np.tril_indices(a.shape[-2], k=-1) triu_idx = np.triu_indices(a.shape[-2], k=1) for index in np.ndindex(a1.shape[:-2]): # Cholesky decomposition a1[index], info = potrf(a1[index], lower=True, overwrite_a=False, clean=False) if info > 0: raise LinAlgError("%d-th leading minor not positive definite" % info) if info < 0: raise ValueError('illegal value in %d-th argument of internal' ' potrf' % -info) # Inversion a1[index], info = potri(a1[index], lower=True, overwrite_c=False) if info > 0: raise LinAlgError("the inverse could not be computed") if info < 0: raise ValueError('illegal value in %d-th argument of internal' ' potrf' % -info) # Make symmetric (dpotri only fills in the lower triangle) a1[index][triu_idx] = a1[index][tril_idx] return a1 class invwishart_gen(wishart_gen): r""" An inverse Wishart random variable. The `df` keyword specifies the degrees of freedom. The `scale` keyword specifies the scale matrix, which must be symmetric and positive definite. In this context, the scale matrix is often interpreted in terms of a multivariate normal covariance matrix. Methods ------- ``pdf(x, df, scale)`` Probability density function. ``logpdf(x, df, scale)`` Log of the probability density function. ``rvs(df, scale, size=1, random_state=None)`` Draw random samples from an inverse Wishart distribution. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. %(_doc_default_callparams)s %(_doc_random_state)s Alternatively, the object may be called (as a function) to fix the degrees of freedom and scale parameters, returning a "frozen" inverse Wishart random variable: rv = invwishart(df=1, scale=1) - Frozen object with the same methods but holding the given degrees of freedom and scale fixed. See Also -------- wishart Notes ----- %(_doc_callparams_note)s The scale matrix `scale` must be a symmetric positive definite matrix. Singular matrices, including the symmetric positive semi-definite case, are not supported. The inverse Wishart distribution is often denoted .. math:: W_p^{-1}(\nu, \Psi) where :math:`\nu` is the degrees of freedom and :math:`\Psi` is the :math:`p \times p` scale matrix. The probability density function for `invwishart` has support over positive definite matrices :math:`S`; if :math:`S \sim W^{-1}_p(\nu, \Sigma)`, then its PDF is given by: .. math:: f(S) = \frac{|\Sigma|^\frac{\nu}{2}}{2^{ \frac{\nu p}{2} } |S|^{\frac{\nu + p + 1}{2}} \Gamma_p \left(\frac{\nu}{2} \right)} \exp\left( -tr(\Sigma S^{-1}) / 2 \right) If :math:`S \sim W_p^{-1}(\nu, \Psi)` (inverse Wishart) then :math:`S^{-1} \sim W_p(\nu, \Psi^{-1})` (Wishart). If the scale matrix is 1-dimensional and equal to one, then the inverse Wishart distribution :math:`W_1(\nu, 1)` collapses to the inverse Gamma distribution with parameters shape = :math:`\frac{\nu}{2}` and scale = :math:`\frac{1}{2}`. .. versionadded:: 0.16.0 References ---------- .. [1] M.L. Eaton, "Multivariate Statistics: A Vector Space Approach", Wiley, 1983. .. [2] M.C. Jones, "Generating Inverse Wishart Matrices", Communications in Statistics - Simulation and Computation, vol. 14.2, pp.511-514, 1985. Examples -------- >>> import matplotlib.pyplot as plt >>> from scipy.stats import invwishart, invgamma >>> x = np.linspace(0.01, 1, 100) >>> iw = invwishart.pdf(x, df=6, scale=1) >>> iw[:3] array([ 1.20546865e-15, 5.42497807e-06, 4.45813929e-03]) >>> ig = invgamma.pdf(x, 6/2., scale=1./2) >>> ig[:3] array([ 1.20546865e-15, 5.42497807e-06, 4.45813929e-03]) >>> plt.plot(x, iw) The input quantiles can be any shape of array, as long as the last axis labels the components. """ def __init__(self, seed=None): super(invwishart_gen, self).__init__(seed) self.__doc__ = doccer.docformat(self.__doc__, wishart_docdict_params) def __call__(self, df=None, scale=None, seed=None): """ Create a frozen inverse Wishart distribution. See `invwishart_frozen` for more information. """ return invwishart_frozen(df, scale, seed) def _logpdf(self, x, dim, df, scale, log_det_scale): """ Parameters ---------- x : ndarray Points at which to evaluate the log of the probability density function. dim : int Dimension of the scale matrix df : int Degrees of freedom scale : ndarray Scale matrix log_det_scale : float Logarithm of the determinant of the scale matrix Notes ----- As this function does no argument checking, it should not be called directly; use 'logpdf' instead. """ log_det_x = np.zeros(x.shape[-1]) #scale_x_inv = np.zeros(x.shape) x_inv = np.copy(x).T if dim > 1: _cho_inv_batch(x_inv) # works in-place else: x_inv = 1./x_inv tr_scale_x_inv = np.zeros(x.shape[-1]) for i in range(x.shape[-1]): C, lower = scipy.linalg.cho_factor(x[:,:,i], lower=True) log_det_x[i] = 2 * np.sum(np.log(C.diagonal())) #scale_x_inv[:,:,i] = scipy.linalg.cho_solve((C, True), scale).T tr_scale_x_inv[i] = np.dot(scale, x_inv[i]).trace() # Log PDF out = ((0.5 * df * log_det_scale - 0.5 * tr_scale_x_inv) - (0.5 * df * dim * _LOG_2 + 0.5 * (df + dim + 1) * log_det_x) - multigammaln(0.5*df, dim)) return out def logpdf(self, x, df, scale): """ Log of the inverse Wishart probability density function. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. Each quantile must be a symmetric positive definite matrix. %(_doc_default_callparams)s Returns ------- pdf : ndarray Log of the probability density function evaluated at `x` Notes ----- %(_doc_callparams_note)s """ dim, df, scale = self._process_parameters(df, scale) x = self._process_quantiles(x, dim) _, log_det_scale = self._cholesky_logdet(scale) out = self._logpdf(x, dim, df, scale, log_det_scale) return _squeeze_output(out) def pdf(self, x, df, scale): """ Inverse Wishart probability density function. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. Each quantile must be a symmetric positive definite matrix. %(_doc_default_callparams)s Returns ------- pdf : ndarray Probability density function evaluated at `x` Notes ----- %(_doc_callparams_note)s """ return np.exp(self.logpdf(x, df, scale)) def _mean(self, dim, df, scale): """ Parameters ---------- dim : int Dimension of the scale matrix %(_doc_default_callparams)s Notes ----- As this function does no argument checking, it should not be called directly; use 'mean' instead. """ if df > dim + 1: out = scale / (df - dim - 1) else: out = None return out def mean(self, df, scale): """ Mean of the inverse Wishart distribution Only valid if the degrees of freedom are greater than the dimension of the scale matrix plus one. Parameters ---------- %(_doc_default_callparams)s Returns ------- mean : float or None The mean of the distribution """ dim, df, scale = self._process_parameters(df, scale) out = self._mean(dim, df, scale) return _squeeze_output(out) if out is not None else out def _mode(self, dim, df, scale): """ Parameters ---------- dim : int Dimension of the scale matrix %(_doc_default_callparams)s Notes ----- As this function does no argument checking, it should not be called directly; use 'mode' instead. """ return scale / (df + dim + 1) def mode(self, df, scale): """ Mode of the inverse Wishart distribution Parameters ---------- %(_doc_default_callparams)s Returns ------- mode : float The Mode of the distribution """ dim, df, scale = self._process_parameters(df, scale) out = self._mode(dim, df, scale) return _squeeze_output(out) def _var(self, dim, df, scale): """ Parameters ---------- dim : int Dimension of the scale matrix %(_doc_default_callparams)s Notes ----- As this function does no argument checking, it should not be called directly; use 'var' instead. """ if df > dim + 3: var = (df - dim + 1) * scale**2 diag = scale.diagonal() # 1 x dim array var += (df - dim - 1) * np.outer(diag, diag) var /= (df - dim) * (df - dim - 1)**2 * (df - dim - 3) else: var = None return var def var(self, df, scale): """ Variance of the inverse Wishart distribution Only valid if the degrees of freedom are greater than the dimension of the scale matrix plus three. Parameters ---------- %(_doc_default_callparams)s Returns ------- var : float The variance of the distribution """ dim, df, scale = self._process_parameters(df, scale) out = self._var(dim, df, scale) return _squeeze_output(out) if out is not None else out def _rvs(self, n, shape, dim, df, C, random_state): """ Parameters ---------- n : integer Number of variates to generate shape : iterable Shape of the variates to generate dim : int Dimension of the scale matrix df : int Degrees of freedom C : ndarray Cholesky factorization of the scale matrix, lower triagular. %(_doc_random_state)s Notes ----- As this function does no argument checking, it should not be called directly; use 'rvs' instead. """ random_state = self._get_random_state(random_state) # Get random draws A such that A ~ W(df, I) A = super(invwishart_gen, self)._standard_rvs(n, shape, dim, df, random_state) # Calculate SA = (CA)'^{-1} (CA)^{-1} ~ iW(df, scale) eye = np.eye(dim) trtrs = get_lapack_funcs(('trtrs'), (A,)) for index in np.ndindex(A.shape[:-2]): # Calculate CA CA = np.dot(C, A[index]) # Get (C A)^{-1} via triangular solver if dim > 1: CA, info = trtrs(CA, eye, lower=True) if info > 0: raise LinAlgError("Singular matrix.") if info < 0: raise ValueError('Illegal value in %d-th argument of' ' internal trtrs' % -info) else: CA = 1. / CA # Get SA A[index] = np.dot(CA.T, CA) return A def rvs(self, df, scale, size=1, random_state=None): """ Draw random samples from an inverse Wishart distribution. Parameters ---------- %(_doc_default_callparams)s size : integer or iterable of integers, optional Number of samples to draw (default 1). %(_doc_random_state)s Returns ------- rvs : ndarray Random variates of shape (`size`) + (`dim`, `dim), where `dim` is the dimension of the scale matrix. Notes ----- %(_doc_callparams_note)s """ n, shape = self._process_size(size) dim, df, scale = self._process_parameters(df, scale) # Invert the scale eye = np.eye(dim) L, lower = scipy.linalg.cho_factor(scale, lower=True) inv_scale = scipy.linalg.cho_solve((L, lower), eye) # Cholesky decomposition of inverted scale C = scipy.linalg.cholesky(inv_scale, lower=True) out = self._rvs(n, shape, dim, df, C, random_state) return _squeeze_output(out) def entropy(self): # Need to find reference for inverse Wishart entropy raise AttributeError invwishart = invwishart_gen() class invwishart_frozen(multi_rv_frozen): def __init__(self, df, scale, seed=None): """ Create a frozen inverse Wishart distribution. Parameters ---------- df : array_like Degrees of freedom of the distribution scale : array_like Scale matrix of the distribution seed : None or int or np.random.RandomState instance, optional This parameter defines the RandomState object to use for drawing random variates. If None (or np.random), the global np.random state is used. If integer, it is used to seed the local RandomState instance Default is None. """ self._dist = invwishart_gen(seed) self.dim, self.df, self.scale = self._dist._process_parameters( df, scale ) # Get the determinant via Cholesky factorization C, lower = scipy.linalg.cho_factor(self.scale, lower=True) self.log_det_scale = 2 * np.sum(np.log(C.diagonal())) # Get the inverse using the Cholesky factorization eye = np.eye(self.dim) self.inv_scale = scipy.linalg.cho_solve((C, lower), eye) # Get the Cholesky factorization of the inverse scale self.C = scipy.linalg.cholesky(self.inv_scale, lower=True) def logpdf(self, x): x = self._dist._process_quantiles(x, self.dim) out = self._dist._logpdf(x, self.dim, self.df, self.scale, self.log_det_scale) return _squeeze_output(out) def pdf(self, x): return np.exp(self.logpdf(x)) def mean(self): out = self._dist._mean(self.dim, self.df, self.scale) return _squeeze_output(out) if out is not None else out def mode(self): out = self._dist._mode(self.dim, self.df, self.scale) return _squeeze_output(out) def var(self): out = self._dist._var(self.dim, self.df, self.scale) return _squeeze_output(out) if out is not None else out def rvs(self, size=1, random_state=None): n, shape = self._dist._process_size(size) out = self._dist._rvs(n, shape, self.dim, self.df, self.C, random_state) return _squeeze_output(out) def entropy(self): # Need to find reference for inverse Wishart entropy raise AttributeError # Set frozen generator docstrings from corresponding docstrings in # inverse Wishart and fill in default strings in class docstrings for name in ['logpdf', 'pdf', 'mean', 'mode', 'var', 'rvs']: method = invwishart_gen.__dict__[name] method_frozen = wishart_frozen.__dict__[name] method_frozen.__doc__ = doccer.docformat( method.__doc__, wishart_docdict_noparams) method.__doc__ = doccer.docformat(method.__doc__, wishart_docdict_params)
bsd-3-clause
stuart-knock/bokeh
bokeh/cli/utils.py
42
8119
from __future__ import absolute_import, print_function from collections import OrderedDict from six.moves.urllib import request as urllib2 import io import pandas as pd from .. import charts from . import help_messages as hm def keep_source_input_sync(filepath, callback, start=0): """ Monitor file at filepath checking for new lines (similar to tail -f) and calls callback on every new line found. Args: filepath (str): path to the series data file ( i.e.: /source/to/my/data.csv) callback (callable): function to be called with the a DataFrame created from the new lines found from file at filepath starting byte start start (int): specifies where to start reading from the file at filepath. Default: 0 Returns: DataFrame created from data read from filepath """ if filepath is None: msg = "No Input! Please specify --source_filename or --buffer t" raise IOError(msg) if filepath.lower().startswith('http'): # Create a request for the given URL. while True: request = urllib2.Request(filepath) data = get_data_from_url(request, start) f = io.BytesIO(data) f.seek(start) line = f.readline() # See note below if not line: continue # No data, try again callback(line) start = len(data) else: f = open(filepath, 'r') f.seek(start) while True: line = f.readline() # See note below if not line: continue # No data, try again callback(line) source = pd.read_csv(filepath) return source # Try to get the response. This will raise a urllib2.URLError if there is a # problem (e.g., invalid URL). # Reference: # - http://stackoverflow.com/questions/5209087/python-seek-in-http-response-stream # - http://stackoverflow.com/questions/1971240/python-seek-on-remote-file-using-http def get_data_from_url(request, start=0, length=0): """ Read from request after adding headers to retrieve data from byte specified in start. request (urllib2.Request): request object related to the data to read start (int, optional): byte to start reading from. Default: 0 length: length of the data range to read from start. If 0 it reads until the end of the stream. Default: 0 Returns: String read from request """ # Add the header to specify the range to download. if start and length: request.add_header("Range", "bytes=%d-%d" % (start, start + length - 1)) elif start: request.add_header("Range", "bytes=%s-" % start) response = urllib2.urlopen(request) # If a content-range header is present, partial retrieval worked. if "content-range" in response.headers: print("Partial retrieval successful.") # The header contains the string 'bytes', followed by a space, then the # range in the format 'start-end', followed by a slash and then the total # size of the page (or an asterix if the total size is unknown). Lets get # the range and total size from this. _range, total = response.headers['content-range'].split(' ')[-1].split('/') # Print a message giving the range information. if total == '*': print("Bytes %s of an unknown total were retrieved." % _range) else: print("Bytes %s of a total of %s were retrieved." % (_range, total)) # # No header, so partial retrieval was unsuccessful. # else: # print "Unable to use partial retrieval." data = response.read() return data def parse_output_config(output): """Parse the output specification string and return the related chart output attribute. Attr: output (str): String with the syntax convention specified for the cli output option is as follows: <output_type>://<type_arg> Valid values: output_type: file or server type_arg: file_path if output_type is file serve path if output_type is server Returns: dictionary containing the output arguments to pass to a chart object """ output_type, output_options = output.split('://') if output_type == 'file': return {'filename': output_options} elif output_type == 'server': # TODO: check if server configuration is as flexible as with plotting # interface and add support for url/name if so. out_opt = output_options.split("@") attrnames = ['server', 'url', 'name'] # unpack server output parametrs in order to pass them to the plot # creation function kws = dict((attrn, val) for attrn, val in zip( attrnames, out_opt)) return {'server': kws['server']} else: msg = "Unknown output type %s found. Please use: file|server" print (msg % output_type) return {} def get_chart_params(title, output, show_legend=False): """Parse output type and output options and return related chart parameters. For example: returns filename if output_type is file or server it output_type is server Args: title (str): the title of your plot. output (str): selected output. Follows the following convention: <output_type>://<type_arg> where output_type can be `file` (in that case type_arg specifies the file path) or `server` (in that case type_arg specify the server name). Returns: dictionary containing the arguments to pass to a chart object related to title and output options """ params = {'title': title, 'legend': show_legend} output_params = parse_output_config(output) if output_params: params.update(output_params) return params def get_data_series(series, source, indexes): """Generate an OrderedDict from the source series excluding index and all series not specified in series. Args: series (list(str)): list of strings specifying the names of the series to keep from source source (DataFrame): pandas DataFrame with the data series to be plotted indexes (lst(str)): name of the series of source to be used as index. Returns: OrderedDict with the data series from source """ series = define_series(series, source, indexes) # generate charts data data_series = OrderedDict() for i, colname in enumerate(series+indexes): try: data_series[colname] = source[colname] except KeyError: raise KeyError(hm.ERR_MSG_SERIES_NOT_FOUND % (colname, source.keys())) return data_series def define_series(series, source, indexes): """If series is empty returns source_columns excluding the column where column == index. Otherwise returns the series.split(',') Args: series (str): string that contains the names of the series to keep from source, separated by `,` source (DataFrame): pandas DataFrame with the data series to be plotted indexes (lst(str)): name of the series of source to be used as index. Returns: list of the names (as str) of the series except index """ if not series: return [c for c in source.columns if c not in indexes] else: return series.split(',') def get_charts_mapping(): """Return a dict with chart classes names (lower case) as keys and their related class as values. Returns: dict mapping chart classes names to chart classes """ mapping = {} for (clsname, cls) in charts.__dict__.items(): try: # TODO: We may need to restore the objects filtering # when charts creators (or builders registration) is added # to the charts API mapping[clsname.lower()] = cls except TypeError: pass return mapping
bsd-3-clause
SciTools/cartopy
examples/miscellanea/un_flag.py
2
7533
""" UN Flag ------- A demonstration of the power of Matplotlib combined with cartopy's Azimuthal Equidistant projection to reproduce the UN flag. """ import cartopy.crs as ccrs import cartopy.feature as cfeature import matplotlib.pyplot as plt from matplotlib.patches import PathPatch import matplotlib.path import matplotlib.ticker from matplotlib.transforms import BboxTransform, Bbox import numpy as np # When drawing the flag, we can either use white filled land, or be a little # more fancy and use the Natural Earth shaded relief imagery. filled_land = True def olive_path(): """ Return a Matplotlib path representing a single olive branch from the UN Flag. The path coordinates were extracted from the SVG at https://commons.wikimedia.org/wiki/File:Flag_of_the_United_Nations.svg. """ olives_verts = np.array( [[0, 2, 6, 9, 30, 55, 79, 94, 104, 117, 134, 157, 177, 188, 199, 207, 191, 167, 149, 129, 109, 87, 53, 22, 0, 663, 245, 223, 187, 158, 154, 150, 146, 149, 154, 158, 181, 184, 197, 181, 167, 153, 142, 129, 116, 119, 123, 127, 151, 178, 203, 220, 237, 245, 663, 280, 267, 232, 209, 205, 201, 196, 196, 201, 207, 211, 224, 219, 230, 220, 212, 207, 198, 195, 176, 197, 220, 239, 259, 277, 280, 663, 295, 293, 264, 250, 247, 244, 240, 240, 243, 244, 249, 251, 250, 248, 242, 245, 233, 236, 230, 228, 224, 222, 234, 249, 262, 275, 285, 291, 295, 296, 295, 663, 294, 293, 292, 289, 294, 277, 271, 269, 268, 265, 264, 264, 264, 272, 260, 248, 245, 243, 242, 240, 243, 245, 247, 252, 256, 259, 258, 257, 258, 267, 285, 290, 294, 297, 294, 663, 285, 285, 277, 266, 265, 265, 265, 277, 266, 268, 269, 269, 269, 268, 268, 267, 267, 264, 248, 235, 232, 229, 228, 229, 232, 236, 246, 266, 269, 271, 285, 285, 663, 252, 245, 238, 230, 246, 245, 250, 252, 255, 256, 256, 253, 249, 242, 231, 214, 208, 208, 227, 244, 252, 258, 262, 262, 261, 262, 264, 265, 252, 663, 185, 197, 206, 215, 223, 233, 242, 237, 237, 230, 220, 202, 185, 663], [8, 5, 3, 0, 22, 46, 46, 46, 35, 27, 16, 10, 18, 22, 28, 38, 27, 26, 33, 41, 52, 52, 52, 30, 8, 595, 77, 52, 61, 54, 53, 52, 53, 55, 55, 57, 65, 90, 106, 96, 81, 68, 58, 54, 51, 50, 51, 50, 44, 34, 43, 48, 61, 77, 595, 135, 104, 102, 83, 79, 76, 74, 74, 79, 84, 90, 109, 135, 156, 145, 133, 121, 100, 77, 62, 69, 67, 80, 92, 113, 135, 595, 198, 171, 156, 134, 129, 124, 120, 123, 126, 129, 138, 149, 161, 175, 188, 202, 177, 144, 116, 110, 105, 99, 108, 116, 126, 136, 147, 162, 173, 186, 198, 595, 249, 255, 261, 267, 241, 222, 200, 192, 183, 175, 175, 175, 175, 199, 221, 240, 245, 250, 256, 245, 233, 222, 207, 194, 180, 172, 162, 153, 154, 171, 184, 202, 216, 233, 249, 595, 276, 296, 312, 327, 327, 327, 327, 308, 284, 262, 240, 240, 239, 239, 242, 244, 247, 265, 277, 290, 293, 296, 300, 291, 282, 274, 253, 236, 213, 235, 252, 276, 595, 342, 349, 355, 357, 346, 326, 309, 303, 297, 291, 290, 297, 304, 310, 321, 327, 343, 321, 305, 292, 286, 278, 270, 276, 281, 287, 306, 328, 342, 595, 379, 369, 355, 343, 333, 326, 318, 328, 340, 349, 366, 373, 379, 595]]).T olives_codes = np.array([1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 79, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 79, 1, 4, 4, 4, 4, 4, 4, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 79, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 79, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 4, 4, 4, 4, 4, 4, 79, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 79, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 79, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 79], dtype=np.uint8) return matplotlib.path.Path(olives_verts, olives_codes) def main(): blue = '#4b92db' # We're drawing a flag with a 3:5 aspect ratio. fig = plt.figure(figsize=[7.5, 4.5], facecolor=blue) # Put a blue background on the figure. blue_background = PathPatch(matplotlib.path.Path.unit_rectangle(), transform=fig.transFigure, color=blue, zorder=-1) fig.patches.append(blue_background) # Set up the Azimuthal Equidistant and Plate Carree projections # for later use. az_eq = ccrs.AzimuthalEquidistant(central_latitude=90) pc = ccrs.PlateCarree() # Pick a suitable location for the map (which is in an Azimuthal # Equidistant projection). ax = fig.add_axes([0.25, 0.24, 0.5, 0.54], projection=az_eq) # The background patch is not needed in this example. ax.patch.set_facecolor('none') # The Axes frame produces the outer meridian line. for spine in ax.spines.values(): spine.update({'edgecolor': 'white', 'linewidth': 2}) # We want the map to go down to -60 degrees latitude. ax.set_extent([-180, 180, -60, 90], ccrs.PlateCarree()) # Importantly, we want the axes to be circular at the -60 latitude # rather than cartopy's default behaviour of zooming in and becoming # square. _, patch_radius = az_eq.transform_point(0, -60, pc) circular_path = matplotlib.path.Path.circle(0, patch_radius) ax.set_boundary(circular_path) if filled_land: ax.add_feature( cfeature.LAND, facecolor='white', edgecolor='none') else: ax.stock_img() gl = ax.gridlines(crs=pc, linewidth=2, color='white', linestyle='-') # Meridians every 45 degrees, and 4 parallels. gl.xlocator = matplotlib.ticker.FixedLocator(np.arange(-180, 181, 45)) parallels = np.arange(-30, 70, 30) gl.ylocator = matplotlib.ticker.FixedLocator(parallels) # Now add the olive branches around the axes. We do this in normalised # figure coordinates olive_leaf = olive_path() olives_bbox = Bbox.null() olives_bbox.update_from_path(olive_leaf) # The first olive branch goes from left to right. olive1_axes_bbox = Bbox([[0.45, 0.15], [0.725, 0.75]]) olive1_trans = BboxTransform(olives_bbox, olive1_axes_bbox) # THe second olive branch goes from right to left (mirroring the first). olive2_axes_bbox = Bbox([[0.55, 0.15], [0.275, 0.75]]) olive2_trans = BboxTransform(olives_bbox, olive2_axes_bbox) olive1 = PathPatch(olive_leaf, facecolor='white', edgecolor='none', transform=olive1_trans + fig.transFigure) olive2 = PathPatch(olive_leaf, facecolor='white', edgecolor='none', transform=olive2_trans + fig.transFigure) fig.patches.append(olive1) fig.patches.append(olive2) plt.show() if __name__ == '__main__': main()
lgpl-3.0
Winand/pandas
asv_bench/benchmarks/panel_ctor.py
7
2304
from .pandas_vb_common import * from datetime import timedelta class Constructors1(object): goal_time = 0.2 def setup(self): self.data_frames = {} self.start = datetime(1990, 1, 1) self.end = datetime(2012, 1, 1) for x in range(100): self.end += timedelta(days=1) self.dr = np.asarray(date_range(self.start, self.end)) self.df = DataFrame({'a': ([0] * len(self.dr)), 'b': ([1] * len(self.dr)), 'c': ([2] * len(self.dr)), }, index=self.dr) self.data_frames[x] = self.df def time_panel_from_dict_all_different_indexes(self): Panel.from_dict(self.data_frames) class Constructors2(object): goal_time = 0.2 def setup(self): self.data_frames = {} for x in range(100): self.dr = np.asarray(DatetimeIndex(start=datetime(1990, 1, 1), end=datetime(2012, 1, 1), freq='D')) self.df = DataFrame({'a': ([0] * len(self.dr)), 'b': ([1] * len(self.dr)), 'c': ([2] * len(self.dr)), }, index=self.dr) self.data_frames[x] = self.df def time_panel_from_dict_equiv_indexes(self): Panel.from_dict(self.data_frames) class Constructors3(object): goal_time = 0.2 def setup(self): self.dr = np.asarray(DatetimeIndex(start=datetime(1990, 1, 1), end=datetime(2012, 1, 1), freq='D')) self.data_frames = {} for x in range(100): self.df = DataFrame({'a': ([0] * len(self.dr)), 'b': ([1] * len(self.dr)), 'c': ([2] * len(self.dr)), }, index=self.dr) self.data_frames[x] = self.df def time_panel_from_dict_same_index(self): Panel.from_dict(self.data_frames) class Constructors4(object): goal_time = 0.2 def setup(self): self.data_frames = {} self.start = datetime(1990, 1, 1) self.end = datetime(2012, 1, 1) for x in range(100): if (x == 50): self.end += timedelta(days=1) self.dr = np.asarray(date_range(self.start, self.end)) self.df = DataFrame({'a': ([0] * len(self.dr)), 'b': ([1] * len(self.dr)), 'c': ([2] * len(self.dr)), }, index=self.dr) self.data_frames[x] = self.df def time_panel_from_dict_two_different_indexes(self): Panel.from_dict(self.data_frames)
bsd-3-clause
jdorvi/CSHORE
other/print_folders.py
1
1423
# coding: utf-8 #Extracts all .63.bz2 files in directory folder starting at current directory import os import pandas as pd DATAFILES_DIRECTORY = "P:/02/LakeOntario/Storm/" def main(datafiles_directory): """ doc string """ os.chdir(datafiles_directory) stormlist = [] for root, dirs, files in os.walk("."): if os.path.exists(root+"/fort.63") is True: if len(root) == 10: print(root.strip(".").strip("\\")) stormlist.append(root.strip(".").strip("\\")) stormlist.sort() stormlist1 = stormlist[0:30] stormlist2 = stormlist[30:60] stormlist3 = stormlist[60:90] stormlist4 = stormlist[90:120] stormlist5 = stormlist[120:150] stormlist1.insert(0, len(stormlist1)) stormlist2.insert(0, len(stormlist2)) stormlist3.insert(0, len(stormlist3)) stormlist4.insert(0, len(stormlist4)) stormlist5.insert(0, len(stormlist5)) storms1 = pd.Series(stormlist1) storms2 = pd.Series(stormlist2) storms3 = pd.Series(stormlist3) storms4 = pd.Series(stormlist4) storms5 = pd.Series(stormlist5) storms1.to_csv('stormslist1.txt', index=False) storms2.to_csv('stormslist2.txt', index=False) storms3.to_csv('stormslist3.txt', index=False) storms4.to_csv('stormslist4.txt', index=False) storms5.to_csv('stormslist5.txt', index=False) if __name__ == '__main__': main(DATAFILES_DIRECTORY)
apache-2.0
matsushitayuki/space-modeling
denoise_setup.py
1
1756
import numpy as np import matplotlib.pyplot as plt from OD_setup import * def R_gene(N,n): R_0 = np.zeros((n,N)) p = int(N**0.5 - n**0.5 + 1) R_init = [int(N**0.5*i + j) for i in range(p) for j in range(p)] R_list = [] for r in R_init: R = np.array(R_0) R_element = [int(r + N**0.5*i + j) for i in range(int(n**0.5)) for j in range(int((n**0.5)))] for i in range(n): R[i,R_element[i]] = 1 R_list.append(R) return R_list def alpha_line(lamda,x,D,T,e): alpha = alpha_ADMM(lamda,x,D,T) while np.linalg.norm(x - D@alpha)**2 > e: lamda = 0.8*lamda alpha = alpha_ADMM(lamda,x,D,T) return alpha def alpha_patch(lamda,X,D,T,e,R_list): alpha_list = [] i = 1 for r in R_list: x = r@X alpha_r = alpha_line(lamda,x,D,T,e) alpha_list.append(alpha_r) i += 1 return np.array(alpha_list) def det_X(mu,X,D,alpha_list,R_list,inv): RDalpha = np.zeros((R_list[1].shape[1],1)) for i in range(len(R_list)): RDalpha += R_list[i].T @ D @ alpha_list[i] X = inv @ (mu*X + RDalpha) return X def denoise_show(x_list): for i in range(len(x_list)): x_t = x_list[i].reshape(int(x_list[i].shape[0]**0.5),int(x_list[i].shape[0]**0.5)) plt.subplot(1,3,i+1) plt.imshow(x_t) plt.gray() def R(X,i,j,n): return X[i:i+n,j:j+n] def R_T(x,i,j,N): n = x.shape[0] C = np.zeros((N,N)) C[i:i+n,j:j+n] = x return C def R_T_R(N,n): A = np.ones((N,N)) B = np.zeros((N,N)) for i in range(N-n+1): for j in range(N-n+1): RA = R(A,i,j,n) R_T_RA = R_T(RA,i,j,N) B += R_T_RA B = B.reshape(N**2,1) return B
gpl-3.0
mrgloom/h2o-3
h2o-py/tests/testdir_algos/kmeans/pyunit_emptyclusKmeans.py
3
1902
import sys sys.path.insert(1, "../../../") import h2o import random import numpy as np from sklearn import preprocessing from sklearn.cluster import KMeans def emptyclusKmeans(ip,port): # Connect to a pre-existing cluster # connect to localhost:54321 #Log.info("Importing ozone.csv data...\n") ozone_sci = np.loadtxt(h2o.locate("smalldata/glm_test/ozone.csv"), delimiter=',', skiprows=1) ozone_h2o = h2o.import_file(path=h2o.locate("smalldata/glm_test/ozone.csv")) ncent = 10 nempty = random.randint(1,ncent/2) initial_centers = [[41,190,67,7.4], [36,118,72,8], [12,149,74,12.6], [18,313,62,11.5], [23,299,65,8.6], [19,99,59,13.8], [8,19,61,20.1], [16,256,69,9.7], [11,290,66,9.2], [14,274,68,10.9]] for i in random.sample(range(0,ncent-1), nempty): initial_centers[i] = [100*i for z in range(1,len(initial_centers[0])+1)] initial_centers_h2o = h2o.H2OFrame(initial_centers) initial_centers_sci = np.asarray(initial_centers) #Log.info("Initial cluster centers:") print "H2O initial centers:" initial_centers_h2o.show() print "scikit initial centers:" print initial_centers_sci # H2O can handle empty clusters and so can scikit #Log.info("Check that H2O can handle badly initialized centers") km_sci = KMeans(n_clusters=ncent, init=initial_centers_sci, n_init=1) km_sci.fit(preprocessing.scale(ozone_sci)) print "scikit final centers" print km_sci.cluster_centers_ km_h2o = h2o.kmeans(x=ozone_h2o, k=ncent, user_points=initial_centers_h2o, standardize=True) print "H2O final centers" print km_h2o.centers() if __name__ == "__main__": h2o.run_test(sys.argv, emptyclusKmeans)
apache-2.0
airbnb/airflow
airflow/providers/snowflake/transfers/snowflake_to_slack.py
5
7089
# Licensed to the Apache Software Foundation (ASF) under one # or more contributor license agreements. See the NOTICE file # distributed with this work for additional information # regarding copyright ownership. The ASF licenses this file # to you under the Apache License, Version 2.0 (the # "License"); you may not use this file except in compliance # with the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, # software distributed under the License is distributed on an # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either express or implied. See the License for the # specific language governing permissions and limitations # under the License. from typing import Iterable, Mapping, Optional, Union from pandas import DataFrame from tabulate import tabulate from airflow.exceptions import AirflowException from airflow.models import BaseOperator from airflow.providers.slack.hooks.slack_webhook import SlackWebhookHook from airflow.providers.snowflake.hooks.snowflake import SnowflakeHook from airflow.utils.decorators import apply_defaults class SnowflakeToSlackOperator(BaseOperator): """ Executes an SQL statement in Snowflake and sends the results to Slack. The results of the query are rendered into the 'slack_message' parameter as a Pandas dataframe using a JINJA variable called '{{ results_df }}'. The 'results_df' variable name can be changed by specifying a different 'results_df_name' parameter. The Tabulate library is added to the JINJA environment as a filter to allow the dataframe to be rendered nicely. For example, set 'slack_message' to {{ results_df | tabulate(tablefmt="pretty", headers="keys") }} to send the results to Slack as an ascii rendered table. .. seealso:: For more information on how to use this operator, take a look at the guide: :ref:`howto/operator:SnowflakeToSlackOperator` :param sql: The SQL statement to execute on Snowflake (templated) :type sql: str :param slack_message: The templated Slack message to send with the data returned from Snowflake. You can use the default JINJA variable {{ results_df }} to access the pandas dataframe containing the SQL results :type slack_message: str :param snowflake_conn_id: The Snowflake connection id :type snowflake_conn_id: str :param slack_conn_id: The connection id for Slack :type slack_conn_id: str :param results_df_name: The name of the JINJA template's dataframe variable, default is 'results_df' :type results_df_name: str :param parameters: The parameters to pass to the SQL query :type parameters: Optional[Union[Iterable, Mapping]] :param warehouse: The Snowflake virtual warehouse to use to run the SQL query :type warehouse: Optional[str] :param database: The Snowflake database to use for the SQL query :type database: Optional[str] :param schema: The schema to run the SQL against in Snowflake :type schema: Optional[str] :param role: The role to use when connecting to Snowflake :type role: Optional[str] :param slack_token: The token to use to authenticate to Slack. If this is not provided, the 'webhook_token' attribute needs to be specified in the 'Extra' JSON field against the slack_conn_id :type slack_token: Optional[str] """ template_fields = ['sql', 'slack_message'] template_ext = ['.sql', '.jinja', '.j2'] times_rendered = 0 @apply_defaults def __init__( # pylint: disable=too-many-arguments self, *, sql: str, slack_message: str, snowflake_conn_id: str = 'snowflake_default', slack_conn_id: str = 'slack_default', results_df_name: str = 'results_df', parameters: Optional[Union[Iterable, Mapping]] = None, warehouse: Optional[str] = None, database: Optional[str] = None, schema: Optional[str] = None, role: Optional[str] = None, slack_token: Optional[str] = None, **kwargs, ) -> None: super().__init__(**kwargs) self.snowflake_conn_id = snowflake_conn_id self.sql = sql self.parameters = parameters self.warehouse = warehouse self.database = database self.schema = schema self.role = role self.slack_conn_id = slack_conn_id self.slack_token = slack_token self.slack_message = slack_message self.results_df_name = results_df_name def _get_query_results(self) -> DataFrame: snowflake_hook = self._get_snowflake_hook() self.log.info('Running SQL query: %s', self.sql) df = snowflake_hook.get_pandas_df(self.sql, parameters=self.parameters) return df def _render_and_send_slack_message(self, context, df) -> None: # Put the dataframe into the context and render the JINJA template fields context[self.results_df_name] = df self.render_template_fields(context) slack_hook = self._get_slack_hook() self.log.info('Sending slack message: %s', self.slack_message) slack_hook.execute() def _get_snowflake_hook(self) -> SnowflakeHook: return SnowflakeHook( snowflake_conn_id=self.snowflake_conn_id, warehouse=self.warehouse, database=self.database, role=self.role, schema=self.schema, ) def _get_slack_hook(self) -> SlackWebhookHook: return SlackWebhookHook( http_conn_id=self.slack_conn_id, message=self.slack_message, webhook_token=self.slack_token ) def render_template_fields(self, context, jinja_env=None) -> None: # If this is the first render of the template fields, exclude slack_message from rendering since # the snowflake results haven't been retrieved yet. if self.times_rendered == 0: fields_to_render: Iterable[str] = filter(lambda x: x != 'slack_message', self.template_fields) else: fields_to_render = self.template_fields if not jinja_env: jinja_env = self.get_template_env() # Add the tabulate library into the JINJA environment jinja_env.filters['tabulate'] = tabulate self._do_render_template_fields(self, fields_to_render, context, jinja_env, set()) self.times_rendered += 1 def execute(self, context) -> None: if not isinstance(self.sql, str): raise AirflowException("Expected 'sql' parameter should be a string.") if self.sql is None or self.sql.strip() == "": raise AirflowException("Expected 'sql' parameter is missing.") if self.slack_message is None or self.slack_message.strip() == "": raise AirflowException("Expected 'slack_message' parameter is missing.") df = self._get_query_results() self._render_and_send_slack_message(context, df) self.log.debug('Finished sending Snowflake data to Slack')
apache-2.0
vlsd/nlsymb
sin_optim.py
1
9685
# this is written for python2.7 # will not work with python3.3 # TODO figure out why!? import sys import numpy as np import sympy as sym from sympy import Symbol as S import nlsymb # nlsymb = reload(nlsymb) from nlsymb import Timer, LineSearch, np, colored from nlsymb.sys import * from nlsymb.lqr import * # coming soon to a theatre near you # DoublePlot def DPlot(tj, s, fig=None, clear=False, xlims=(-2.6, 0.2), ylims=(-1.6, 1.1), label="", **kwargs): import matplotlib.pyplot as plt if fig is None: fig = plt.figure() # rect = 0.15, 0.1, 0.7, 0.3 axl = fig.add_subplot(121, aspect='equal', xlim=xlims, ylim=ylims, xlabel="$x(m)$", ylabel="$y(m)$", title='(a)') axr = fig.add_subplot(122, aspect='equal', xlim=xlims, ylim=ylims, xlabel=r"$\bar{x}$", ylabel=r"$\bar{y}$", title='(b)') xlist = np.linspace(*xlims, num=200) bound = axl.fill_between(xlist, ylims[0], np.sin(xlist), facecolor='grey', alpha=0.5) bound = axr.fill_between(xlims, ylims[0], 0.0, facecolor='grey', alpha=0.5) philbl = axl.text(-6, -4, "$\phi(q)<0$") psilbl = axr.text(-6, -4, r"$\bar{\phi}(\bar{q})<0$") [axl, axr] = fig.get_axes() tj.xtoq(s) q = np.array(tj._q).T qb = np.array(map(s.Psi, tj._q)).T tj.xtonq(s) z = np.array(tj._q).T zb = np.array(map(s.Psi, tj._q)).T axl.plot(q[0], q[1], 'b-', label='q' + label, **kwargs) axl.plot(z[0], z[1], 'r--', label='z' + label, **kwargs) axr.plot(qb[0], qb[1], 'b-', label='qb' + label, **kwargs) axr.plot(zb[0], zb[1], 'r--', label='zb' + label, **kwargs) fig.show() # ax.redraw_in_frame() return fig # plots a trajectory on the given canvas def TPlot(tj, s, fig=None, ax=None, init=False, #xlims=(-3.1, 0.2), ylims=(-1.6, 1.1), label="", xlims=(-3.1, 0.2), ylims=(-1.6, 1.1), label="", **kwargs): import matplotlib.pyplot as plt if fig is None: fig = plt.figure(figsize=(4, 4)) # rect = 0.15, 0.1, 0.7, 0.3 ax = fig.gca(aspect='equal', xlim=xlims, ylim=ylims, xlabel="$x(m)$", ylabel="$y(m)$") xlist = np.linspace(*xlims, num=200) bound = ax.fill_between(xlist, ylims[0], np.sin(xlist), facecolor='grey', alpha=0.5) philbl = ax.text(-1, -1, "$\phi(q)<0$") if ax is None: ax = fig.gca() if init is not False: ax.set(aspect='equal', xlim=xlims, ylim=ylims, xlabel="$x(m)$", ylabel="$y(m)$") xlist = np.linspace(*xlims, num=200) ax.fill_between(xlist, ylims[0], np.sin(xlist), facecolor='grey', alpha=0.5) ax.text(-1, -1, "$\phi(q)<0$") tj.xtoq(s) q = np.array(tj._q).T tj.xtonq(s) z = np.array(tj._q).T ax.plot(z[0], z[1], '--', label='z' + label, **kwargs) ax.plot(q[0], q[1], '-', label='q' + label, lw=1.5, **kwargs) fig.show() plt.draw() return fig def quickPlot(): fig = TPlot(ref) # TPlot(itj, fig=fig) for tj in trajectories: tj.xtonq(s) TPlot(tj, fig=fig) return fig if __name__ == "__main__": import matplotlib.pyplot as plt import time import pickle # the following lines are in order to be able to reload nlsymb # in ipython # dreload(nlsymb, excludes) from IPython.lib.deepreload import reload as dreload excludes = ['time', 'pickle', 'matplotlib.pyplot', 'sys', '__builtin__', '__main__', 'numpy', 'scipy', 'matplotlib', 'os.path', 'sympy', 'scipy.integrate', 'scipy.interpolate', 'nlsymb.sympy', 'nlsymb.numpy', 'nlsymb.scipy', 'nlsymb.copy', 'copy', 'nlsymb.time', 'scipy.linalg', 'numpy.linalg'] # load the reference (target) trajectory ref_fn = sys.argv[1] ref_file = open(ref_fn, 'rb') ref = pickle.load(ref_file) ref.feasible = False # let's not assume feasibility ref_file.close() # ref.tlims might be all jacked, lemme fix it first #ref.tlims = (min(ref._t), max(ref._t)) #tlims = ref.tlims tlims = (0, 3) ta, tb = tlims """ t = np.linspace(0, 10, 100) x = map(ref.x, t) u = map(ref.u, t) """ with Timer("whole program"): with Timer("creating symbolic system"): #s = FlatFloor2D(k=3) s = SinFloor2D(k=3) # ref.xtonq(s) ref.interpolate() ref.tlims = tlims if len(sys.argv)>2: # initial trajectory was passed to us, use it init_file = open(sys.argv[2], 'rb') itj = pickle.load(init_file) init_file.close() itj.feasible = False # let's not assume feasibility if not hasattr(itj, 'jumps'): itj.jumps=[] else: # make an initial guess trajectory qinit = np.array([0.0, 1.0]) qdoti = np.array([0.0, 0.0]) xinit = np.concatenate((s.Psi(qinit), np.dot(s.dPsi(qinit), qdoti))) itj = Trajectory('x', 'u') #tmid1 = (2*tlims[0] + tlims[1])/3 #tmid2 = (tlims[0] + 2*tlims[1])/3 itj.addpoint(tlims[0], x=xinit, u=np.array([0.0, 0.0])) #itj.addpoint(tmid1, x=ref.x(tmid1), u=np.array([0.0, 0.0])) #itj.addpoint(tmid2, x=ref.x(tmid2), u=np.array([0.0, 0.0])) # itj.addpoint(tlims[0], x=ref.x(tlims[0])*1.1, u=ref.u(tlims[0])) # itj.addpoint(1.5, x=ref.x(1.5), u=ref.u(1.5)) itj.addpoint(tlims[1], x=xinit, u=np.array([0.0, 0.0])) itj.jumps=[] itj.xtoq(s) itj.interpolate() nlsys = System(s.f, tlims=tlims, xinit=itj.x(tlims[0]), dfdx=s.dfdx, dfdu=s.dfdu) nlsys.phi = s.phi nlsys.ref = ref nlsys.delf = s.delf Rcost = lambda t: np.diag([1, 1]) Qcost = lambda t: t*np.diag([100, 200, 1, 1])/tb #Qcost = lambda t: t*np.diag([10, 10, 1, 1]) PTcost = np.diag([0,0,0,0]) #PTcost = Qcost(tb) # zerocontrol = Controller(reference=ref) # nlsys.set_u(zerocontrol) trajectories = [] costs = [] gradcosts = [] with Timer("initial projection and descent direction"): tj = nlsys.project(itj, lin=True) trajectories.append(tj) cost = nlsys.build_cost(R=Rcost, Q=Qcost, PT=PTcost) q = lambda t: matmult(tj.x(t) - ref.x(t), Qcost(t)) r = lambda t: matmult(tj.u(t) - ref.u(t), Rcost(t)) qf = matmult(tj.x(tb) - ref.x(tb), PTcost) descdir = GradDirection(tlims, tj.A, tj.B, jumps=tj.jumps, q=q, r=r, qf=qf) descdir.solve() costs.append(cost(tj)) print("[initial cost]\t\t" + colored("%f" % costs[-1], 'red')) ddir = descdir.direction ddircost = cost(ddir, tspace=True) gradcosts.append(ddircost) print("[descent direction]\t" + colored("%f" % ddircost, 'yellow')) index = 0 ls = None while ddircost > 1e-3 and index < 20: index = index + 1 with Timer("line search "): if index is not 1: costs.append(cost(tj)) print("[cost]\t\t" + colored("%f" % costs[-1], 'blue')) ddir = descdir.direction ddircost = cost(ddir, tspace=True) gradcosts.append(ddircost) print("[descent direction]\t" +\ colored("%f" % ddircost, 'yellow')) if ls is None: alpha = max(1 / ddircost, 1e-3) else: alpha = ls.gamma * 10 ls = LineSearch(cost, cost.grad, alpha=alpha, beta=1e-8) ls.x = tj ls.p = descdir.direction ls.search() tj = tj + ls.gamma * descdir.direction # print("cost of trajectory after descent: %f" % cost(tj)) with Timer("second projection"): tj = nlsys.project(tj, tlims=tlims, lin=True) trajectories.append(tj) with Timer("saving trajectory to file"): ofile = open('pkl/sin_plastic_opt_tj.p','wb') pickle.dump(tj, ofile) ofile.close() cost = nlsys.build_cost(R=Rcost, Q=Qcost, PT=PTcost) q = lambda t: matmult(tj.x(t) - ref.x(t), Qcost(t)) r = lambda t: matmult(tj.u(t) - ref.u(t), Rcost(t)) qf = matmult(tj.x(tb) - ref.x(tb), PTcost) with Timer("descent direction"): descdir = GradDirection(tlims, tj.A, tj.B, jumps=tj.jumps, q=q, r=r, qf=qf) descdir.solve() # tjt = tj # qref = [s.xtopq(ref.x(t)) for t in tjt._t] # q0 = map(s.xtopq, trajectories[0]._x) # qnu = map(s.xtopq, tjt._x) # plt.plot([qq[0] for qq in q0], # [np.sin(qq[0]) for qq in q0]) # plt.plot([qq[0] for qq in qref], [qq[1] for qq in qref]) # plt.plot([qq[0] for qq in q0], [qq[1] for qq in q0]) # plt.plot([qq[0] for qq in qnu], [qq[1] for qq in qnu]) # plt.axis('equal') # plt.show()
mit
HolgerPeters/scikit-learn
sklearn/feature_selection/tests/test_rfe.py
56
11274
""" Testing Recursive feature elimination """ import numpy as np from numpy.testing import assert_array_almost_equal, assert_array_equal from scipy import sparse from sklearn.feature_selection.rfe import RFE, RFECV from sklearn.datasets import load_iris, make_friedman1 from sklearn.metrics import zero_one_loss from sklearn.svm import SVC, SVR from sklearn.ensemble import RandomForestClassifier from sklearn.model_selection import cross_val_score from sklearn.utils import check_random_state from sklearn.utils.testing import ignore_warnings from sklearn.utils.testing import assert_greater, assert_equal, assert_true from sklearn.metrics import make_scorer from sklearn.metrics import get_scorer class MockClassifier(object): """ Dummy classifier to test recursive feature elimination """ def __init__(self, foo_param=0): self.foo_param = foo_param def fit(self, X, Y): assert_true(len(X) == len(Y)) self.coef_ = np.ones(X.shape[1], dtype=np.float64) return self def predict(self, T): return T.shape[0] predict_proba = predict decision_function = predict transform = predict def score(self, X=None, Y=None): if self.foo_param > 1: score = 1. else: score = 0. return score def get_params(self, deep=True): return {'foo_param': self.foo_param} def set_params(self, **params): return self def test_rfe_features_importance(): generator = check_random_state(0) iris = load_iris() X = np.c_[iris.data, generator.normal(size=(len(iris.data), 6))] y = iris.target clf = RandomForestClassifier(n_estimators=20, random_state=generator, max_depth=2) rfe = RFE(estimator=clf, n_features_to_select=4, step=0.1) rfe.fit(X, y) assert_equal(len(rfe.ranking_), X.shape[1]) clf_svc = SVC(kernel="linear") rfe_svc = RFE(estimator=clf_svc, n_features_to_select=4, step=0.1) rfe_svc.fit(X, y) # Check if the supports are equal assert_array_equal(rfe.get_support(), rfe_svc.get_support()) def test_rfe(): generator = check_random_state(0) iris = load_iris() X = np.c_[iris.data, generator.normal(size=(len(iris.data), 6))] X_sparse = sparse.csr_matrix(X) y = iris.target # dense model clf = SVC(kernel="linear") rfe = RFE(estimator=clf, n_features_to_select=4, step=0.1) rfe.fit(X, y) X_r = rfe.transform(X) clf.fit(X_r, y) assert_equal(len(rfe.ranking_), X.shape[1]) # sparse model clf_sparse = SVC(kernel="linear") rfe_sparse = RFE(estimator=clf_sparse, n_features_to_select=4, step=0.1) rfe_sparse.fit(X_sparse, y) X_r_sparse = rfe_sparse.transform(X_sparse) assert_equal(X_r.shape, iris.data.shape) assert_array_almost_equal(X_r[:10], iris.data[:10]) assert_array_almost_equal(rfe.predict(X), clf.predict(iris.data)) assert_equal(rfe.score(X, y), clf.score(iris.data, iris.target)) assert_array_almost_equal(X_r, X_r_sparse.toarray()) def test_rfe_mockclassifier(): generator = check_random_state(0) iris = load_iris() X = np.c_[iris.data, generator.normal(size=(len(iris.data), 6))] y = iris.target # dense model clf = MockClassifier() rfe = RFE(estimator=clf, n_features_to_select=4, step=0.1) rfe.fit(X, y) X_r = rfe.transform(X) clf.fit(X_r, y) assert_equal(len(rfe.ranking_), X.shape[1]) assert_equal(X_r.shape, iris.data.shape) def test_rfecv(): generator = check_random_state(0) iris = load_iris() X = np.c_[iris.data, generator.normal(size=(len(iris.data), 6))] y = list(iris.target) # regression test: list should be supported # Test using the score function rfecv = RFECV(estimator=SVC(kernel="linear"), step=1, cv=5) rfecv.fit(X, y) # non-regression test for missing worst feature: assert_equal(len(rfecv.grid_scores_), X.shape[1]) assert_equal(len(rfecv.ranking_), X.shape[1]) X_r = rfecv.transform(X) # All the noisy variable were filtered out assert_array_equal(X_r, iris.data) # same in sparse rfecv_sparse = RFECV(estimator=SVC(kernel="linear"), step=1, cv=5) X_sparse = sparse.csr_matrix(X) rfecv_sparse.fit(X_sparse, y) X_r_sparse = rfecv_sparse.transform(X_sparse) assert_array_equal(X_r_sparse.toarray(), iris.data) # Test using a customized loss function scoring = make_scorer(zero_one_loss, greater_is_better=False) rfecv = RFECV(estimator=SVC(kernel="linear"), step=1, cv=5, scoring=scoring) ignore_warnings(rfecv.fit)(X, y) X_r = rfecv.transform(X) assert_array_equal(X_r, iris.data) # Test using a scorer scorer = get_scorer('accuracy') rfecv = RFECV(estimator=SVC(kernel="linear"), step=1, cv=5, scoring=scorer) rfecv.fit(X, y) X_r = rfecv.transform(X) assert_array_equal(X_r, iris.data) # Test fix on grid_scores def test_scorer(estimator, X, y): return 1.0 rfecv = RFECV(estimator=SVC(kernel="linear"), step=1, cv=5, scoring=test_scorer) rfecv.fit(X, y) assert_array_equal(rfecv.grid_scores_, np.ones(len(rfecv.grid_scores_))) # Same as the first two tests, but with step=2 rfecv = RFECV(estimator=SVC(kernel="linear"), step=2, cv=5) rfecv.fit(X, y) assert_equal(len(rfecv.grid_scores_), 6) assert_equal(len(rfecv.ranking_), X.shape[1]) X_r = rfecv.transform(X) assert_array_equal(X_r, iris.data) rfecv_sparse = RFECV(estimator=SVC(kernel="linear"), step=2, cv=5) X_sparse = sparse.csr_matrix(X) rfecv_sparse.fit(X_sparse, y) X_r_sparse = rfecv_sparse.transform(X_sparse) assert_array_equal(X_r_sparse.toarray(), iris.data) # Verifying that steps < 1 don't blow up. rfecv_sparse = RFECV(estimator=SVC(kernel="linear"), step=.2, cv=5) X_sparse = sparse.csr_matrix(X) rfecv_sparse.fit(X_sparse, y) X_r_sparse = rfecv_sparse.transform(X_sparse) assert_array_equal(X_r_sparse.toarray(), iris.data) def test_rfecv_mockclassifier(): generator = check_random_state(0) iris = load_iris() X = np.c_[iris.data, generator.normal(size=(len(iris.data), 6))] y = list(iris.target) # regression test: list should be supported # Test using the score function rfecv = RFECV(estimator=MockClassifier(), step=1, cv=5) rfecv.fit(X, y) # non-regression test for missing worst feature: assert_equal(len(rfecv.grid_scores_), X.shape[1]) assert_equal(len(rfecv.ranking_), X.shape[1]) def test_rfecv_verbose_output(): # Check verbose=1 is producing an output. from sklearn.externals.six.moves import cStringIO as StringIO import sys sys.stdout = StringIO() generator = check_random_state(0) iris = load_iris() X = np.c_[iris.data, generator.normal(size=(len(iris.data), 6))] y = list(iris.target) rfecv = RFECV(estimator=SVC(kernel="linear"), step=1, cv=5, verbose=1) rfecv.fit(X, y) verbose_output = sys.stdout verbose_output.seek(0) assert_greater(len(verbose_output.readline()), 0) def test_rfe_estimator_tags(): rfe = RFE(SVC(kernel='linear')) assert_equal(rfe._estimator_type, "classifier") # make sure that cross-validation is stratified iris = load_iris() score = cross_val_score(rfe, iris.data, iris.target) assert_greater(score.min(), .7) def test_rfe_min_step(): n_features = 10 X, y = make_friedman1(n_samples=50, n_features=n_features, random_state=0) n_samples, n_features = X.shape estimator = SVR(kernel="linear") # Test when floor(step * n_features) <= 0 selector = RFE(estimator, step=0.01) sel = selector.fit(X, y) assert_equal(sel.support_.sum(), n_features // 2) # Test when step is between (0,1) and floor(step * n_features) > 0 selector = RFE(estimator, step=0.20) sel = selector.fit(X, y) assert_equal(sel.support_.sum(), n_features // 2) # Test when step is an integer selector = RFE(estimator, step=5) sel = selector.fit(X, y) assert_equal(sel.support_.sum(), n_features // 2) def test_number_of_subsets_of_features(): # In RFE, 'number_of_subsets_of_features' # = the number of iterations in '_fit' # = max(ranking_) # = 1 + (n_features + step - n_features_to_select - 1) // step # After optimization #4534, this number # = 1 + np.ceil((n_features - n_features_to_select) / float(step)) # This test case is to test their equivalence, refer to #4534 and #3824 def formula1(n_features, n_features_to_select, step): return 1 + ((n_features + step - n_features_to_select - 1) // step) def formula2(n_features, n_features_to_select, step): return 1 + np.ceil((n_features - n_features_to_select) / float(step)) # RFE # Case 1, n_features - n_features_to_select is divisible by step # Case 2, n_features - n_features_to_select is not divisible by step n_features_list = [11, 11] n_features_to_select_list = [3, 3] step_list = [2, 3] for n_features, n_features_to_select, step in zip( n_features_list, n_features_to_select_list, step_list): generator = check_random_state(43) X = generator.normal(size=(100, n_features)) y = generator.rand(100).round() rfe = RFE(estimator=SVC(kernel="linear"), n_features_to_select=n_features_to_select, step=step) rfe.fit(X, y) # this number also equals to the maximum of ranking_ assert_equal(np.max(rfe.ranking_), formula1(n_features, n_features_to_select, step)) assert_equal(np.max(rfe.ranking_), formula2(n_features, n_features_to_select, step)) # In RFECV, 'fit' calls 'RFE._fit' # 'number_of_subsets_of_features' of RFE # = the size of 'grid_scores' of RFECV # = the number of iterations of the for loop before optimization #4534 # RFECV, n_features_to_select = 1 # Case 1, n_features - 1 is divisible by step # Case 2, n_features - 1 is not divisible by step n_features_to_select = 1 n_features_list = [11, 10] step_list = [2, 2] for n_features, step in zip(n_features_list, step_list): generator = check_random_state(43) X = generator.normal(size=(100, n_features)) y = generator.rand(100).round() rfecv = RFECV(estimator=SVC(kernel="linear"), step=step, cv=5) rfecv.fit(X, y) assert_equal(rfecv.grid_scores_.shape[0], formula1(n_features, n_features_to_select, step)) assert_equal(rfecv.grid_scores_.shape[0], formula2(n_features, n_features_to_select, step)) def test_rfe_cv_n_jobs(): generator = check_random_state(0) iris = load_iris() X = np.c_[iris.data, generator.normal(size=(len(iris.data), 6))] y = iris.target rfecv = RFECV(estimator=SVC(kernel='linear')) rfecv.fit(X, y) rfecv_ranking = rfecv.ranking_ rfecv_grid_scores = rfecv.grid_scores_ rfecv.set_params(n_jobs=2) rfecv.fit(X, y) assert_array_almost_equal(rfecv.ranking_, rfecv_ranking) assert_array_almost_equal(rfecv.grid_scores_, rfecv_grid_scores)
bsd-3-clause
nrhine1/scikit-learn
sklearn/cluster/tests/test_mean_shift.py
150
3651
""" Testing for mean shift clustering methods """ import numpy as np import warnings from sklearn.utils.testing import assert_equal from sklearn.utils.testing import assert_false from sklearn.utils.testing import assert_true from sklearn.utils.testing import assert_array_equal from sklearn.utils.testing import assert_raise_message from sklearn.cluster import MeanShift from sklearn.cluster import mean_shift from sklearn.cluster import estimate_bandwidth from sklearn.cluster import get_bin_seeds from sklearn.datasets.samples_generator import make_blobs n_clusters = 3 centers = np.array([[1, 1], [-1, -1], [1, -1]]) + 10 X, _ = make_blobs(n_samples=300, n_features=2, centers=centers, cluster_std=0.4, shuffle=True, random_state=11) def test_estimate_bandwidth(): # Test estimate_bandwidth bandwidth = estimate_bandwidth(X, n_samples=200) assert_true(0.9 <= bandwidth <= 1.5) def test_mean_shift(): # Test MeanShift algorithm bandwidth = 1.2 ms = MeanShift(bandwidth=bandwidth) labels = ms.fit(X).labels_ labels_unique = np.unique(labels) n_clusters_ = len(labels_unique) assert_equal(n_clusters_, n_clusters) cluster_centers, labels = mean_shift(X, bandwidth=bandwidth) labels_unique = np.unique(labels) n_clusters_ = len(labels_unique) assert_equal(n_clusters_, n_clusters) def test_parallel(): ms1 = MeanShift(n_jobs=2) ms1.fit(X) ms2 = MeanShift() ms2.fit(X) assert_array_equal(ms1.cluster_centers_,ms2.cluster_centers_) assert_array_equal(ms1.labels_,ms2.labels_) def test_meanshift_predict(): # Test MeanShift.predict ms = MeanShift(bandwidth=1.2) labels = ms.fit_predict(X) labels2 = ms.predict(X) assert_array_equal(labels, labels2) def test_meanshift_all_orphans(): # init away from the data, crash with a sensible warning ms = MeanShift(bandwidth=0.1, seeds=[[-9, -9], [-10, -10]]) msg = "No point was within bandwidth=0.1" assert_raise_message(ValueError, msg, ms.fit, X,) def test_unfitted(): # Non-regression: before fit, there should be not fitted attributes. ms = MeanShift() assert_false(hasattr(ms, "cluster_centers_")) assert_false(hasattr(ms, "labels_")) def test_bin_seeds(): # Test the bin seeding technique which can be used in the mean shift # algorithm # Data is just 6 points in the plane X = np.array([[1., 1.], [1.4, 1.4], [1.8, 1.2], [2., 1.], [2.1, 1.1], [0., 0.]]) # With a bin coarseness of 1.0 and min_bin_freq of 1, 3 bins should be # found ground_truth = set([(1., 1.), (2., 1.), (0., 0.)]) test_bins = get_bin_seeds(X, 1, 1) test_result = set([tuple(p) for p in test_bins]) assert_true(len(ground_truth.symmetric_difference(test_result)) == 0) # With a bin coarseness of 1.0 and min_bin_freq of 2, 2 bins should be # found ground_truth = set([(1., 1.), (2., 1.)]) test_bins = get_bin_seeds(X, 1, 2) test_result = set([tuple(p) for p in test_bins]) assert_true(len(ground_truth.symmetric_difference(test_result)) == 0) # With a bin size of 0.01 and min_bin_freq of 1, 6 bins should be found # we bail and use the whole data here. with warnings.catch_warnings(record=True): test_bins = get_bin_seeds(X, 0.01, 1) assert_array_equal(test_bins, X) # tight clusters around [0, 0] and [1, 1], only get two bins X, _ = make_blobs(n_samples=100, n_features=2, centers=[[0, 0], [1, 1]], cluster_std=0.1, random_state=0) test_bins = get_bin_seeds(X, 1) assert_array_equal(test_bins, [[0, 0], [1, 1]])
bsd-3-clause
GenericMappingTools/gmt-python
pygmt/src/blockm.py
1
5803
""" blockm - Block average (x,y,z) data tables by mean or median estimation. """ import pandas as pd from pygmt.clib import Session from pygmt.helpers import ( GMTTempFile, build_arg_string, fmt_docstring, kwargs_to_strings, use_alias, ) def _blockm(block_method, table, outfile, x, y, z, **kwargs): r""" Block average (x,y,z) data tables by mean or median estimation. Reads arbitrarily located (x,y,z) triples [or optionally weighted quadruples (x,y,z,w)] from a table and writes to the output a mean or median (depending on ``block_method``) position and value for every non-empty block in a grid region defined by the ``region`` and ``spacing`` parameters. Parameters ---------- block_method : str Name of the GMT module to call. Must be "blockmean" or "blockmedian". Returns ------- output : pandas.DataFrame or None Return type depends on whether the ``outfile`` parameter is set: - :class:`pandas.DataFrame` table with (x, y, z) columns if ``outfile`` is not set - None if ``outfile`` is set (filtered output will be stored in file set by ``outfile``) """ with GMTTempFile(suffix=".csv") as tmpfile: with Session() as lib: # Choose how data will be passed into the module table_context = lib.virtualfile_from_data( check_kind="vector", data=table, x=x, y=y, z=z ) # Run blockm* on data table with table_context as infile: if outfile is None: outfile = tmpfile.name arg_str = " ".join([infile, build_arg_string(kwargs), "->" + outfile]) lib.call_module(module=block_method, args=arg_str) # Read temporary csv output to a pandas table if outfile == tmpfile.name: # if user did not set outfile, return pd.DataFrame try: column_names = table.columns.to_list() result = pd.read_csv(tmpfile.name, sep="\t", names=column_names) except AttributeError: # 'str' object has no attribute 'columns' result = pd.read_csv(tmpfile.name, sep="\t", header=None, comment=">") elif outfile != tmpfile.name: # return None if outfile set, output in outfile result = None return result @fmt_docstring @use_alias( I="spacing", R="region", V="verbose", a="aspatial", f="coltypes", i="incols", r="registration", ) @kwargs_to_strings(R="sequence") def blockmean(table=None, outfile=None, *, x=None, y=None, z=None, **kwargs): r""" Block average (x,y,z) data tables by mean estimation. Reads arbitrarily located (x,y,z) triples [or optionally weighted quadruples (x,y,z,w)] and writes to the output a mean position and value for every non-empty block in a grid region defined by the ``region`` and ``spacing`` parameters. Takes a matrix, xyz triplets, or a file name as input. Must provide either ``table`` or ``x``, ``y``, and ``z``. Full option list at :gmt-docs:`blockmean.html` {aliases} Parameters ---------- table : str or {table-like} Pass in (x, y, z) or (longitude, latitude, elevation) values by providing a file name to an ASCII data table, a 2D {table-classes}. x/y/z : 1d arrays Arrays of x and y coordinates and values z of the data points. {I} {R} outfile : str The file name for the output ASCII file. {V} {a} {i} {f} {r} Returns ------- output : pandas.DataFrame or None Return type depends on whether the ``outfile`` parameter is set: - :class:`pandas.DataFrame` table with (x, y, z) columns if ``outfile`` is not set. - None if ``outfile`` is set (filtered output will be stored in file set by ``outfile``). """ return _blockm( block_method="blockmean", table=table, outfile=outfile, x=x, y=y, z=z, **kwargs ) @fmt_docstring @use_alias( I="spacing", R="region", V="verbose", a="aspatial", f="coltypes", i="incols", r="registration", ) @kwargs_to_strings(R="sequence") def blockmedian(table=None, outfile=None, *, x=None, y=None, z=None, **kwargs): r""" Block average (x,y,z) data tables by median estimation. Reads arbitrarily located (x,y,z) triples [or optionally weighted quadruples (x,y,z,w)] and writes to the output a median position and value for every non-empty block in a grid region defined by the ``region`` and ``spacing`` parameters. Takes a matrix, xyz triplets, or a file name as input. Must provide either ``table`` or ``x``, ``y``, and ``z``. Full option list at :gmt-docs:`blockmedian.html` {aliases} Parameters ---------- table : str or {table-like} Pass in (x, y, z) or (longitude, latitude, elevation) values by providing a file name to an ASCII data table, a 2D {table-classes}. x/y/z : 1d arrays Arrays of x and y coordinates and values z of the data points. {I} {R} outfile : str The file name for the output ASCII file. {V} {a} {f} {i} {r} Returns ------- output : pandas.DataFrame or None Return type depends on whether the ``outfile`` parameter is set: - :class:`pandas.DataFrame` table with (x, y, z) columns if ``outfile`` is not set. - None if ``outfile`` is set (filtered output will be stored in file set by ``outfile``). """ return _blockm( block_method="blockmedian", table=table, outfile=outfile, x=x, y=y, z=z, **kwargs )
bsd-3-clause
jmontgom10/Mimir_pyPol
01a_buildIndex.py
1
12298
# -*- coding: utf-8 -*- """ Restructures the rawFileIndex from PRISM_pyBDP to contain ONLY the science images, and break those up into individual groups based on changes in 1) OBJECT (object name) 2) FILTER (optical filter value) 3) EXPTIME (the exposure time of the images) 4) Pointing changes (more than 1.5 degrees of chang is considered a new group) Attempts to associate each group with a target in the 'targetList' variable on the basis of the string in the OBJECT column of that group. Saves the index file with a USE and GROUP_ID columns added to the table. """ #Import whatever modules will be used import os import sys import datetime import time import numpy as np import matplotlib.pyplot as plt from astropy.io import fits from astropy.table import Table, Column from astropy.coordinates import SkyCoord import astropy.units as u from scipy import stats # Add the AstroImage class import astroimage as ai #============================================================================== # *********************** CUSTOM USER CODE ************************************ # this is where the user specifies where the raw data is stored # and some of the subdirectory structure to find the actual .FITS images #============================================================================== # Set the directory for the PPOL reduced data PPOL_data = 'C:\\Users\\Jordan\\FITS_data\\Mimir_data\\PPOL_Reduced\\201611\\notPreFlattened' S3_dir = os.path.join(PPOL_data, 'S3_Astrometry') # This is the location where all pyPol data will be saved pyPol_data='C:\\Users\\Jordan\\FITS_data\\Mimir_data\\pyPol_Reduced\\201611\\' if (not os.path.isdir(pyPol_data)): os.mkdir(pyPol_data, 0o755) # Set the filename for the reduced data indexFile indexFile = os.path.join(pyPol_data, 'reducedFileIndex.csv') # Compose a list of expected targets. All groups will be assigned to ONE of # these targets within a given tolerance. If no match is found for a group # within this list of targets, then an error will be raised. targetList = [ 'M78', 'NGC7023', 'NGC2023' ] # Create a dictionary with known group name problems. They keys should be the # name of the group as it is currently, and the value should be the name of the # group as it *ought* to be. problematicGroupNames = {'NGC723_H3': 'NGC7023_H3'} # Force all the targets to be upper case to remove ambiguity targetList = [t.upper() for t in targetList] ################################################################################ # Generate a list of files in the 'polarimetry' directories # fileList = np.array(recursive_file_search(BDP_data, exten='.fits')) fileList = np.array(os.listdir(S3_dir)) #Sort the fileList fileNums = [''.join((os.path.basename(f).split('.'))[0:2]) for f in fileList] fileNums = np.array([f.split('_')[0] for f in fileNums], dtype=np.int64) sortInds = fileNums.argsort() fileList = fileList[sortInds] # Define a dictionary for translating HWP rotation into IPPA HWPstepList = np.array([ 0, 33, 67, 100, 133, 167, 200, 233, 267, 300, 333, 367, 400, 433, 467, 500 ]) HWPlist = np.arange(16, dtype=int) + 1 IPPAlist = np.array(4*[0, 45, 90, 135]) HWPstep_to_HWP = dict(zip(HWPstepList, HWPlist)) HWPstep_to_IPPA = dict(zip(HWPstepList, IPPAlist)) # Test for image type print('\nCategorizing files into TARGET, HWP, BAAB\n') startTime = time.time() # Begin by initalizing some arrays to store the image classifications OBJECT = [] OBSTYPE = [] FILTER = [] TELRA = [] TELDEC = [] EXPTIME = [] HWP = [] IPPA = [] AB = [] NIGHT = [] MJD = [] percentage = 0 #Loop through each file in the fileList variable numberOfFiles = len(fileList) for iFile, filename in enumerate(fileList): # Read in the file thisFile = os.path.join(S3_dir, filename) thisHDU = fits.open(thisFile) thisHeader = thisHDU[0].header # Grab the OBJECT header value tmpOBJECT = thisHeader['OBJECT'] if len(tmpOBJECT) < 1: tmpOBJECT = 'blank' OBJECT.append(tmpOBJECT) # Grab the OBSTYPE header value OBSTYPE.append(thisHeader['OBSTYPE']) # Grab the FILTNME3 header value FILTER.append(thisHeader['FILTNME2']) # Grab the TELRA header value try: TELRA.append(thisHeader['TELRA']) except: TELRA.append(0) try: TELDEC.append(thisHeader['TELDEC']) except: TELDEC.append(0) # Grab the HWP header value thisHWP = thisHeader['HWP'] HWPdiff = np.abs(HWPstepList - thisHWP) thisHWPstep = HWPstepList[HWPdiff.argmin()] thisHWP = HWPstep_to_HWP[thisHWPstep] HWP.append(thisHWP) # Apped the IPPA equivalent IPPA.append(HWPstep_to_IPPA[thisHWPstep]) # Search for the A-pos B-pos value if 'COMMENT' in thisHeader: # This is SUPER lazy, but it gets the job done for thisComment in thisHeader['COMMENT']: if 'HWP' in thisComment and 'posn' in thisComment: thisAB = thisComment[-6] else: thisAB = 'A' else: thisAB = 'A' # Append the AB value to the list if thisAB == 'A' or thisAB == 'B': AB.append(thisAB) else: # Oops... something went wrong. You should only have As or Bs import pdb; pdb.set_trace() # Grab the EXPTIME value from the header EXPTIME.append(thisHeader['EXPTIME']) # Assign a NIGHT value for this image NIGHT.append(''.join((os.path.basename(filename).split('.'))[0])) ############################################################################ # Compute the julian date for this observation # Compute proleptic Gregorian date (Number of days since 0001-01-01 AD) thisDatetime = datetime.datetime.strptime( thisHeader['DATE'], '%Y-%m-%dT%H:%M:%S' ) prolepticGregorianDate = thisDatetime.toordinal() # Grab the time of this observation tmpTime = thisDatetime.time() # Compute the fraction of a day represented by the above time fractionOfDay = ( (tmpTime.hour + (tmpTime.minute + (tmpTime.second/60.0))/60.0)/24.0 ) # Compute the julian date (including the fraction of a day) julianDate = prolepticGregorianDate + fractionOfDay + 1721424.5 thisMJD = julianDate - 2400000.5 MJD.append(julianDate) ############################################################################ # Count the files completed and print update progress message percentage1 = np.floor(100*iFile/numberOfFiles) if percentage1 != percentage: print('completed {0:3g}%'.format(percentage1), end="\r") percentage = percentage1 print('completed {0:3g}%'.format(100), end="\r") endTime = time.time() print('\nFile processing completed in {0:g} seconds'.format(endTime - startTime)) # Query the user about the targets of each group... # Write the file index to disk reducedFileIndex = Table( [fileList, NIGHT, MJD, OBSTYPE, OBJECT, FILTER, TELRA, TELDEC, EXPTIME, HWP, IPPA, AB], names = ['FILENAME', 'NIGHT', 'MJD', 'OBSTYPE', 'OBJECT', 'FILTER', 'TELRA', 'TELDEC', 'EXPTIME', 'HWP', 'IPPA', 'AB']) # Remap the filenames to be the reduced filenames fileBasenames = [os.path.basename(f) for f in reducedFileIndex['FILENAME']] # reducedFilenames = [os.path.join(pyBDP_reducedDir, f) for f in fileBasenames] # reducedFileIndex['FILENAME'] = reducedFilenames # Find the breaks in observation procedure. These are candidates for group # boundaries. # 1) OBJECT changes objectChange = (reducedFileIndex['OBJECT'][1:] != reducedFileIndex['OBJECT'][0:-1]) # 2) OBSTYPE changes obstypeChange = (reducedFileIndex['OBSTYPE'][1:] != reducedFileIndex['OBSTYPE'][0:-1]) # 3) FILTER changes filterChange = (reducedFileIndex['FILTER'][1:] != reducedFileIndex['FILTER'][0:-1]) # 4) EXPTIME changes expTimeChange = (reducedFileIndex['EXPTIME'][1:] != reducedFileIndex['EXPTIME'][0:-1]) # 5) Pointing changes # Look for any pointing differences 1.5 degree (or more) for further separations allPointings = SkyCoord( reducedFileIndex['TELRA'], reducedFileIndex['TELDEC'], unit=(u.hour, u.degree) ) medianDecs = 0.5*(allPointings[1:].ra.to(u.rad) + allPointings[0:-1].ra.to(u.rad)) deltaDec = allPointings[1:].dec - allPointings[0:-1].dec deltaRA = (allPointings[1:].ra - allPointings[0:-1].ra)*np.cos(medianDecs) deltaPointing = np.sqrt(deltaRA**2 + deltaDec**2) pointingChange = deltaPointing > (1.5*u.deg) # Identify all changes allChanges = objectChange allChanges = np.logical_or(allChanges, obstypeChange) allChanges = np.logical_or(allChanges, filterChange) allChanges = np.logical_or(allChanges, expTimeChange) allChanges = np.logical_or(allChanges, pointingChange) # Assign a GROUP_ID for each group groupBoundaries = np.hstack([0, np.where(allChanges)[0] + 1, allChanges.size]) groupIDs = [] for i in range(groupBoundaries.size - 1): # Find the start and end indices of the group groupStartInd = groupBoundaries[i] groupEndInd = groupBoundaries[i+1] # Build the gorup ID number groupID = i + 1 # Count the number of images in this group numberOfImages = groupEndInd - groupStartInd # Build the list of ID numbers for THIS group and append it to the full list thisGroupID = numberOfImages*[groupID] groupIDs.extend(thisGroupID) # Fill in the final entry groupIDs.append(groupID) # Store the groupID number in the reducedFileIndex groupIDcolumn = Column(name='GROUP_ID', data=groupIDs) reducedFileIndex.add_column(groupIDcolumn, index=2) # Now remove any GROUPS with less than 8 images groupIndex = reducedFileIndex.group_by('GROUP_ID') goodGroupInds = [] groupInds = groupIndex.groups.indices for startInd, endInd in zip(groupInds[:-1], groupInds[+1:]): # Count the number of images in this group and test if it's any good. if (endInd - startInd) >= 8: goodGroupInds.extend(range(startInd, endInd)) # Cull the reducedFileIndex to only include viable groups goodGroupInds = np.array(goodGroupInds) reducedFileIndex = reducedFileIndex[goodGroupInds] # Match a dither type for each group ("ABBA" or "HEX") groupIndex = reducedFileIndex.group_by('GROUP_ID') ditherType = [] for group in groupIndex.groups: # Count the number of images in this group numberOfImages = len(group) # Test if this is an ABBA or HEX dither if ('A' in group['AB']) and ('B' in group['AB']): ditherType.extend(numberOfImages*['ABBA']) if ('A' in group['AB']) and not ('B' in group['AB']): ditherType.extend(numberOfImages*['HEX']) # Store the ditherNames number in the reducedFileIndex ditherTypeColumn = Column(name='DITHER_TYPE', data=ditherType) groupIndex.add_column(ditherTypeColumn, index=10) # Identify meta-groups pointing at a single target with a single dither style. targets = [] for group in groupIndex.groups: # Count the number of images in this group numberOfImages = len(group) # Get the group name groupName = np.unique(group['OBJECT'])[0] # Capitalize the group name to remove ambiguity groupName = groupName.upper() # Rename the group if it needs to be renamed if groupName in problematicGroupNames: groupName = problematicGroupNames[groupName] # Test it a target name occurs in this group name for target in targetList: if target in groupName: targets.extend(numberOfImages*[target]) break else: import pdb; pdb.set_trace() raise ValueError('Gorup {} found no match in the target list'.format(groupName)) # Add the target identifications to the groupIndex table targetColumn = Column(name='TARGET', data=targets) groupIndex.add_column(targetColumn, index=5) # Re-order by filename. Start by getting the sorting array sortInds = groupIndex['FILENAME'].data.argsort() reducedFileIndex = groupIndex[sortInds] # Add a "BACKGROUND" column reducedFileIndex['BACKGROUND'] = -1e6*np.ones(len(reducedFileIndex)) # Finally, add a column of "use" flags at the first index useColumn = Column(name='USE', data=np.ones((len(reducedFileIndex),), dtype=int)) reducedFileIndex.add_column(useColumn, index=0) # Save the index to disk. reducedFileIndex.write(indexFile, format='ascii.csv', overwrite=True) print('Done!')
mit
wbap/Hackathon2015
Hiroshiba/NeuralNetwork/test_LastML.py
2
11668
# coding: utf-8 # In[ ]: import os import sys import re # for regex import math import json import pickle from PIL import Image import numpy as np from sklearn.datasets import fetch_mldata # import matplotlib.pyplot as plt # get_ipython().magic('matplotlib inline') from chainer import cuda, Function, FunctionSet, gradient_check, Variable, optimizers import chainer.functions as F from dA import DenoisingAutoencoder from SdA import StackedDenoisingAutoencoder import utils # In[ ]: ## Params use_cuda = True batchsize = 100 if use_cuda: n_epoch_SdA = 30 n_epoch_fA = 50 n_epoch_last = 30 else: n_epoch_SdA = 5 n_epoch_fA = 10 n_epoch_last = 30 if use_cuda: path_imagedir = {'self':os.environ['HOME'] + '/Hevy/wba_hackathon/self_mit_fp_50x1000/', 'other':os.environ['HOME'] + '/Hevy/wba_hackathon/other_mit_fp_50x100/'} n_dataset_self = 1000 n_dataset_other = 100 else: path_imagedir = {'self':os.environ['HOME'] + '/Hevy/wba_hackathon/self_mit_fp_50x100/', 'other':os.environ['HOME'] + '/Hevy/wba_hackathon/other_mit_fp_50x100/'} n_dataset_self = 100 n_dataset_other = 100 n_dataset = n_dataset_self + n_dataset_other size_image = [64, 64] scale = 4 size_image[0]=size_image[0]/scale size_image[1]=size_image[1]/scale n_hold = 10 n_cross = 1 n_fA_node = 128 n_loss_node = 48 n_moveframe = 50 n_oneframe = 5 n_onemovie = int(n_moveframe / n_oneframe) if use_cuda: n_hiddens = (18**2, 12**2, 6**2) else: n_hiddens = (8**2, 2**2) num_images = n_dataset * n_moveframe num_movie = num_images / n_oneframe num_test_dataset = n_dataset // n_hold num_train_dataset = n_dataset - num_test_dataset num_test_movie = num_movie // n_hold num_train_movie = num_movie - num_test_movie if use_cuda: cuda.check_cuda_available() # In[ ]: ## load images size = size_image[0] num_pximage = size**2 num_pxmovie = n_oneframe * num_pximage # load images movies = np.zeros((n_dataset, n_moveframe, num_pximage), dtype=np.float32) i = 0 for label in {'self', 'other'}: for name in os.listdir(path_imagedir[label]): if re.match( '.*png$', name ): img = Image.open( os.path.join(path_imagedir[label], name) ) img.thumbnail( (size_image[0], size_image[1]) ) img = np.asarray(img, dtype=np.float32).mean(axis=2).T movies[i//n_moveframe, i%n_moveframe, :] = np.reshape( img / 255.0, (1, -1) ) i = i+1 ## load json files joint_angles = [{}] * num_images i = 0 for label in {'self', 'other'}: for name in os.listdir(path_imagedir[label]): if re.match( '.*json$', name ): j = json.load( open(os.path.join(path_imagedir[label], name)) ) joint_angles[i] = j['joint_angle'] i = i+1 # In[ ]: ## setup ML values v_all = np.reshape(movies, (n_dataset, -1)) v_all = utils.splitInputs(v_all, n_moveframe/n_oneframe) num_node_x = 8 x_all = np.zeros((num_images, num_node_x), dtype=np.float32) for i in range(len(joint_angles)): x_all[i][0:3] = [joint_angles[i]['left_shoulder']['y'], joint_angles[i]['left_shoulder']['p'], joint_angles[i]['left_shoulder']['r']] x_all[i][3] = joint_angles[i]['left_elbow']['p'] x_all[i][4:7] = [joint_angles[i]['right_shoulder']['y'], joint_angles[i]['right_shoulder']['p'], joint_angles[i]['right_shoulder']['r']] x_all[i][7] = joint_angles[i]['right_elbow']['p'] x_all = x_all/180 x_all = utils.bindInputs(x_all, n_moveframe) x_all = utils.splitInputs(x_all, n_moveframe/n_oneframe) # x_all[0:n_dataset, :, :] = np.random.rand(x_all.shape[-1]) # v_all[0:n_dataset_self, :, :] = np.random.rand(v_all.shape[-1]) # v_all[n_dataset_self:n_dataset, :, :] = np.random.rand(n_dataset_other, n_onemovie, v_all.shape[-1]) # label 0:other, 1:self label_x = np.append( np.ones((n_dataset_self), dtype=np.int32), np.zeros((n_dataset_other), dtype=np.int32) ) # In[ ]: # shuffle all data rng = np.random.RandomState(1234) indices = np.arange(n_dataset, dtype=np.int32) rng.shuffle(indices) v_all = v_all[indices] x_all = x_all[indices] label_x = label_x[indices] n_set = n_dataset / n_hold # split each data into 10 block v_s = np.split(v_all, n_set*np.r_[1:n_hold]) x_s = np.split(x_all, n_set*np.r_[1:n_hold]) label_x_s = np.split(label_x, n_set*np.r_[1:n_hold]) num_layers= len(n_hiddens) # In[ ]: def forward(x_data, y_data): x = Variable(x_data); t = Variable(y_data) h = F.sigmoid(model.l1(x)) y = model.l2(h) return F.mean_squared_error(y, t), y def forwardLastML(x_data, y_data): x = Variable(x_data); t = Variable(y_data) h = F.sigmoid(model.l1(x)) y = model.l2(h) return F.softmax_cross_entropy(y, t), y list_cross = [] for i in range(n_cross): # split test and train data set_l = list(set(range(n_hold)).difference([i])) v_train = np.empty(0, dtype=np.float32) x_train = np.empty(0, dtype=np.float32) label_train = np.empty(0, dtype=np.int32) for i_set in range(n_hold-1): v_train = utils.vstack_(v_train, v_s[set_l[i_set]]) x_train = utils.vstack_(x_train, x_s[set_l[i_set]]) label_train = utils.vstack_(label_train, label_x_s[set_l[i_set]]) v_train = np.reshape(v_train, (num_train_movie, -1)) x_train = np.reshape(x_train, (num_train_movie, -1)) label_train = np.reshape(label_train, (num_train_dataset, -1)) v_test = np.reshape(v_s[i], (num_test_movie, -1)) x_test = np.reshape(x_s[i], (num_test_movie, -1)) label_test = label_x_s[i] # create SdA sda = StackedDenoisingAutoencoder(num_pxmovie, n_hiddens, n_epoch=n_epoch_SdA, use_cuda=use_cuda) sda.train(v_train) # split test and train data y_train_each = sda.predict(v_train, bAllLayer=True) y_test_each = sda.predict(v_test, bAllLayer=True) list_layer = [] for j in range(num_layers): y_train = y_train_each[j] y_test = y_test_each[j] # separate x&y into other and self x_test_split = [np.empty(0,dtype=np.float32), np.empty(0,dtype=np.float32)] y_test_split = [np.empty(0,dtype=np.float32), np.empty(0,dtype=np.float32)] for i_test in range(int(num_test_movie)): label = label_test[i_test//n_onemovie] x_test_split[label] = utils.vstack_(x_test_split[label], x_test[i_test]) y_test_split[label] = utils.vstack_(y_test_split[label], y_test[i_test]) # train with only self body num_train_self = 0 x_train_split = np.empty(0,dtype=np.float32) y_train_split = np.empty(0,dtype=np.float32) for i_train in range(int(num_train_movie)): if label_train[i_train//n_onemovie]==1: x_train_split = utils.vstack_(x_train_split, x_train[i_train]) y_train_split = utils.vstack_(y_train_split, y_train[i_train]) num_train_self = num_train_self + 1 # f(x->y) model = FunctionSet( l1 = F.Linear(num_node_x*n_oneframe, n_fA_node), l2 = F.Linear(n_fA_node, n_hiddens[j]) ) optimizer = optimizers.SGD() optimizer.setup(model.collect_parameters()) dic = {'loss':{}, 'hist':{}, 'lastpredict':{}} dic['loss'] = {'self':np.empty(0,dtype=np.float32), 'other':np.empty(0,dtype=np.float32)} for epoch in range(n_epoch_fA): indexes = np.random.permutation(int(num_train_self)) sum_loss = 0 for k in range(0, num_train_self, batchsize): x_batch = x_train_split[indexes[k : k + batchsize]] y_batch = y_train_split[indexes[k : k + batchsize]] optimizer.zero_grads() loss, output = forward(x_batch, y_batch) loss.backward() optimizer.update() sum_loss = sum_loss+loss.data*batchsize print('fA: epoch:'+str(epoch)+' loss:' + str(sum_loss/num_train_movie)) # test loss, output = forward(x_test_split[1], y_test_split[1]) dic['loss']['self'] = utils.vstack_(dic['loss']['self'], loss.data) loss, output = forward(x_test_split[0], y_test_split[0]) dic['loss']['other'] = utils.vstack_(dic['loss']['other'], loss.data) print('test loss:' + str(loss.data)) dic['hist'] = {'self':np.empty(0, dtype=np.float32), 'other':np.empty(0, dtype=np.float32)} for i_test in range((x_test_split[1].shape[0])): loss, output = forward(x_test_split[1][i_test][None], y_test_split[1][i_test][None]) # [8,][None] -> [1,8] dic['hist']['self'] = utils.vstack_(dic['hist']['self'], loss.data) for i_test in range(x_test_split[0].shape[0]): loss, output = forward(x_test_split[0][i_test][None], y_test_split[0][i_test][None]) dic['hist']['other'] = utils.vstack_(dic['hist']['other'], loss.data) # loss => self or other loss_train = np.zeros((num_train_dataset, n_onemovie), dtype=np.float32) for i_train in range(num_train_dataset): for i_movie in range(n_onemovie): loss, output = forward(x_train[i_train*n_onemovie+i_movie][None], y_train[i_train*n_onemovie+i_movie][None]) loss_train[i_train, i_movie] = loss.data loss_test = np.zeros((num_test_dataset, n_onemovie), dtype=np.float32) for i_test in range(num_test_dataset): for i_movie in range(n_onemovie): loss, output = forward(x_test[i_test*n_onemovie+i_movie][None], y_test[i_test*n_onemovie+i_movie][None]) loss_test[i_test, i_movie] = loss.data m = np.r_[loss_train, loss_test].max() loss_train = loss_train / m loss_test = loss_train / m model = FunctionSet( l1 = F.Linear(n_onemovie, n_loss_node), l2 = F.Linear(n_loss_node, 2) ) optimizer = optimizers.SGD() optimizer.setup(model.collect_parameters()) for epoch in range(n_epoch_last): indexes = np.random.permutation(int(num_train_dataset)) sum_loss = 0 for k in range(0, int(num_train_dataset), batchsize): x_batch = loss_train[indexes[k : k + batchsize]] y_batch = label_train[indexes[k : k + batchsize]].ravel() optimizer.zero_grads() loss, output = forwardLastML(x_batch, y_batch) loss.backward() optimizer.update() sum_loss = sum_loss+loss.data*batchsize print('LastML: epoch:'+str(epoch)+' loss:' + str(sum_loss/num_train_dataset)) dic['lastpredict']['label'] = label_test dic['lastpredict']['pedict'] = np.empty(0, dtype=np.int) dic['lastpredict']['output'] = np.empty(0, dtype=np.float) for i_test in range(num_test_dataset): loss, output = forwardLastML(loss_test[i_test][None], label_test[i_test].ravel()) dic['lastpredict']['output'] = utils.vstack_(dic['lastpredict']['output'], output.data) if output.data[0,0] > output.data[0,1]: dic['lastpredict']['pedict'] = utils.vstack_(dic['lastpredict']['pedict'], 0) else: dic['lastpredict']['pedict'] = utils.vstack_(dic['lastpredict']['pedict'], 1) list_layer.append(dic) list_cross.append(list_layer) # In[ ]: # save data f = open('save.dump', 'wb') pickle.dump(list_cross, f) print('finish!') # In[ ]:
apache-2.0
toobaz/pandas
pandas/tests/util/test_util.py
2
2648
import os import sys import pytest import pandas.compat as compat from pandas.compat import raise_with_traceback import pandas.util.testing as tm def test_rands(): r = tm.rands(10) assert len(r) == 10 def test_rands_array_1d(): arr = tm.rands_array(5, size=10) assert arr.shape == (10,) assert len(arr[0]) == 5 def test_rands_array_2d(): arr = tm.rands_array(7, size=(10, 10)) assert arr.shape == (10, 10) assert len(arr[1, 1]) == 7 def test_numpy_err_state_is_default(): expected = {"over": "warn", "divide": "warn", "invalid": "warn", "under": "ignore"} import numpy as np # The error state should be unchanged after that import. assert np.geterr() == expected def test_raise_with_traceback(): with pytest.raises(LookupError, match="error_text"): try: raise ValueError("THIS IS AN ERROR") except ValueError: e = LookupError("error_text") raise_with_traceback(e) with pytest.raises(LookupError, match="error_text"): try: raise ValueError("This is another error") except ValueError: e = LookupError("error_text") _, _, traceback = sys.exc_info() raise_with_traceback(e, traceback) def test_convert_rows_list_to_csv_str(): rows_list = ["aaa", "bbb", "ccc"] ret = tm.convert_rows_list_to_csv_str(rows_list) if compat.is_platform_windows(): expected = "aaa\r\nbbb\r\nccc\r\n" else: expected = "aaa\nbbb\nccc\n" assert ret == expected def test_create_temp_directory(): with tm.ensure_clean_dir() as path: assert os.path.exists(path) assert os.path.isdir(path) assert not os.path.exists(path) def test_assert_raises_regex_deprecated(): # see gh-23592 with tm.assert_produces_warning(FutureWarning): msg = "Not equal!" with tm.assert_raises_regex(AssertionError, msg): assert 1 == 2, msg @pytest.mark.parametrize("strict_data_files", [True, False]) def test_datapath_missing(datapath): with pytest.raises(ValueError, match="Could not find file"): datapath("not_a_file") def test_datapath(datapath): args = ("data", "iris.csv") result = datapath(*args) expected = os.path.join(os.path.dirname(os.path.dirname(__file__)), *args) assert result == expected def test_rng_context(): import numpy as np expected0 = 1.764052345967664 expected1 = 1.6243453636632417 with tm.RNGContext(0): with tm.RNGContext(1): assert np.random.randn() == expected1 assert np.random.randn() == expected0
bsd-3-clause
AnasGhrab/scikit-learn
doc/conf.py
210
8446
# -*- coding: utf-8 -*- # # scikit-learn documentation build configuration file, created by # sphinx-quickstart on Fri Jan 8 09:13:42 2010. # # This file is execfile()d with the current directory set to its containing # dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. from __future__ import print_function import sys import os from sklearn.externals.six import u # If extensions (or modules to document with autodoc) are in another # directory, add these directories to sys.path here. If the directory # is relative to the documentation root, use os.path.abspath to make it # absolute, like shown here. sys.path.insert(0, os.path.abspath('sphinxext')) from github_link import make_linkcode_resolve # -- General configuration --------------------------------------------------- # Try to override the matplotlib configuration as early as possible try: import gen_rst except: pass # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom ones. extensions = ['gen_rst', 'sphinx.ext.autodoc', 'sphinx.ext.autosummary', 'sphinx.ext.pngmath', 'numpy_ext.numpydoc', 'sphinx.ext.linkcode', ] autosummary_generate = True autodoc_default_flags = ['members', 'inherited-members'] # Add any paths that contain templates here, relative to this directory. templates_path = ['templates'] # generate autosummary even if no references autosummary_generate = True # The suffix of source filenames. source_suffix = '.rst' # The encoding of source files. #source_encoding = 'utf-8' # Generate the plots for the gallery plot_gallery = True # The master toctree document. master_doc = 'index' # General information about the project. project = u('scikit-learn') copyright = u('2010 - 2014, scikit-learn developers (BSD License)') # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # The short X.Y version. import sklearn version = sklearn.__version__ # The full version, including alpha/beta/rc tags. release = sklearn.__version__ # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. #language = None # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: #today = '' # Else, today_fmt is used as the format for a strftime call. #today_fmt = '%B %d, %Y' # List of documents that shouldn't be included in the build. #unused_docs = [] # List of directories, relative to source directory, that shouldn't be # searched for source files. exclude_trees = ['_build', 'templates', 'includes'] # The reST default role (used for this markup: `text`) to use for all # documents. #default_role = None # If true, '()' will be appended to :func: etc. cross-reference text. add_function_parentheses = False # If true, the current module name will be prepended to all description # unit titles (such as .. function::). #add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. #show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' # A list of ignored prefixes for module index sorting. #modindex_common_prefix = [] # -- Options for HTML output ------------------------------------------------- # The theme to use for HTML and HTML Help pages. Major themes that come with # Sphinx are currently 'default' and 'sphinxdoc'. html_theme = 'scikit-learn' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. html_theme_options = {'oldversion': False, 'collapsiblesidebar': True, 'google_analytics': True, 'surveybanner': False, 'sprintbanner': True} # Add any paths that contain custom themes here, relative to this directory. html_theme_path = ['themes'] # The name for this set of Sphinx documents. If None, it defaults to # "<project> v<release> documentation". #html_title = None # A shorter title for the navigation bar. Default is the same as html_title. html_short_title = 'scikit-learn' # The name of an image file (relative to this directory) to place at the top # of the sidebar. html_logo = 'logos/scikit-learn-logo-small.png' # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. html_favicon = 'logos/favicon.ico' # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ['images'] # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. #html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. #html_use_smartypants = True # Custom sidebar templates, maps document names to template names. #html_sidebars = {} # Additional templates that should be rendered to pages, maps page names to # template names. #html_additional_pages = {} # If false, no module index is generated. html_domain_indices = False # If false, no index is generated. html_use_index = False # If true, the index is split into individual pages for each letter. #html_split_index = False # If true, links to the reST sources are added to the pages. #html_show_sourcelink = True # If true, an OpenSearch description file will be output, and all pages will # contain a <link> tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. #html_use_opensearch = '' # If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml"). #html_file_suffix = '' # Output file base name for HTML help builder. htmlhelp_basename = 'scikit-learndoc' # -- Options for LaTeX output ------------------------------------------------ # The paper size ('letter' or 'a4'). #latex_paper_size = 'letter' # The font size ('10pt', '11pt' or '12pt'). #latex_font_size = '10pt' # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, documentclass # [howto/manual]). latex_documents = [('index', 'user_guide.tex', u('scikit-learn user guide'), u('scikit-learn developers'), 'manual'), ] # The name of an image file (relative to this directory) to place at the top of # the title page. latex_logo = "logos/scikit-learn-logo.png" # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. #latex_use_parts = False # Additional stuff for the LaTeX preamble. latex_preamble = r""" \usepackage{amsmath}\usepackage{amsfonts}\usepackage{bm}\usepackage{morefloats} \usepackage{enumitem} \setlistdepth{10} """ # Documents to append as an appendix to all manuals. #latex_appendices = [] # If false, no module index is generated. latex_domain_indices = False trim_doctests_flags = True def generate_example_rst(app, what, name, obj, options, lines): # generate empty examples files, so that we don't get # inclusion errors if there are no examples for a class / module examples_path = os.path.join(app.srcdir, "modules", "generated", "%s.examples" % name) if not os.path.exists(examples_path): # touch file open(examples_path, 'w').close() def setup(app): # to hide/show the prompt in code examples: app.add_javascript('js/copybutton.js') app.connect('autodoc-process-docstring', generate_example_rst) # The following is used by sphinx.ext.linkcode to provide links to github linkcode_resolve = make_linkcode_resolve('sklearn', u'https://github.com/scikit-learn/' 'scikit-learn/blob/{revision}/' '{package}/{path}#L{lineno}')
bsd-3-clause
winklerand/pandas
pandas/tests/test_algos.py
1
55742
# -*- coding: utf-8 -*- import numpy as np import pytest from numpy.random import RandomState from numpy import nan from datetime import datetime from itertools import permutations from pandas import (Series, Categorical, CategoricalIndex, Timestamp, DatetimeIndex, Index, IntervalIndex) import pandas as pd from pandas import compat from pandas._libs import (groupby as libgroupby, algos as libalgos, hashtable as ht) from pandas._libs.hashtable import unique_label_indices from pandas.compat import lrange, range import pandas.core.algorithms as algos import pandas.util.testing as tm from pandas.compat.numpy import np_array_datetime64_compat from pandas.util.testing import assert_almost_equal class TestMatch(object): def test_ints(self): values = np.array([0, 2, 1]) to_match = np.array([0, 1, 2, 2, 0, 1, 3, 0]) result = algos.match(to_match, values) expected = np.array([0, 2, 1, 1, 0, 2, -1, 0], dtype=np.int64) tm.assert_numpy_array_equal(result, expected) result = Series(algos.match(to_match, values, np.nan)) expected = Series(np.array([0, 2, 1, 1, 0, 2, np.nan, 0])) tm.assert_series_equal(result, expected) s = Series(np.arange(5), dtype=np.float32) result = algos.match(s, [2, 4]) expected = np.array([-1, -1, 0, -1, 1], dtype=np.int64) tm.assert_numpy_array_equal(result, expected) result = Series(algos.match(s, [2, 4], np.nan)) expected = Series(np.array([np.nan, np.nan, 0, np.nan, 1])) tm.assert_series_equal(result, expected) def test_strings(self): values = ['foo', 'bar', 'baz'] to_match = ['bar', 'foo', 'qux', 'foo', 'bar', 'baz', 'qux'] result = algos.match(to_match, values) expected = np.array([1, 0, -1, 0, 1, 2, -1], dtype=np.int64) tm.assert_numpy_array_equal(result, expected) result = Series(algos.match(to_match, values, np.nan)) expected = Series(np.array([1, 0, np.nan, 0, 1, 2, np.nan])) tm.assert_series_equal(result, expected) class TestFactorize(object): def test_basic(self): labels, uniques = algos.factorize(['a', 'b', 'b', 'a', 'a', 'c', 'c', 'c']) tm.assert_numpy_array_equal( uniques, np.array(['a', 'b', 'c'], dtype=object)) labels, uniques = algos.factorize(['a', 'b', 'b', 'a', 'a', 'c', 'c', 'c'], sort=True) exp = np.array([0, 1, 1, 0, 0, 2, 2, 2], dtype=np.intp) tm.assert_numpy_array_equal(labels, exp) exp = np.array(['a', 'b', 'c'], dtype=object) tm.assert_numpy_array_equal(uniques, exp) labels, uniques = algos.factorize(list(reversed(range(5)))) exp = np.array([0, 1, 2, 3, 4], dtype=np.intp) tm.assert_numpy_array_equal(labels, exp) exp = np.array([4, 3, 2, 1, 0], dtype=np.int64) tm.assert_numpy_array_equal(uniques, exp) labels, uniques = algos.factorize(list(reversed(range(5))), sort=True) exp = np.array([4, 3, 2, 1, 0], dtype=np.intp) tm.assert_numpy_array_equal(labels, exp) exp = np.array([0, 1, 2, 3, 4], dtype=np.int64) tm.assert_numpy_array_equal(uniques, exp) labels, uniques = algos.factorize(list(reversed(np.arange(5.)))) exp = np.array([0, 1, 2, 3, 4], dtype=np.intp) tm.assert_numpy_array_equal(labels, exp) exp = np.array([4., 3., 2., 1., 0.], dtype=np.float64) tm.assert_numpy_array_equal(uniques, exp) labels, uniques = algos.factorize(list(reversed(np.arange(5.))), sort=True) exp = np.array([4, 3, 2, 1, 0], dtype=np.intp) tm.assert_numpy_array_equal(labels, exp) exp = np.array([0., 1., 2., 3., 4.], dtype=np.float64) tm.assert_numpy_array_equal(uniques, exp) def test_mixed(self): # doc example reshaping.rst x = Series(['A', 'A', np.nan, 'B', 3.14, np.inf]) labels, uniques = algos.factorize(x) exp = np.array([0, 0, -1, 1, 2, 3], dtype=np.intp) tm.assert_numpy_array_equal(labels, exp) exp = Index(['A', 'B', 3.14, np.inf]) tm.assert_index_equal(uniques, exp) labels, uniques = algos.factorize(x, sort=True) exp = np.array([2, 2, -1, 3, 0, 1], dtype=np.intp) tm.assert_numpy_array_equal(labels, exp) exp = Index([3.14, np.inf, 'A', 'B']) tm.assert_index_equal(uniques, exp) def test_datelike(self): # M8 v1 = Timestamp('20130101 09:00:00.00004') v2 = Timestamp('20130101') x = Series([v1, v1, v1, v2, v2, v1]) labels, uniques = algos.factorize(x) exp = np.array([0, 0, 0, 1, 1, 0], dtype=np.intp) tm.assert_numpy_array_equal(labels, exp) exp = DatetimeIndex([v1, v2]) tm.assert_index_equal(uniques, exp) labels, uniques = algos.factorize(x, sort=True) exp = np.array([1, 1, 1, 0, 0, 1], dtype=np.intp) tm.assert_numpy_array_equal(labels, exp) exp = DatetimeIndex([v2, v1]) tm.assert_index_equal(uniques, exp) # period v1 = pd.Period('201302', freq='M') v2 = pd.Period('201303', freq='M') x = Series([v1, v1, v1, v2, v2, v1]) # periods are not 'sorted' as they are converted back into an index labels, uniques = algos.factorize(x) exp = np.array([0, 0, 0, 1, 1, 0], dtype=np.intp) tm.assert_numpy_array_equal(labels, exp) tm.assert_index_equal(uniques, pd.PeriodIndex([v1, v2])) labels, uniques = algos.factorize(x, sort=True) exp = np.array([0, 0, 0, 1, 1, 0], dtype=np.intp) tm.assert_numpy_array_equal(labels, exp) tm.assert_index_equal(uniques, pd.PeriodIndex([v1, v2])) # GH 5986 v1 = pd.to_timedelta('1 day 1 min') v2 = pd.to_timedelta('1 day') x = Series([v1, v2, v1, v1, v2, v2, v1]) labels, uniques = algos.factorize(x) exp = np.array([0, 1, 0, 0, 1, 1, 0], dtype=np.intp) tm.assert_numpy_array_equal(labels, exp) tm.assert_index_equal(uniques, pd.to_timedelta([v1, v2])) labels, uniques = algos.factorize(x, sort=True) exp = np.array([1, 0, 1, 1, 0, 0, 1], dtype=np.intp) tm.assert_numpy_array_equal(labels, exp) tm.assert_index_equal(uniques, pd.to_timedelta([v2, v1])) def test_factorize_nan(self): # nan should map to na_sentinel, not reverse_indexer[na_sentinel] # rizer.factorize should not raise an exception if na_sentinel indexes # outside of reverse_indexer key = np.array([1, 2, 1, np.nan], dtype='O') rizer = ht.Factorizer(len(key)) for na_sentinel in (-1, 20): ids = rizer.factorize(key, sort=True, na_sentinel=na_sentinel) expected = np.array([0, 1, 0, na_sentinel], dtype='int32') assert len(set(key)) == len(set(expected)) tm.assert_numpy_array_equal(pd.isna(key), expected == na_sentinel) # nan still maps to na_sentinel when sort=False key = np.array([0, np.nan, 1], dtype='O') na_sentinel = -1 # TODO(wesm): unused? ids = rizer.factorize(key, sort=False, na_sentinel=na_sentinel) # noqa expected = np.array([2, -1, 0], dtype='int32') assert len(set(key)) == len(set(expected)) tm.assert_numpy_array_equal(pd.isna(key), expected == na_sentinel) def test_complex_sorting(self): # gh 12666 - check no segfault # Test not valid numpy versions older than 1.11 if pd._np_version_under1p11: pytest.skip("Test valid only for numpy 1.11+") x17 = np.array([complex(i) for i in range(17)], dtype=object) pytest.raises(TypeError, algos.factorize, x17[::-1], sort=True) def test_uint64_factorize(self): data = np.array([2**63, 1, 2**63], dtype=np.uint64) exp_labels = np.array([0, 1, 0], dtype=np.intp) exp_uniques = np.array([2**63, 1], dtype=np.uint64) labels, uniques = algos.factorize(data) tm.assert_numpy_array_equal(labels, exp_labels) tm.assert_numpy_array_equal(uniques, exp_uniques) data = np.array([2**63, -1, 2**63], dtype=object) exp_labels = np.array([0, 1, 0], dtype=np.intp) exp_uniques = np.array([2**63, -1], dtype=object) labels, uniques = algos.factorize(data) tm.assert_numpy_array_equal(labels, exp_labels) tm.assert_numpy_array_equal(uniques, exp_uniques) class TestUnique(object): def test_ints(self): arr = np.random.randint(0, 100, size=50) result = algos.unique(arr) assert isinstance(result, np.ndarray) def test_objects(self): arr = np.random.randint(0, 100, size=50).astype('O') result = algos.unique(arr) assert isinstance(result, np.ndarray) def test_object_refcount_bug(self): lst = ['A', 'B', 'C', 'D', 'E'] for i in range(1000): len(algos.unique(lst)) def test_on_index_object(self): mindex = pd.MultiIndex.from_arrays([np.arange(5).repeat(5), np.tile( np.arange(5), 5)]) expected = mindex.values expected.sort() mindex = mindex.repeat(2) result = pd.unique(mindex) result.sort() tm.assert_almost_equal(result, expected) def test_datetime64_dtype_array_returned(self): # GH 9431 expected = np_array_datetime64_compat( ['2015-01-03T00:00:00.000000000+0000', '2015-01-01T00:00:00.000000000+0000'], dtype='M8[ns]') dt_index = pd.to_datetime(['2015-01-03T00:00:00.000000000+0000', '2015-01-01T00:00:00.000000000+0000', '2015-01-01T00:00:00.000000000+0000']) result = algos.unique(dt_index) tm.assert_numpy_array_equal(result, expected) assert result.dtype == expected.dtype s = Series(dt_index) result = algos.unique(s) tm.assert_numpy_array_equal(result, expected) assert result.dtype == expected.dtype arr = s.values result = algos.unique(arr) tm.assert_numpy_array_equal(result, expected) assert result.dtype == expected.dtype def test_timedelta64_dtype_array_returned(self): # GH 9431 expected = np.array([31200, 45678, 10000], dtype='m8[ns]') td_index = pd.to_timedelta([31200, 45678, 31200, 10000, 45678]) result = algos.unique(td_index) tm.assert_numpy_array_equal(result, expected) assert result.dtype == expected.dtype s = Series(td_index) result = algos.unique(s) tm.assert_numpy_array_equal(result, expected) assert result.dtype == expected.dtype arr = s.values result = algos.unique(arr) tm.assert_numpy_array_equal(result, expected) assert result.dtype == expected.dtype def test_uint64_overflow(self): s = Series([1, 2, 2**63, 2**63], dtype=np.uint64) exp = np.array([1, 2, 2**63], dtype=np.uint64) tm.assert_numpy_array_equal(algos.unique(s), exp) def test_nan_in_object_array(self): l = ['a', np.nan, 'c', 'c'] result = pd.unique(l) expected = np.array(['a', np.nan, 'c'], dtype=object) tm.assert_numpy_array_equal(result, expected) def test_categorical(self): # we are expecting to return in the order # of appearance expected = Categorical(list('bac'), categories=list('bac')) # we are expecting to return in the order # of the categories expected_o = Categorical( list('bac'), categories=list('abc'), ordered=True) # GH 15939 c = Categorical(list('baabc')) result = c.unique() tm.assert_categorical_equal(result, expected) result = algos.unique(c) tm.assert_categorical_equal(result, expected) c = Categorical(list('baabc'), ordered=True) result = c.unique() tm.assert_categorical_equal(result, expected_o) result = algos.unique(c) tm.assert_categorical_equal(result, expected_o) # Series of categorical dtype s = Series(Categorical(list('baabc')), name='foo') result = s.unique() tm.assert_categorical_equal(result, expected) result = pd.unique(s) tm.assert_categorical_equal(result, expected) # CI -> return CI ci = CategoricalIndex(Categorical(list('baabc'), categories=list('bac'))) expected = CategoricalIndex(expected) result = ci.unique() tm.assert_index_equal(result, expected) result = pd.unique(ci) tm.assert_index_equal(result, expected) def test_datetime64tz_aware(self): # GH 15939 result = Series( Index([Timestamp('20160101', tz='US/Eastern'), Timestamp('20160101', tz='US/Eastern')])).unique() expected = np.array([Timestamp('2016-01-01 00:00:00-0500', tz='US/Eastern')], dtype=object) tm.assert_numpy_array_equal(result, expected) result = Index([Timestamp('20160101', tz='US/Eastern'), Timestamp('20160101', tz='US/Eastern')]).unique() expected = DatetimeIndex(['2016-01-01 00:00:00'], dtype='datetime64[ns, US/Eastern]', freq=None) tm.assert_index_equal(result, expected) result = pd.unique( Series(Index([Timestamp('20160101', tz='US/Eastern'), Timestamp('20160101', tz='US/Eastern')]))) expected = np.array([Timestamp('2016-01-01 00:00:00-0500', tz='US/Eastern')], dtype=object) tm.assert_numpy_array_equal(result, expected) result = pd.unique(Index([Timestamp('20160101', tz='US/Eastern'), Timestamp('20160101', tz='US/Eastern')])) expected = DatetimeIndex(['2016-01-01 00:00:00'], dtype='datetime64[ns, US/Eastern]', freq=None) tm.assert_index_equal(result, expected) def test_order_of_appearance(self): # 9346 # light testing of guarantee of order of appearance # these also are the doc-examples result = pd.unique(Series([2, 1, 3, 3])) tm.assert_numpy_array_equal(result, np.array([2, 1, 3], dtype='int64')) result = pd.unique(Series([2] + [1] * 5)) tm.assert_numpy_array_equal(result, np.array([2, 1], dtype='int64')) result = pd.unique(Series([Timestamp('20160101'), Timestamp('20160101')])) expected = np.array(['2016-01-01T00:00:00.000000000'], dtype='datetime64[ns]') tm.assert_numpy_array_equal(result, expected) result = pd.unique(Index( [Timestamp('20160101', tz='US/Eastern'), Timestamp('20160101', tz='US/Eastern')])) expected = DatetimeIndex(['2016-01-01 00:00:00'], dtype='datetime64[ns, US/Eastern]', freq=None) tm.assert_index_equal(result, expected) result = pd.unique(list('aabc')) expected = np.array(['a', 'b', 'c'], dtype=object) tm.assert_numpy_array_equal(result, expected) result = pd.unique(Series(Categorical(list('aabc')))) expected = Categorical(list('abc')) tm.assert_categorical_equal(result, expected) @pytest.mark.parametrize("arg ,expected", [ (('1', '1', '2'), np.array(['1', '2'], dtype=object)), (('foo',), np.array(['foo'], dtype=object)) ]) def test_tuple_with_strings(self, arg, expected): # see GH 17108 result = pd.unique(arg) tm.assert_numpy_array_equal(result, expected) class TestIsin(object): def test_invalid(self): pytest.raises(TypeError, lambda: algos.isin(1, 1)) pytest.raises(TypeError, lambda: algos.isin(1, [1])) pytest.raises(TypeError, lambda: algos.isin([1], 1)) def test_basic(self): result = algos.isin([1, 2], [1]) expected = np.array([True, False]) tm.assert_numpy_array_equal(result, expected) result = algos.isin(np.array([1, 2]), [1]) expected = np.array([True, False]) tm.assert_numpy_array_equal(result, expected) result = algos.isin(Series([1, 2]), [1]) expected = np.array([True, False]) tm.assert_numpy_array_equal(result, expected) result = algos.isin(Series([1, 2]), Series([1])) expected = np.array([True, False]) tm.assert_numpy_array_equal(result, expected) result = algos.isin(Series([1, 2]), set([1])) expected = np.array([True, False]) tm.assert_numpy_array_equal(result, expected) result = algos.isin(['a', 'b'], ['a']) expected = np.array([True, False]) tm.assert_numpy_array_equal(result, expected) result = algos.isin(Series(['a', 'b']), Series(['a'])) expected = np.array([True, False]) tm.assert_numpy_array_equal(result, expected) result = algos.isin(Series(['a', 'b']), set(['a'])) expected = np.array([True, False]) tm.assert_numpy_array_equal(result, expected) result = algos.isin(['a', 'b'], [1]) expected = np.array([False, False]) tm.assert_numpy_array_equal(result, expected) def test_i8(self): arr = pd.date_range('20130101', periods=3).values result = algos.isin(arr, [arr[0]]) expected = np.array([True, False, False]) tm.assert_numpy_array_equal(result, expected) result = algos.isin(arr, arr[0:2]) expected = np.array([True, True, False]) tm.assert_numpy_array_equal(result, expected) result = algos.isin(arr, set(arr[0:2])) expected = np.array([True, True, False]) tm.assert_numpy_array_equal(result, expected) arr = pd.timedelta_range('1 day', periods=3).values result = algos.isin(arr, [arr[0]]) expected = np.array([True, False, False]) tm.assert_numpy_array_equal(result, expected) result = algos.isin(arr, arr[0:2]) expected = np.array([True, True, False]) tm.assert_numpy_array_equal(result, expected) result = algos.isin(arr, set(arr[0:2])) expected = np.array([True, True, False]) tm.assert_numpy_array_equal(result, expected) def test_large(self): s = pd.date_range('20000101', periods=2000000, freq='s').values result = algos.isin(s, s[0:2]) expected = np.zeros(len(s), dtype=bool) expected[0] = True expected[1] = True tm.assert_numpy_array_equal(result, expected) def test_categorical_from_codes(self): # GH 16639 vals = np.array([0, 1, 2, 0]) cats = ['a', 'b', 'c'] Sd = Series(Categorical(1).from_codes(vals, cats)) St = Series(Categorical(1).from_codes(np.array([0, 1]), cats)) expected = np.array([True, True, False, True]) result = algos.isin(Sd, St) tm.assert_numpy_array_equal(expected, result) @pytest.mark.parametrize("empty", [[], Series(), np.array([])]) def test_empty(self, empty): # see gh-16991 vals = Index(["a", "b"]) expected = np.array([False, False]) result = algos.isin(vals, empty) tm.assert_numpy_array_equal(expected, result) class TestValueCounts(object): def test_value_counts(self): np.random.seed(1234) from pandas.core.reshape.tile import cut arr = np.random.randn(4) factor = cut(arr, 4) # assert isinstance(factor, n) result = algos.value_counts(factor) breaks = [-1.194, -0.535, 0.121, 0.777, 1.433] expected_index = IntervalIndex.from_breaks(breaks).astype('category') expected = Series([1, 1, 1, 1], index=expected_index) tm.assert_series_equal(result.sort_index(), expected.sort_index()) def test_value_counts_bins(self): s = [1, 2, 3, 4] result = algos.value_counts(s, bins=1) expected = Series([4], index=IntervalIndex.from_tuples([(0.996, 4.0)])) tm.assert_series_equal(result, expected) result = algos.value_counts(s, bins=2, sort=False) expected = Series([2, 2], index=IntervalIndex.from_tuples([(0.996, 2.5), (2.5, 4.0)])) tm.assert_series_equal(result, expected) def test_value_counts_dtypes(self): result = algos.value_counts([1, 1.]) assert len(result) == 1 result = algos.value_counts([1, 1.], bins=1) assert len(result) == 1 result = algos.value_counts(Series([1, 1., '1'])) # object assert len(result) == 2 pytest.raises(TypeError, lambda s: algos.value_counts(s, bins=1), ['1', 1]) def test_value_counts_nat(self): td = Series([np.timedelta64(10000), pd.NaT], dtype='timedelta64[ns]') dt = pd.to_datetime(['NaT', '2014-01-01']) for s in [td, dt]: vc = algos.value_counts(s) vc_with_na = algos.value_counts(s, dropna=False) assert len(vc) == 1 assert len(vc_with_na) == 2 exp_dt = Series({Timestamp('2014-01-01 00:00:00'): 1}) tm.assert_series_equal(algos.value_counts(dt), exp_dt) # TODO same for (timedelta) def test_value_counts_datetime_outofbounds(self): # GH 13663 s = Series([datetime(3000, 1, 1), datetime(5000, 1, 1), datetime(5000, 1, 1), datetime(6000, 1, 1), datetime(3000, 1, 1), datetime(3000, 1, 1)]) res = s.value_counts() exp_index = Index([datetime(3000, 1, 1), datetime(5000, 1, 1), datetime(6000, 1, 1)], dtype=object) exp = Series([3, 2, 1], index=exp_index) tm.assert_series_equal(res, exp) # GH 12424 res = pd.to_datetime(Series(['2362-01-01', np.nan]), errors='ignore') exp = Series(['2362-01-01', np.nan], dtype=object) tm.assert_series_equal(res, exp) def test_categorical(self): s = Series(Categorical(list('aaabbc'))) result = s.value_counts() expected = Series([3, 2, 1], index=CategoricalIndex(['a', 'b', 'c'])) tm.assert_series_equal(result, expected, check_index_type=True) # preserve order? s = s.cat.as_ordered() result = s.value_counts() expected.index = expected.index.as_ordered() tm.assert_series_equal(result, expected, check_index_type=True) def test_categorical_nans(self): s = Series(Categorical(list('aaaaabbbcc'))) # 4,3,2,1 (nan) s.iloc[1] = np.nan result = s.value_counts() expected = Series([4, 3, 2], index=CategoricalIndex( ['a', 'b', 'c'], categories=['a', 'b', 'c'])) tm.assert_series_equal(result, expected, check_index_type=True) result = s.value_counts(dropna=False) expected = Series([ 4, 3, 2, 1 ], index=CategoricalIndex(['a', 'b', 'c', np.nan])) tm.assert_series_equal(result, expected, check_index_type=True) # out of order s = Series(Categorical( list('aaaaabbbcc'), ordered=True, categories=['b', 'a', 'c'])) s.iloc[1] = np.nan result = s.value_counts() expected = Series([4, 3, 2], index=CategoricalIndex( ['a', 'b', 'c'], categories=['b', 'a', 'c'], ordered=True)) tm.assert_series_equal(result, expected, check_index_type=True) result = s.value_counts(dropna=False) expected = Series([4, 3, 2, 1], index=CategoricalIndex( ['a', 'b', 'c', np.nan], categories=['b', 'a', 'c'], ordered=True)) tm.assert_series_equal(result, expected, check_index_type=True) def test_categorical_zeroes(self): # keep the `d` category with 0 s = Series(Categorical( list('bbbaac'), categories=list('abcd'), ordered=True)) result = s.value_counts() expected = Series([3, 2, 1, 0], index=Categorical( ['b', 'a', 'c', 'd'], categories=list('abcd'), ordered=True)) tm.assert_series_equal(result, expected, check_index_type=True) def test_dropna(self): # https://github.com/pandas-dev/pandas/issues/9443#issuecomment-73719328 tm.assert_series_equal( Series([True, True, False]).value_counts(dropna=True), Series([2, 1], index=[True, False])) tm.assert_series_equal( Series([True, True, False]).value_counts(dropna=False), Series([2, 1], index=[True, False])) tm.assert_series_equal( Series([True, True, False, None]).value_counts(dropna=True), Series([2, 1], index=[True, False])) tm.assert_series_equal( Series([True, True, False, None]).value_counts(dropna=False), Series([2, 1, 1], index=[True, False, np.nan])) tm.assert_series_equal( Series([10.3, 5., 5.]).value_counts(dropna=True), Series([2, 1], index=[5., 10.3])) tm.assert_series_equal( Series([10.3, 5., 5.]).value_counts(dropna=False), Series([2, 1], index=[5., 10.3])) tm.assert_series_equal( Series([10.3, 5., 5., None]).value_counts(dropna=True), Series([2, 1], index=[5., 10.3])) # 32-bit linux has a different ordering if not compat.is_platform_32bit(): result = Series([10.3, 5., 5., None]).value_counts(dropna=False) expected = Series([2, 1, 1], index=[5., 10.3, np.nan]) tm.assert_series_equal(result, expected) def test_value_counts_normalized(self): # GH12558 s = Series([1, 2, np.nan, np.nan, np.nan]) dtypes = (np.float64, np.object, 'M8[ns]') for t in dtypes: s_typed = s.astype(t) result = s_typed.value_counts(normalize=True, dropna=False) expected = Series([0.6, 0.2, 0.2], index=Series([np.nan, 2.0, 1.0], dtype=t)) tm.assert_series_equal(result, expected) result = s_typed.value_counts(normalize=True, dropna=True) expected = Series([0.5, 0.5], index=Series([2.0, 1.0], dtype=t)) tm.assert_series_equal(result, expected) def test_value_counts_uint64(self): arr = np.array([2**63], dtype=np.uint64) expected = Series([1], index=[2**63]) result = algos.value_counts(arr) tm.assert_series_equal(result, expected) arr = np.array([-1, 2**63], dtype=object) expected = Series([1, 1], index=[-1, 2**63]) result = algos.value_counts(arr) # 32-bit linux has a different ordering if not compat.is_platform_32bit(): tm.assert_series_equal(result, expected) class TestDuplicated(object): def test_duplicated_with_nas(self): keys = np.array([0, 1, np.nan, 0, 2, np.nan], dtype=object) result = algos.duplicated(keys) expected = np.array([False, False, False, True, False, True]) tm.assert_numpy_array_equal(result, expected) result = algos.duplicated(keys, keep='first') expected = np.array([False, False, False, True, False, True]) tm.assert_numpy_array_equal(result, expected) result = algos.duplicated(keys, keep='last') expected = np.array([True, False, True, False, False, False]) tm.assert_numpy_array_equal(result, expected) result = algos.duplicated(keys, keep=False) expected = np.array([True, False, True, True, False, True]) tm.assert_numpy_array_equal(result, expected) keys = np.empty(8, dtype=object) for i, t in enumerate(zip([0, 0, np.nan, np.nan] * 2, [0, np.nan, 0, np.nan] * 2)): keys[i] = t result = algos.duplicated(keys) falses = [False] * 4 trues = [True] * 4 expected = np.array(falses + trues) tm.assert_numpy_array_equal(result, expected) result = algos.duplicated(keys, keep='last') expected = np.array(trues + falses) tm.assert_numpy_array_equal(result, expected) result = algos.duplicated(keys, keep=False) expected = np.array(trues + trues) tm.assert_numpy_array_equal(result, expected) @pytest.mark.parametrize('case', [ np.array([1, 2, 1, 5, 3, 2, 4, 1, 5, 6]), np.array([1.1, 2.2, 1.1, np.nan, 3.3, 2.2, 4.4, 1.1, np.nan, 6.6]), pytest.mark.xfail(reason="Complex bug. GH 16399")( np.array([1 + 1j, 2 + 2j, 1 + 1j, 5 + 5j, 3 + 3j, 2 + 2j, 4 + 4j, 1 + 1j, 5 + 5j, 6 + 6j]) ), np.array(['a', 'b', 'a', 'e', 'c', 'b', 'd', 'a', 'e', 'f'], dtype=object), np.array([1, 2**63, 1, 3**5, 10, 2**63, 39, 1, 3**5, 7], dtype=np.uint64), ]) def test_numeric_object_likes(self, case): exp_first = np.array([False, False, True, False, False, True, False, True, True, False]) exp_last = np.array([True, True, True, True, False, False, False, False, False, False]) exp_false = exp_first | exp_last res_first = algos.duplicated(case, keep='first') tm.assert_numpy_array_equal(res_first, exp_first) res_last = algos.duplicated(case, keep='last') tm.assert_numpy_array_equal(res_last, exp_last) res_false = algos.duplicated(case, keep=False) tm.assert_numpy_array_equal(res_false, exp_false) # index for idx in [Index(case), Index(case, dtype='category')]: res_first = idx.duplicated(keep='first') tm.assert_numpy_array_equal(res_first, exp_first) res_last = idx.duplicated(keep='last') tm.assert_numpy_array_equal(res_last, exp_last) res_false = idx.duplicated(keep=False) tm.assert_numpy_array_equal(res_false, exp_false) # series for s in [Series(case), Series(case, dtype='category')]: res_first = s.duplicated(keep='first') tm.assert_series_equal(res_first, Series(exp_first)) res_last = s.duplicated(keep='last') tm.assert_series_equal(res_last, Series(exp_last)) res_false = s.duplicated(keep=False) tm.assert_series_equal(res_false, Series(exp_false)) def test_datetime_likes(self): dt = ['2011-01-01', '2011-01-02', '2011-01-01', 'NaT', '2011-01-03', '2011-01-02', '2011-01-04', '2011-01-01', 'NaT', '2011-01-06'] td = ['1 days', '2 days', '1 days', 'NaT', '3 days', '2 days', '4 days', '1 days', 'NaT', '6 days'] cases = [np.array([Timestamp(d) for d in dt]), np.array([Timestamp(d, tz='US/Eastern') for d in dt]), np.array([pd.Period(d, freq='D') for d in dt]), np.array([np.datetime64(d) for d in dt]), np.array([pd.Timedelta(d) for d in td])] exp_first = np.array([False, False, True, False, False, True, False, True, True, False]) exp_last = np.array([True, True, True, True, False, False, False, False, False, False]) exp_false = exp_first | exp_last for case in cases: res_first = algos.duplicated(case, keep='first') tm.assert_numpy_array_equal(res_first, exp_first) res_last = algos.duplicated(case, keep='last') tm.assert_numpy_array_equal(res_last, exp_last) res_false = algos.duplicated(case, keep=False) tm.assert_numpy_array_equal(res_false, exp_false) # index for idx in [Index(case), Index(case, dtype='category'), Index(case, dtype=object)]: res_first = idx.duplicated(keep='first') tm.assert_numpy_array_equal(res_first, exp_first) res_last = idx.duplicated(keep='last') tm.assert_numpy_array_equal(res_last, exp_last) res_false = idx.duplicated(keep=False) tm.assert_numpy_array_equal(res_false, exp_false) # series for s in [Series(case), Series(case, dtype='category'), Series(case, dtype=object)]: res_first = s.duplicated(keep='first') tm.assert_series_equal(res_first, Series(exp_first)) res_last = s.duplicated(keep='last') tm.assert_series_equal(res_last, Series(exp_last)) res_false = s.duplicated(keep=False) tm.assert_series_equal(res_false, Series(exp_false)) def test_unique_index(self): cases = [Index([1, 2, 3]), pd.RangeIndex(0, 3)] for case in cases: assert case.is_unique tm.assert_numpy_array_equal(case.duplicated(), np.array([False, False, False])) @pytest.mark.parametrize('arr, unique', [ ([(0, 0), (0, 1), (1, 0), (1, 1), (0, 0), (0, 1), (1, 0), (1, 1)], [(0, 0), (0, 1), (1, 0), (1, 1)]), ([('b', 'c'), ('a', 'b'), ('a', 'b'), ('b', 'c')], [('b', 'c'), ('a', 'b')]), ([('a', 1), ('b', 2), ('a', 3), ('a', 1)], [('a', 1), ('b', 2), ('a', 3)]), ]) def test_unique_tuples(self, arr, unique): # https://github.com/pandas-dev/pandas/issues/16519 expected = np.empty(len(unique), dtype=object) expected[:] = unique result = pd.unique(arr) tm.assert_numpy_array_equal(result, expected) class GroupVarTestMixin(object): def test_group_var_generic_1d(self): prng = RandomState(1234) out = (np.nan * np.ones((5, 1))).astype(self.dtype) counts = np.zeros(5, dtype='int64') values = 10 * prng.rand(15, 1).astype(self.dtype) labels = np.tile(np.arange(5), (3, )).astype('int64') expected_out = (np.squeeze(values) .reshape((5, 3), order='F') .std(axis=1, ddof=1) ** 2)[:, np.newaxis] expected_counts = counts + 3 self.algo(out, counts, values, labels) assert np.allclose(out, expected_out, self.rtol) tm.assert_numpy_array_equal(counts, expected_counts) def test_group_var_generic_1d_flat_labels(self): prng = RandomState(1234) out = (np.nan * np.ones((1, 1))).astype(self.dtype) counts = np.zeros(1, dtype='int64') values = 10 * prng.rand(5, 1).astype(self.dtype) labels = np.zeros(5, dtype='int64') expected_out = np.array([[values.std(ddof=1) ** 2]]) expected_counts = counts + 5 self.algo(out, counts, values, labels) assert np.allclose(out, expected_out, self.rtol) tm.assert_numpy_array_equal(counts, expected_counts) def test_group_var_generic_2d_all_finite(self): prng = RandomState(1234) out = (np.nan * np.ones((5, 2))).astype(self.dtype) counts = np.zeros(5, dtype='int64') values = 10 * prng.rand(10, 2).astype(self.dtype) labels = np.tile(np.arange(5), (2, )).astype('int64') expected_out = np.std(values.reshape(2, 5, 2), ddof=1, axis=0) ** 2 expected_counts = counts + 2 self.algo(out, counts, values, labels) assert np.allclose(out, expected_out, self.rtol) tm.assert_numpy_array_equal(counts, expected_counts) def test_group_var_generic_2d_some_nan(self): prng = RandomState(1234) out = (np.nan * np.ones((5, 2))).astype(self.dtype) counts = np.zeros(5, dtype='int64') values = 10 * prng.rand(10, 2).astype(self.dtype) values[:, 1] = np.nan labels = np.tile(np.arange(5), (2, )).astype('int64') expected_out = np.vstack([values[:, 0] .reshape(5, 2, order='F') .std(ddof=1, axis=1) ** 2, np.nan * np.ones(5)]).T.astype(self.dtype) expected_counts = counts + 2 self.algo(out, counts, values, labels) tm.assert_almost_equal(out, expected_out, check_less_precise=6) tm.assert_numpy_array_equal(counts, expected_counts) def test_group_var_constant(self): # Regression test from GH 10448. out = np.array([[np.nan]], dtype=self.dtype) counts = np.array([0], dtype='int64') values = 0.832845131556193 * np.ones((3, 1), dtype=self.dtype) labels = np.zeros(3, dtype='int64') self.algo(out, counts, values, labels) assert counts[0] == 3 assert out[0, 0] >= 0 tm.assert_almost_equal(out[0, 0], 0.0) class TestGroupVarFloat64(GroupVarTestMixin): __test__ = True algo = libgroupby.group_var_float64 dtype = np.float64 rtol = 1e-5 def test_group_var_large_inputs(self): prng = RandomState(1234) out = np.array([[np.nan]], dtype=self.dtype) counts = np.array([0], dtype='int64') values = (prng.rand(10 ** 6) + 10 ** 12).astype(self.dtype) values.shape = (10 ** 6, 1) labels = np.zeros(10 ** 6, dtype='int64') self.algo(out, counts, values, labels) assert counts[0] == 10 ** 6 tm.assert_almost_equal(out[0, 0], 1.0 / 12, check_less_precise=True) class TestGroupVarFloat32(GroupVarTestMixin): __test__ = True algo = libgroupby.group_var_float32 dtype = np.float32 rtol = 1e-2 class TestHashTable(object): def test_lookup_nan(self): xs = np.array([2.718, 3.14, np.nan, -7, 5, 2, 3]) m = ht.Float64HashTable() m.map_locations(xs) tm.assert_numpy_array_equal(m.lookup(xs), np.arange(len(xs), dtype=np.int64)) def test_lookup_overflow(self): xs = np.array([1, 2, 2**63], dtype=np.uint64) m = ht.UInt64HashTable() m.map_locations(xs) tm.assert_numpy_array_equal(m.lookup(xs), np.arange(len(xs), dtype=np.int64)) def test_get_unique(self): s = Series([1, 2, 2**63, 2**63], dtype=np.uint64) exp = np.array([1, 2, 2**63], dtype=np.uint64) tm.assert_numpy_array_equal(s.unique(), exp) def test_vector_resize(self): # Test for memory errors after internal vector # reallocations (pull request #7157) def _test_vector_resize(htable, uniques, dtype, nvals, safely_resizes): vals = np.array(np.random.randn(1000), dtype=dtype) # get_labels may append to uniques htable.get_labels(vals[:nvals], uniques, 0, -1) # to_array() set an external_view_exists flag on uniques. tmp = uniques.to_array() oldshape = tmp.shape # subsequent get_labels() calls can no longer append to it # (for all but StringHashTables + ObjectVector) if safely_resizes: htable.get_labels(vals, uniques, 0, -1) else: with pytest.raises(ValueError) as excinfo: htable.get_labels(vals, uniques, 0, -1) assert str(excinfo.value).startswith('external reference') uniques.to_array() # should not raise here assert tmp.shape == oldshape test_cases = [ (ht.PyObjectHashTable, ht.ObjectVector, 'object', False), (ht.StringHashTable, ht.ObjectVector, 'object', True), (ht.Float64HashTable, ht.Float64Vector, 'float64', False), (ht.Int64HashTable, ht.Int64Vector, 'int64', False), (ht.UInt64HashTable, ht.UInt64Vector, 'uint64', False)] for (tbl, vect, dtype, safely_resizes) in test_cases: # resizing to empty is a special case _test_vector_resize(tbl(), vect(), dtype, 0, safely_resizes) _test_vector_resize(tbl(), vect(), dtype, 10, safely_resizes) def test_quantile(): s = Series(np.random.randn(100)) result = algos.quantile(s, [0, .25, .5, .75, 1.]) expected = algos.quantile(s.values, [0, .25, .5, .75, 1.]) tm.assert_almost_equal(result, expected) def test_unique_label_indices(): a = np.random.randint(1, 1 << 10, 1 << 15).astype('i8') left = unique_label_indices(a) right = np.unique(a, return_index=True)[1] tm.assert_numpy_array_equal(left, right, check_dtype=False) a[np.random.choice(len(a), 10)] = -1 left = unique_label_indices(a) right = np.unique(a, return_index=True)[1][1:] tm.assert_numpy_array_equal(left, right, check_dtype=False) class TestRank(object): def test_scipy_compat(self): tm._skip_if_no_scipy() from scipy.stats import rankdata def _check(arr): mask = ~np.isfinite(arr) arr = arr.copy() result = libalgos.rank_1d_float64(arr) arr[mask] = np.inf exp = rankdata(arr) exp[mask] = nan assert_almost_equal(result, exp) _check(np.array([nan, nan, 5., 5., 5., nan, 1, 2, 3, nan])) _check(np.array([4., nan, 5., 5., 5., nan, 1, 2, 4., nan])) def test_basic(self): exp = np.array([1, 2], dtype=np.float64) for dtype in np.typecodes['AllInteger']: s = Series([1, 100], dtype=dtype) tm.assert_numpy_array_equal(algos.rank(s), exp) def test_uint64_overflow(self): exp = np.array([1, 2], dtype=np.float64) for dtype in [np.float64, np.uint64]: s = Series([1, 2**63], dtype=dtype) tm.assert_numpy_array_equal(algos.rank(s), exp) def test_too_many_ndims(self): arr = np.array([[[1, 2, 3], [4, 5, 6], [7, 8, 9]]]) msg = "Array with ndim > 2 are not supported" with tm.assert_raises_regex(TypeError, msg): algos.rank(arr) def test_pad_backfill_object_segfault(): old = np.array([], dtype='O') new = np.array([datetime(2010, 12, 31)], dtype='O') result = libalgos.pad_object(old, new) expected = np.array([-1], dtype=np.int64) tm.assert_numpy_array_equal(result, expected) result = libalgos.pad_object(new, old) expected = np.array([], dtype=np.int64) tm.assert_numpy_array_equal(result, expected) result = libalgos.backfill_object(old, new) expected = np.array([-1], dtype=np.int64) tm.assert_numpy_array_equal(result, expected) result = libalgos.backfill_object(new, old) expected = np.array([], dtype=np.int64) tm.assert_numpy_array_equal(result, expected) def test_arrmap(): values = np.array(['foo', 'foo', 'bar', 'bar', 'baz', 'qux'], dtype='O') result = libalgos.arrmap_object(values, lambda x: x in ['foo', 'bar']) assert (result.dtype == np.bool_) class TestTseriesUtil(object): def test_combineFunc(self): pass def test_reindex(self): pass def test_isna(self): pass def test_groupby(self): pass def test_groupby_withnull(self): pass def test_backfill(self): old = Index([1, 5, 10]) new = Index(lrange(12)) filler = libalgos.backfill_int64(old.values, new.values) expect_filler = np.array([0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, -1], dtype=np.int64) tm.assert_numpy_array_equal(filler, expect_filler) # corner case old = Index([1, 4]) new = Index(lrange(5, 10)) filler = libalgos.backfill_int64(old.values, new.values) expect_filler = np.array([-1, -1, -1, -1, -1], dtype=np.int64) tm.assert_numpy_array_equal(filler, expect_filler) def test_pad(self): old = Index([1, 5, 10]) new = Index(lrange(12)) filler = libalgos.pad_int64(old.values, new.values) expect_filler = np.array([-1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2], dtype=np.int64) tm.assert_numpy_array_equal(filler, expect_filler) # corner case old = Index([5, 10]) new = Index(lrange(5)) filler = libalgos.pad_int64(old.values, new.values) expect_filler = np.array([-1, -1, -1, -1, -1], dtype=np.int64) tm.assert_numpy_array_equal(filler, expect_filler) def test_is_lexsorted(): failure = [ np.array([3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], dtype='int64'), np.array([30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0], dtype='int64')] assert (not libalgos.is_lexsorted(failure)) def test_groupsort_indexer(): a = np.random.randint(0, 1000, 100).astype(np.int64) b = np.random.randint(0, 1000, 100).astype(np.int64) result = libalgos.groupsort_indexer(a, 1000)[0] # need to use a stable sort # np.argsort returns int, groupsort_indexer # always returns int64 expected = np.argsort(a, kind='mergesort') expected = expected.astype(np.int64) tm.assert_numpy_array_equal(result, expected) # compare with lexsort # np.lexsort returns int, groupsort_indexer # always returns int64 key = a * 1000 + b result = libalgos.groupsort_indexer(key, 1000000)[0] expected = np.lexsort((b, a)) expected = expected.astype(np.int64) tm.assert_numpy_array_equal(result, expected) def test_infinity_sort(): # GH 13445 # numpy's argsort can be unhappy if something is less than # itself. Instead, let's give our infinities a self-consistent # ordering, but outside the float extended real line. Inf = libalgos.Infinity() NegInf = libalgos.NegInfinity() ref_nums = [NegInf, float("-inf"), -1e100, 0, 1e100, float("inf"), Inf] assert all(Inf >= x for x in ref_nums) assert all(Inf > x or x is Inf for x in ref_nums) assert Inf >= Inf and Inf == Inf assert not Inf < Inf and not Inf > Inf assert all(NegInf <= x for x in ref_nums) assert all(NegInf < x or x is NegInf for x in ref_nums) assert NegInf <= NegInf and NegInf == NegInf assert not NegInf < NegInf and not NegInf > NegInf for perm in permutations(ref_nums): assert sorted(perm) == ref_nums # smoke tests np.array([libalgos.Infinity()] * 32).argsort() np.array([libalgos.NegInfinity()] * 32).argsort() def test_ensure_platform_int(): arr = np.arange(100, dtype=np.intp) result = libalgos.ensure_platform_int(arr) assert (result is arr) def test_int64_add_overflow(): # see gh-14068 msg = "Overflow in int64 addition" m = np.iinfo(np.int64).max n = np.iinfo(np.int64).min with tm.assert_raises_regex(OverflowError, msg): algos.checked_add_with_arr(np.array([m, m]), m) with tm.assert_raises_regex(OverflowError, msg): algos.checked_add_with_arr(np.array([m, m]), np.array([m, m])) with tm.assert_raises_regex(OverflowError, msg): algos.checked_add_with_arr(np.array([n, n]), n) with tm.assert_raises_regex(OverflowError, msg): algos.checked_add_with_arr(np.array([n, n]), np.array([n, n])) with tm.assert_raises_regex(OverflowError, msg): algos.checked_add_with_arr(np.array([m, n]), np.array([n, n])) with tm.assert_raises_regex(OverflowError, msg): algos.checked_add_with_arr(np.array([m, m]), np.array([m, m]), arr_mask=np.array([False, True])) with tm.assert_raises_regex(OverflowError, msg): algos.checked_add_with_arr(np.array([m, m]), np.array([m, m]), b_mask=np.array([False, True])) with tm.assert_raises_regex(OverflowError, msg): algos.checked_add_with_arr(np.array([m, m]), np.array([m, m]), arr_mask=np.array([False, True]), b_mask=np.array([False, True])) with tm.assert_raises_regex(OverflowError, msg): with tm.assert_produces_warning(RuntimeWarning): algos.checked_add_with_arr(np.array([m, m]), np.array([np.nan, m])) # Check that the nan boolean arrays override whether or not # the addition overflows. We don't check the result but just # the fact that an OverflowError is not raised. with pytest.raises(AssertionError): with tm.assert_raises_regex(OverflowError, msg): algos.checked_add_with_arr(np.array([m, m]), np.array([m, m]), arr_mask=np.array([True, True])) with pytest.raises(AssertionError): with tm.assert_raises_regex(OverflowError, msg): algos.checked_add_with_arr(np.array([m, m]), np.array([m, m]), b_mask=np.array([True, True])) with pytest.raises(AssertionError): with tm.assert_raises_regex(OverflowError, msg): algos.checked_add_with_arr(np.array([m, m]), np.array([m, m]), arr_mask=np.array([True, False]), b_mask=np.array([False, True])) class TestMode(object): def test_no_mode(self): exp = Series([], dtype=np.float64) tm.assert_series_equal(algos.mode([]), exp) def test_mode_single(self): # GH 15714 exp_single = [1] data_single = [1] exp_multi = [1] data_multi = [1, 1] for dt in np.typecodes['AllInteger'] + np.typecodes['Float']: s = Series(data_single, dtype=dt) exp = Series(exp_single, dtype=dt) tm.assert_series_equal(algos.mode(s), exp) s = Series(data_multi, dtype=dt) exp = Series(exp_multi, dtype=dt) tm.assert_series_equal(algos.mode(s), exp) exp = Series([1], dtype=np.int) tm.assert_series_equal(algos.mode([1]), exp) exp = Series(['a', 'b', 'c'], dtype=np.object) tm.assert_series_equal(algos.mode(['a', 'b', 'c']), exp) def test_number_mode(self): exp_single = [1] data_single = [1] * 5 + [2] * 3 exp_multi = [1, 3] data_multi = [1] * 5 + [2] * 3 + [3] * 5 for dt in np.typecodes['AllInteger'] + np.typecodes['Float']: s = Series(data_single, dtype=dt) exp = Series(exp_single, dtype=dt) tm.assert_series_equal(algos.mode(s), exp) s = Series(data_multi, dtype=dt) exp = Series(exp_multi, dtype=dt) tm.assert_series_equal(algos.mode(s), exp) def test_strobj_mode(self): exp = ['b'] data = ['a'] * 2 + ['b'] * 3 s = Series(data, dtype='c') exp = Series(exp, dtype='c') tm.assert_series_equal(algos.mode(s), exp) exp = ['bar'] data = ['foo'] * 2 + ['bar'] * 3 for dt in [str, object]: s = Series(data, dtype=dt) exp = Series(exp, dtype=dt) tm.assert_series_equal(algos.mode(s), exp) def test_datelike_mode(self): exp = Series(['1900-05-03', '2011-01-03', '2013-01-02'], dtype="M8[ns]") s = Series(['2011-01-03', '2013-01-02', '1900-05-03'], dtype='M8[ns]') tm.assert_series_equal(algos.mode(s), exp) exp = Series(['2011-01-03', '2013-01-02'], dtype='M8[ns]') s = Series(['2011-01-03', '2013-01-02', '1900-05-03', '2011-01-03', '2013-01-02'], dtype='M8[ns]') tm.assert_series_equal(algos.mode(s), exp) def test_timedelta_mode(self): exp = Series(['-1 days', '0 days', '1 days'], dtype='timedelta64[ns]') s = Series(['1 days', '-1 days', '0 days'], dtype='timedelta64[ns]') tm.assert_series_equal(algos.mode(s), exp) exp = Series(['2 min', '1 day'], dtype='timedelta64[ns]') s = Series(['1 day', '1 day', '-1 day', '-1 day 2 min', '2 min', '2 min'], dtype='timedelta64[ns]') tm.assert_series_equal(algos.mode(s), exp) def test_mixed_dtype(self): exp = Series(['foo']) s = Series([1, 'foo', 'foo']) tm.assert_series_equal(algos.mode(s), exp) def test_uint64_overflow(self): exp = Series([2**63], dtype=np.uint64) s = Series([1, 2**63, 2**63], dtype=np.uint64) tm.assert_series_equal(algos.mode(s), exp) exp = Series([1, 2**63], dtype=np.uint64) s = Series([1, 2**63], dtype=np.uint64) tm.assert_series_equal(algos.mode(s), exp) def test_categorical(self): c = Categorical([1, 2]) exp = c tm.assert_categorical_equal(algos.mode(c), exp) tm.assert_categorical_equal(c.mode(), exp) c = Categorical([1, 'a', 'a']) exp = Categorical(['a'], categories=[1, 'a']) tm.assert_categorical_equal(algos.mode(c), exp) tm.assert_categorical_equal(c.mode(), exp) c = Categorical([1, 1, 2, 3, 3]) exp = Categorical([1, 3], categories=[1, 2, 3]) tm.assert_categorical_equal(algos.mode(c), exp) tm.assert_categorical_equal(c.mode(), exp) def test_index(self): idx = Index([1, 2, 3]) exp = Series([1, 2, 3], dtype=np.int64) tm.assert_series_equal(algos.mode(idx), exp) idx = Index([1, 'a', 'a']) exp = Series(['a'], dtype=object) tm.assert_series_equal(algos.mode(idx), exp) idx = Index([1, 1, 2, 3, 3]) exp = Series([1, 3], dtype=np.int64) tm.assert_series_equal(algos.mode(idx), exp) exp = Series(['2 min', '1 day'], dtype='timedelta64[ns]') idx = Index(['1 day', '1 day', '-1 day', '-1 day 2 min', '2 min', '2 min'], dtype='timedelta64[ns]') tm.assert_series_equal(algos.mode(idx), exp)
bsd-3-clause
IshankGulati/scikit-learn
sklearn/ensemble/tests/test_iforest.py
13
7616
""" Testing for Isolation Forest algorithm (sklearn.ensemble.iforest). """ # Authors: Nicolas Goix <[email protected]> # Alexandre Gramfort <[email protected]> # License: BSD 3 clause import numpy as np from sklearn.utils.testing import assert_array_equal from sklearn.utils.testing import assert_array_almost_equal from sklearn.utils.testing import assert_raises from sklearn.utils.testing import assert_warns_message from sklearn.utils.testing import assert_equal from sklearn.utils.testing import assert_no_warnings from sklearn.utils.testing import assert_greater from sklearn.utils.testing import ignore_warnings from sklearn.model_selection import ParameterGrid from sklearn.ensemble import IsolationForest from sklearn.model_selection import train_test_split from sklearn.datasets import load_boston, load_iris from sklearn.utils import check_random_state from sklearn.metrics import roc_auc_score from scipy.sparse import csc_matrix, csr_matrix rng = check_random_state(0) # load the iris dataset # and randomly permute it iris = load_iris() perm = rng.permutation(iris.target.size) iris.data = iris.data[perm] iris.target = iris.target[perm] # also load the boston dataset # and randomly permute it boston = load_boston() perm = rng.permutation(boston.target.size) boston.data = boston.data[perm] boston.target = boston.target[perm] def test_iforest(): """Check Isolation Forest for various parameter settings.""" X_train = np.array([[0, 1], [1, 2]]) X_test = np.array([[2, 1], [1, 1]]) grid = ParameterGrid({"n_estimators": [3], "max_samples": [0.5, 1.0, 3], "bootstrap": [True, False]}) with ignore_warnings(): for params in grid: IsolationForest(random_state=rng, **params).fit(X_train).predict(X_test) def test_iforest_sparse(): """Check IForest for various parameter settings on sparse input.""" rng = check_random_state(0) X_train, X_test, y_train, y_test = train_test_split(boston.data[:50], boston.target[:50], random_state=rng) grid = ParameterGrid({"max_samples": [0.5, 1.0], "bootstrap": [True, False]}) for sparse_format in [csc_matrix, csr_matrix]: X_train_sparse = sparse_format(X_train) X_test_sparse = sparse_format(X_test) for params in grid: # Trained on sparse format sparse_classifier = IsolationForest( n_estimators=10, random_state=1, **params).fit(X_train_sparse) sparse_results = sparse_classifier.predict(X_test_sparse) # Trained on dense format dense_classifier = IsolationForest( n_estimators=10, random_state=1, **params).fit(X_train) dense_results = dense_classifier.predict(X_test) assert_array_equal(sparse_results, dense_results) assert_array_equal(sparse_results, dense_results) def test_iforest_error(): """Test that it gives proper exception on deficient input.""" X = iris.data # Test max_samples assert_raises(ValueError, IsolationForest(max_samples=-1).fit, X) assert_raises(ValueError, IsolationForest(max_samples=0.0).fit, X) assert_raises(ValueError, IsolationForest(max_samples=2.0).fit, X) # The dataset has less than 256 samples, explicitly setting # max_samples > n_samples should result in a warning. If not set # explicitly there should be no warning assert_warns_message(UserWarning, "max_samples will be set to n_samples for estimation", IsolationForest(max_samples=1000).fit, X) assert_no_warnings(IsolationForest(max_samples='auto').fit, X) assert_no_warnings(IsolationForest(max_samples=np.int64(2)).fit, X) assert_raises(ValueError, IsolationForest(max_samples='foobar').fit, X) assert_raises(ValueError, IsolationForest(max_samples=1.5).fit, X) def test_recalculate_max_depth(): """Check max_depth recalculation when max_samples is reset to n_samples""" X = iris.data clf = IsolationForest().fit(X) for est in clf.estimators_: assert_equal(est.max_depth, int(np.ceil(np.log2(X.shape[0])))) def test_max_samples_attribute(): X = iris.data clf = IsolationForest().fit(X) assert_equal(clf.max_samples_, X.shape[0]) clf = IsolationForest(max_samples=500) assert_warns_message(UserWarning, "max_samples will be set to n_samples for estimation", clf.fit, X) assert_equal(clf.max_samples_, X.shape[0]) clf = IsolationForest(max_samples=0.4).fit(X) assert_equal(clf.max_samples_, 0.4*X.shape[0]) def test_iforest_parallel_regression(): """Check parallel regression.""" rng = check_random_state(0) X_train, X_test, y_train, y_test = train_test_split(boston.data, boston.target, random_state=rng) ensemble = IsolationForest(n_jobs=3, random_state=0).fit(X_train) ensemble.set_params(n_jobs=1) y1 = ensemble.predict(X_test) ensemble.set_params(n_jobs=2) y2 = ensemble.predict(X_test) assert_array_almost_equal(y1, y2) ensemble = IsolationForest(n_jobs=1, random_state=0).fit(X_train) y3 = ensemble.predict(X_test) assert_array_almost_equal(y1, y3) def test_iforest_performance(): """Test Isolation Forest performs well""" # Generate train/test data rng = check_random_state(2) X = 0.3 * rng.randn(120, 2) X_train = np.r_[X + 2, X - 2] X_train = X[:100] # Generate some abnormal novel observations X_outliers = rng.uniform(low=-4, high=4, size=(20, 2)) X_test = np.r_[X[100:], X_outliers] y_test = np.array([0] * 20 + [1] * 20) # fit the model clf = IsolationForest(max_samples=100, random_state=rng).fit(X_train) # predict scores (the lower, the more normal) y_pred = - clf.decision_function(X_test) # check that there is at most 6 errors (false positive or false negative) assert_greater(roc_auc_score(y_test, y_pred), 0.98) def test_iforest_works(): # toy sample (the last two samples are outliers) X = [[-2, -1], [-1, -1], [-1, -2], [1, 1], [1, 2], [2, 1], [6, 3], [-4, 7]] # Test LOF clf = IsolationForest(random_state=rng, contamination=0.25) clf.fit(X) decision_func = - clf.decision_function(X) pred = clf.predict(X) # assert detect outliers: assert_greater(np.min(decision_func[-2:]), np.max(decision_func[:-2])) assert_array_equal(pred, 6 * [1] + 2 * [-1]) def test_max_samples_consistency(): # Make sure validated max_samples in iforest and BaseBagging are identical X = iris.data clf = IsolationForest().fit(X) assert_equal(clf.max_samples_, clf._max_samples) def test_iforest_subsampled_features(): # It tests non-regression for #5732 which failed at predict. rng = check_random_state(0) X_train, X_test, y_train, y_test = train_test_split(boston.data[:50], boston.target[:50], random_state=rng) clf = IsolationForest(max_features=0.8) clf.fit(X_train, y_train) clf.predict(X_test)
bsd-3-clause
BeiLuoShiMen/nupic
external/linux32/lib/python2.6/site-packages/matplotlib/pylab.py
70
10245
""" This is a procedural interface to the matplotlib object-oriented plotting library. The following plotting commands are provided; the majority have Matlab(TM) analogs and similar argument. _Plotting commands acorr - plot the autocorrelation function annotate - annotate something in the figure arrow - add an arrow to the axes axes - Create a new axes axhline - draw a horizontal line across axes axvline - draw a vertical line across axes axhspan - draw a horizontal bar across axes axvspan - draw a vertical bar across axes axis - Set or return the current axis limits bar - make a bar chart barh - a horizontal bar chart broken_barh - a set of horizontal bars with gaps box - set the axes frame on/off state boxplot - make a box and whisker plot cla - clear current axes clabel - label a contour plot clf - clear a figure window clim - adjust the color limits of the current image close - close a figure window colorbar - add a colorbar to the current figure cohere - make a plot of coherence contour - make a contour plot contourf - make a filled contour plot csd - make a plot of cross spectral density delaxes - delete an axes from the current figure draw - Force a redraw of the current figure errorbar - make an errorbar graph figlegend - make legend on the figure rather than the axes figimage - make a figure image figtext - add text in figure coords figure - create or change active figure fill - make filled polygons findobj - recursively find all objects matching some criteria gca - return the current axes gcf - return the current figure gci - get the current image, or None getp - get a handle graphics property grid - set whether gridding is on hist - make a histogram hold - set the axes hold state ioff - turn interaction mode off ion - turn interaction mode on isinteractive - return True if interaction mode is on imread - load image file into array imshow - plot image data ishold - return the hold state of the current axes legend - make an axes legend loglog - a log log plot matshow - display a matrix in a new figure preserving aspect pcolor - make a pseudocolor plot pcolormesh - make a pseudocolor plot using a quadrilateral mesh pie - make a pie chart plot - make a line plot plot_date - plot dates plotfile - plot column data from an ASCII tab/space/comma delimited file pie - pie charts polar - make a polar plot on a PolarAxes psd - make a plot of power spectral density quiver - make a direction field (arrows) plot rc - control the default params rgrids - customize the radial grids and labels for polar savefig - save the current figure scatter - make a scatter plot setp - set a handle graphics property semilogx - log x axis semilogy - log y axis show - show the figures specgram - a spectrogram plot spy - plot sparsity pattern using markers or image stem - make a stem plot subplot - make a subplot (numrows, numcols, axesnum) subplots_adjust - change the params controlling the subplot positions of current figure subplot_tool - launch the subplot configuration tool suptitle - add a figure title table - add a table to the plot text - add some text at location x,y to the current axes thetagrids - customize the radial theta grids and labels for polar title - add a title to the current axes xcorr - plot the autocorrelation function of x and y xlim - set/get the xlimits ylim - set/get the ylimits xticks - set/get the xticks yticks - set/get the yticks xlabel - add an xlabel to the current axes ylabel - add a ylabel to the current axes autumn - set the default colormap to autumn bone - set the default colormap to bone cool - set the default colormap to cool copper - set the default colormap to copper flag - set the default colormap to flag gray - set the default colormap to gray hot - set the default colormap to hot hsv - set the default colormap to hsv jet - set the default colormap to jet pink - set the default colormap to pink prism - set the default colormap to prism spring - set the default colormap to spring summer - set the default colormap to summer winter - set the default colormap to winter spectral - set the default colormap to spectral _Event handling connect - register an event handler disconnect - remove a connected event handler _Matrix commands cumprod - the cumulative product along a dimension cumsum - the cumulative sum along a dimension detrend - remove the mean or besdt fit line from an array diag - the k-th diagonal of matrix diff - the n-th differnce of an array eig - the eigenvalues and eigen vectors of v eye - a matrix where the k-th diagonal is ones, else zero find - return the indices where a condition is nonzero fliplr - flip the rows of a matrix up/down flipud - flip the columns of a matrix left/right linspace - a linear spaced vector of N values from min to max inclusive logspace - a log spaced vector of N values from min to max inclusive meshgrid - repeat x and y to make regular matrices ones - an array of ones rand - an array from the uniform distribution [0,1] randn - an array from the normal distribution rot90 - rotate matrix k*90 degress counterclockwise squeeze - squeeze an array removing any dimensions of length 1 tri - a triangular matrix tril - a lower triangular matrix triu - an upper triangular matrix vander - the Vandermonde matrix of vector x svd - singular value decomposition zeros - a matrix of zeros _Probability levypdf - The levy probability density function from the char. func. normpdf - The Gaussian probability density function rand - random numbers from the uniform distribution randn - random numbers from the normal distribution _Statistics corrcoef - correlation coefficient cov - covariance matrix amax - the maximum along dimension m mean - the mean along dimension m median - the median along dimension m amin - the minimum along dimension m norm - the norm of vector x prod - the product along dimension m ptp - the max-min along dimension m std - the standard deviation along dimension m asum - the sum along dimension m _Time series analysis bartlett - M-point Bartlett window blackman - M-point Blackman window cohere - the coherence using average periodiogram csd - the cross spectral density using average periodiogram fft - the fast Fourier transform of vector x hamming - M-point Hamming window hanning - M-point Hanning window hist - compute the histogram of x kaiser - M length Kaiser window psd - the power spectral density using average periodiogram sinc - the sinc function of array x _Dates date2num - convert python datetimes to numeric representation drange - create an array of numbers for date plots num2date - convert numeric type (float days since 0001) to datetime _Other angle - the angle of a complex array griddata - interpolate irregularly distributed data to a regular grid load - load ASCII data into array polyfit - fit x, y to an n-th order polynomial polyval - evaluate an n-th order polynomial roots - the roots of the polynomial coefficients in p save - save an array to an ASCII file trapz - trapezoidal integration __end """ import sys, warnings from cbook import flatten, is_string_like, exception_to_str, popd, \ silent_list, iterable, dedent import numpy as np from numpy import ma from matplotlib import mpl # pulls in most modules from matplotlib.dates import date2num, num2date,\ datestr2num, strpdate2num, drange,\ epoch2num, num2epoch, mx2num,\ DateFormatter, IndexDateFormatter, DateLocator,\ RRuleLocator, YearLocator, MonthLocator, WeekdayLocator,\ DayLocator, HourLocator, MinuteLocator, SecondLocator,\ rrule, MO, TU, WE, TH, FR, SA, SU, YEARLY, MONTHLY,\ WEEKLY, DAILY, HOURLY, MINUTELY, SECONDLY, relativedelta import matplotlib.dates # bring all the symbols in so folks can import them from # pylab in one fell swoop from matplotlib.mlab import window_hanning, window_none,\ conv, detrend, detrend_mean, detrend_none, detrend_linear,\ polyfit, polyval, entropy, normpdf, griddata,\ levypdf, find, trapz, prepca, rem, norm, orth, rank,\ sqrtm, prctile, center_matrix, rk4, exp_safe, amap,\ sum_flat, mean_flat, rms_flat, l1norm, l2norm, norm, frange,\ diagonal_matrix, base_repr, binary_repr, log2, ispower2,\ bivariate_normal, load, save from matplotlib.mlab import stineman_interp, slopes, \ stineman_interp, inside_poly, poly_below, poly_between, \ is_closed_polygon, path_length, distances_along_curve, vector_lengths from numpy import * from numpy.fft import * from numpy.random import * from numpy.linalg import * from matplotlib.mlab import window_hanning, window_none, conv, detrend, demean, \ detrend_mean, detrend_none, detrend_linear, entropy, normpdf, levypdf, \ find, longest_contiguous_ones, longest_ones, prepca, prctile, prctile_rank, \ center_matrix, rk4, bivariate_normal, get_xyz_where, get_sparse_matrix, dist, \ dist_point_to_segment, segments_intersect, fftsurr, liaupunov, movavg, \ save, load, exp_safe, \ amap, rms_flat, l1norm, l2norm, norm_flat, frange, diagonal_matrix, identity, \ base_repr, binary_repr, log2, ispower2, fromfunction_kw, rem, norm, orth, rank, sqrtm,\ mfuncC, approx_real, rec_append_field, rec_drop_fields, rec_join, csv2rec, rec2csv, isvector from matplotlib.pyplot import * # provide the recommended module abbrevs in the pylab namespace import matplotlib.pyplot as plt import numpy as np
agpl-3.0
abele/bokeh
examples/compat/mpl/subplots.py
34
1826
""" Edward Tufte uses this example from Anscombe to show 4 datasets of x and y that have the same mean, standard deviation, and regression line, but which are qualitatively different. matplotlib fun for a rainy day """ import matplotlib.pyplot as plt import numpy as np from bokeh import mpl from bokeh.plotting import output_file, show x = np.array([10, 8, 13, 9, 11, 14, 6, 4, 12, 7, 5]) y1 = np.array([8.04, 6.95, 7.58, 8.81, 8.33, 9.96, 7.24, 4.26, 10.84, 4.82, 5.68]) y2 = np.array([9.14, 8.14, 8.74, 8.77, 9.26, 8.10, 6.13, 3.10, 9.13, 7.26, 4.74]) y3 = np.array([7.46, 6.77, 12.74, 7.11, 7.81, 8.84, 6.08, 5.39, 8.15, 6.42, 5.73]) x4 = np.array([8, 8, 8, 8, 8, 8, 8, 19, 8, 8, 8]) y4 = np.array([6.58, 5.76, 7.71, 8.84, 8.47, 7.04, 5.25, 12.50, 5.56, 7.91, 6.89]) def fit(x): return 3 + 0.5 * x xfit = np.linspace(np.amin(x), np.amax(x), len(x)) plt.subplot(221) plt.plot(x, y1, 'ks', xfit, fit(xfit), 'r-', lw=2) plt.axis([2, 20, 2, 14]) plt.setp(plt.gca(), xticklabels=[], yticks=(4, 8, 12), xticks=(0, 10, 20)) plt.ylabel('I', fontsize=20) plt.subplot(222) plt.plot(x, y2, 'ks', xfit, fit(xfit), 'r-', lw=2) plt.axis([2, 20, 2, 14]) plt.setp(plt.gca(), xticklabels=[], yticks=(4, 8, 12), yticklabels=[], xticks=(0, 10, 20)) plt.ylabel('II', fontsize=20) plt.subplot(223) plt.plot(x, y3, 'ks', xfit, fit(xfit), 'r-', lw=2) plt.axis([2, 20, 2, 14]) plt.ylabel('III', fontsize=20) plt.setp(plt.gca(), yticks=(4, 8, 12), xticks=(0, 10, 20)) plt.subplot(224) xfit = np.array([np.amin(x4), np.amax(x4)]) plt.plot(x4, y4, 'ks', xfit, fit(xfit), 'r-', lw=2) plt.axis([2, 20, 2, 14]) plt.setp(plt.gca(), yticklabels=[], yticks=(4, 8, 12), xticks=(0, 10, 20)) plt.ylabel('IV', fontsize=20) # We create the figure in matplotlib and then we "pass it" to Bokeh output_file("subplots.html") show(mpl.to_bokeh())
bsd-3-clause
mehdidc/scikit-learn
sklearn/metrics/cluster/tests/test_bicluster.py
394
1770
"""Testing for bicluster metrics module""" import numpy as np from sklearn.utils.testing import assert_equal, assert_almost_equal from sklearn.metrics.cluster.bicluster import _jaccard from sklearn.metrics import consensus_score def test_jaccard(): a1 = np.array([True, True, False, False]) a2 = np.array([True, True, True, True]) a3 = np.array([False, True, True, False]) a4 = np.array([False, False, True, True]) assert_equal(_jaccard(a1, a1, a1, a1), 1) assert_equal(_jaccard(a1, a1, a2, a2), 0.25) assert_equal(_jaccard(a1, a1, a3, a3), 1.0 / 7) assert_equal(_jaccard(a1, a1, a4, a4), 0) def test_consensus_score(): a = [[True, True, False, False], [False, False, True, True]] b = a[::-1] assert_equal(consensus_score((a, a), (a, a)), 1) assert_equal(consensus_score((a, a), (b, b)), 1) assert_equal(consensus_score((a, b), (a, b)), 1) assert_equal(consensus_score((a, b), (b, a)), 1) assert_equal(consensus_score((a, a), (b, a)), 0) assert_equal(consensus_score((a, a), (a, b)), 0) assert_equal(consensus_score((b, b), (a, b)), 0) assert_equal(consensus_score((b, b), (b, a)), 0) def test_consensus_score_issue2445(): ''' Different number of biclusters in A and B''' a_rows = np.array([[True, True, False, False], [False, False, True, True], [False, False, False, True]]) a_cols = np.array([[True, True, False, False], [False, False, True, True], [False, False, False, True]]) idx = [0, 2] s = consensus_score((a_rows, a_cols), (a_rows[idx], a_cols[idx])) # B contains 2 of the 3 biclusters in A, so score should be 2/3 assert_almost_equal(s, 2.0/3.0)
bsd-3-clause
rangwala/dmgrader
gradingwebapp/gmugrader/fileuploader/views.py
1
21915
from django.http import HttpResponseRedirect,HttpResponse from django.core.urlresolvers import reverse from django.template import loader from django.shortcuts import render_to_response, render, get_object_or_404 from django.core.context_processors import csrf from django.conf import settings from .forms import submissionAssignmentForm, submissionForm, AssignmentForm, ArticleForm, UserForm, ClassForm # UserProfileForm from .models import Article, Assignment, Solution, Class from django.template import RequestContext from django.contrib import auth from django.contrib.auth.decorators import login_required from django.contrib.admin.views.decorators import staff_member_required from sklearn import metrics, cross_validation import numpy as np import matplotlib.pyplot as plt import datetime from django.utils import timezone from datetime import datetime, timedelta from django.db.models import Max, Min def computeSampledMetrics (predfile, solfile,samplesize,scoring_method): myPredFile = open (settings.MEDIA_ROOT + str(predfile), 'r') #myPredFile = open (settings.MEDIA_ROOT + '/solution_files/sol.txt', 'r') myTrueFile = open (settings.MEDIA_ROOT + str(solfile), 'r') predictions = [] ground = [] for predline in myPredFile: predictions.append(predline) for trueline in myTrueFile: ground.append(trueline) ground = np.array (ground) predictions= np.array (predictions) rs = cross_validation.ShuffleSplit (len(ground), n_iter=1, test_size=0.01 * samplesize, random_state=0) for train_index, test_index in rs: sample_ground = ground [test_index] sample_predictions = predictions [test_index] #print np.mean (sample_ground == sample_predictions) #print metrics.classification_report (sample_ground, sample_predictions) #return metrics.f1_score (sample_ground,sample_predictions, pos_label=1) if scoring_method == 'RE' or scoring_method == 'RC': ypred = np.array (sample_predictions, dtype=np.float) if scoring_method == 'RE': ytrue = np.array (sample_ground, dtype=np.float) else: ytrue = np.array (sample_ground,dtype=np.int) else: ytrue = np.array(sample_ground,dtype=np.int) ypred = np.array(sample_predictions,dtype=np.int) if scoring_method == 'F1': return metrics.f1_score(ytrue,ypred,pos_label=1) if scoring_method == 'AC': return metrics.accuracy_score(ytrue, ypred) if scoring_method == 'V1': return metrics.v_measure_score(ytrue, ypred) if scoring_method == 'RE': return metrics.mean_squared_error (ytrue, ypred) ** 0.5 if scoring_method == 'RC': return metrics.roc_auc_score (ytrue, ypred) # return metrics.accuracy_score(sample_ground, sample_predictions) """ corr = 0 for i in range (len(ground)): if (ground[i] == predictions[i]): corr = corr+1; print corr myPredFile.close() myTrueFile.close() return (1.0 * corr)/len(ground) """ def computeMetrics (predfile, solfile, scoring_method): myPredFile = open (settings.MEDIA_ROOT + str(predfile), 'r') #myPredFile = open (settings.MEDIA_ROOT + '/solution_files/sol.txt', 'r') myTrueFile = open (settings.MEDIA_ROOT + str(solfile), 'r') predictions = [] ground = [] for predline in myPredFile: predictions.append(predline) for trueline in myTrueFile: ground.append(trueline) if len(predictions) != len(ground): return -100.0 else: #print np.mean (ground == predictions) #print metrics.classification_report (ground, predictions) print ("Hi") if scoring_method == 'RE' or scoring_method == 'RC': ypred = np.array (predictions, dtype=np.float) if scoring_method == 'RE': ytrue = np.array (ground, dtype=np.float) else: ytrue = np.array (ground, dtype=np.int) else: ytrue = np.array(ground,dtype=np.int) ypred = np.array(predictions,dtype=np.int) if scoring_method == 'F1': return metrics.f1_score(ytrue,ypred,pos_label=1) if scoring_method == 'AC': return metrics.accuracy_score(ytrue, ypred) if scoring_method == 'V1': return metrics.v_measure_score(ytrue, ypred) if scoring_method == 'RE': return metrics.mean_squared_error (ytrue, ypred) ** 0.5 if scoring_method == 'RC': return metrics.roc_auc_score (ytrue, ypred) """ corr = 0 for i in range (len(ground)): if (ground[i] == predictions[i]): corr = corr+1; print corr myPredFile.close() myTrueFile.close() return (1.0 * corr)/len(ground) """ def get_accuracy_value (filename): myPredFile = open (settings.MEDIA_ROOT + str(filename), 'r') #myPredFile = open (settings.MEDIA_ROOT + '/solution_files/sol.txt', 'r') myTrueFile = open (settings.MEDIA_ROOT + '/solution_files/sol.txt', 'r') predictions = [] ground = [] for predline in myPredFile: predictions.append(predline) for trueline in myTrueFile: ground.append(trueline) corr = 0 for i in range (len(ground)): if (ground[i] == predictions[i]): corr = corr+1; #print corr myPredFile.close() myTrueFile.close() return (1.0 * corr)/len(ground) def index(request): form = ArticleForm() args = {} args.update(csrf(request)) args['form'] = form return render_to_response('fileuploader/create_article.html',args) def articles(request): if not request.user.is_authenticated(): return HttpResponseRedirect('/fileuploader/login/') #username = request.POST.get('username') #password = request.POST.get('password') #user = authenticate(username=username, password=password) args = {} args.update(csrf(request)) args['articles'] = Article.objects.all() return render_to_response('fileuploader/articles.html',args) #def login(request,user): def login (request): c={} c.update(csrf(request)) return render_to_response('login.html',c) def auth_view (request): username = request.POST.get('username') password = request.POST.get('password') user = auth.authenticate(username=username, password=password) #print user, username, password if user is not None: auth.login(request,user) args={} args.update(csrf(request)) args['user'] = user return render_to_response('loggedin.html',args) else: return HttpResponseRedirect('/fileuploader/invalid') @login_required def loggedin(request): args = {} args.update (csrf (request)) args['user'] = request.user return render_to_response('loggedin.html', args) def invalid_login(request): return render_to_response('invalid_login.html') def logout_page(request): """ Log users out and re-direct them to the main page. """ auth.logout(request) return render_to_response('logout.html') def computescores (request): args = {} args.update(csrf(request)) #args['articles'] = Article.objects.filter(title='aaa').update(accuracy=get_accuracy_value(Article.fileshot.filename)) obj1 = Article.objects.filter(accuracy=0.0) for items in obj1: items.accuracy = get_accuracy_value (items.fileshot) items.save() args['articles'] = obj1 return render_to_response('fileuploader/computescores.html', args) # this is only allowable by the ADMIN/INSTRUCTOR @staff_member_required def createAssignment (request): if request.POST: form = AssignmentForm (request.POST, request.FILES) if form.is_valid(): a = form.save() return HttpResponseRedirect('viewAssignments.html') else: form = AssignmentForm() args = {} args.update(csrf(request)) args['form'] = form return render_to_response('fileuploader/createAssignment.html',args) @login_required def viewErrorMessage(request,message): args = {} args['message'] = message args['user'] = request.user return render_to_response ('fileuploader/viewErrorMessage.html', args) @login_required def submitChosenAssignment (request,assignment_id): if request.POST: form = submissionAssignmentForm(request.POST, request.FILES) if form.is_valid(): a = form.save(commit=False) a.user = request.user #print a.user assignment = get_object_or_404 (Assignment, pk = assignment_id) if timezone.now() > assignment.deadline_date: htmlmessage = "Past Deadline Date" args = {} args.update (csrf (request)) args['message'] = htmlmessage args['user'] = request.user return render_to_response ('fileuploader/viewErrorMessage.html',args) min_dt = timezone.now () - timedelta (hours=24) max_dt = timezone.now() previous_today = Solution.objects.filter(assignment=assignment_id,user=a.user,status='OK',submission_time__range = (min_dt,max_dt)).count() #submission_time > (timezone.now()-timedelta(1))) if previous_today >= assignment.num_subs_per_day: htmlmessage = "You have already submitted the allowed submissions in a 24-hour cycle" args = {} args.update (csrf (request)) args['message'] = htmlmessage args['user'] = request.user return render_to_response ('fileuploader/viewErrorMessage.html',args) truthFile = assignment.ground_truth a.assignment = assignment a.save() # update the counter # also update the score obj1 = Assignment.objects.get(pk = a.assignment_id) #.update(uploaded_cnt = uploaded_cnt + 1) truthFile = obj1.ground_truth scorer = obj1.scoring_method obj1.uploaded_cnt = obj1.uploaded_cnt + 1 counter = obj1.uploaded_cnt obj1.save() # gets all the files back... # we need a table of student - attempts - etc obj2 = Solution.objects.filter (assignment = a.assignment) #print len(obj2) for items in obj2: if items.solution_file == a.solution_file: items.attempt = counter items.score = computeMetrics (items.solution_file, truthFile,scorer) flag_save = 1 if items.score == -100: htmlmessage = "Your Prediction File has incorrect number of entries" args = {} args.update (csrf (request)) args['message'] = htmlmessage args['user'] = request.user return render_to_response ('fileuploader/viewErrorMessage.html',args) #return HttpResponse(htmlmessage) else: items.submission_time = timezone.now() items.status = 'OK' #Compute the Public_SCORE items.public_score = computeSampledMetrics (items.solution_file, truthFile, obj1.sampling_private,scorer) items.save() args={} args.update (csrf (request)) #create a splash page args['user'] = request.user return render_to_response('fileuploader/thanksSubmissions.html',args) #return render_to_response('fileuploader/viewSubmissions.html',args) else: assignment = get_object_or_404 (Assignment, pk = assignment_id) form = submissionAssignmentForm() args = {} args.update(csrf (request)) args['form'] = form args['assignment'] = assignment args['user'] = request.user #return HttpResponseRedirect('viewSubmissions.html') return render_to_response('fileuploader/submitChosenAssignment.html',args) #@login_required #def submitAssignment (request): # if request.POST: # form = submissionForm(request.POST, request.FILES) # if form.is_valid(): # a = form.save(commit=False) # a.user = request.user # print a.user # a.save() # update the counter # also update the score # obj1 = Assignment.objects.filter(name = a.assignment) #.update(uploaded_cnt = uploaded_cnt + 1) # for items in obj1: # items.uploaded_cnt = items.uploaded_cnt + 1 # counter = items.uploaded_cnt # truthFile = items.ground_truth # items.save() # gets all the files back... # we need a table of student - attempts - etc # obj2 = Solution.objects.filter (assignment = a.assignment) # for items in obj2: # if items.solution_file == a.solution_file: # items.attempt = counter # items.score = computeMetrics (items.solution_file, truthFile) # items.save() # return HttpResponseRedirect('viewSubmissions.html') # else: # form = submissionForm() # args = {} # args.update(csrf (request)) # args['form'] = form # return render_to_response('fileuploader/submitAssignment.html',args) #''' def thanksSubmissions (request): return render_to_response ('fileuploader/thanksSubmissions.html') @staff_member_required def viewSubmissions (request): args = {} args.update (csrf (request)) args['solutions'] = Solution.objects.all () return render_to_response ('fileuploader/viewSubmissions.html', args) @login_required def selectClass (request): if request.POST: form = ClassForm (request.POST) if form.is_valid(): a = form.save(commit=False) a.user = request.user a.save() return HttpResponseRedirect('viewAssignments.html') else: form = ClassForm() args = {} args.update(csrf(request)) args['form'] = form return render_to_response('fileuploader/selectClass.html',args) @login_required def viewAssignments (request): args = {} args.update(csrf(request)) current_user = request.user sc=Class.objects.filter(user=current_user) if sc.count() == 1: section = Class.objects.get(user=current_user) else: if sc.count () == 0: return HttpResponseRedirect('/fileuploader/selectClass.html') #return render_to_response('fileuploader/selectClass.html',args) else: htmlmessage = "Class Chosen Already - Contact Instructor or Create a New User Account" args = {} args.update (csrf (request)) args['message'] = htmlmessage args['user'] = request.user return render_to_response ('fileuploader/viewErrorMessage.html',args) if request.user.is_superuser: args['assignments'] = Assignment.objects.all() else: args['assignments'] = Assignment.objects.all().filter(hidden_status = 0,class_name=section.classnum) #UTC TIME args['currenttime'] = datetime.datetime.now() args['currenttime'] = timezone.now() args['user'] = request.user return render_to_response('fileuploader/viewAssignments.html',args) @staff_member_required def viewPrivateRankings (request, assignment_id): args = {} args.update (csrf (request)) assignment = get_object_or_404 (Assignment, pk = assignment_id) args ['assignment'] = assignment subset_entries = Solution.objects.filter (assignment=assignment_id).filter(status = "OK").order_by('user','-submission_time') u = "None" leaderboard = [] i = 0 for entry in subset_entries: if entry.user != u: u = entry.user leaderboard.append(entry) i = i + 1 if assignment.scoring_method == 'RE': leaderboard.sort(key = lambda x: x.score) else: leaderboard.sort(key = lambda x: x.score, reverse=True) args['submissions'] = leaderboard return render (request, 'fileuploader/viewPrivateRankings.html', args) #student view @login_required def viewPublicRankings (request, assignment_id): args = {} args.update (csrf (request)) assignment = get_object_or_404 (Assignment, pk = assignment_id) args ['assignment'] = assignment subset_entries = Solution.objects.filter (assignment=assignment_id).filter(status = "OK").order_by('user','-submission_time') u = "None" leaderboard = [] i = 0 for entry in subset_entries: if entry.user != u: u = entry.user leaderboard.append(entry) i = i + 1 if assignment.scoring_method == 'RE': leaderboard.sort(key = lambda x: x.public_score) else: leaderboard.sort(key = lambda x: x.public_score, reverse=True) args['submissions'] = leaderboard return render (request, 'fileuploader/viewPublicRankings.html', args) #student view of Assignments #for download #seeing his own submissions @staff_member_required def viewSubmissionLogs (request, assignment_id): args = {} args.update (csrf (request)) assignment = get_object_or_404 (Assignment, pk = assignment_id) args ['assignment'] = assignment args['user'] = request.user args['submissions'] = Solution.objects.filter (assignment = assignment_id,status='OK').order_by('submission_time') scores_so_far = Solution.objects.values_list('score').filter (assignment = assignment_id,status='OK').order_by('submission_time') pub_scores_so_far = Solution.objects.values_list('public_score').filter (assignment = assignment_id,status='OK').order_by('submission_time') #print np.array (scores_so_far) plt.plot (np.array(scores_so_far), 'ro') plt.plot (np.array(pub_scores_so_far), 'b*') pngfilename = str('test' + assignment_id + '.png') plt.savefig(settings.MEDIA_ROOT + pngfilename) args['figplot'] = pngfilename return render (request, 'fileuploader/viewSubmissionLogs.html', args) @login_required def viewAssignmentsDetail (request,assignment_id): args = {} args.update (csrf (request)) assignment = get_object_or_404 (Assignment, pk = assignment_id) args['assignment'] = assignment current_user = request.user args['submissions'] = Solution.objects.filter (assignment = assignment_id,user=current_user).order_by('-submission_time') ''' # create a plot scores_so_far = Solution.objects.values_list('score').filter (assignment = assignment_id) #print np.array (scores_so_far) plt.plot (np.array(scores_so_far), 'ro') pngfilename = str('test' + assignment_id + '.png') plt.savefig(settings.MEDIA_ROOT + pngfilename) args['figplot'] = pngfilename ''' fileurls = settings.MEDIA_URL args['fileurls'] = fileurls #plt.show () return render (request, 'fileuploader/viewAssignmentsDetail.html', args) @staff_member_required def deleteAssignment (request, assignment_id): if request.user.is_superuser: obj2 = Solution.objects.filter (assignment = assignment_id).count() if obj2 > 0: u1 = Solution.objects.filter(assignment=assignment_id).delete() u2 = Assignment.objects.get(pk=assignment_id).delete() return render_to_response ('fileuploader/viewAssignments.html') else: html = "<html><body>You are not authorized to permit this action</body></html>" return HttpResponse(html) @staff_member_required def editAssignment (request,assignment_id): assignment = get_object_or_404 (Assignment, pk = assignment_id) if request.POST: form = AssignmentForm(request.POST, request.FILES, instance=assignment) if form.is_valid(): a = form.save() #viewAssignmentsDetail (request, assignment_id) return HttpResponseRedirect('../../viewAssignments.html') else: form = AssignmentForm(instance=assignment) args = {} args.update(csrf(request)) args['form'] = form return render(request, 'fileuploader/editAssignment.html',args) def create(request): if request.POST: form = ArticleForm(request.POST, request.FILES) if form.is_valid(): a = form.save() return HttpResponseRedirect('/fileuploader/articles.html') else: form = ArticleForm() args = {} args.update(csrf(request)) args['form'] = form return render_to_response('fileuploader/create_article.html',args) def register(request): if request.POST: uf = UserForm(request.POST, prefix='user') if uf.is_valid(): cuser = uf.save() cuser.set_password(cuser.password) cuser.save() return HttpResponseRedirect('/fileuploader/selectClass.html') else: uf = UserForm(prefix='user') #return render_to_response('register.html', dict(userform=uf,userprofileform=upf), context_instance=RequestContext(request)) return render_to_response('register.html', dict(userform=uf), context_instance=RequestContext(request)) #user = User.objects.create_user(username=request.POST['login'], password=request.POST['password']) # Create your views here.
gpl-2.0
pp-mo/iris
lib/iris/tests/test_plot.py
2
31819
# Copyright Iris contributors # # This file is part of Iris and is released under the LGPL license. # See COPYING and COPYING.LESSER in the root of the repository for full # licensing details. # import iris tests first so that some things can be initialised before # importing anything else import iris.tests as tests from functools import wraps import types import warnings import cf_units import numpy as np import iris import iris.coords as coords import iris.tests.stock # Run tests in no graphics mode if matplotlib is not available. if tests.MPL_AVAILABLE: import matplotlib.pyplot as plt import iris.plot as iplt import iris.quickplot as qplt import iris.symbols @tests.skip_data def simple_cube(): cube = iris.tests.stock.realistic_4d() cube = cube[:, 0, 0, :] cube.coord("time").guess_bounds() return cube @tests.skip_plot class TestSimple(tests.GraphicsTest): def test_points(self): cube = simple_cube() qplt.contourf(cube) self.check_graphic() def test_bounds(self): cube = simple_cube() qplt.pcolor(cube) self.check_graphic() @tests.skip_plot class TestMissingCoord(tests.GraphicsTest): def _check(self, cube): qplt.contourf(cube) self.check_graphic() qplt.pcolor(cube) self.check_graphic() def test_no_u(self): cube = simple_cube() cube.remove_coord("grid_longitude") self._check(cube) def test_no_v(self): cube = simple_cube() cube.remove_coord("time") self._check(cube) def test_none(self): cube = simple_cube() cube.remove_coord("grid_longitude") cube.remove_coord("time") self._check(cube) @tests.skip_data @tests.skip_plot class TestMissingCS(tests.GraphicsTest): @tests.skip_data def test_missing_cs(self): cube = tests.stock.simple_pp() cube.coord("latitude").coord_system = None cube.coord("longitude").coord_system = None qplt.contourf(cube) qplt.plt.gca().coastlines() self.check_graphic() @tests.skip_plot @tests.skip_data class TestHybridHeight(tests.GraphicsTest): def setUp(self): super().setUp() self.cube = iris.tests.stock.realistic_4d()[0, :15, 0, :] def _check(self, plt_method, test_altitude=True): plt_method(self.cube) self.check_graphic() plt_method(self.cube, coords=["level_height", "grid_longitude"]) self.check_graphic() plt_method(self.cube, coords=["grid_longitude", "level_height"]) self.check_graphic() if test_altitude: plt_method(self.cube, coords=["grid_longitude", "altitude"]) self.check_graphic() plt_method(self.cube, coords=["altitude", "grid_longitude"]) self.check_graphic() def test_points(self): self._check(qplt.contourf) def test_bounds(self): self._check(qplt.pcolor, test_altitude=False) def test_orography(self): qplt.contourf(self.cube) iplt.orography_at_points(self.cube) iplt.points(self.cube) self.check_graphic() coords = ["altitude", "grid_longitude"] qplt.contourf(self.cube, coords=coords) iplt.orography_at_points(self.cube, coords=coords) iplt.points(self.cube, coords=coords) self.check_graphic() # TODO: Test bounds once they are supported. with self.assertRaises(NotImplementedError): qplt.pcolor(self.cube) iplt.orography_at_bounds(self.cube) iplt.outline(self.cube) self.check_graphic() @tests.skip_plot @tests.skip_data class Test1dPlotMultiArgs(tests.GraphicsTest): # tests for iris.plot using multi-argument calling convention def setUp(self): super().setUp() self.cube1d = _load_4d_testcube()[0, :, 0, 0] self.draw_method = iplt.plot def test_cube(self): # just plot a cube against its dim coord self.draw_method(self.cube1d) # altitude vs temp self.check_graphic() def test_coord(self): # plot the altitude coordinate self.draw_method(self.cube1d.coord("altitude")) self.check_graphic() def test_coord_cube(self): # plot temperature against sigma self.draw_method(self.cube1d.coord("sigma"), self.cube1d) self.check_graphic() def test_cube_coord(self): # plot a vertical profile of temperature self.draw_method(self.cube1d, self.cube1d.coord("altitude")) self.check_graphic() def test_coord_coord(self): # plot two coordinates that are not mappable self.draw_method( self.cube1d.coord("sigma"), self.cube1d.coord("altitude") ) self.check_graphic() def test_coord_coord_map(self): # plot lat-lon aux coordinates of a trajectory, which draws a map lon = iris.coords.AuxCoord( [0, 5, 10, 15, 20, 25, 30, 35, 40, 45], standard_name="longitude", units="degrees_north", ) lat = iris.coords.AuxCoord( [45, 55, 50, 60, 55, 65, 60, 70, 65, 75], standard_name="latitude", units="degrees_north", ) self.draw_method(lon, lat) plt.gca().coastlines() self.check_graphic() def test_cube_cube(self): # plot two phenomena against eachother, in this case just dummy data cube1 = self.cube1d.copy() cube2 = self.cube1d.copy() cube1.rename("some phenomenon") cube2.rename("some other phenomenon") cube1.units = cf_units.Unit("no_unit") cube2.units = cf_units.Unit("no_unit") cube1.data[:] = np.linspace(0, 1, 7) cube2.data[:] = np.exp(cube1.data) self.draw_method(cube1, cube2) self.check_graphic() def test_incompatible_objects(self): # incompatible objects (not the same length) should raise an error with self.assertRaises(ValueError): self.draw_method(self.cube1d.coord("time"), (self.cube1d)) def test_multimidmensional(self): # multidimensional cubes are not allowed cube = _load_4d_testcube()[0, :, :, 0] with self.assertRaises(ValueError): self.draw_method(cube) def test_not_cube_or_coord(self): # inputs must be cubes or coordinates, otherwise an error should be # raised xdim = np.arange(self.cube1d.shape[0]) with self.assertRaises(TypeError): self.draw_method(xdim, self.cube1d) def test_plot_old_coords_kwarg(self): # Coords used to be a valid kwarg to plot, but it was deprecated and # we are maintaining a reasonable exception, check that it is raised # here. with self.assertRaises(TypeError): self.draw_method(self.cube1d, coords=None) @tests.skip_plot class Test1dQuickplotPlotMultiArgs(Test1dPlotMultiArgs): # tests for iris.plot using multi-argument calling convention def setUp(self): tests.GraphicsTest.setUp(self) self.cube1d = _load_4d_testcube()[0, :, 0, 0] self.draw_method = qplt.plot @tests.skip_data @tests.skip_plot class Test1dScatter(tests.GraphicsTest): def setUp(self): super().setUp() self.cube = iris.load_cube( tests.get_data_path(("NAME", "NAMEIII_trajectory.txt")), "Temperature", ) self.draw_method = iplt.scatter def test_coord_coord(self): x = self.cube.coord("longitude") y = self.cube.coord("altitude") c = self.cube.data self.draw_method(x, y, c=c, edgecolor="none") self.check_graphic() def test_coord_coord_map(self): x = self.cube.coord("longitude") y = self.cube.coord("latitude") c = self.cube.data self.draw_method(x, y, c=c, edgecolor="none") plt.gca().coastlines() self.check_graphic() def test_coord_cube(self): x = self.cube.coord("latitude") y = self.cube c = self.cube.coord("Travel Time").points self.draw_method(x, y, c=c, edgecolor="none") self.check_graphic() def test_cube_coord(self): x = self.cube y = self.cube.coord("altitude") c = self.cube.coord("Travel Time").points self.draw_method(x, y, c=c, edgecolor="none") self.check_graphic() def test_cube_cube(self): x = iris.load_cube( tests.get_data_path(("NAME", "NAMEIII_trajectory.txt")), "Rel Humidity", ) y = self.cube c = self.cube.coord("Travel Time").points self.draw_method(x, y, c=c, edgecolor="none") self.check_graphic() def test_incompatible_objects(self): # cubes/coordinates of different sizes cannot be plotted x = self.cube y = self.cube.coord("altitude")[:-1] with self.assertRaises(ValueError): self.draw_method(x, y) def test_multidimensional(self): # multidimensional cubes/coordinates are not allowed x = _load_4d_testcube()[0, :, :, 0] y = x.coord("model_level_number") with self.assertRaises(ValueError): self.draw_method(x, y) def test_not_cube_or_coord(self): # inputs must be cubes or coordinates x = np.arange(self.cube.shape[0]) y = self.cube with self.assertRaises(TypeError): self.draw_method(x, y) @tests.skip_data @tests.skip_plot class Test1dQuickplotScatter(Test1dScatter): def setUp(self): tests.GraphicsTest.setUp(self) self.cube = iris.load_cube( tests.get_data_path(("NAME", "NAMEIII_trajectory.txt")), "Temperature", ) self.draw_method = qplt.scatter @tests.skip_data @tests.skip_plot class TestAttributePositive(tests.GraphicsTest): def test_1d_positive_up(self): path = tests.get_data_path(("NetCDF", "ORCA2", "votemper.nc")) cube = iris.load_cube(path) qplt.plot(cube.coord("depth"), cube[0, :, 60, 80]) self.check_graphic() def test_1d_positive_down(self): path = tests.get_data_path(("NetCDF", "ORCA2", "votemper.nc")) cube = iris.load_cube(path) qplt.plot(cube[0, :, 60, 80], cube.coord("depth")) self.check_graphic() def test_2d_positive_up(self): path = tests.get_data_path( ("NetCDF", "testing", "small_theta_colpex.nc") ) cube = iris.load_cube(path, "air_potential_temperature")[0, :, 42, :] qplt.pcolormesh(cube) self.check_graphic() def test_2d_positive_down(self): path = tests.get_data_path(("NetCDF", "ORCA2", "votemper.nc")) cube = iris.load_cube(path)[0, :, 42, :] qplt.pcolormesh(cube) self.check_graphic() # Caches _load_4d_testcube so subsequent calls are faster def cache(fn, cache={}): def inner(*args, **kwargs): key = fn.__name__ if key not in cache: cache[key] = fn(*args, **kwargs) return cache[key] return inner @cache @tests.skip_data def _load_4d_testcube(): # Load example 4d data (TZYX). test_cube = iris.tests.stock.realistic_4d() # Replace forecast_period coord with a multi-valued version. time_coord = test_cube.coord("time") n_times = len(time_coord.points) forecast_dims = test_cube.coord_dims(time_coord) test_cube.remove_coord("forecast_period") # Make up values (including bounds), to roughly match older testdata. point_values = np.linspace((1 + 1.0 / 6), 2.0, n_times) point_uppers = point_values + (point_values[1] - point_values[0]) bound_values = np.column_stack([point_values, point_uppers]) # NOTE: this must be a DimCoord # - an equivalent AuxCoord produces different plots. new_forecast_coord = iris.coords.DimCoord( points=point_values, bounds=bound_values, standard_name="forecast_period", units=cf_units.Unit("hours"), ) test_cube.add_aux_coord(new_forecast_coord, forecast_dims) # Heavily reduce dimensions for faster testing. # NOTE: this makes ZYX non-contiguous. Doesn't seem to matter for now. test_cube = test_cube[:, ::10, ::10, ::10] return test_cube @cache def _load_wind_no_bounds(): # Load the COLPEX data => TZYX path = tests.get_data_path(("PP", "COLPEX", "small_eastward_wind.pp")) wind = iris.load_cube(path, "x_wind") # Remove bounds from all coords that have them. wind.coord("grid_latitude").bounds = None wind.coord("grid_longitude").bounds = None wind.coord("level_height").bounds = None wind.coord("sigma").bounds = None return wind[:, :, :50, :50] def _time_series(src_cube): # Until we have plotting support for multiple axes on the same dimension, # remove the time coordinate and its axis. cube = src_cube.copy() cube.remove_coord("time") return cube def _date_series(src_cube): # Until we have plotting support for multiple axes on the same dimension, # remove the forecast_period coordinate and its axis. cube = src_cube.copy() cube.remove_coord("forecast_period") return cube @tests.skip_plot class SliceMixin: """Mixin class providing tests for each 2-dimensional permutation of axes. Requires self.draw_method to be the relevant plotting function, and self.results to be a dictionary containing the desired test results.""" def test_yx(self): cube = self.wind[0, 0, :, :] self.draw_method(cube) self.check_graphic() def test_zx(self): cube = self.wind[0, :, 0, :] self.draw_method(cube) self.check_graphic() def test_tx(self): cube = _time_series(self.wind[:, 0, 0, :]) self.draw_method(cube) self.check_graphic() def test_zy(self): cube = self.wind[0, :, :, 0] self.draw_method(cube) self.check_graphic() def test_ty(self): cube = _time_series(self.wind[:, 0, :, 0]) self.draw_method(cube) self.check_graphic() def test_tz(self): cube = _time_series(self.wind[:, :, 0, 0]) self.draw_method(cube) self.check_graphic() @tests.skip_data class TestContour(tests.GraphicsTest, SliceMixin): """Test the iris.plot.contour routine.""" def setUp(self): super().setUp() self.wind = _load_4d_testcube() self.draw_method = iplt.contour @tests.skip_data class TestContourf(tests.GraphicsTest, SliceMixin): """Test the iris.plot.contourf routine.""" def setUp(self): super().setUp() self.wind = _load_4d_testcube() self.draw_method = iplt.contourf @tests.skip_data class TestPcolor(tests.GraphicsTest, SliceMixin): """Test the iris.plot.pcolor routine.""" def setUp(self): super().setUp() self.wind = _load_4d_testcube() self.draw_method = iplt.pcolor @tests.skip_data class TestPcolormesh(tests.GraphicsTest, SliceMixin): """Test the iris.plot.pcolormesh routine.""" def setUp(self): super().setUp() self.wind = _load_4d_testcube() self.draw_method = iplt.pcolormesh def check_warnings(method): """ Decorator that adds a catch_warnings and filter to assert the method being decorated issues a UserWarning. """ @wraps(method) def decorated_method(self, *args, **kwargs): # Force reset of iris.coords warnings registry to avoid suppression of # repeated warnings. warnings.resetwarnings() does not do this. if hasattr(coords, "__warningregistry__"): coords.__warningregistry__.clear() # Check that method raises warning. with warnings.catch_warnings(): warnings.simplefilter("error") with self.assertRaises(UserWarning): return method(self, *args, **kwargs) return decorated_method def ignore_warnings(method): """ Decorator that adds a catch_warnings and filter to suppress any warnings issues by the method being decorated. """ @wraps(method) def decorated_method(self, *args, **kwargs): with warnings.catch_warnings(): warnings.simplefilter("ignore") return method(self, *args, **kwargs) return decorated_method class CheckForWarningsMetaclass(type): """ Metaclass that adds a further test for each base class test that checks that each test raises a UserWarning. Each base class test is then overriden to ignore warnings in order to check the underlying functionality. """ def __new__(cls, name, bases, local): def add_decorated_methods(attr_dict, target_dict, decorator): for key, value in attr_dict.items(): if isinstance(value, types.FunctionType) and key.startswith( "test" ): new_key = "_".join((key, decorator.__name__)) if new_key not in target_dict: wrapped = decorator(value) wrapped.__name__ = new_key target_dict[new_key] = wrapped else: raise RuntimeError( "A attribute called {!r} " "already exists.".format(new_key) ) def override_with_decorated_methods(attr_dict, target_dict, decorator): for key, value in attr_dict.items(): if isinstance(value, types.FunctionType) and key.startswith( "test" ): target_dict[key] = decorator(value) # Add decorated versions of base methods # to check for warnings. for base in bases: add_decorated_methods(base.__dict__, local, check_warnings) # Override base methods to ignore warnings. for base in bases: override_with_decorated_methods( base.__dict__, local, ignore_warnings ) return type.__new__(cls, name, bases, local) @tests.skip_data @tests.iristest_timing_decorator class TestPcolorNoBounds( tests.GraphicsTest_nometa, SliceMixin, metaclass=CheckForWarningsMetaclass ): """ Test the iris.plot.pcolor routine on a cube with coordinates that have no bounds. """ def setUp(self): super().setUp() self.wind = _load_wind_no_bounds() self.draw_method = iplt.pcolor @tests.skip_data @tests.iristest_timing_decorator class TestPcolormeshNoBounds( tests.GraphicsTest_nometa, SliceMixin, metaclass=CheckForWarningsMetaclass ): """ Test the iris.plot.pcolormesh routine on a cube with coordinates that have no bounds. """ def setUp(self): super().setUp() self.wind = _load_wind_no_bounds() self.draw_method = iplt.pcolormesh @tests.skip_plot class Slice1dMixin: """Mixin class providing tests for each 1-dimensional permutation of axes. Requires self.draw_method to be the relevant plotting function, and self.results to be a dictionary containing the desired test results.""" def test_x(self): cube = self.wind[0, 0, 0, :] self.draw_method(cube) self.check_graphic() def test_y(self): cube = self.wind[0, 0, :, 0] self.draw_method(cube) self.check_graphic() def test_z(self): cube = self.wind[0, :, 0, 0] self.draw_method(cube) self.check_graphic() def test_t(self): cube = _time_series(self.wind[:, 0, 0, 0]) self.draw_method(cube) self.check_graphic() def test_t_dates(self): cube = _date_series(self.wind[:, 0, 0, 0]) self.draw_method(cube) plt.gcf().autofmt_xdate() plt.xlabel("Phenomenon time") self.check_graphic() @tests.skip_data class TestPlot(tests.GraphicsTest, Slice1dMixin): """Test the iris.plot.plot routine.""" def setUp(self): super().setUp() self.wind = _load_4d_testcube() self.draw_method = iplt.plot @tests.skip_data class TestQuickplotPlot(tests.GraphicsTest, Slice1dMixin): """Test the iris.quickplot.plot routine.""" def setUp(self): super().setUp() self.wind = _load_4d_testcube() self.draw_method = qplt.plot _load_cube_once_cache = {} def load_cube_once(filename, constraint): """Same syntax as load_cube, but will only load a file once, then cache the answer in a dictionary. """ global _load_cube_once_cache key = (filename, str(constraint)) cube = _load_cube_once_cache.get(key, None) if cube is None: cube = iris.load_cube(filename, constraint) _load_cube_once_cache[key] = cube return cube class LambdaStr: """Provides a callable function which has a sensible __repr__.""" def __init__(self, repr, lambda_fn): self.repr = repr self.lambda_fn = lambda_fn def __call__(self, *args, **kwargs): return self.lambda_fn(*args, **kwargs) def __repr__(self): return self.repr @tests.skip_data @tests.skip_plot class TestPlotCoordinatesGiven(tests.GraphicsTest): def setUp(self): super().setUp() filename = tests.get_data_path( ("PP", "COLPEX", "theta_and_orog_subset.pp") ) self.cube = load_cube_once(filename, "air_potential_temperature") self.draw_module = iris.plot self.contourf = LambdaStr( "iris.plot.contourf", lambda cube, *args, **kwargs: iris.plot.contourf( cube, *args, **kwargs ), ) self.contour = LambdaStr( "iris.plot.contour", lambda cube, *args, **kwargs: iris.plot.contour( cube, *args, **kwargs ), ) self.points = LambdaStr( "iris.plot.points", lambda cube, *args, **kwargs: iris.plot.points( cube, c=cube.data, *args, **kwargs ), ) self.plot = LambdaStr( "iris.plot.plot", lambda cube, *args, **kwargs: iris.plot.plot( cube, *args, **kwargs ), ) self.results = { "yx": ( [self.contourf, ["grid_latitude", "grid_longitude"]], [self.contourf, ["grid_longitude", "grid_latitude"]], [self.contour, ["grid_latitude", "grid_longitude"]], [self.contour, ["grid_longitude", "grid_latitude"]], [self.points, ["grid_latitude", "grid_longitude"]], [self.points, ["grid_longitude", "grid_latitude"]], ), "zx": ( [self.contourf, ["model_level_number", "grid_longitude"]], [self.contourf, ["grid_longitude", "model_level_number"]], [self.contour, ["model_level_number", "grid_longitude"]], [self.contour, ["grid_longitude", "model_level_number"]], [self.points, ["model_level_number", "grid_longitude"]], [self.points, ["grid_longitude", "model_level_number"]], ), "tx": ( [self.contourf, ["time", "grid_longitude"]], [self.contourf, ["grid_longitude", "time"]], [self.contour, ["time", "grid_longitude"]], [self.contour, ["grid_longitude", "time"]], [self.points, ["time", "grid_longitude"]], [self.points, ["grid_longitude", "time"]], ), "x": ([self.plot, ["grid_longitude"]],), "y": ([self.plot, ["grid_latitude"]],), } def draw(self, draw_method, *args, **kwargs): draw_fn = getattr(self.draw_module, draw_method) draw_fn(*args, **kwargs) self.check_graphic() def run_tests(self, cube, results): for draw_method, rcoords in results: draw_method(cube, coords=rcoords) try: self.check_graphic() except AssertionError as err: self.fail( "Draw method %r failed with coords: %r. " "Assertion message: %s" % (draw_method, rcoords, err) ) def run_tests_1d(self, cube, results): # there is a different calling convention for 1d plots for draw_method, rcoords in results: draw_method(cube.coord(rcoords[0]), cube) try: self.check_graphic() except AssertionError as err: msg = ( "Draw method {!r} failed with coords: {!r}. " "Assertion message: {!s}" ) self.fail(msg.format(draw_method, rcoords, err)) def test_yx(self): test_cube = self.cube[0, 0, :, :] self.run_tests(test_cube, self.results["yx"]) def test_zx(self): test_cube = self.cube[0, :15, 0, :] self.run_tests(test_cube, self.results["zx"]) def test_tx(self): test_cube = self.cube[:, 0, 0, :] self.run_tests(test_cube, self.results["tx"]) def test_x(self): test_cube = self.cube[0, 0, 0, :] self.run_tests_1d(test_cube, self.results["x"]) def test_y(self): test_cube = self.cube[0, 0, :, 0] self.run_tests_1d(test_cube, self.results["y"]) def test_badcoords(self): cube = self.cube[0, 0, :, :] draw_fn = getattr(self.draw_module, "contourf") self.assertRaises( ValueError, draw_fn, cube, coords=["grid_longitude", "grid_longitude"], ) self.assertRaises( ValueError, draw_fn, cube, coords=["grid_longitude", "grid_longitude", "grid_latitude"], ) self.assertRaises( iris.exceptions.CoordinateNotFoundError, draw_fn, cube, coords=["grid_longitude", "wibble"], ) self.assertRaises(ValueError, draw_fn, cube, coords=[]) self.assertRaises( ValueError, draw_fn, cube, coords=[ cube.coord("grid_longitude"), cube.coord("grid_longitude"), ], ) self.assertRaises( ValueError, draw_fn, cube, coords=[ cube.coord("grid_longitude"), cube.coord("grid_longitude"), cube.coord("grid_longitude"), ], ) def test_non_cube_coordinate(self): cube = self.cube[0, :, :, 0] pts = -100 + np.arange(cube.shape[1]) * 13 x = coords.DimCoord( pts, standard_name="model_level_number", attributes={"positive": "up"}, ) self.draw("contourf", cube, coords=["grid_latitude", x]) @tests.skip_data @tests.skip_plot class TestPlotDimAndAuxCoordsKwarg(tests.GraphicsTest): def setUp(self): super().setUp() filename = tests.get_data_path( ("NetCDF", "rotated", "xy", "rotPole_landAreaFraction.nc") ) self.cube = iris.load_cube(filename) def test_default(self): iplt.contourf(self.cube) plt.gca().coastlines() self.check_graphic() def test_coords(self): # Pass in dimension coords. rlat = self.cube.coord("grid_latitude") rlon = self.cube.coord("grid_longitude") iplt.contourf(self.cube, coords=[rlon, rlat]) plt.gca().coastlines() self.check_graphic() # Pass in auxiliary coords. lat = self.cube.coord("latitude") lon = self.cube.coord("longitude") iplt.contourf(self.cube, coords=[lon, lat]) plt.gca().coastlines() self.check_graphic() def test_coord_names(self): # Pass in names of dimension coords. iplt.contourf(self.cube, coords=["grid_longitude", "grid_latitude"]) plt.gca().coastlines() self.check_graphic() # Pass in names of auxiliary coords. iplt.contourf(self.cube, coords=["longitude", "latitude"]) plt.gca().coastlines() self.check_graphic() def test_yx_order(self): # Do not attempt to draw coastlines as it is not a map. iplt.contourf(self.cube, coords=["grid_latitude", "grid_longitude"]) self.check_graphic() iplt.contourf(self.cube, coords=["latitude", "longitude"]) self.check_graphic() @tests.skip_plot class TestSymbols(tests.GraphicsTest): def test_cloud_cover(self): iplt.symbols( list(range(10)), [0] * 10, [iris.symbols.CLOUD_COVER[i] for i in range(10)], 0.375, ) iplt.plt.axis("off") self.check_graphic() @tests.skip_plot class TestPlottingExceptions(tests.IrisTest): def setUp(self): self.bounded_cube = tests.stock.lat_lon_cube() self.bounded_cube.coord("latitude").guess_bounds() self.bounded_cube.coord("longitude").guess_bounds() def test_boundmode_multidim(self): # Test exception translation. # We can't get contiguous bounded grids from multi-d coords. cube = self.bounded_cube cube.remove_coord("latitude") cube.add_aux_coord( coords.AuxCoord( points=cube.data, standard_name="latitude", units="degrees" ), [0, 1], ) with self.assertRaises(ValueError): iplt.pcolormesh(cube, coords=["longitude", "latitude"]) def test_boundmode_4bounds(self): # Test exception translation. # We can only get contiguous bounded grids with 2 bounds per point. cube = self.bounded_cube lat = coords.AuxCoord.from_coord(cube.coord("latitude")) lat.bounds = np.array( [lat.points, lat.points + 1, lat.points + 2, lat.points + 3] ).transpose() cube.remove_coord("latitude") cube.add_aux_coord(lat, 0) with self.assertRaises(ValueError): iplt.pcolormesh(cube, coords=["longitude", "latitude"]) def test_different_coord_systems(self): cube = self.bounded_cube lat = cube.coord("latitude") lon = cube.coord("longitude") lat.coord_system = iris.coord_systems.GeogCS(7000000) lon.coord_system = iris.coord_systems.GeogCS(7000001) with self.assertRaises(ValueError): iplt.pcolormesh(cube, coords=["longitude", "latitude"]) @tests.skip_data @tests.skip_plot class TestPlotOtherCoordSystems(tests.GraphicsTest): def test_plot_tmerc(self): filename = tests.get_data_path( ("NetCDF", "transverse_mercator", "tmean_1910_1910.nc") ) self.cube = iris.load_cube(filename) iplt.pcolormesh(self.cube[0]) plt.gca().coastlines() self.check_graphic() @tests.skip_plot class TestPlotCitation(tests.GraphicsTest): def setUp(self): super().setUp() self.figure = plt.figure() self.axes = self.figure.gca() self.text = ( "Lorem ipsum dolor sit amet, consectetur adipiscing " "elit, sed do eiusmod tempor incididunt ut labore et " "dolore magna aliqua." ) def test(self): iplt.citation(self.text) self.check_graphic() def test_figure(self): iplt.citation(self.text, figure=self.figure) self.check_graphic() def test_axes(self): iplt.citation(self.text, axes=self.axes) self.check_graphic() if __name__ == "__main__": tests.main()
lgpl-3.0
darcy0511/Dato-Core
src/unity/python/graphlab/test/test_sframe.py
13
108197
''' Copyright (C) 2015 Dato, Inc. All rights reserved. This software may be modified and distributed under the terms of the BSD license. See the DATO-PYTHON-LICENSE file for details. ''' # from nose import with_setup import graphlab as gl from graphlab.data_structures.sframe import SFrame from graphlab.data_structures.sarray import SArray from graphlab.data_structures.image import Image from graphlab.connect import main as glconnect from graphlab.connect import server from graphlab.util import _assert_sframe_equal import pandas as pd from graphlab_util.timezone import GMT from pandas.util.testing import assert_frame_equal import unittest import datetime as dt import tempfile import os import csv import gzip import util import string import time import numpy as np import array import math import random import shutil import functools HAS_PYSPARK = True try: from pyspark import SparkContext, SQLContext except: HAS_PYSPARK = False ####################################################### # Metrics tracking tests are in test_usage_metrics.py # ####################################################### # Taken from http://stackoverflow.com/questions/1151658/python-hashable-dicts # by Alex Martelli class hashabledict(dict): def __key(self): return tuple((k,self[k]) for k in sorted(self)) def __hash__(self): return hash(self.__key()) def __eq__(self, other): return self.__key() == other.__key() class SFrameTest(unittest.TestCase): def setUp(self): self.int_data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] self.float_data = [1., 2., 3., 4., 5., 6., 7., 8., 9., 10.] self.string_data = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"] self.a_to_z = [str(unichr(97 + i)) for i in range(0, 26)] self.dataframe = pd.DataFrame({'int_data': self.int_data, 'float_data': self.float_data, 'string_data': self.string_data}) self.url = "http://s3-us-west-2.amazonaws.com/testdatasets/a_to_z.txt.gz" self.int_data2 = range(50,60) self.float_data2 = [1.0 * i for i in range(50,60)] self.string_data2 = [str(i) for i in range(50,60)] self.dataframe2 = pd.DataFrame({'int_data': self.int_data2, 'float_data': self.float_data2, 'string_data': self.string_data2}) # Taken from http://en.wikipedia.org/wiki/Join_(SQL) for fun. self.employees_sf = SFrame() self.employees_sf.add_column(SArray(['Rafferty','Jones','Heisenberg','Robinson','Smith','John']), 'last_name') self.employees_sf.add_column(SArray([31,33,33,34,34,None]), 'dep_id') self.departments_sf = SFrame() self.departments_sf.add_column(SArray([31,33,34,35]), 'dep_id') self.departments_sf.add_column(SArray(['Sales','Engineering','Clerical','Marketing']), 'dep_name') def __assert_sarray_equal(self, sa1, sa2): l1 = list(sa1) l2 = list(sa2) self.assertEquals(len(l1), len(l2)) for i in range(len(l1)): v1 = l1[i] v2 = l2[i] if v1 == None: self.assertEqual(v2, None) else: if type(v1) == dict: self.assertEquals(len(v1), len(v2)) for key in v1: self.assertTrue(v1.has_key(key)) self.assertEqual(v1[key], v2[key]) elif (hasattr(v1, "__iter__")): self.assertEquals(len(v1), len(v2)) for j in range(len(v1)): t1 = v1[j]; t2 = v2[j] if (type(t1) == float): if (math.isnan(t1)): self.assertTrue(math.isnan(t2)) else: self.assertEquals(t1, t2) else: self.assertEquals(t1, t2) else: self.assertEquals(v1, v2) def test_split_datetime(self): from_zone = GMT(0) to_zone = GMT(4.5) utc = dt.datetime.strptime('2011-01-21 02:37:21', '%Y-%m-%d %H:%M:%S') utc = utc.replace(tzinfo=from_zone) central = utc.astimezone(to_zone) sa = SArray([utc,central]) expected = SFrame() expected ['X.year'] = [2011,2011] expected ['X.month'] = [1,1] expected ['X.day'] = [21,21] expected ['X.hour'] = [2,7] expected ['X.minute'] = [37,7] expected ['X.second'] = [21,21] expected ['X.tzone'] = [0.0,4.5] result = sa.split_datetime(tzone=True) assert_frame_equal(result.to_dataframe(), expected.to_dataframe()) # column names expected = SFrame() expected ['ttt.year'] = [2011,2011] expected ['ttt.minute'] = [37,7] expected ['ttt.second'] = [21,21] result = sa.split_datetime(column_name_prefix='ttt',limit=['year','minute','second']); self.assertEqual(result.column_names(), ['ttt.year', 'ttt.minute', 'ttt.second']) assert_frame_equal(result.to_dataframe(), expected.to_dataframe()) sf = SFrame({'datetime': sa}) result = sf.split_datetime('datetime', column_name_prefix='ttt',limit=['year','minute','second']); self.assertEqual(result.column_names(), ['ttt.year', 'ttt.minute', 'ttt.second']) assert_frame_equal(result.to_dataframe(), expected.to_dataframe()) def __test_equal(self, sf, df): self.assertEquals(sf.num_rows(), df.shape[0]) self.assertEquals(sf.num_cols(), df.shape[1]) assert_frame_equal(sf.to_dataframe(), df) def __create_test_df(self, size): int_data = [] float_data = [] string_data = [] for i in range(0,size): int_data.append(i) float_data.append(float(i)) string_data.append(str(i)) return pd.DataFrame({'int_data': int_data, 'float_data': float_data, 'string_data': string_data}) # Test if the rows are all the same...row order does not matter. # (I do expect column order to be the same) def __assert_join_results_equal(self, sf, expected_sf): _assert_sframe_equal(sf, expected_sf, check_row_order=False) def test_creation_from_dataframe(self): # created from empty dataframe sf_empty = SFrame(data=pd.DataFrame()) self.__test_equal(sf_empty, pd.DataFrame()) sf = SFrame(data=self.dataframe, format='dataframe') self.__test_equal(sf, self.dataframe) sf = SFrame(data=self.dataframe, format='auto') self.__test_equal(sf, self.dataframe) original_p = pd.DataFrame({'a':[1.0, float('nan')]}) effective_p = pd.DataFrame({'a':[1.0, None]}) sf = SFrame(data=original_p) self.__test_equal(sf, effective_p) original_p = pd.DataFrame({'a':['a',None,'b',float('nan')]}) effective_p = pd.DataFrame({'a':['a',None,'b',None]}) sf = SFrame(data=original_p) self.__test_equal(sf, effective_p) def test_auto_parse_csv(self): with tempfile.NamedTemporaryFile(delete=False) as csvfile: df = pd.DataFrame({'float_data': self.float_data, 'int_data': self.int_data, 'string_data': self.a_to_z[:len(self.int_data)]}) df.to_csv(csvfile, index=False) csvfile.close() sf = SFrame.read_csv(csvfile.name, header=True) self.assertEqual(sf.dtype(), [float, int, str]) self.__test_equal(sf, df) def test_parse_csv(self): with tempfile.NamedTemporaryFile(delete=False) as csvfile: self.dataframe.to_csv(csvfile, index=False) csvfile.close() # list type hints sf = SFrame.read_csv(csvfile.name, column_type_hints=[int, int, str]) self.assertEqual(sf.dtype(), [int, int, str]) sf['int_data'] = sf['int_data'].astype(int) sf['float_data'] = sf['float_data'].astype(float) sf['string_data'] = sf['string_data'].astype(str) self.__test_equal(sf, self.dataframe) # list type hints, incorrect number of columns self.assertRaises(RuntimeError, lambda: SFrame.read_csv(csvfile.name, column_type_hints=[int, float])) # dictionary type hints sf = SFrame.read_csv(csvfile.name, column_type_hints={'int_data': int, 'float_data': float, 'string_data': str}) self.__test_equal(sf, self.dataframe) # single value type hints sf = SFrame.read_csv(csvfile.name, column_type_hints=str) self.assertEqual(sf.dtype(), [str, str, str]) all_string_column_df = self.dataframe.apply(lambda x: [str(ele) for ele in x]) self.__test_equal(sf, all_string_column_df) # single value type hints row limit sf = SFrame.read_csv(csvfile.name, column_type_hints=str, nrows=5) self.assertEqual(sf.dtype(), [str, str, str]) all_string_column_df = self.dataframe.apply(lambda x: [str(ele) for ele in x]) self.assertEqual(len(sf), 5) self.__test_equal(sf, all_string_column_df[0:len(sf)]) sf = SFrame.read_csv(csvfile.name) sf2 = SFrame(csvfile.name, format='csv') self.__test_equal(sf2, sf.to_dataframe()) f = open(csvfile.name, "w") f.write('a,b,c\n') f.write('NA,PIKA,CHU\n') f.write('1.0,2,3\n') f.close() # Default type hints, all column will be string type sf = SFrame.read_csv(csvfile.name, na_values=['NA','PIKA','CHU'], column_type_hints={'a':float,'b':int}) t = list(sf['a']) self.assertEquals(t[0], None) self.assertEquals(t[1], 1.0) t = list(sf['b']) self.assertEquals(t[0], None) self.assertEquals(t[1], 2) t = list(sf['c']) self.assertEquals(t[0], None) self.assertEquals(t[1], "3") def test_save_load_file_cleanup(self): # when some file is in use, file should not be deleted with util.TempDirectory() as f: sf = SFrame() sf['a'] = SArray(range(1,1000000)) sf.save(f) # many for each sarray, 1 sframe_idx, 1 object.bin, 1 ini file_count = len(os.listdir(f)) self.assertTrue(file_count > 3); # sf1 now references the on disk file sf1 = SFrame(f); # create another SFrame and save to the same location sf2 = SFrame() sf2['b'] = SArray([str(i) for i in range(1,100000)]) sf2['c'] = SArray(range(1, 100000)) sf2.save(f) file_count = len(os.listdir(f)) self.assertTrue(file_count > 3); # now sf1 should still be accessible self.__test_equal(sf1, sf.to_dataframe()) # and sf2 is correct too sf3 = SFrame(f) self.__test_equal(sf3, sf2.to_dataframe()) # when sf1 goes out of scope, the tmp files should be gone sf1 = 1 time.sleep(1) # give time for the files being deleted file_count = len(os.listdir(f)) self.assertTrue(file_count > 3); def test_save_load(self): # Check top level load function, with no suffix with util.TempDirectory() as f: sf = SFrame(data=self.dataframe, format='dataframe') sf.save(f) sf2 = gl.load_sframe(f) self.__test_equal(sf2, self.dataframe) # Check individual formats with the SFrame constructor formats = ['.csv'] for suffix in formats: with tempfile.NamedTemporaryFile(suffix=suffix) as f: sf = SFrame(data=self.dataframe, format='dataframe') sf.save(f.name) sf2 = SFrame(f.name) sf2['int_data'] = sf2['int_data'].astype(int) sf2['float_data'] = sf2['float_data'].astype(float) self.__test_equal(sf2, self.dataframe) g=SArray([['a','b',3],[{'a':'b'}],[1,2,3]]) g2=SFrame() g2['x']=g g2.save(f.name) g3=gl.SFrame.read_csv(f.name,column_type_hints=list) self.__test_equal(g2, g3.to_dataframe()) # Make sure this file don't exist before testing self.assertRaises(IOError, lambda: SFrame(data='__no_such_file__.frame_idx', format='sframe')) # Bad permission test_dir = 'test_dir' if os.path.exists(test_dir): os.removedirs(test_dir) os.makedirs(test_dir, mode=0000) with self.assertRaises(IOError): sf.save(os.path.join(test_dir, 'bad.frame_idx')) # Permissions will affect this test first, so no need # to write something here with self.assertRaises(IOError): sf2 = SFrame(os.path.join(test_dir, 'bad.frame_idx')) # cleanup os.removedirs(test_dir) del sf2 def test_save_to_csv(self): with tempfile.NamedTemporaryFile(suffix='csv', delete=True) as f: sf = SFrame(data=self.dataframe, format='dataframe') sf.save(f.name, format='csv') sf2 = SFrame.read_csv(f.name + '.csv', column_type_hints={'int_data': int, 'float_data': float, 'string_data': str}) self.__test_equal(sf2, self.dataframe) def _remove_sframe_files(self, prefix): filelist = [ f for f in os.listdir(".") if f.startswith(prefix) ] for f in filelist: os.remove(f) def test_creation_from_csv_on_server(self): # create from 'remote' csv url with tempfile.NamedTemporaryFile(suffix='.csv') as csvfile: basesf = SFrame(self.dataframe) basesf.save(csvfile.name, format="csv") # Read csv giving type hints #sf = SFrame(data='remote://' + csvfile.name, format='csv', # column_type_hints={'int_data': int, 'float_data': float, 'string_data': str}) sf = SFrame.read_csv('remote://' + csvfile.name, column_type_hints={'int_data': int, 'float_data': float, 'string_data': str}) self.__test_equal(sf, self.dataframe) # Read csv without giving type hints, all column will be string type sf = SFrame(data='remote://' + csvfile.name, format='csv') self.assertEquals(sf['float_data'].dtype(), int) sf['float_data'] = sf['float_data'].astype(float) self.__test_equal(sf, self.dataframe) def test_creation_from_txt(self): with tempfile.NamedTemporaryFile(suffix='.txt') as f: df = self.dataframe[['string_data']] df.to_csv(f.name, index=False) sf = SFrame(f.name) self.assertEquals(sf['string_data'].dtype(), int) sf['string_data'] = sf['string_data'].astype(str) self.__test_equal(sf, df) with tempfile.NamedTemporaryFile(suffix='.txt.gz') as fgzip: f_in = open(f.name, 'rb') f_out = gzip.open(fgzip.name, 'wb') f_out.writelines(f_in) f_out.close() f_in.close() sf = SFrame(fgzip.name) self.assertEquals(sf['string_data'].dtype(), int) sf['string_data'] = sf['string_data'].astype(str) self.__test_equal(sf, df) def test_creation_from_csv_on_local(self): if (isinstance(glconnect.get_server(), server.LocalServer)): if os.path.exists('./foo.csv'): os.remove('./foo.csv') with open('./foo.csv', 'w') as f: url = f.name basesf = SFrame(self.dataframe) basesf.save(url, format="csv") f.close() sf = SFrame('./foo.csv') self.assertEquals(sf['float_data'].dtype(), int) sf['float_data'] = sf['float_data'].astype(float) self.__test_equal(sf, self.dataframe) sf = SFrame(url) self.assertEquals(sf['float_data'].dtype(), int) sf['float_data'] = sf['float_data'].astype(float) self.__test_equal(sf, self.dataframe) os.remove(url) # test Windows line endings if os.path.exists('./windows_lines.csv'): os.remove('./windows_lines.csv') windows_file_url = None with open('./windows_lines.csv', 'w') as f: windows_file_url = f.name def_writer = csv.writer(f, dialect='excel') column_list = ['numbers'] def_writer.writerow(column_list) for i in self.int_data: def_writer.writerow([i]) sf = SFrame.read_csv('./windows_lines.csv', column_type_hints={'numbers':int}) self.assertEquals(sf.column_names(), column_list) self.assertEquals(sf.column_types(), [int]) self.assertEquals(list(sf['numbers'].head()), self.int_data) sf = SFrame.read_csv('./windows_lines.csv', column_type_hints={'numbers':list}, error_bad_lines=False) self.assertEquals(sf.column_names(), column_list) self.assertEquals(sf.num_rows(), 0) os.remove(windows_file_url) def test_creation_from_csv_on_http(self): pass # sf = SFrame(data=self.url, use_header=False) # self.__test_equal(sf, pd.DataFrame({'1': self.a_to_z})) def test_creation_from_csv_on_s3(self): # Requires s3 account for jenkins # sf = SFrame(data='s3://graphlab-testdata/foo.csv') # print sf.head(sf.num_rows()) pass def test_creation_from_csv_dir_local(self): csv_dir = "./csv_dir" if os.path.exists(csv_dir): shutil.rmtree(csv_dir) os.mkdir(csv_dir) for i in range(0, 100): with open(os.path.join(csv_dir, 'foo.%d.csv' % i), 'w') as f: url = f.name self.dataframe.to_csv(url, index=False) f.close() singleton_sf = SFrame.read_csv(os.path.join(csv_dir, "foo.0.csv")) self.assertEquals(singleton_sf.num_rows(), 10) many_sf = SFrame.read_csv(csv_dir) self.assertEquals(many_sf.num_rows(), 1000) glob_sf = SFrame.read_csv(os.path.join(csv_dir, "foo.*2.csv")) self.assertEquals(glob_sf.num_rows(), 100) with self.assertRaises(RuntimeError): SFrame.read_csv("missingdirectory") with self.assertRaises(ValueError): SFrame.read_csv("") shutil.rmtree(csv_dir) def test_creation_from_iterable(self): # Normal dict of lists the_dict = {'ints':self.int_data,'floats':self.float_data,'strings':self.string_data} sf = SFrame(the_dict) df = pd.DataFrame(the_dict) self.__test_equal(sf, df) # Test that a missing value does not change the data type the_dict['ints'][0] = None sf = SFrame(the_dict) self.assertEquals(sf['ints'].dtype(), int) # numpy.nan is actually a float, so it should cast the column to float the_dict['ints'][0] = np.nan sf = SFrame(the_dict) self.assertEquals(sf['ints'].dtype(), float) # Just a single list sf = SFrame(self.int_data) df = pd.DataFrame(self.int_data) df.columns = ['X1'] self.__test_equal(sf, df) # Normal list of lists list_of_lists = [[1.0,2.0,3.0],[4.0,5.0,6.0],[7.0,8.0,9.0]] sf = SFrame(list_of_lists) cntr = 0 for i in sf: self.assertEquals(list_of_lists[cntr], list(i['X1'])) cntr += 1 self.assertEquals(sf.num_columns(), 1) the_dict = {'ints':self.int_data,'floats':self.float_data,'strings':self.string_data} sf = SFrame(the_dict) sf2 = SFrame({'ints':sf['ints'],'floats':sf['floats'],'strings':sf['strings']}) df = pd.DataFrame(the_dict) self.__test_equal(sf2, df) sf2 = SFrame([sf['ints'],sf['floats'],sf['strings']]) self.assertEquals(['X1','X2','X3'],sf2.column_names()) sf2.rename({'X1':'ints','X2':'floats','X3':'strings'}) sf2=sf2[['floats','ints','strings']] self.__test_equal(sf2, df) def test_head_tail(self): sf = SFrame(data=self.dataframe) assert_frame_equal(sf.head(4).to_dataframe(), self.dataframe.head(4)) # Cannot test for equality the same way because of dataframe indices taildf = sf.tail(4) for i in range(0, 4): self.assertEqual(taildf['int_data'][i], self.dataframe['int_data'][i+6]) self.assertEqual(taildf['float_data'][i], self.dataframe['float_data'][i+6]) self.assertEqual(taildf['string_data'][i], self.dataframe['string_data'][i+6]) def test_head_tail_edge_case(self): sf = SFrame() self.assertEquals(sf.head().num_columns(), 0) self.assertEquals(sf.tail().num_columns(), 0) self.assertEquals(sf.head().num_rows(), 0) self.assertEquals(sf.tail().num_rows(), 0) sf = SFrame() sf['a'] = [] self.assertEquals(sf.head().num_columns(), 1) self.assertEquals(sf.tail().num_columns(), 1) self.assertEquals(sf.head().num_rows(), 0) self.assertEquals(sf.tail().num_rows(), 0) def test_transform(self): sf = SFrame(data=self.dataframe) for i in range(sf.num_cols()): colname = sf.column_names()[i] sa = sf.apply(lambda x: x[colname], sf.column_types()[i]) self.__assert_sarray_equal(sa, sf[sf.column_names()[i]]) sa = sf.apply(lambda x: x['int_data'] + x['float_data'], float) self.__assert_sarray_equal(sf['int_data'] + sf['float_data'], sa) def test_transform_with_type_inference(self): sf = SFrame(data=self.dataframe) for i in range(sf.num_cols()): colname = sf.column_names()[i] sa = sf.apply(lambda x: x[colname]) self.__assert_sarray_equal(sa, sf[sf.column_names()[i]]) sa = sf.apply(lambda x: x['int_data'] + x['float_data']) self.__assert_sarray_equal(sf['int_data'] + sf['float_data'], sa) # SFrame apply returns list of vector of numeric should be vector, not list sa = sf.apply(lambda x: [x['int_data'], x['float_data']]) self.assertEqual(sa.dtype(), array.array); def test_transform_with_exception(self): sf = SFrame(data=self.dataframe) self.assertRaises(KeyError, lambda: sf.apply(lambda x: x['some random key'])) # cannot find the key self.assertRaises(TypeError, lambda: sf.apply(lambda x: sum(x.values()))) # lambda cannot sum int and str self.assertRaises(ZeroDivisionError, lambda: sf.apply(lambda x: x['int_data'] / 0)) # divide by 0 error self.assertRaises(IndexError, lambda: sf.apply(lambda x: x.values()[10])) # index out of bound error def test_empty_transform(self): sf = SFrame() b = sf.apply(lambda x:x) self.assertEquals(len(b.head()), 0) def test_flatmap(self): # Correctness of typical usage n = 10 sf = SFrame({'id': range(n)}) new_sf = sf.flat_map(["id_range"], lambda x: [[str(i)] for i in range(x['id'])]) self.assertEqual(new_sf.column_names(), ["id_range"]) self.assertEqual(new_sf.column_types(), [str]) expected_col = [str(x) for i in range(n) for x in range(i)] self.assertListEqual(list(new_sf['id_range']), expected_col) # Empty SFrame, without explicit column types sf = gl.SFrame() with self.assertRaises(TypeError): new_sf = sf.flat_map(['id_range'], lambda x: [[i] for i in range(x['id'])]) # Empty rows successfully removed sf = gl.SFrame({'id': range(15)}) new_sf = sf.flat_map(['id'], lambda x: [[x['id']]] if x['id'] > 8 else []) self.assertEqual(new_sf.num_rows(), 6) # First ten rows are empty raises error with self.assertRaises(TypeError): new_sf = sf.flat_map(['id'], lambda x: [[x['id']]] if x['id'] > 9 else []) def test_select_column(self): sf = SFrame(data=self.dataframe) sub_sf = sf.select_columns(['int_data', 'string_data']) exp_df = pd.DataFrame({'int_data': self.int_data, 'string_data': self.string_data}) self.__test_equal(sub_sf, exp_df) with self.assertRaises(ValueError): sf.select_columns(['int_data', 'string_data', 'int_data']) # test indexing sub_col = sf['float_data'] self.assertEqual(sub_col.head(10), self.float_data) with self.assertRaises(TypeError): sub_sf = sf.select_columns(['duh',1]) with self.assertRaises(TypeError): sub_sf = sf.select_columns(0) with self.assertRaises(RuntimeError): sub_sf = sf.select_columns(['not_a_column']) sf = SFrame() with self.assertRaises(RuntimeError): sf.select_column('x') with self.assertRaises(RuntimeError): sf.select_columns(['x']) sf.add_column(gl.SArray(), 'x') # does not throw sf.select_column('x') sf.select_columns(['x']) with self.assertRaises(RuntimeError): sf.select_column('y') with self.assertRaises(RuntimeError): sf.select_columns(['y']) def test_topk(self): sf = SFrame(data=self.dataframe) # Test that order is preserved df2 = sf.topk('int_data').to_dataframe() df2_expected = self.dataframe.sort('int_data', ascending=False) df2_expected.index = range(df2.shape[0]) assert_frame_equal(df2, df2_expected) df2 = sf.topk('float_data', 3).to_dataframe() df2_expected = self.dataframe.sort('float_data', ascending=False).head(3) df2_expected.index = range(3) assert_frame_equal(df2, df2_expected) df2 = sf.topk('string_data', 3).to_dataframe() for i in range(0, 3): self.assertEqual(df2['int_data'][2-i], i + 7) with self.assertRaises(TypeError): sf.topk(2,3) sf = SFrame() sf.add_column(SArray([1,2,3,4,5]), 'a') sf.add_column(SArray([1,2,3,4,5]), 'b') sf.topk('a', 1) # should not fail def test_filter(self): sf = SFrame(data=self.dataframe) filter_sa = SArray([1,1,1,0,0,0,0,1,1,1]) sf2 = sf[filter_sa] exp_df = sf.head(3).append(sf.tail(3)) self.__test_equal(sf2, exp_df.to_dataframe()) # filter by 1s sf2 = sf[SArray(self.int_data)] exp_df = sf.head(10).to_dataframe() self.__test_equal(sf2, exp_df) # filter by 0s sf2 = sf[SArray([0,0,0,0,0,0,0,0,0,0])] exp_df = sf.head(0).to_dataframe() self.__test_equal(sf2, exp_df) # wrong size with self.assertRaises(IndexError): sf2 = sf[SArray([0,1,205])] # slightly bigger size sf = gl.SFrame() n = 1000000 sf['a'] = range(n) result = sf[sf['a'] == -1] self.assertEquals(len(result), 0) result = sf[sf['a'] > n - 123] self.assertEquals(len(result), 122) l = list(result['a']) for i in range(len(result)): self.assertEquals(i + n - 122, l[i]) result = sf[sf['a'] < 2000] self.assertEquals(len(result), 2000) l = list(result['a']) for i in range(len(result)): self.assertEquals(i, l[i]) def test_sample_split(self): sf = SFrame(data=self.__create_test_df(100)) entry_list = set() for i in sf: entry_list.add(str(i)) sample_sf = sf.sample(.12, 9) sample_sf2 = sf.sample(.12, 9) self.assertEqual(len(sample_sf), len(sample_sf2)) assert_frame_equal(sample_sf.head().to_dataframe(), sample_sf2.head().to_dataframe()) for i in sample_sf: self.assertTrue(str(i) in entry_list) with self.assertRaises(ValueError): sf.sample(3) sample_sf = SFrame().sample(.12, 9) self.assertEqual(len(sample_sf), 0) a_split = sf.random_split(.12, 9) first_split_entries = set() for i in a_split[0]: first_split_entries.add(str(i)) for i in a_split[1]: self.assertTrue(str(i) in entry_list) self.assertTrue(str(i) not in first_split_entries) with self.assertRaises(ValueError): sf.random_split(3) self.assertEqual(len(SFrame().random_split(.4)[0]), 0) self.assertEqual(len(SFrame().random_split(.4)[1]), 0) # tests add_column, rename def test_edit_column_ops(self): sf = SFrame() # typical add column stuff sf.add_column(SArray(self.int_data)) sf.add_column(SArray(self.float_data)) sf.add_column(SArray(self.string_data)) # Make sure auto names work names = sf.column_names() cntr = 1 for i in names: self.assertEquals("X"+str(cntr), i) cntr = cntr + 1 # Remove a column del sf['X2'] # names names = sf.column_names() self.assertEquals(len(names), 2) self.assertEquals('X1', names[0]) self.assertEquals('X3', names[1]) # check content self.assertEquals(sf['X1'].head(10), self.int_data) self.assertEquals(sf['X3'].head(10), self.string_data) # check that a new automatically named column will not conflict sf.add_column(SArray(self.string_data)) names = sf.column_names() self.assertEquals(len(names), 3) uniq_set = set() for i in names: uniq_set.add(i) if len(uniq_set) == 1: self.assertEquals(list(sf[i].head(10)), self.int_data) else: self.assertEquals(list(sf[i].head(10)), self.string_data) self.assertEquals(len(uniq_set), 3) # replacing columns preserves order names = sf.column_names() for n in names: sf[n] = sf[n].apply(lambda x: x) self.assertEquals(sf.column_names(), names) # do it again! del sf['X1'] sf.add_column(SArray(self.string_data)) names = sf.column_names() self.assertEquals(len(names), 3) uniq_set = set() for i in names: uniq_set.add(i) self.assertEquals(list(sf[i].head(10)), self.string_data) self.assertEquals(len(uniq_set), len(names)) # standard rename rename_dict = {'X3':'data','X3.1':'more_data','X3.2':'even_more'} sf.rename(rename_dict) self.assertEquals(sf.column_names(), ['data','more_data','even_more']) # rename a column to a name that's already taken with self.assertRaises(RuntimeError): sf.rename({'data':'more_data'}) # try to rename a column that doesn't exist with self.assertRaises(ValueError): sf.rename({'foo':'bar'}) # pass something other than a dict with self.assertRaises(TypeError): sf.rename('foo') # Setting a column to const preserves order names = sf.column_names() for n in names: sf[n] = 1 self.assertEquals(sf.column_names(), names) def test_remove_column(self): sf = SFrame() # typical add column stuff sf.add_column(SArray(self.int_data)) sf.add_column(SArray(self.int_data)) sf.add_column(SArray(self.int_data)) sf.add_column(SArray(self.float_data)) sf.add_column(SArray(self.string_data)) self.assertEquals(sf.column_names(), ['X1', 'X2', 'X3', 'X4', 'X5']) sf2 = sf.remove_column('X3') assert sf is sf2 self.assertEquals(sf.column_names(), ['X1', 'X2', 'X4', 'X5']) sf2 = sf.remove_columns(['X2', 'X5']) assert sf is sf2 self.assertEquals(sf.column_names(), ['X1', 'X4']) # with a generator expression sf2 = sf.remove_columns((n for n in ['X1', 'X5'] if n in sf.column_names())) assert sf is sf2 self.assertEquals(sf.column_names(), ['X4']) def test_remove_bad_column(self): sf = SFrame() # typical add column stuff sf.add_column(SArray(self.int_data)) sf.add_column(SArray(self.int_data)) sf.add_column(SArray(self.int_data)) sf.add_column(SArray(self.float_data)) sf.add_column(SArray(self.string_data)) self.assertEquals(sf.column_names(), ['X1', 'X2', 'X3', 'X4', 'X5']) self.assertRaises(KeyError, lambda: sf.remove_column('bad')) self.assertEquals(sf.column_names(), ['X1', 'X2', 'X3', 'X4', 'X5']) self.assertRaises(KeyError, lambda: sf.remove_columns(['X1', 'X2', 'X3', 'bad', 'X4'])) self.assertEquals(sf.column_names(), ['X1', 'X2', 'X3', 'X4', 'X5']) def __generate_synthetic_sframe__(self, num_users): """ synthetic collaborative data. generate 1000 users, user i watched movie 0, ... i-1. rating(i, j) = i + j length(i, j) = i - j """ sf = SFrame() sparse_matrix = {} for i in range(1, num_users + 1): sparse_matrix[i] = [(j, i + j, i - j) for j in range(1, i + 1)] user_ids = [] movie_ids = [] ratings = [] length_of_watching = [] for u in sparse_matrix: user_ids += [u] * len(sparse_matrix[u]) movie_ids += [x[0] for x in sparse_matrix[u]] ratings += [x[1] for x in sparse_matrix[u]] length_of_watching += [x[2] for x in sparse_matrix[u]] # typical add column stuff sf['user_id'] = (SArray(user_ids, int)) sf['movie_id'] = (SArray(movie_ids, str)) sf['rating'] = (SArray(ratings, float)) sf['length'] = (SArray(length_of_watching, int)) return sf def test_aggregate_ops(self): """ Test builtin groupby aggregators """ for m in [1, 10, 20, 50, 100]: values = range(m) vector_values = [[random.randint(1,100) for num in range(10)] for y in range(m)] sf = gl.SFrame() sf['key'] = [1] * m sf['value'] = values sf['vector_values'] = vector_values sf.__materialize__() built_ins = [gl.aggregate.COUNT(), gl.aggregate.SUM('value'), gl.aggregate.AVG('value'), gl.aggregate.MIN('value'), gl.aggregate.MAX('value'), gl.aggregate.VAR('value'), gl.aggregate.STDV('value'), gl.aggregate.SUM('vector_values'), gl.aggregate.MEAN('vector_values')] sf2 = sf.groupby('key', built_ins) self.assertEqual(sf2['Count'], m) self.assertEqual(sf2['Sum of value'], sum(values)) self.assertEqual(sf2['Avg of value'], np.mean(values)) self.assertEqual(sf2['Min of value'], min(values)) self.assertEqual(sf2['Max of value'], max(values)) self.assertEqual(sf2['Var of value'], np.var(values)) self.assertEqual(sf2['Stdv of value'], np.std(values)) self.assertEqual(sf2['Vector Sum of vector_values'], np.sum(vector_values, axis=0)) self.assertEqual(sf2['Vector Avg of vector_values'], np.mean(vector_values, axis=0)) # For vectors def test_aggregate_ops_on_lazy_frame(self): """ Test builtin groupby aggregators """ for m in [1, 10, 20, 50, 100]: values = range(m) vector_values = [[random.randint(1,100) for num in range(10)] for y in range(m)] sf = gl.SFrame() sf['key'] = [1] * m sf['value'] = values sf['vector_values'] = vector_values sf['value'] = sf['value'] + 0 built_ins = [gl.aggregate.COUNT(), gl.aggregate.SUM('value'), gl.aggregate.AVG('value'), gl.aggregate.MIN('value'), gl.aggregate.MAX('value'), gl.aggregate.VAR('value'), gl.aggregate.STDV('value'), gl.aggregate.SUM('vector_values'), gl.aggregate.MEAN('vector_values')] sf2 = sf.groupby('key', built_ins) self.assertEqual(sf2['Count'], m) self.assertEqual(sf2['Sum of value'], sum(values)) self.assertEqual(sf2['Avg of value'], np.mean(values)) self.assertEqual(sf2['Min of value'], min(values)) self.assertEqual(sf2['Max of value'], max(values)) self.assertEqual(sf2['Var of value'], np.var(values)) self.assertEqual(sf2['Stdv of value'], np.std(values)) self.assertEqual(sf2['Vector Sum of vector_values'], np.sum(vector_values, axis=0)) self.assertEqual(sf2['Vector Avg of vector_values'], np.mean(vector_values, axis=0)) def test_aggregate_ops2(self): """ Test builtin groupby aggregators using explicit named columns """ for m in [1, 10, 20, 50, 100]: values = range(m) vector_values = [[random.randint(1,100) for num in range(10)] for y in range(m)] sf = gl.SFrame() sf['key'] = [1] * m sf['value'] = values sf['vector_values'] = vector_values built_ins = {'count':gl.aggregate.COUNT, 'sum':gl.aggregate.SUM('value'), 'avg':gl.aggregate.AVG('value'), 'avg2':gl.aggregate.MEAN('value'), 'min':gl.aggregate.MIN('value'), 'max':gl.aggregate.MAX('value'), 'var':gl.aggregate.VAR('value'), 'var2':gl.aggregate.VARIANCE('value'), 'stdv':gl.aggregate.STD('value'), 'stdv2':gl.aggregate.STDV('value'),'vector_sum': gl.aggregate.SUM('vector_values'),'vector_mean': gl.aggregate.MEAN('vector_values')} sf2 = sf.groupby('key', built_ins) self.assertEqual(sf2['count'], m) self.assertEqual(sf2['sum'], sum(values)) self.assertEqual(sf2['avg'], np.mean(values)) self.assertEqual(sf2['avg2'], np.mean(values)) self.assertEqual(sf2['min'], min(values)) self.assertEqual(sf2['max'], max(values)) self.assertEqual(sf2['var'], np.var(values)) self.assertEqual(sf2['var2'], np.var(values)) self.assertEqual(sf2['stdv'], np.std(values)) self.assertEqual(sf2['stdv2'], np.std(values)) self.assertEqual(sf2['vector_sum'], np.sum(vector_values, axis=0)) self.assertEqual(sf2['vector_mean'], np.mean(vector_values, axis=0)) def test_groupby(self): """ Test builtin groupby and aggregate on different column types """ num_users = 500 sf = self.__generate_synthetic_sframe__(num_users=num_users) built_ins = [gl.aggregate.COUNT(), gl.aggregate.SUM('rating'), gl.aggregate.AVG('rating'), gl.aggregate.MIN('rating'), gl.aggregate.MAX('rating'), gl.aggregate.VAR('rating'), gl.aggregate.STDV('rating')] built_in_names = ['Sum', 'Avg', 'Min', 'Max', 'Var', 'Stdv'] """ Test groupby user_id and aggregate on rating """ sf_user_rating = sf.groupby('user_id', built_ins) actual = sf_user_rating.column_names() expected = ['%s of rating' % v for v in built_in_names] + ['user_id'] + ['Count'] self.assertSetEqual(set(actual), set(expected)) for row in sf_user_rating: uid = row['user_id'] mids = range(1, uid + 1) ratings = [uid + i for i in mids] expected = [len(ratings), sum(ratings), np.mean(ratings), min(ratings), max(ratings), np.var(ratings), np.sqrt(np.var(ratings))] actual = [row['Count']] + [row['%s of rating' % op] for op in built_in_names] for i in range(len(actual)): self.assertAlmostEqual(actual[i], expected[i]) """ Test that count can be applied on empty aggregate column. """ sf_user_rating = sf.groupby("user_id", {'counter': gl.aggregate.COUNT()}) actual = {x['user_id']: x['counter'] for x in sf_user_rating} expected = {i: i for i in range(1, num_users + 1)} self.assertDictEqual(actual, expected) """ Test groupby movie_id and aggregate on length_of_watching """ built_ins = [gl.aggregate.COUNT(), gl.aggregate.SUM('length'), gl.aggregate.AVG('length'), gl.aggregate.MIN('length'), gl.aggregate.MAX('length'), gl.aggregate.VAR('length'), gl.aggregate.STDV('length')] sf_movie_length = sf.groupby('movie_id', built_ins) actual = sf_movie_length.column_names() expected = ['%s of length' % v for v in built_in_names] + ['movie_id'] + ['Count'] self.assertSetEqual(set(actual), set(expected)) for row in sf_movie_length: mid = row['movie_id'] uids = range(int(mid), num_users + 1) values = [i - int(mid) for i in uids] expected = [len(values), sum(values), np.mean(values), min(values), max(values), np.var(values), np.std(values)] actual = [row['Count']] + [row['%s of length' % op] for op in built_in_names] for i in range(len(actual)): self.assertAlmostEqual(actual[i], expected[i]) def test_quantile_groupby(self): sf = self.__generate_synthetic_sframe__(num_users=500) # max and min rating for each user g = sf.groupby('user_id', [gl.aggregate.MIN('rating'), gl.aggregate.MAX('rating'), gl.aggregate.QUANTILE('rating', 0, 1)]) self.assertEquals(len(g), 500) for row in g: minrating = row['Min of rating'] maxrating = row['Max of rating'] arr = list(row['Quantiles of rating']) self.assertEquals(len(arr), 2) self.assertEquals(arr[0], minrating) self.assertEquals(arr[1], maxrating) def test_argmax_argmin_groupby(self): sf = self.__generate_synthetic_sframe__(num_users=500) sf_ret = sf.groupby('user_id', {'movie with max rating':gl.aggregate.ARGMAX('rating','movie_id'), 'movie with min rating':gl.aggregate.ARGMIN('rating','movie_id')}) self.assertEquals(len(sf_ret), 500) self.assertEqual(sf_ret["movie with max rating"].dtype(), str) self.assertEqual(sf_ret["movie with min rating"].dtype(), str) self.assertEqual(sf_ret["user_id"].dtype(), int) # make sure we have computed correctly. max_d = {} min_d = {} for i in sf: key = i['user_id'] if key not in max_d: max_d[key] = (i['movie_id'],i['rating']) min_d[key] = (i['movie_id'],i['rating']) else: if max_d[key][1] < i['rating']: max_d[key] = (i['movie_id'],i['rating']) if min_d[key][1] > i['rating']: min_d[key] = (i['movie_id'],i['rating']) for i in sf_ret: key = i['user_id'] self.assertEqual(i["movie with max rating"],max_d[key][0]) self.assertEqual(i["movie with min rating"],min_d[key][0]) def test_multicolumn_groupby(self): sf = self.__generate_synthetic_sframe__(num_users=500) sf_um = sf.groupby(["user_id", "movie_id"], gl.aggregate.COUNT) # I can query it t = sf_um.to_dataframe() self.assertEqual(sf_um["user_id"].dtype(), int) self.assertEqual(sf_um["movie_id"].dtype(), str) # make sure we have counted correctly d = {} for i in sf: key = str(i['user_id']) + "," + i["movie_id"] if key not in d: d[key] = 0 d[key] = d[key] + 1 for i in sf_um: key = str(i['user_id']) + "," + i["movie_id"] self.assertTrue(key in d) self.assertEqual(i['Count'], d[key]) sf_um = sf.groupby(["movie_id", "user_id"], gl.aggregate.COUNT()) # I can query it t = sf_um.to_dataframe() self.assertEqual(sf_um["user_id"].dtype(), int) self.assertEqual(sf_um["movie_id"].dtype(), str) # make sure we have counted correctly d = {} for i in sf: key = str(i['user_id']) + "," + i["movie_id"] if key not in d: d[key] = 0 d[key] = d[key] + 1 for i in sf_um: key = str(i['user_id']) + "," + i["movie_id"] self.assertTrue(key in d) self.assertEqual(i['Count'], d[key]) def __assert_concat_result_equal(self, result, expected, list_columns): self.assertEqual(result.num_columns(), expected.num_columns()) for column in result.column_names(): c1 = result[column] c2 = expected[column] self.assertEqual(c1.dtype(), c2.dtype()) self.assertEqual(c1.size(), c2.size()) if (column in list_columns): for i in range(len(c1)): if (c1[i] == None): self.assertTrue(c2[i] == None) continue if (c1.dtype() == dict): for k in c1[i]: self.assertEqual(c2[i][k], c1[i][k]) else: s1 = list(c1[i]); if s1 != None: s1.sort() s2 = list(c2[i]); if s2 != None: s2.sort() self.assertEqual(s1, s2) else: self.assertEqual(list(c1),list(c2)) def test_groupby_dict_key(self): t = gl.SFrame({'a':[{1:2},{3:4}]}) with self.assertRaises(TypeError): t.groupby('a', {}) def test_concat(self): sf = SFrame() sf['a'] = [1,1,1,1, 2,2,2, 3, 4,4, 5] sf['b'] = [1,2,1,2, 3,3,1, 4, None, 2, None] sf['c'] = ['a','b','a','b', 'e','e', None, 'h', 'i','j', 'k'] sf['d'] = [1.0,2.0,1.0,2.0, 3.0,3.0,1.0, 4.0, None, 2.0, None] result = sf.groupby('a', gl.aggregate.CONCAT('b')) expected_result = SFrame({ 'a': [1,2,3,4, 5], 'List of b': [[1,1,2,2],[1,3,3],[4],[2], []] }) expected_result['List of b'] = expected_result['List of b'].astype(list) self.__assert_concat_result_equal(result.sort('a'), expected_result.sort('a'), ['List of b']) result = sf.groupby('a', gl.aggregate.CONCAT('d')) expected_result = SFrame({ 'a': [1,2,3,4, 5], 'List of d': [[1,1,2,2],[1,3,3],[4],[2], []] }) self.__assert_concat_result_equal(result.sort('a'), expected_result.sort('a'), ['List of d']) result = sf.groupby('a', {'c_c' :gl.aggregate.CONCAT('c')}) expected_result = SFrame({ 'a': [1,2,3,4, 5], 'c_c': [['a','b','a','b'],['e','e'],['h'],['i','j'], ['k']] }) self.__assert_concat_result_equal(result.sort('a'), expected_result.sort('a'), ['c_c']) result = sf.groupby('a', gl.aggregate.CONCAT('b','c')) expected_result = SFrame({ 'a': [1,2,3,4,5], 'Dict of b_c': [{1:'a',2:'b'},{3:'e', 1: None},{4:'h'},{2:'j'}, {}] }) self.__assert_concat_result_equal(result.sort('a'), expected_result.sort('a'), ['Dict of b_c']) result = sf.groupby('a', {'c_b':gl.aggregate.CONCAT('c','b')}) expected_result = SFrame({ 'a': [1,2,3,4,5], 'c_b': [{'a':1, 'b':2},{'e':3},{'h':4},{'i':None, 'j':2},{'k':None}] }) self.__assert_concat_result_equal(result.sort('a'), expected_result.sort('a'), ['c_b']) result = sf.groupby('a', {'cs':gl.aggregate.CONCAT('c'), 'bs':gl.aggregate.CONCAT('b')}) expected_result = SFrame({ 'a': [1,2,3,4,5], 'bs': [[1,1,2,2],[1,3,3],[4],[2], []], 'cs': [['a','b','a','b'],['e','e'],['h'],['i','j'], ['k']] }) expected_result['bs'] = expected_result['bs'].astype(list) self.__assert_concat_result_equal(result.sort('a'), expected_result.sort('a'), ['bs','cs']) #exception fail if there is not column with self.assertRaises(TypeError): sf.groupby('a', gl.aggregate.CONCAT()) with self.assertRaises(KeyError): sf.groupby('a', gl.aggregate.CONCAT('nonexist')) def test_select_one(self): sf = SFrame({'a':[1,1,2,2,3,3,4,4,5,5],'b':[1,2,3,4,5,6,7,8,9,10]}) res = list(sf.groupby('a', {'b':gl.aggregate.SELECT_ONE('b')})) self.assertEqual(len(res), 5) for i in res: self.assertTrue(i['b'] == 2 * i['a'] or i['b'] == 2 * i['a'] - 1) def test_unique(self): sf = SFrame({'a':[1,1,2,2,3,3,4,4,5,5],'b':[1,2,3,4,5,6,7,8,9,10]}) self.assertEqual(len(sf.unique()), 10) vals = [1,1,2,2,3,3,4,4, None, None] sf = SFrame({'a':vals,'b':vals}) res = sf.unique() self.assertEqual(len(res), 5) self.assertEqual(sorted(list(res['a'])), sorted([1,2,3,4,None])) self.assertEqual(sorted(list(res['b'])), sorted([1,2,3,4,None])) def test_append_all_match(self): sf1 = SFrame(data=self.dataframe) sf2 = SFrame(data=self.dataframe2) new_sf = sf1.append(sf2) assert_frame_equal(self.dataframe.append(self.dataframe2, ignore_index=True), new_sf.to_dataframe()) def test_append_lazy(self): sf1 = SFrame(data=self.dataframe) sf2 = SFrame(data=self.dataframe2) new_sf = sf1.append(sf2) self.assertTrue(new_sf.__is_materialized__()) filter_sf1 = SArray([1 for i in range(sf1.num_rows())] + [0 for i in range(sf2.num_rows())]) filter_sf2 = SArray([0 for i in range(sf1.num_rows())] + [1 for i in range(sf2.num_rows())]) new_sf1 = new_sf[filter_sf1] new_sf2 = new_sf[filter_sf2] assert_frame_equal(self.dataframe.append(self.dataframe2, ignore_index=True), new_sf.to_dataframe()) assert_frame_equal(sf1.to_dataframe(), new_sf1.to_dataframe()) assert_frame_equal(sf2.to_dataframe(), new_sf2.to_dataframe()) row = sf1.head(1) sf = SFrame() for i in range(10): sf = sf.append(row) df = sf.to_dataframe() for i in range(10): self.assertEqual(list(df.iloc[[i]]), list(sf.head(1).to_dataframe().iloc[[0]])) def test_recursive_append(self): sf = SFrame() for i in range(200): sf = sf.append(SFrame(data = self.dataframe)) #consume sf.__materialize__() def test_print_sframe(self): sf = SFrame() def _test_print(): sf.__repr__() sf._repr_html_() sf.print_rows() n = 20 sf['int'] = [i for i in range(n)] sf['float'] = [float(i) for i in range(n)] sf['str'] = [str(i) for i in range(n)] uc = '\xe5\xa4\xa7\xe5\xa4\xb4' # dato pronounced in chinese, big head sf['unicode'] = [uc for i in range(n)] sf['array'] = [array.array('d', [i]) for i in range(n)] sf['list'] = [[i, float(i), [i]] for i in range(n)] utc = dt.datetime.strptime('2011-01-21 02:37:21', '%Y-%m-%d %H:%M:%S') sf['dt'] = [utc for i in range(n)] sf['img'] = [Image() for i in range(n)] sf['long_str'] = ["".join([str(i)] * 50) for i in range(n)] sf['long_unicode'] = ["".join([uc] * 50) for i in range(n)] sf['bad_unicode'] = ['\x9d' + uc for i in range(n)] _test_print() def test_print_lazy_sframe(self): sf1 = SFrame(data=self.dataframe) self.assertTrue(sf1.__is_materialized__()) sf2 = sf1[sf1['int_data'] > 3] sf2.__repr__() sf2.__str__() self.assertFalse(sf2.__is_materialized__()) len(sf2) self.assertTrue(sf2.__is_materialized__()) def test_append_order_diff(self): # name match but column type order not match sf1 = SFrame(data=self.dataframe) sf2 = SFrame(data=self.dataframe2) sf2.swap_columns('int_data', 'string_data') new_sf = sf1.append(sf2) assert_frame_equal(self.dataframe.append(self.dataframe2, ignore_index=True), new_sf.to_dataframe()) def test_append_empty_sframe(self): sf = SFrame(data=self.dataframe) other = SFrame() # non empty append empty assert_frame_equal(sf.append(other).to_dataframe(), self.dataframe) # empty append non empty assert_frame_equal(other.append(sf).to_dataframe(), self.dataframe) #empty append empty assert_frame_equal(other.append(other).to_dataframe(), pd.DataFrame()) def test_append_exception(self): sf = SFrame(data=self.dataframe) # column number not match other = SFrame() other.add_column(SArray(), "test") self.assertRaises(RuntimeError, lambda: sf.append(other)) # column not the same # column name not match other = SFrame() names = sf.column_names() for name in sf.column_names(): other.add_column(SArray(), name) names[0] = 'some name not match' self.assertRaises(RuntimeError, lambda: sf.append(other)) # name match but column type order not match sf1 = SFrame(data=self.dataframe) sf2 = SFrame(data=self.dataframe2) #change one column type sf1["int_data"] = sf2.select_column("int_data").astype(float) self.assertRaises(RuntimeError, lambda: sf.append(other)) def test_simple_joins(self): inner_expected = SFrame() inner_expected.add_column(SArray(['Robinson','Jones','Smith','Heisenberg','Rafferty']), 'last_name') inner_expected.add_column(SArray([34,33,34,33,31]), 'dep_id') inner_expected.add_column(SArray(['Clerical','Engineering','Clerical','Engineering','Sales']), 'dep_name') # Tests the "natural join" case beg = time.time() res = self.employees_sf.join(self.departments_sf) end = time.time() print "Really small join: " + str(end-beg) + " s" self.__assert_join_results_equal(res, inner_expected) left_join_row = SFrame() left_join_row.add_column(SArray(['John']), 'last_name') left_join_row.add_column(SArray([None], int), 'dep_id') left_join_row.add_column(SArray([None], str), 'dep_name') left_expected = inner_expected.append(left_join_row) # Left outer join, passing string to 'on' res = self.employees_sf.join(self.departments_sf, how='left', on='dep_id') self.__assert_join_results_equal(res, left_expected) right_join_row = SFrame() right_join_row.add_column(SArray([None], str), 'last_name') right_join_row.add_column(SArray([35]), 'dep_id') right_join_row.add_column(SArray(['Marketing']), 'dep_name') right_expected = inner_expected.append(right_join_row) # Right outer join, passing list to 'on' res = self.employees_sf.join(self.departments_sf, how='right', on=['dep_id']) self.__assert_join_results_equal(res, right_expected) outer_expected = left_expected.append(right_join_row) # Full outer join, passing dict to 'on' res = self.employees_sf.join(self.departments_sf, how='outer', on={'dep_id':'dep_id'}) self.__assert_join_results_equal(res, outer_expected) # Test a join on non-matching key res = self.employees_sf.join(self.departments_sf, on={'last_name':'dep_name'}) self.assertEquals(res.num_rows(), 0) self.assertEquals(res.num_cols(), 3) self.assertEquals(res.column_names(), ['last_name', 'dep_id', 'dep_id.1']) # Test a join on a non-unique key bad_departments = SFrame() bad_departments['dep_id'] = SArray([33,33,31,31]) bad_departments['dep_name'] = self.departments_sf['dep_name'] no_pk_expected = SFrame() no_pk_expected['last_name'] = SArray(['Rafferty','Rafferty','Heisenberg','Jones','Heisenberg','Jones']) no_pk_expected['dep_id'] = SArray([31,31,33,33,33,33]) no_pk_expected['dep_name'] = SArray(['Clerical','Marketing','Sales','Sales','Engineering','Engineering']) res = self.employees_sf.join(bad_departments, on='dep_id') self.__assert_join_results_equal(res, no_pk_expected) # Left join on non-unique key bad_departments = bad_departments.append(right_join_row[['dep_id', 'dep_name']]) bad_departments = bad_departments.append(right_join_row[['dep_id', 'dep_name']]) no_pk_expected = no_pk_expected.append(right_join_row) no_pk_expected = no_pk_expected.append(right_join_row) no_pk_expected = no_pk_expected[['dep_id', 'dep_name', 'last_name']] res = bad_departments.join(self.employees_sf, on='dep_id', how='left') self.__assert_join_results_equal(res, no_pk_expected) def test_big_composite_join(self): # Create a semi large SFrame with composite primary key (letter, number) letter_keys = [] number_keys = [] data = [] for i in string.ascii_lowercase: for j in range(0,100): letter_keys.append(i) number_keys.append(j) which = j % 3 if which == 0: data.append(string.ascii_uppercase) elif which == 1: data.append(string.digits) elif which == 2: data.append(string.hexdigits) pk_gibberish = SFrame() pk_gibberish['letter'] = SArray(letter_keys, str) pk_gibberish['number'] = SArray(number_keys, int) pk_gibberish['data'] = SArray(data, str) # Some rows that won't match more_data = [] more_letter_keys = [] more_number_keys = [] for i in range(0,40000): more_data.append('fish') more_letter_keys.append('A') more_number_keys.append(200) for i in range(0,80): for j in range(100,1000): more_data.append('waffles') more_letter_keys.append(letter_keys[j]) more_number_keys.append(number_keys[j]) # Non-matching row in this stretch if j == 147: more_letter_keys[-1] = 'A' for i in range(0,5000): more_data.append('pizza') more_letter_keys.append('Z') more_number_keys.append(400) join_with_gibberish = SFrame() join_with_gibberish['data'] = SArray(more_data, str) join_with_gibberish['moredata'] = SArray(more_data, str) join_with_gibberish['a_number'] = SArray(more_number_keys, int) join_with_gibberish['a_letter'] = SArray(more_letter_keys, str) expected_answer = SFrame() exp_letter = [] exp_number = [] exp_data = [] for i in range(0,80): exp_letter.extend(letter_keys[100:147]) exp_number.extend(number_keys[100:147]) exp_letter.extend(letter_keys[148:1000]) exp_number.extend(number_keys[148:1000]) exp_data.extend(data[100:147]) exp_data.extend(data[148:1000]) expected_answer['letter'] = SArray(exp_letter, str) expected_answer['number'] = SArray(exp_number, int) expected_answer['data'] = SArray(exp_data, str) expected_answer['data.1'] = 'waffles' expected_answer['moredata'] = 'waffles' beg = time.time() res = pk_gibberish.join(join_with_gibberish, on={'letter':'a_letter','number':'a_number'}) end = time.time() print "Join took " + str(end-beg) + " seconds" self.__assert_join_results_equal(res, expected_answer) def test_convert_dataframe_empty(self): sf = SFrame() sf['a'] = gl.SArray([], int) df = sf.to_dataframe() self.assertEqual(df['a'].dtype, int) sf1 = SFrame(df) self.assertEquals(sf1['a'].dtype(), int) self.assertEqual(sf1.num_rows(), 0) def test_replace_one_column(self): sf = SFrame() sf['a'] = [1,2,3] self.assertEquals(sf['a'], [1,2,3]) # this should succeed as we are replacing a new column sf['a'] = [1,2] self.assertEquals(sf['a'], [1,2]) # failed to add new column should revert original sframe with self.assertRaises(TypeError): sf['a'] = [1,2,'a'] self.assertEquals(sf['a'], [1,2]) # add a column with different length should fail if there are more than one column sf = SFrame() sf['a'] = [1,2,3] sf['b'] = ['a', 'b', 'c'] with self.assertRaises(RuntimeError): sf['a'] = [1,2] def test_filter_by(self): # Set up SFrame to filter by sf = SFrame() sf.add_column(SArray(self.int_data), "ints") sf.add_column(SArray(self.float_data), "floats") sf.add_column(SArray(self.string_data), "strings") # Normal cases res = sf.filter_by(SArray(self.int_data), "ints") self.__assert_join_results_equal(res, sf) res = sf.filter_by(SArray(self.int_data), "ints", exclude=True) self.assertEquals(list(res), []) res = sf.filter_by([5,6], "ints") exp = SFrame() exp.add_column(SArray(self.int_data[4:6]), "ints") exp.add_column(SArray(self.float_data[4:6]), "floats") exp.add_column(SArray(self.string_data[4:6]), "strings") self.__assert_join_results_equal(res, exp) exp_opposite = SFrame() exp_opposite.add_column(SArray(self.int_data[:4]+self.int_data[6:]), "ints") exp_opposite.add_column(SArray(self.float_data[:4]+self.float_data[6:]), "floats") exp_opposite.add_column(SArray(self.string_data[:4]+self.string_data[6:]), "strings") res = sf.filter_by([5,6], "ints", exclude=True) self.__assert_join_results_equal(res, exp_opposite) exp_one = SFrame() exp_one.add_column(SArray(self.int_data[4:5]), "ints") exp_one.add_column(SArray(self.float_data[4:5]), "floats") exp_one.add_column(SArray(self.string_data[4:5]), "strings") exp_all_but_one = SFrame() exp_all_but_one.add_column(SArray(self.int_data[:4]+self.int_data[5:]), "ints") exp_all_but_one.add_column(SArray(self.float_data[:4]+self.float_data[5:]), "floats") exp_all_but_one.add_column(SArray(self.string_data[:4]+self.string_data[5:]), "strings") res = sf.filter_by(5, "ints") self.__assert_join_results_equal(res, exp_one) res = sf.filter_by(5, "ints", exclude=True) self.__assert_join_results_equal(res, exp_all_but_one) res = sf.filter_by("5", "strings") self.__assert_join_results_equal(res, exp_one) res = sf.filter_by(5, "ints", exclude=True) self.__assert_join_results_equal(res, exp_all_but_one) # Only missing values res = sf.filter_by([77,77,88,88], "ints") # Test against empty SFrame with correct columns/types self.__assert_join_results_equal(res, exp_one[exp_one['ints'] == 9000]) res = sf.filter_by([77,77,88,88], "ints", exclude=True) self.__assert_join_results_equal(res, sf) # Duplicate values res = sf.filter_by([6,6,5,5,6,5,5,6,5,5,5], "ints") self.__assert_join_results_equal(res, exp) res = sf.filter_by([6,6,5,5,6,5,5,6,5,5,5], "ints", exclude=True) self.__assert_join_results_equal(res, exp_opposite) # Duplicate and missing res = sf.filter_by([11,12,46,6,6,55,5,5], "ints") self.__assert_join_results_equal(res, exp) res = sf.filter_by([11,12,46,6,6,55,5,5], "ints", exclude=True) self.__assert_join_results_equal(res, exp_opposite) # Type mismatch with self.assertRaises(TypeError): res = sf.filter_by(["hi"], "ints") # Column doesn't exist with self.assertRaises(KeyError): res = sf.filter_by([1,2], "intssss") # Something that can't be turned into an SArray with self.assertRaises(Exception): res = sf.filter_by({1:2,3:4}, "ints") # column_name not given as string with self.assertRaises(TypeError): res = sf.filter_by(1,2) # Duplicate column names after join. Should be last because of the # renames. sf.rename({'ints':'id','floats':'id1','strings':'id11'}) exp.rename({'ints':'id','floats':'id1','strings':'id11'}) exp_opposite.rename({'ints':'id','floats':'id1','strings':'id11'}) res = sf.filter_by([5,6], "id") self.__assert_join_results_equal(res, exp) res = sf.filter_by([5,6], "id", exclude=True) self.__assert_join_results_equal(res, exp_opposite) def __test_to_from_dataframe(self, data, type): sf = SFrame() sf['a'] = data df = sf.to_dataframe() sf1 = SFrame(df) self.assertTrue(sf1.dtype()[0]== type) df = pd.DataFrame({'val': data}) sf1 = SFrame(df) self.assertTrue(sf1.dtype()[0]== type) def test_to_from_dataframe(self): self.__test_to_from_dataframe([1,2,3], int) self.__test_to_from_dataframe(['a', 'b', 'c'], str) self.__test_to_from_dataframe([1.0, 2.0, 3.0], float) self.__test_to_from_dataframe([[1, 'b', {'a': 1}], [1,2,3]], list) self.__test_to_from_dataframe([{'a':1, 1:None}, {'b':2}], dict) self.__test_to_from_dataframe([[1,2],[1,2],[]], array.array) def test_pack_columns_exception(self): sf = SFrame() sf['a'] = [1, 2, 3, None, None] sf['b'] = [None, '2', '3', None, '5'] sf['c'] = [None, 2.0, 3.0, None, 5.0] # cannot pack non array value into array with self.assertRaises(TypeError): sf.pack_columns(dtype=array.array) # cannnot given non numeric na vlaue to array with self.assertRaises(ValueError): sf.pack_columns(dtype=array.array, fill_na='c') # cannot pack non exist columns with self.assertRaises(ValueError): sf.pack_columns(['d','a']) # cannot pack less than two columns with self.assertRaises(ValueError): sf.pack_columns(['a']) # dtype has to be dict/array/list with self.assertRaises(ValueError): sf.pack_columns(dtype=str) # pack duplicate columns with self.assertRaises(ValueError): sf.pack_columns(['a','a']) # pack partial columns to array, should fail if for columns that are not numeric with self.assertRaises(TypeError): sf.pack_columns(['a','b'], dtype=array.array) with self.assertRaises(TypeError): sf.pack_columns(column_prefix = 1) with self.assertRaises(ValueError): sf.pack_columns(column_prefix = '1') with self.assertRaises(ValueError): sf.pack_columns(column_prefix = 'c', columns=['a', 'b']) def test_pack_columns2(self): from graphlab import SFrame, SArray sf = SFrame() sf['id'] = [1, 2, 3, 4] sf['category.a'] = [None, '2', '3', None] sf['category.b'] = [None, 2.0, None, 4.0] expected = SArray([ [None, None], ['2', 2.0], ['3', None], [None, 4.0]]) result = sf.pack_columns(column_prefix='category') self.assertEqual(result.column_names(), ['id', 'category']) self.__assert_sarray_equal(result['id'], sf['id']) self.__assert_sarray_equal(result['category'], expected) result = sf.pack_columns(column_prefix='category', new_column_name="new name") self.assertEqual(result.column_names(), ['id', 'new name']) self.__assert_sarray_equal(result['id'], sf['id']) self.__assert_sarray_equal(result['new name'], expected) # default dtype is list result = sf.pack_columns(column_prefix='category', dtype=list) self.assertEqual(result.column_names(), ['id', 'category']) self.__assert_sarray_equal(result['category'], expected) # remove prefix == True by default expected = SArray([ {}, {'a':'2', 'b':2.0}, {'a':'3'}, {'b':4.0} ]) result = sf.pack_columns(column_prefix='category', dtype=dict) self.__assert_sarray_equal(result['category'], expected) # remove prefix == False expected = SArray([ {}, {'category.a':'2', 'category.b':2.0}, {'category.a':'3'}, {'category.b':4.0} ]) result = sf.pack_columns(column_prefix='category', dtype=dict, remove_prefix=False) self.assertEqual(result.column_names(), ['id', 'category']) self.__assert_sarray_equal(result['category'], expected) # fill_na expected = SArray([ {'a':1, 'b':1}, {'a':'2', 'b':2.0}, {'a':'3', 'b':1}, {'a':1, 'b':4.0} ]) result = sf.pack_columns(column_prefix='category', dtype=dict, fill_na = 1) self.__assert_sarray_equal(result['category'], expected) def test_pack_columns(self): sf = SFrame() sf['id'] = [1, 2, 3, 4, 5] sf['b'] = [None, '2', '3', None, '5'] sf['c'] = [None, 2.0, 3.0, None, 5.0] expected_all_default = SArray([ [1, None, None], [2, '2', 2.0], [3, '3', 3.0], [4, None, None], [5, '5', 5.0] ]) # pack all columns, all default values self.__assert_sarray_equal(sf.pack_columns()['X1'], expected_all_default) expected_ab_default = SArray([ [1, None], [2, '2'], [3, '3'], [4, None], [5, '5'] ]) expected_all_fillna_1 = SArray([ [1, -1, -1], [2, '2', 2.0], [3, '3', 3.0], [4, -1, -1], [5, '5', 5.0] ]) # pack all columns do not drop na and also fill with some value result = sf.pack_columns(fill_na=-1) self.assertEqual(result.column_names(), ['X1']) self.__assert_sarray_equal(result['X1'], expected_all_fillna_1) # pack partial columns, all default value result = sf.pack_columns(['id','b']) self.assertEqual(result.column_names(), ['c','X2']) self.__assert_sarray_equal(result['c'], sf['c']) self.__assert_sarray_equal(result['X2'], expected_ab_default) expected_sarray_ac_fillna_default = SArray([ [1, float('NaN')], [2, 2.0], [3, 3.0], [4, float('NaN')], [5, 5.0] ]) result = sf.pack_columns(['id','c'], dtype=array.array) self.assertEqual(result.column_names(), ['b', 'X2']) self.__assert_sarray_equal(result['b'], sf['b']) self.__assert_sarray_equal(result['X2'], expected_sarray_ac_fillna_default) expected_dict_default = SArray([ {'id': 1}, {'id': 2, 'b':'2', 'c': 2.0}, {'id': 3, 'b':'3', 'c': 3.0}, {'id':4 }, {'id':5, 'b':'5', 'c': 5.0} ]) result = sf.pack_columns(dtype=dict) self.__assert_sarray_equal(result['X1'], expected_dict_default) expected_dict_fillna = SArray([ {'id': 1, 'b':-1, 'c': -1}, {'id': 2, 'b':'2', 'c': 2.0}, {'id': 3, 'b':'3', 'c': 3.0}, {'id': 4, 'b':-1, 'c': -1}, {'id': 5, 'b':'5', 'c': 5.0} ]) result = sf.pack_columns(dtype=dict, fill_na=-1) self.__assert_sarray_equal(result['X1'], expected_dict_fillna) # pack large number of rows sf = SFrame() num_rows = 100000 sf['a'] = range(0, num_rows); sf['b'] = range(0, num_rows); result = sf.pack_columns(['a', 'b']); self.assertEqual(len(result), num_rows); def test_pack_columns_dtype(self): a = SFrame({'name':[-140500967,-1405039672],'data':[3,4]}) b = a.pack_columns(['name','data'],dtype=array.array) expected = SArray([[-140500967, 3],[-1405039672,4]]) self.__assert_sarray_equal(b['X1'], expected) def test_unpack_list(self): sa = SArray([ [1, None, None], [2, '2', 2.0], [3, '3', 3.0], [4, None, None], [5, '5', 5.0] ]) expected = SFrame() expected ['a'] = [1, 2, 3, 4, 5] expected ['b'] = [None, '2', '3', None, '5'] expected ['c'] = [None, 2.0, 3.0, None, 5.0] result = sa.unpack(); result.rename(dict(zip(result.column_names(), ['a','b','c']))) assert_frame_equal(result.to_dataframe(), expected.to_dataframe()) result = sa.unpack(column_name_prefix='ttt'); self.assertEqual(result.column_names(), ['ttt.0', 'ttt.1', 'ttt.2']) result.rename(dict(zip(result.column_names(), ['a','b','c']))) assert_frame_equal(result.to_dataframe(), expected.to_dataframe()) # column types result = sa.unpack(column_types=[int, str, float]); result.rename(dict(zip(result.column_names(), ['a','b','c']))) assert_frame_equal(result.to_dataframe(), expected.to_dataframe()) # more column types result = sa.unpack(column_types=[int, str, float, int]); result.rename(dict(zip(result.column_names(), ['a','b','c','d']))) e = expected.select_columns(['a','b','c']) e.add_column(SArray([None for i in range(5)], int),'d') assert_frame_equal(result.to_dataframe(), e.to_dataframe()) # less column types result = sa.unpack(column_types=[int, str]); result.rename(dict(zip(result.column_names(), ['a','b']))) e = expected.select_columns(['a','b']) assert_frame_equal(result.to_dataframe(), e.to_dataframe()) # fill na_value e = SFrame() e['a'] = [1, 2, None, 4, 5] e['b'] = [None, '2', '3', None, '5'] e['c'] = [None, 2.0, None, None, 5.0] result = sa.unpack(na_value=3); result.rename(dict(zip(result.column_names(), ['a','b','c']))) assert_frame_equal(result.to_dataframe(), e.to_dataframe()) # wrong length with self.assertRaises(TypeError): sa.unpack(column_name_prefix=['a','b']) # wrong type with self.assertRaises(RuntimeError): sa.unpack(column_types = [str, int, float]) # wrong limit types with self.assertRaises(TypeError): sa.unpack(limit=["1"]) # int array cannot be unpacked with self.assertRaises(TypeError): SArray([1,2,3,4]).unpack() # column name must be a string with self.assertRaises(TypeError): sa.unpack(1) # invalid column type with self.assertRaises(TypeError): sa.unpack(column_types = int) # invalid column type with self.assertRaises(TypeError): sa.unpack(column_types = [np.array]) # cannot infer type if no values with self.assertRaises(RuntimeError): SArray([], list).unpack() def test_unpack_array(self): sa = SArray([ [1, 1, 0], [2, -1, 1], [3, 3, 2], [-1, 2, 3], [5, 5, 4] ]) expected = SFrame() expected ['a'] = [1.0, 2.0, 3.0, -1.0, 5.0] expected ['b'] = [1.0, -1.0, 3.0, 2.0, 5.0] expected ['c'] = [0.0, 1.0, 2.0, 3.0, 4.0] result = sa.unpack(); result.rename(dict(zip(result.column_names(), ['a','b','c']))) assert_frame_equal(result.to_dataframe(), expected.to_dataframe()) # right amount column names result = sa.unpack(column_name_prefix = 'unpacked'); result.rename(dict(zip(result.column_names(), ['t.0', 't.1', 't.2']))) result.rename(dict(zip(result.column_names(), ['a','b','c']))) assert_frame_equal(result.to_dataframe(), expected.to_dataframe()) # column types result = sa.unpack(column_types=[int, str, float]); result.rename(dict(zip(result.column_names(), ['a','b','c']))) expected['a'] = expected['a'].astype(int) expected['b'] = expected['b'].astype(str) expected['c'] = expected['c'].astype(float) assert_frame_equal(result.to_dataframe(), expected.to_dataframe()) # more column types result = sa.unpack(column_types=[int, str, float, int]); result.rename(dict(zip(result.column_names(), ['a','b','c','d']))) e = expected.select_columns(['a','b','c']) e.add_column(SArray([None for i in range(5)], int),'d') assert_frame_equal(result.to_dataframe(), e.to_dataframe()) # less column types result = sa.unpack(column_types=[int, str]); result.rename(dict(zip(result.column_names(), ['a','b']))) e = expected.select_columns(['a','b']) assert_frame_equal(result.to_dataframe(), e.to_dataframe()) # fill na_value e = SFrame() e['a'] = gl.SArray([1, 2, 3, None, 5], float) e['b'] = gl.SArray([1, None, 3, 2, 5], float) e['c'] = gl.SArray([0, 1, 2, 3, 4], float) result = sa.unpack(na_value=-1); result.rename(dict(zip(result.column_names(), ['a','b','c']))) assert_frame_equal(result.to_dataframe(), e.to_dataframe()) def test_unpack_dict(self): sf = SFrame() sf["user_id"] = [1,2,3,4,5,6,7] sf["is_restaurant"] = [1, 1,0,0, 1, None, None] sf["is_retail"] = [None,1,1,None,1, None, None] sf["is_electronics"] = ["yes", "no","yes",None,"no", None, None] packed_sf = gl.SFrame() packed_sf['user_id'] = sf['user_id'] packed_sf["category"] = [ {"is_restaurant": 1, "is_electronics": "yes"}, {"is_restaurant": 1, "is_retail": 1, "is_electronics": "no"}, {"is_restaurant": 0, "is_retail": 1, "is_electronics": "yes"}, {"is_restaurant": 0 }, {"is_restaurant": 1, "is_retail": 1, "is_electronics": "no"}, { }, None] with self.assertRaises(TypeError): packed_sf['user_id'].unpack() with self.assertRaises(TypeError): packed_sf['category'].unpack(1) with self.assertRaises(TypeError): packed_sf['category'].unpack(value_types = [int]) # unpack only one column expected_sf = gl.SFrame() expected_sf["is_retail"] = sf["is_retail"] unpacked_sf = packed_sf['category'].unpack(limit=["is_retail"], column_types=[int], column_name_prefix=None) assert_frame_equal(unpacked_sf.to_dataframe(), expected_sf.to_dataframe()) # unpack all unpacked_sf = packed_sf['category'].unpack(column_name_prefix=None, column_types=[int, int, str], limit=["is_restaurant", "is_retail", "is_electronics"]) assert_frame_equal(unpacked_sf.to_dataframe(), sf[["is_restaurant", "is_retail", "is_electronics"]].to_dataframe()) # auto infer types, the column order may be different, so use order here before comparison unpacked_sf = packed_sf["category"].unpack() unpacked_sf.rename({ "X.is_restaurant": "is_restaurant", "X.is_retail": "is_retail", "X.is_electronics": "is_electronics" }) assert_frame_equal(unpacked_sf.to_dataframe().sort(axis=1), sf[["is_restaurant", "is_retail", "is_electronics"]].to_dataframe().sort(axis=1)) unpacked_sf = packed_sf["category"].unpack(na_value = 0, column_name_prefix="new") expected = SFrame() expected["new.is_restaurant"] = [1, 1,None,None, 1, None, None] expected["new.is_retail"] = [None,1,1,None,1, None, None] expected["new.is_electronics"] = ["yes", "no","yes",None,"no", None, None] assert_frame_equal(unpacked_sf.to_dataframe().sort(axis=1), expected.to_dataframe().sort(axis=1)) # unpack a dictionary key integer as key from graphlab import SArray sa = SArray([ {1: 'a'}, {2: 'b'} ]) result = sa.unpack() expected = SFrame({'X.1':['a', None], 'X.2':[None, 'b']}) assert_frame_equal(result.to_dataframe(), expected.to_dataframe()) result = sa.unpack(limit=[2]) expected = SFrame({'X.2':[None, 'b']}) assert_frame_equal(result.to_dataframe(), expected.to_dataframe()) result = sa.unpack(limit=[2], column_name_prefix="expanded") expected = SFrame({'expanded.2':[None, 'b']}) assert_frame_equal(result.to_dataframe(), expected.to_dataframe()) sa = gl.SArray([{i:i} for i in range(500)]) unpacked_sa = sa.unpack() self.assertEqual(len(unpacked_sa), len(sa)) i = 0 for v in unpacked_sa: for j in range(500): val = v['X.' + str(j)] if (j == i): self.assertEqual(val, i); else: self.assertEqual(val, None); i = i + 1 # if types don't agree, convert to string automatically sa = gl.SArray([{'a':1},{'a': 'a_3'}]) sf = sa.unpack() self.assertEqual(sf.column_types(), [str]) sa = gl.SArray([{'a':None}, {'a': 1}]) sf = sa.unpack() self.assertEqual(sf.column_types(), [int]) sa = gl.SArray([{'a':1}, {'a': None}]) sf = sa.unpack() self.assertEqual(sf.column_types(), [int]) # type inferrence is already at server side even if limit is given sa = gl.SArray([{'c'+str(i): i if i % 2 == 0 else 'v' + str(i)} for i in range(1000)]) unpacked = sa.unpack(limit=['c'+str(i) for i in range(10)], column_name_prefix="") for i in range(10): v = unpacked[i] for j in range(10): if (j != i): self.assertEqual(v['c'+str(j)], None) elif j % 2 == 0: self.assertEqual(v['c'+str(j)], j) else: self.assertEqual(v['c'+str(j)], 'v' + str(j)) def test_unpack_sframe(self): from graphlab import SFrame, SArray import graphlab as gl sf = gl.SFrame() sf['user_id'] = range(7) sf["category"] = [ {"is_restaurant": 1, "is_electronics": "yes"}, {"is_restaurant": 1, "is_retail": 1, "is_electronics": "no"}, {"is_restaurant": 0, "is_retail": 1, "is_electronics": "yes"}, {"is_restaurant": 0 }, {"is_restaurant": 1, "is_retail": 1, "is_electronics": "no"}, { }, None] sf['list'] = [ None, range(1), range(2), range(3), range(1), range(2), range(3), ] with self.assertRaises(TypeError): sf.unpack('user_id') expected = SFrame() expected['user_id'] = sf['user_id'] expected['list'] = sf['list'] expected["is_restaurant"] = [1, 1,0,0, 1, None, None] expected["is_retail"] = [None,1,1,None,1, None, None] expected["is_electronics"] = ["yes", "no","yes",None,"no", None, None] result = sf.unpack('category') result.rename({ 'category.is_restaurant': 'is_restaurant', 'category.is_retail': 'is_retail', 'category.is_electronics': 'is_electronics' }) assert_frame_equal(expected.to_dataframe().sort(axis=1), result.to_dataframe().sort(axis=1)) result = sf.unpack(unpack_column='category', column_name_prefix="") assert_frame_equal(expected.to_dataframe().sort(axis=1), result.to_dataframe().sort(axis=1)) result = sf.unpack(unpack_column='category', column_name_prefix="abc") result.rename({ 'abc.is_restaurant': 'is_restaurant', 'abc.is_retail': 'is_retail', 'abc.is_electronics': 'is_electronics' }) assert_frame_equal(expected.to_dataframe().sort(axis=1), result.to_dataframe().sort(axis=1)) result = sf.unpack(unpack_column='category', column_name_prefix="", column_types=[str], limit=['is_restaurant']) new_expected = expected[['user_id', 'list', 'is_restaurant']] new_expected['is_restaurant'] = new_expected['is_restaurant'].astype(str) assert_frame_equal(new_expected.to_dataframe().sort(axis=1), result.to_dataframe().sort(axis=1)) result = sf.unpack(unpack_column='category', column_name_prefix="", na_value = None) assert_frame_equal(expected.to_dataframe().sort(axis=1), result.to_dataframe().sort(axis=1)) result = sf.unpack(unpack_column='list') expected = SFrame() expected['user_id'] = sf['user_id'] expected['list.0'] = [None,0,0,0, 0,0,0] expected['list.1'] = [None,None,1,1, None,1,1] expected['list.2'] = [None,None,None,2, None, None,2] expected['category'] = sf['category'] assert_frame_equal(expected.to_dataframe().sort(axis=1), result.to_dataframe().sort(axis=1)) result = sf.unpack(unpack_column='list', na_value= 2) expected = SFrame() expected['user_id'] = sf['user_id'] expected['list.0'] = [None,0,0,0, 0,0,0] expected['list.1'] = [None,None,1,1, None,1,1] expected['list.2'] = [None,None,None,None, None, None,None] expected['category'] = sf['category'] assert_frame_equal(expected.to_dataframe().sort(axis=1), result.to_dataframe().sort(axis=1)) # auto resolving conflicting names sf = SFrame() sf['a'] = range(100) sf['b'] = [range(5) for i in range(100)] sf['b.0'] = range(100) sf['b.0.1'] = range(100) result = sf.unpack('b') self.assertEqual(result.column_names(), ['a', 'b.0', 'b.0.1', 'b.0.1.1', 'b.1.1.1', 'b.2.1.1', 'b.3.1.1', 'b.4.1.1']) sf = SFrame() sf['a'] = range(100) sf['b'] = [{'str1': i, 'str2':i + 1} for i in range(100)] sf['b.str1'] = range(100) result = sf.unpack('b') self.assertEqual(len(result.column_names()), 4) def test_stack_dict(self): sf = SFrame() sf["user_id"] = [1,2,3,4,5] sf["user_name"] = ['user' + str(i) for i in list(sf['user_id'])] sf["category"] = [ {"is_restaurant": 1, }, {"is_restaurant": 0, "is_retail": 1 }, { "is_retail": 0 }, {}, None] expected_sf = SFrame(); expected_sf["user_id"] = [1,2, 2, 3,4,5] expected_sf["user_name"] = ['user' + str(i) for i in list(expected_sf['user_id'])] expected_sf['category'] = ['is_restaurant', 'is_restaurant', 'is_retail', 'is_retail', None, None] expected_sf['value'] = [1,0,1,0, None, None] df_expected = expected_sf.to_dataframe().sort(['user_id', 'category']).reset_index(drop=True) with self.assertRaises(TypeError): sf.stack() with self.assertRaises(ValueError): sf.stack('sss') with self.assertRaises(ValueError): sf.stack('category', ['user_id', 'value']) # normal case stacked_sf = sf.stack('category', ['category', 'value']) assert_frame_equal(stacked_sf.to_dataframe().sort(["user_id", "category"]).reset_index(drop=True), df_expected) # set column types stacked_sf = sf.stack('category') self.assertTrue(stacked_sf.column_types()[2] == str) self.assertTrue(stacked_sf.column_types()[3] == int) # auto generate column names stacked_sf = sf.stack('category') new_column_names = stacked_sf.column_names() self.assertTrue(len(new_column_names) == 4) expected_sf.rename({'category':new_column_names[2], 'value':new_column_names[3]}) df_expected = expected_sf.to_dataframe().sort(['user_id', new_column_names[2]]).reset_index(drop=True) assert_frame_equal(stacked_sf.to_dataframe().sort(["user_id", new_column_names[2]]).reset_index(drop=True), df_expected) #dropna expected_sf = SFrame(); expected_sf["user_id"] = [1,2, 2, 3, 4, 5] expected_sf["user_name"] = ['user' + str(i) for i in list(expected_sf['user_id'])] expected_sf['category'] = ['is_restaurant', 'is_restaurant', 'is_retail', 'is_retail', None, None] expected_sf['value'] = [1,0,1,0, None, None] df_expected = expected_sf.to_dataframe().sort(['user_id', 'category']).reset_index(drop=True) stacked_sf = sf.stack('category', ['category','value'], drop_na = False) assert_frame_equal(stacked_sf.to_dataframe().sort(["user_id", "category"]).reset_index(drop=True), df_expected) def test_stack_list(self): sf = SFrame() sf["a"] = [1,2,3,4,5] sf["b"] = [['a', 'b'], ['c'], ['d'],['e', None], None] expected_result = SFrame() expected_result['a'] = [1,1,2,3,4,4,5] expected_result['X1'] = ['a','b','c','d','e',None, None] with self.assertRaises(TypeError): sf.stack() with self.assertRaises(ValueError): sf.stack('sss') with self.assertRaises(TypeError): sf.stack('a') with self.assertRaises(TypeError): sf.stack('b', ["something"]) result = sf.stack("b", drop_na = False) stacked_column_name = result.column_names()[1] expected_result.rename({'X1':stacked_column_name}) assert_frame_equal(result.to_dataframe(), expected_result.to_dataframe()) # default drop_na=False result = sf.stack("b") assert_frame_equal(result.to_dataframe(), expected_result.to_dataframe()) result = sf.stack("b", new_column_name = "b", drop_na = False) expected_result.rename({stacked_column_name: 'b'}) assert_frame_equal(result.to_dataframe(), expected_result.to_dataframe()) result = sf.stack("b", new_column_name = "b", drop_na = False) assert_frame_equal(result.to_dataframe(), expected_result.to_dataframe()) # drop_na=True result = sf.stack("b", drop_na = True) expected_result = SFrame() expected_result['a'] = [1,1,2,3,4,4] expected_result[result.column_names()[1]] = ['a','b','c','d','e',None] assert_frame_equal(result.to_dataframe(), expected_result.to_dataframe()) sf = SFrame() n = 1000000 sf['a'] = range(1,n) sf['b'] = [[str(i), str(i+1)] for i in range(1,n)] result = sf.stack('b') self.assertTrue(len(result), n * 2) def test_stack_vector(self): sf = SFrame() sf["a"] = [1,2,3,4,5] sf["b"] = [[1],[1,2],[1,2,3],[1,2,3,4],None] expected_result = SFrame() expected_result['a'] = [1,2,2,3,3,3,4,4,4,4,5] expected_result['X1'] = [1,1,2,1,2,3,1,2,3,4,None] with self.assertRaises(TypeError): sf.stack() with self.assertRaises(ValueError): sf.stack('sss') with self.assertRaises(TypeError): sf.stack('a') with self.assertRaises(TypeError): sf.stack('b', ["something"]) result = sf.stack("b", drop_na = False) stacked_column_name = result.column_names()[1] expected_result.rename({'X1':stacked_column_name}) assert_frame_equal(result.to_dataframe(), expected_result.to_dataframe()) # default drop_na=False result = sf.stack("b") assert_frame_equal(result.to_dataframe(), expected_result.to_dataframe()) result = sf.stack("b", new_column_name = "b", drop_na = False) expected_result.rename({stacked_column_name: 'b'}) assert_frame_equal(result.to_dataframe(), expected_result.to_dataframe()) result = sf.stack("b", new_column_name = "b", drop_na = False) assert_frame_equal(result.to_dataframe(), expected_result.to_dataframe()) # drop_na=True result = sf.stack("b", drop_na = True) expected_result = SFrame() expected_result['a'] = [1,2,2,3,3,3,4,4,4,4] expected_result[result.column_names()[1]] = gl.SArray([1,1,2,1,2,3,1,2,3,4], float) assert_frame_equal(result.to_dataframe(), expected_result.to_dataframe()) def test_unstack_dict(self): sf = SFrame() sf["user_id"] = [1,2,3,4] sf["user_name"] = ['user' + str(i) for i in list(sf['user_id'])] sf["categories"] = [ {"is_restaurant": 1, }, {"is_restaurant": 0, "is_retail": 1 }, { "is_retail": 0 }, None] stacked_sf = sf.stack('categories', ['category', 'value'], drop_na=False) # normal unstack unstacked_sf = stacked_sf.unstack(column=['category', 'value'], new_column_name = 'categories') # these frames are *almost* equal except user4 will be {} instead of None assert_frame_equal(sf.fillna('categories',{}).to_dataframe(), unstacked_sf.to_dataframe().sort("user_id").reset_index(drop=True)) # missing new column name unstacked_sf = stacked_sf.unstack(['category', 'value']) self.assertEqual(len(unstacked_sf.column_names()), 3) unstacked_sf.rename({unstacked_sf.column_names()[2] : 'categories'}) assert_frame_equal(sf.fillna('categories',{}).to_dataframe(), unstacked_sf.to_dataframe().sort("user_id").reset_index(drop=True)) # missing column names with self.assertRaises(KeyError): stacked_sf.unstack(['category','value1']) # wrong input with self.assertRaises(TypeError): stacked_sf.unstack(['category']) # duplicate new column name with self.assertRaises(RuntimeError): unstacked_sf = stacked_sf.unstack(['category', 'value'], 'user_name') def test_unstack_list(self): sf = SFrame() sf['a'] = [1,2,3,4] sf['b'] = [range(10), range(20), range(30), range(50)] stacked_sf = sf.stack('b', new_column_name = 'new_b') unstacked_sf = stacked_sf.unstack('new_b', new_column_name = 'b') self.__assert_concat_result_equal(sf.sort('a'), unstacked_sf.sort('a'), ['b']) unstacked_sf = stacked_sf.unstack('new_b') unstacked_sf.rename({unstacked_sf.column_names()[1]: 'b'}) self.__assert_concat_result_equal(sf.sort('a'), unstacked_sf.sort('a'), ['b']) unstacked_sf = stacked_sf.unstack('new_b', new_column_name='b') unstacked_sf.rename({unstacked_sf.column_names()[1]: 'b'}) self.__assert_concat_result_equal(sf.sort('a'), unstacked_sf.sort('a'), ['b']) with self.assertRaises(RuntimeError): stacked_sf.unstack('new_b', new_column_name='a') with self.assertRaises(TypeError): stacked_sf.unstack(['new_b']) with self.assertRaises(KeyError): stacked_sf.unstack('non exist') def test_content_identifier(self): sf = SFrame({"a":[1,2,3,4],"b":["1","2","3","4"]}) a1 = sf['a'].__get_content_identifier__() a2 = sf['a'].__get_content_identifier__() self.assertEquals(a1, a2) def test_random_access(self): t1 = list(range(0,100000)) t2 = [str(i) for i in t1] t = [{'t1':t1[i], 't2':t2[i]} for i in range(len(t1))]; s = gl.SFrame({'t1':t1,'t2':t2}) # simple slices self.__test_equal(s[1:10000], pd.DataFrame(t[1:10000])) self.__test_equal(s[0:10000:3], pd.DataFrame(t[0:10000:3])) self.__test_equal(s[1:10000:3], pd.DataFrame(t[1:10000:3])) self.__test_equal(s[2:10000:3], pd.DataFrame(t[2:10000:3])) self.__test_equal(s[3:10000:101], pd.DataFrame(t[3:10000:101])) # negative slices self.__test_equal(s[-5:], pd.DataFrame(t[-5:])) self.__test_equal(s[-1:], pd.DataFrame(t[-1:])) self.__test_equal(s[-100:-10], pd.DataFrame(t[-100:-10])) self.__test_equal(s[-100:-10:2], pd.DataFrame(t[-100:-10:2])) # single element reads self.assertEqual(s[511], t[511]) self.assertEqual(s[1912],t[1912]) self.assertEqual(s[-1], t[-1]) self.assertEqual(s[-10],t[-10]) # edge case odities self.__test_equal(s[10:100:100], pd.DataFrame(t[10:100:100])) self.__test_equal(s[-100:len(s):10], pd.DataFrame(t[-100:len(t):10])) self.assertEqual(len(s[-1:-2]), 0) self.assertEqual(len(s[-1:-1000:2]), 0) with self.assertRaises(IndexError): s[len(s)] def test_sort(self): sf = SFrame() nrows = 100 sf['a'] = range(1, nrows) sf['b'] = [float(i) for i in range(1,nrows)] sf['c'] = [str(i) for i in range(1,nrows)] sf['d'] = [[i, i+1] for i in range(1,nrows)] reversed_sf = SFrame() reversed_sf['a'] = range(nrows-1, 0, -1) reversed_sf['b'] = [float(i) for i in range(nrows-1, 0, -1)] reversed_sf['c'] = [str(i) for i in range(nrows-1, 0, -1)] reversed_sf['d'] = [[i, i+1] for i in range(nrows-1, 0, -1)] with self.assertRaises(TypeError): sf.sort() with self.assertRaises(TypeError): sf.sort(1) with self.assertRaises(TypeError): sf.sort("d") with self.assertRaises(ValueError): sf.sort("nonexist") with self.assertRaises(TypeError): sf.sort({'a':True}) result = sf.sort('a') assert_frame_equal(sf.to_dataframe(), result.to_dataframe()); result = sf.sort('a', ascending = False) assert_frame_equal(reversed_sf.to_dataframe(), result.to_dataframe()); # sort two columns result = sf.sort(['a', 'b']) assert_frame_equal(sf.to_dataframe(), result.to_dataframe()); result = sf.sort(['a', 'c'], ascending = False) assert_frame_equal(reversed_sf.to_dataframe(), result.to_dataframe()); result = sf.sort([('a', True), ('b', False)]) assert_frame_equal(sf.to_dataframe(), result.to_dataframe()); result = sf.sort([('a', False), ('b', True)]) assert_frame_equal(reversed_sf.to_dataframe(), result.to_dataframe()); def test_dropna(self): # empty case sf = SFrame() self.assertEquals(len(sf.dropna()), 0) # normal case self.__test_equal(self.employees_sf.dropna(), self.employees_sf[0:5].to_dataframe()) test_split = self.employees_sf.dropna_split() self.__test_equal(test_split[0], self.employees_sf[0:5].to_dataframe()) self.__test_equal(test_split[1], self.employees_sf[5:6].to_dataframe()) # create some other test sframe test_sf = SFrame({'ints':SArray([None,None,3,4,None], int), 'floats':SArray([np.nan,2.,3.,4.,np.nan],float), 'strs':SArray(['1',np.nan,'','4',None], str), 'lists':SArray([[1],None,[],[1,1,1,1],None], list), 'dicts':SArray([{1:2},{2:3},{},{4:5},None], dict)}) # another normal, but more interesting case self.__test_equal(test_sf.dropna(), pd.DataFrame({'ints':[3,4],'floats':[3.,4.],'strs':['','4'],'lists':[[],[1,1,1,1]],'dicts':[{},{4:5}]})) test_split = test_sf.dropna_split() self.__test_equal(test_split[0], test_sf[2:4].to_dataframe()) self.__test_equal(test_split[1], test_sf[0:2].append(test_sf[4:5]).to_dataframe()) # the 'all' case self.__test_equal(test_sf.dropna(how='all'), test_sf[0:4].to_dataframe()) test_split = test_sf.dropna_split(how='all') self.__test_equal(test_split[0], test_sf[0:4].to_dataframe()) self.__test_equal(test_split[1], test_sf[4:5].to_dataframe()) # select some columns self.__test_equal(test_sf.dropna(['ints','floats'], how='all'), test_sf[1:4].to_dataframe()) test_split = test_sf.dropna_split(['ints','floats'], how='all') self.__test_equal(test_split[0], test_sf[1:4].to_dataframe()) self.__test_equal(test_split[1], test_sf[0:1].append(test_sf[4:5]).to_dataframe()) self.__test_equal(test_sf.dropna('strs'), test_sf[0:4].to_dataframe()) test_split = test_sf.dropna_split('strs') self.__test_equal(test_split[0], test_sf[0:4].to_dataframe()) self.__test_equal(test_split[1], test_sf[4:5].to_dataframe()) self.__test_equal(test_sf.dropna(['strs','dicts']), test_sf[0:4].to_dataframe()) test_split = test_sf.dropna_split(['strs','dicts']) self.__test_equal(test_split[0], test_sf[0:4].to_dataframe()) self.__test_equal(test_split[1], test_sf[4:5].to_dataframe()) # bad stuff with self.assertRaises(TypeError): test_sf.dropna(1) test_sf.dropna([1,2]) test_sf.dropna('strs', how=1) test_sf.dropna_split(1) test_sf.dropna_split([1,2]) test_sf.dropna_split('strs', how=1) with self.assertRaises(ValueError): test_sf.dropna('ints', how='blah') test_sf.dropna_split('ints', how='blah') with self.assertRaises(RuntimeError): test_sf.dropna('dontexist') test_sf.dropna_split('dontexist') def test_add_row_number(self): sf = SFrame(self.__create_test_df(400000)) sf = sf.add_row_number('id') self.assertEquals(list(sf['id']), range(0,400000)) del sf['id'] sf = sf.add_row_number('id', -20000) self.assertEquals(list(sf['id']), range(-20000,380000)) del sf['id'] sf = sf.add_row_number('id', 40000) self.assertEquals(list(sf['id']), range(40000,440000)) with self.assertRaises(RuntimeError): sf.add_row_number('id') with self.assertRaises(TypeError): sf = sf.add_row_number(46) sf = sf.add_row_number('id2',start='hi') def test_check_lazy_sframe_size(self): # empty sframe, materialized, has_size sf = SFrame() self.assertTrue(sf.__is_materialized__()) self.assertTrue(sf.__has_size__()) # add one column, not materialized, has_size sf['a'] = range(1000) self.assertTrue(sf.__is_materialized__()) self.assertTrue(sf.__has_size__()) # materialize it, materialized, has_size sf['a'] = range(1000) sf.__materialize__() self.assertTrue(sf.__is_materialized__()) self.assertTrue(sf.__has_size__()) # logical filter, not materialized, not has_size sf = sf[sf['a'] > 5000] self.assertFalse(sf.__is_materialized__()) self.assertFalse(sf.__has_size__()) def test_sframe_to_rdd(self): if not HAS_PYSPARK: print "Did not run Pyspark unit tests!" return sc = SparkContext('local') # Easiest case: single column of integers test_rdd = sc.parallelize(range(100)) sf = SFrame.from_rdd(test_rdd) self.assertTrue(sf.num_cols(), 1) self.assertTrue(sf.column_names(), ['X1']) # We cast integers to floats to be safe on varying types self.assertEquals([float(i) for i in range(0,100)], list(sf['X1'])) sc.stop() def test_rdd_to_sframe(self): if not HAS_PYSPARK: print "Did not run Pyspark unit tests!" return sc = SparkContext('local') # Easiest case: single column of integers sf = SFrame({'column_name':range(100)}) test_rdd = sf.to_rdd(sc) res = test_rdd.collect() self.assertEquals(res, [{'column_name':long(i)} for i in range(100)]) sc.stop() def test_column_manipulation_of_lazy_sframe(self): import graphlab as gl g=gl.SFrame({'a':[1,2,3,4,5],'id':[1,2,3,4,5]}) g = g[g['id'] > 2] del g['id'] # if lazy column deletion is quirky, this will cause an exception self.assertEquals(list(g[0:2]['a']), [3,4]) g=gl.SFrame({'a':[1,2,3,4,5],'id':[1,2,3,4,5]}) g = g[g['id'] > 2] g.swap_columns('a','id') # if lazy column swap is quirky, this will cause an exception self.assertEquals(list(g[0:2]['a']), [3,4]) def test_empty_sarray(self): with util.TempDirectory() as f: sf = SArray() sf.save(f) sf2 = SArray(f) self.assertEquals(len(sf2), 0) def test_empty_sframe(self): with util.TempDirectory() as f: sf = SFrame() sf.save(f) sf2 = SFrame(f) self.assertEquals(len(sf2), 0) self.assertEquals(sf2.num_columns(), 0) def test_none_column(self): sf = SFrame({'a':[1,2,3,4,5]}) sf['b'] = None self.assertEqual(sf['b'].dtype(), float) df = pd.DataFrame({'a': [1,2,3,4,5], 'b': [None,None,None,None,None]}) self.__test_equal(sf, df) sa = SArray.from_const(None, 100) self.assertEquals(list(sa), [None] * 100) self.assertEqual(sa.dtype(), float) def test_apply_with_partial(self): sf = SFrame({'a': [1, 2, 3, 4, 5]}) def concat_fn(character, row): return '%s%d' % (character, row['a']) my_partial_fn = functools.partial(concat_fn, 'x') sa = sf.apply(my_partial_fn) self.assertEqual(list(sa), ['x1', 'x2', 'x3', 'x4', 'x5']) def test_apply_with_functor(self): sf = SFrame({'a': [1, 2, 3, 4, 5]}) class Concatenator(object): def __init__(self, character): self.character = character def __call__(self, row): return '%s%d' % (self.character, row['a']) concatenator = Concatenator('x') sa = sf.apply(concatenator) self.assertEqual(list(sa), ['x1', 'x2', 'x3', 'x4', 'x5']) if __name__ == "__main__": import sys # Check if we are supposed to connect to another server for i, v in enumerate(sys.argv): if v.startswith("ipc://"): gl._launch(v) # The rest of the arguments need to get passed through to # the unittest module del sys.argv[i] break unittest.main()
agpl-3.0
m4rx9/rna-pdb-tools
rna_tools/tools/pdbs_measure_atom_dists/pdbs_measure_atom_dists.py
2
5992
#!/usr/bin/env python # -*- coding: utf-8 -*- """This is a quick and dirty method of comparison two RNA structures (stored in pdb files). It measures the distance between the relevan atoms (C4') for nucleotides defined as "x" in the sequence alignment. author: F. Stefaniak, modified by A. Zyla, supervision of mmagnus """ from __future__ import print_function from Bio.PDB import PDBParser from scipy.spatial import distance from Bio.SeqRecord import SeqRecord from Bio import SeqIO import logging import argparse import numpy as np import matplotlib.pyplot as plt # logger logger = logging.getLogger() handler = logging.StreamHandler() logger.addHandler(handler) def get_seq(alignfn, seqid): """Get seq from an alignment with gaps. Args: alignfn (str): a path to an alignment seqid (str): seq id in an alignment Usage:: >>> get_seq('test_data/ALN_OBJ1_OBJ2.fa', 'obj1') SeqRecord(seq=SeqRecord(seq=Seq('GUUCAG-------------------UGAC-', SingleLetterAlphabet()), id='obj1', name='obj1', description='obj1', dbxrefs=[]), id='<unknown id>', name='<unknown name>', description='<unknown description>', dbxrefs=[]) Returns: SeqRecord """ # alignment = AlignIO.read(alignfn, 'fasta') alignment = SeqIO.index(alignfn, 'fasta') # print SeqRecord(alignment[seqid]) sequence = SeqRecord(alignment[seqid]) return sequence def open_pdb(pdbfn): """Open pdb with Biopython. Args: pdbfn1 (str): a path to a pdb structure Returns: PDB Biopython object: with a pdb structure """ parser = PDBParser() return parser.get_structure('', pdbfn) def find_core(seq_with_gaps1, seq_with_gaps2): """. Args: seq_with_gaps1 (str): a sequence 1 from the alignment seq_with_gaps1 (str): a sequence 2 from the alignment Usage:: >>> find_core('GUUCAG-------------------UGAC-', 'CUUCGCAGCCAUUGCACUCCGGCUGCGAUG') 'xxxxxx-------------------xxxx-' Returns: core="xxxxxx-------------------xxxx-" """ core = "".join(["x" if (a != '-' and b != '-') else "-" for (a, b) in zip(seq_with_gaps1, seq_with_gaps2)]) return core def map_coords_atom(structure): """. Args: structure (pdb): PDB Biopython object: with a pdb structure Returns: struct1dict: a list of coords for atoms structure1realNumber: a list of residues """ resNumber = 0 struct1dict = {} structure1realNumbers = {} for res in structure.get_residues(): # print res for atom in res: name, coord = atom.name.strip(), atom.coord # G C5' [-15.50800037 -7.05600023 13.91800022] if name == atomToCompare: # print name, coord struct1dict[resNumber] = coord structure1realNumbers[resNumber] = res.get_full_id()[3][1] resNumber += 1 return struct1dict, structure1realNumbers def get_parser(): parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) parser.add_argument("-v", "--verbose", help="increase output verbosity", action="store_true") parser.add_argument("seqid1", help="seq1 id in the alignemnt") parser.add_argument("seqid2", help="seq2 id in the alignemnt") parser.add_argument("alignfn", help="alignemnt in the Fasta format") parser.add_argument("pdbfn1", help="pdb file1") parser.add_argument("pdbfn2", help="pdb file2") return parser # main if __name__ == '__main__': import doctest doctest.testmod() args = get_parser().parse_args() if args.verbose: logger.setLevel(logging.INFO) # if not args.outfn: # args.outfn = args.pdbfn.replace('.pdb', '_out.pdb') seq_with_gaps1 = get_seq(args.alignfn, args.seqid1) seq_with_gaps2 = get_seq(args.alignfn, args.seqid2) pdb1 = open_pdb(args.pdbfn1) pdb2 = open_pdb(args.pdbfn2) core = find_core(seq_with_gaps1, seq_with_gaps2) atomToCompare = "C4'" sep = '\t' structure1 = pdb1 structure2 = pdb2 struct1dict, structure1realNumbers = map_coords_atom(pdb1) struct2dict, structure2realNumbers = map_coords_atom(pdb2) stats = [] stats.append(["res1", "res2", "distance [A]"]) resNumber = 0 seq1number = -1 seq2number = -1 for char in core: # local sequence numbering if seq_with_gaps1[resNumber] != '-': seq1number += 1 # print "seq1", seq1number, seq1[resNumber] if seq_with_gaps2[resNumber] != '-': seq2number += 1 # print "seq2", seq2number, seq2[resNumber] # alignment checking (iksy) if char == 'x': vect1 = struct1dict[seq1number] vect2 = struct2dict[seq2number] stats.append([str(structure1realNumbers[seq1number]), str(structure2realNumbers[seq2number]), str(distance.euclidean(vect1, vect2))]) # print vect1,vect2 resNumber += 1 # struc = renumber(seq_with_gaps, pdb, args.residue_index_start) # write_struc(struc, args.outfn) list_res=[] for i in stats: print(sep.join(i)) table=(sep.join(i)) list_res.append(i) #print (list_res) res_matrix = np.array(list_res[1:]) ''' Creating a plot ''' new_resi = list_res[1:] new_resis = [] for i in new_resi: #print (j) new_resis.append(str(i[0]) + '/' + str(i[1])) #print (new_resis) list2_matrix= new_resis list2_matrix1 = map(float, list(res_matrix[:,2])) #print (list2_matrix1) plt.bar(list2_matrix,list2_matrix1,facecolor='pink' ) plt.suptitle('Distance between C4 atoms of residues') plt.ylabel("distance [A]") plt.xlabel('Nr of residue') plt.show()
mit
rseubert/scikit-learn
sklearn/cross_decomposition/cca_.py
23
3087
from .pls_ import _PLS __all__ = ['CCA'] class CCA(_PLS): """CCA Canonical Correlation Analysis. CCA inherits from PLS with mode="B" and deflation_mode="canonical". Parameters ---------- n_components : int, (default 2). number of components to keep. scale : boolean, (default True) whether to scale the data? max_iter : an integer, (default 500) the maximum number of iterations of the NIPALS inner loop tol : non-negative real, default 1e-06. the tolerance used in the iterative algorithm copy : boolean Whether the deflation be done on a copy. Let the default value to True unless you don't care about side effects Attributes ---------- x_weights_ : array, [p, n_components] X block weights vectors. y_weights_ : array, [q, n_components] Y block weights vectors. x_loadings_ : array, [p, n_components] X block loadings vectors. y_loadings_ : array, [q, n_components] Y block loadings vectors. x_scores_ : array, [n_samples, n_components] X scores. y_scores_ : array, [n_samples, n_components] Y scores. x_rotations_ : array, [p, n_components] X block to latents rotations. y_rotations_ : array, [q, n_components] Y block to latents rotations. n_iter_ : array-like Number of iterations of the NIPALS inner loop for each component. Notes ----- For each component k, find the weights u, v that maximizes max corr(Xk u, Yk v), such that ``|u| = |v| = 1`` Note that it maximizes only the correlations between the scores. The residual matrix of X (Xk+1) block is obtained by the deflation on the current X score: x_score. The residual matrix of Y (Yk+1) block is obtained by deflation on the current Y score. Examples -------- >>> from sklearn.cross_decomposition import CCA >>> X = [[0., 0., 1.], [1.,0.,0.], [2.,2.,2.], [3.,5.,4.]] >>> Y = [[0.1, -0.2], [0.9, 1.1], [6.2, 5.9], [11.9, 12.3]] >>> cca = CCA(n_components=1) >>> cca.fit(X, Y) ... # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE CCA(copy=True, max_iter=500, n_components=1, scale=True, tol=1e-06) >>> X_c, Y_c = cca.transform(X, Y) References ---------- Jacob A. Wegelin. A survey of Partial Least Squares (PLS) methods, with emphasis on the two-block case. Technical Report 371, Department of Statistics, University of Washington, Seattle, 2000. In french but still a reference: Tenenhaus, M. (1998). La regression PLS: theorie et pratique. Paris: Editions Technic. See also -------- PLSCanonical PLSSVD """ def __init__(self, n_components=2, scale=True, max_iter=500, tol=1e-06, copy=True): _PLS.__init__(self, n_components=n_components, scale=scale, deflation_mode="canonical", mode="B", norm_y_weights=True, algorithm="nipals", max_iter=max_iter, tol=tol, copy=copy)
bsd-3-clause
JeffHeard/terrapyn
geocms/drivers/ogr.py
1
11631
# from ga_ows.views import wms, wfs import shutil import json from zipfile import ZipFile import pandas from django.contrib.gis.geos import Polygon import os from osgeo import osr, ogr from pandas import DataFrame from shapely import wkb from django.template.defaultfilters import slugify import re from . import Driver def ogrfield(elt): return re.sub('-', '_', slugify(elt).encode('ascii'))[0:10] def identity(x): return '"' + x + '"' if isinstance(x, basestring) else str(x) dtypes = { 'int64': ogr.OFTInteger, 'float64': ogr.OFTReal, 'object': ogr.OFTString, 'datetime64[ns]': ogr.OFTDateTime } geomTypes = { 'GeometryCollection': ogr.wkbGeometryCollection, 'LinearRing': ogr.wkbLinearRing, 'LineString': ogr.wkbLineString, 'MultiLineString': ogr.wkbMultiLineString, 'MultiPoint': ogr.wkbMultiPoint, 'MultiPolygon': ogr.wkbMultiPolygon, 'Point': ogr.wkbPoint, 'Polygon': ogr.wkbPolygon } def transform(geom, crx): if crx: geom.Transform(crx) return geom class OGRDriver(Driver): def ready_data_resource(self, **kwargs): """Other keyword args get passed in as a matter of course, like BBOX, time, and elevation, but this basic driver ignores them""" slug, srs = super(OGRDriver, self).ready_data_resource(**kwargs) cfg = self.resource.driver_config mapnik_config = { 'type' : 'ogr', 'base' : self.cache_path, } if 'sublayer' in kwargs: mapnik_config['layer'] = kwargs['sublayer'] elif 'layer' in cfg: mapnik_config['layer'] = cfg['layer'] elif 'layer_by_index' in cfg: mapnik_config['layer_by_index'] = cfg['layer_by_index'] else: mapnik_config['layer_by_index'] = 0 if 'multiple_geometries' in cfg: mapnik_config['multiple_geometries'] = cfg['multiple_geometries'] if 'encoding' in cfg: mapnik_config['encoding'] = cfg['encoding'] if 'string' in cfg: mapnik_config['string'] = cfg['string'] else: mapnik_config['file'] = self.get_master_filename() return slug, srs, mapnik_config def get_master_filename(self): cfg = self.resource.driver_config if 'file' in cfg: return self.cache_path + '/' + cfg['file'] elif 'xtn' in cfg: return self.get_filename(cfg['xtn']) else: return self.get_filename('')[:-1] # omit the trailing period and assume we're using the directory (such as for MapInfo) def compute_spatial_metadata(self, **kwargs): """Other keyword args get passed in as a matter of course, like BBOX, time, and elevation, but this basic driver ignores them""" super(OGRDriver, self).compute_spatial_metadata(**kwargs) # if we have a zip archive, we should expand it now archive_filename = self.get_filename('zip') if os.path.exists(archive_filename): archive = ZipFile(self.cached_basename + self.src_ext) os.mkdir(self.cached_basename) # we will put everything cached underneath the cached base directory archive.extractall(self.cached_basename) ds = ogr.Open(self.get_master_filename()) lyr = ds.GetLayerByIndex(0) if 'sublayer' not in kwargs else ds.GetLayerByName(kwargs['sublayer']) xmin, xmax, ymin, ymax = lyr.GetExtent() crs = lyr.GetSpatialRef() self.resource.spatial_metadata.native_srs = crs.ExportToProj4() e4326 = osr.SpatialReference() e4326.ImportFromEPSG(4326) crx = osr.CoordinateTransformation(crs, e4326) x04326, y04326, _ = crx.TransformPoint(xmin, ymin) x14326, y14326, _ = crx.TransformPoint(xmax, ymax) self.resource.spatial_metadata.bounding_box = Polygon.from_bbox((x04326, y04326, x14326, y14326)) self.resource.spatial_metadata.native_bounding_box = Polygon.from_bbox((xmin, ymin, xmax, ymax)) self.resource.spatial_metadata.three_d = False self.resource.spatial_metadata.save() self.resource.save() def get_data_fields(self, **kwargs): _, _, result = self.ready_data_resource(**kwargs) ds = ogr.Open(self.get_master_filename()) lyr = ds.GetLayerByIndex(0) if 'layer' not in kwargs else ds.GetLayerByName(kwargs['sublayer']) return [(field.name, field.GetTypeName(), field.width) for field in lyr.schema] def get_data_for_point(self, wherex, wherey, srs, **kwargs): result, x1, y1, epsilon = super(OGRDriver, self).get_data_for_point(wherex, wherey, srs, **kwargs) ds = ogr.Open(result['file']) lyr = ds.GetLayerByIndex(0) if 'sublayer' not in kwargs else ds.GetLayerByName(kwargs['sublayer']) if epsilon == 0: lyr.SetSpatialFilter(ogr.CreateGeometryFromWkt("POINT({x1} {y1})".format(**locals()))) else: from django.contrib.gis import geos wkt = geos.Point(x1, y1).buffer(epsilon).wkt print wkt lyr.SetSpatialFilter(ogr.CreateGeometryFromWkt(wkt)) return [f.items() for f in lyr] def attrquery(self, key, value): key, op = key.split('__') op = { 'gt': ">", 'gte': ">=", 'lt': "<", 'lte': '<=', 'startswith': 'LIKE', 'endswith': 'LIKE', 'istartswith': 'ILIKE', 'iendswith': 'ILIKE', 'icontains': "ILIKE", 'contains': "LIKE", 'in': 'IN', 'ne': "<>" }[op] value = { 'gt': identity, 'gte': identity, 'lt': identity, 'lte': identity, 'startswith': lambda x: '%' + x, 'endswith': lambda x: x + '%', 'istartswith': lambda x: '%' + x, 'iendswith': lambda x: x + '%', 'icontains': lambda x: '%' + x + '%', 'contains': lambda x: '%' + x + '%', 'in': lambda x: x if isinstance(x, basestring) else '(' + ','.join(identity(a) for a in x) + ')', 'ne': identity }[op](value) return ' '.join([key, op, value]) def as_dataframe(self, **kwargs): """ Creates a dataframe object for a shapefile's main layer using layer_as_dataframe. This object is cached on disk for layer use, but the cached copy will only be picked up if the shapefile's mtime is older than the dataframe's mtime. :param shp: The shapefile :return: """ dfx_path = self.get_filename('dfx') if len(kwargs) != 0: ds = ogr.Open(self.get_master_filename()) lyr = ds.GetLayerByIndex(0) crx = xrc = None if 'bbox' in kwargs: minx, miny, maxx, maxy = kwargs['bbox'] if 'srs' in kwargs: if isinstance(kwargs['srs'], basestring): s_srs = osr.SpatialReference() if kwargs['srs'].lower().startswith('epsg:'): s_srs.ImportFromEPSG(int(kwargs['srs'].split(':')[1])) else: s_srs.ImportFromProj4(kwargs['srs']) else: s_srs = kwargs['srs'] t_srs = self.resource.srs if s_srs.ExportToProj4() != t_srs.ExportToProj4(): crx = osr.CoordinateTransformation(s_srs, t_srs) minx, miny, _ = crx.TransformPoint(minx, miny) maxx, maxy, _ = crx.TransformPoint(maxx, maxy) xrc = osr.CoordinateTransformation(t_srs, s_srs) lyr.SetSpatialFilterRect(minx, miny, maxx, maxy) elif 'boundary' in kwargs: boundary = ogr.Geometry(geomTypes[kwargs['boundary_type']], kwargs["boundary"]) lyr.SetSpatialFilter(boundary) if 'query' in kwargs: if isinstance(kwargs['query'], basestring): query = json.loads(kwargs['query']) else: query = kwargs['query'] for key, value in query.items(): attrq = self.attrquery(key, value) if '__' in key else key, '=' lyr.SetAttributeFilter(attrq) start = kwargs['start'] if 'start' in kwargs else 0 count = kwargs['count'] if 'count' in kwargs else len(lyr) - start records = [] for i in range(start): lyr.next() for i in range(count): f = lyr.next() if f.geometry(): records.append( dict(fid=i, geometry=wkb.loads(transform(f.geometry(), xrc).ExportToWkb()), **f.items())) df = DataFrame.from_records( data=records, index='fid' ) if 'sort_by' in kwargs: df = df.sort_index(by=kwargs['sort_by']) return df elif hasattr(self, '_df'): return self._df elif os.path.exists(dfx_path) and os.stat(dfx_path).st_mtime >= os.stat(self.get_master_filename()).st_mtime: if self.resource.big: self._df = pandas.read_hdf(dfx_path, 'df') else: self._df = pandas.read_pickle(dfx_path) return self._df else: ds = ogr.Open(self.get_master_filename()) lyr = ds.GetLayerByIndex(0) df = DataFrame.from_records( data=[dict(fid=f.GetFID(), geometry=wkb.loads(f.geometry().ExportToWkb()), **f.items()) for f in lyr if f.geometry()], index='fid' ) if self.resource.big: df.to_hdf(dfx_path, 'df') else: df.to_pickle(dfx_path) self._df = df return self._df @classmethod def from_dataframe(cls, df, shp, driver, srs, in_subdir=False): """Write an dataframe object out as a shapefile""" drv = ogr.GetDriverByName(driver) if driver != 'Memory': if in_subdir: if os.path.exists(shp): shutil.rmtree(shp) os.mkdir(shp) else: if os.path.exists(shp): os.unlink(shp) ds = drv.CreateDataSource(shp) keys = df.keys() fieldDefns = [ogr.FieldDefn(ogrfield(name), dtypes[df[name].dtype.name]) for name in keys if name != 'geometry'] geomType = geomTypes[(f for f in df['geometry']).next().type] l = ds.CreateLayer( name=os.path.split(shp)[-1], srs=srs, geom_type=geomType ) for f in fieldDefns: l.CreateField(f) for i, record in df.iterrows(): feature = ogr.Feature(l.GetLayerDefn()) for field, value in ((k, v) for k, v in record.to_dict().items() if k != 'geometry'): if isinstance(value, basestring): value = value.encode('ascii') feature.SetField(ogrfield(field), value) feature.SetGeometry(ogr.CreateGeometryFromWkb(record['geometry'].wkb)) l.CreateFeature(feature) if driver != 'Memory': # then write to file and flush the dataset del ds else: # we're done. return the dataset that was created in memory. return ds driver = OGRDriver
apache-2.0
aruneral01/auto-sklearn
autosklearn/models/paramsklearn.py
5
2588
from ParamSklearn.classification import ParamSklearnClassifier from ParamSklearn.regression import ParamSklearnRegressor from autosklearn.constants import * def get_configuration_space(info, include_estimators=None, include_preprocessors=None): if info['task'] in REGRESSION_TASKS: return _get_regression_configuration_space(info, include_estimators, include_preprocessors) else: return _get_classification_configuration_space(info, include_estimators, include_preprocessors) def _get_regression_configuration_space(info, include_estimators=None, include_preprocessors=None): sparse = False if info['is_sparse'] == 1: sparse = True configuration_space = ParamSklearnRegressor. \ get_hyperparameter_search_space(include_estimators=include_estimators, include_preprocessors=include_preprocessors, dataset_properties={'sparse': sparse}) return configuration_space def _get_classification_configuration_space(info, include_estimators=None, include_preprocessors=None): task_type = info['task'] multilabel = False multiclass = False sparse = False if task_type == MULTILABEL_CLASSIFICATION: multilabel = True if task_type == REGRESSION: raise NotImplementedError() if task_type == MULTICLASS_CLASSIFICATION: multiclass = True pass if task_type == BINARY_CLASSIFICATION: pass if info['is_sparse'] == 1: sparse = True dataset_properties = {'multilabel': multilabel, 'multiclass': multiclass, 'sparse': sparse} return ParamSklearnClassifier.get_hyperparameter_search_space( dataset_properties=dataset_properties, include_estimators=include_estimators, include_preprocessors=include_preprocessors) # exclude_preprocessors=["sparse_filtering"]) def get_model(configuration, seed): if 'classifier' in configuration: return ParamSklearnClassifier(configuration, seed) elif 'regressor' in configuration: return ParamSklearnRegressor(configuration, seed) def get_class(info): if info['task'] in REGRESSION_TASKS: return ParamSklearnRegressor else: return ParamSklearnClassifier
bsd-3-clause
lin-credible/scikit-learn
examples/cluster/plot_ward_structured_vs_unstructured.py
320
3369
""" =========================================================== Hierarchical clustering: structured vs unstructured ward =========================================================== Example builds a swiss roll dataset and runs hierarchical clustering on their position. For more information, see :ref:`hierarchical_clustering`. In a first step, the hierarchical clustering is performed without connectivity constraints on the structure and is solely based on distance, whereas in a second step the clustering is restricted to the k-Nearest Neighbors graph: it's a hierarchical clustering with structure prior. Some of the clusters learned without connectivity constraints do not respect the structure of the swiss roll and extend across different folds of the manifolds. On the opposite, when opposing connectivity constraints, the clusters form a nice parcellation of the swiss roll. """ # Authors : Vincent Michel, 2010 # Alexandre Gramfort, 2010 # Gael Varoquaux, 2010 # License: BSD 3 clause print(__doc__) import time as time import numpy as np import matplotlib.pyplot as plt import mpl_toolkits.mplot3d.axes3d as p3 from sklearn.cluster import AgglomerativeClustering from sklearn.datasets.samples_generator import make_swiss_roll ############################################################################### # Generate data (swiss roll dataset) n_samples = 1500 noise = 0.05 X, _ = make_swiss_roll(n_samples, noise) # Make it thinner X[:, 1] *= .5 ############################################################################### # Compute clustering print("Compute unstructured hierarchical clustering...") st = time.time() ward = AgglomerativeClustering(n_clusters=6, linkage='ward').fit(X) elapsed_time = time.time() - st label = ward.labels_ print("Elapsed time: %.2fs" % elapsed_time) print("Number of points: %i" % label.size) ############################################################################### # Plot result fig = plt.figure() ax = p3.Axes3D(fig) ax.view_init(7, -80) for l in np.unique(label): ax.plot3D(X[label == l, 0], X[label == l, 1], X[label == l, 2], 'o', color=plt.cm.jet(np.float(l) / np.max(label + 1))) plt.title('Without connectivity constraints (time %.2fs)' % elapsed_time) ############################################################################### # Define the structure A of the data. Here a 10 nearest neighbors from sklearn.neighbors import kneighbors_graph connectivity = kneighbors_graph(X, n_neighbors=10, include_self=False) ############################################################################### # Compute clustering print("Compute structured hierarchical clustering...") st = time.time() ward = AgglomerativeClustering(n_clusters=6, connectivity=connectivity, linkage='ward').fit(X) elapsed_time = time.time() - st label = ward.labels_ print("Elapsed time: %.2fs" % elapsed_time) print("Number of points: %i" % label.size) ############################################################################### # Plot result fig = plt.figure() ax = p3.Axes3D(fig) ax.view_init(7, -80) for l in np.unique(label): ax.plot3D(X[label == l, 0], X[label == l, 1], X[label == l, 2], 'o', color=plt.cm.jet(float(l) / np.max(label + 1))) plt.title('With connectivity constraints (time %.2fs)' % elapsed_time) plt.show()
bsd-3-clause
mhdella/scikit-learn
sklearn/linear_model/tests/test_least_angle.py
57
16523
from nose.tools import assert_equal import numpy as np from scipy import linalg from sklearn.cross_validation import train_test_split from sklearn.externals import joblib from sklearn.utils.testing import assert_array_almost_equal from sklearn.utils.testing import assert_true from sklearn.utils.testing import assert_less from sklearn.utils.testing import assert_greater from sklearn.utils.testing import assert_raises from sklearn.utils.testing import ignore_warnings from sklearn.utils.testing import assert_no_warnings, assert_warns from sklearn.utils.testing import TempMemmap from sklearn.utils import ConvergenceWarning from sklearn import linear_model, datasets from sklearn.linear_model.least_angle import _lars_path_residues diabetes = datasets.load_diabetes() X, y = diabetes.data, diabetes.target # TODO: use another dataset that has multiple drops def test_simple(): # Principle of Lars is to keep covariances tied and decreasing # also test verbose output from sklearn.externals.six.moves import cStringIO as StringIO import sys old_stdout = sys.stdout try: sys.stdout = StringIO() alphas_, active, coef_path_ = linear_model.lars_path( diabetes.data, diabetes.target, method="lar", verbose=10) sys.stdout = old_stdout for (i, coef_) in enumerate(coef_path_.T): res = y - np.dot(X, coef_) cov = np.dot(X.T, res) C = np.max(abs(cov)) eps = 1e-3 ocur = len(cov[C - eps < abs(cov)]) if i < X.shape[1]: assert_true(ocur == i + 1) else: # no more than max_pred variables can go into the active set assert_true(ocur == X.shape[1]) finally: sys.stdout = old_stdout def test_simple_precomputed(): # The same, with precomputed Gram matrix G = np.dot(diabetes.data.T, diabetes.data) alphas_, active, coef_path_ = linear_model.lars_path( diabetes.data, diabetes.target, Gram=G, method="lar") for i, coef_ in enumerate(coef_path_.T): res = y - np.dot(X, coef_) cov = np.dot(X.T, res) C = np.max(abs(cov)) eps = 1e-3 ocur = len(cov[C - eps < abs(cov)]) if i < X.shape[1]: assert_true(ocur == i + 1) else: # no more than max_pred variables can go into the active set assert_true(ocur == X.shape[1]) def test_all_precomputed(): # Test that lars_path with precomputed Gram and Xy gives the right answer X, y = diabetes.data, diabetes.target G = np.dot(X.T, X) Xy = np.dot(X.T, y) for method in 'lar', 'lasso': output = linear_model.lars_path(X, y, method=method) output_pre = linear_model.lars_path(X, y, Gram=G, Xy=Xy, method=method) for expected, got in zip(output, output_pre): assert_array_almost_equal(expected, got) def test_lars_lstsq(): # Test that Lars gives least square solution at the end # of the path X1 = 3 * diabetes.data # use un-normalized dataset clf = linear_model.LassoLars(alpha=0.) clf.fit(X1, y) coef_lstsq = np.linalg.lstsq(X1, y)[0] assert_array_almost_equal(clf.coef_, coef_lstsq) def test_lasso_gives_lstsq_solution(): # Test that Lars Lasso gives least square solution at the end # of the path alphas_, active, coef_path_ = linear_model.lars_path(X, y, method="lasso") coef_lstsq = np.linalg.lstsq(X, y)[0] assert_array_almost_equal(coef_lstsq, coef_path_[:, -1]) def test_collinearity(): # Check that lars_path is robust to collinearity in input X = np.array([[3., 3., 1.], [2., 2., 0.], [1., 1., 0]]) y = np.array([1., 0., 0]) f = ignore_warnings _, _, coef_path_ = f(linear_model.lars_path)(X, y, alpha_min=0.01) assert_true(not np.isnan(coef_path_).any()) residual = np.dot(X, coef_path_[:, -1]) - y assert_less((residual ** 2).sum(), 1.) # just make sure it's bounded n_samples = 10 X = np.random.rand(n_samples, 5) y = np.zeros(n_samples) _, _, coef_path_ = linear_model.lars_path(X, y, Gram='auto', copy_X=False, copy_Gram=False, alpha_min=0., method='lasso', verbose=0, max_iter=500) assert_array_almost_equal(coef_path_, np.zeros_like(coef_path_)) def test_no_path(): # Test that the ``return_path=False`` option returns the correct output alphas_, active_, coef_path_ = linear_model.lars_path( diabetes.data, diabetes.target, method="lar") alpha_, active, coef = linear_model.lars_path( diabetes.data, diabetes.target, method="lar", return_path=False) assert_array_almost_equal(coef, coef_path_[:, -1]) assert_true(alpha_ == alphas_[-1]) def test_no_path_precomputed(): # Test that the ``return_path=False`` option with Gram remains correct G = np.dot(diabetes.data.T, diabetes.data) alphas_, active_, coef_path_ = linear_model.lars_path( diabetes.data, diabetes.target, method="lar", Gram=G) alpha_, active, coef = linear_model.lars_path( diabetes.data, diabetes.target, method="lar", Gram=G, return_path=False) assert_array_almost_equal(coef, coef_path_[:, -1]) assert_true(alpha_ == alphas_[-1]) def test_no_path_all_precomputed(): # Test that the ``return_path=False`` option with Gram and Xy remains correct X, y = 3 * diabetes.data, diabetes.target G = np.dot(X.T, X) Xy = np.dot(X.T, y) alphas_, active_, coef_path_ = linear_model.lars_path( X, y, method="lasso", Gram=G, Xy=Xy, alpha_min=0.9) print("---") alpha_, active, coef = linear_model.lars_path( X, y, method="lasso", Gram=G, Xy=Xy, alpha_min=0.9, return_path=False) assert_array_almost_equal(coef, coef_path_[:, -1]) assert_true(alpha_ == alphas_[-1]) def test_singular_matrix(): # Test when input is a singular matrix X1 = np.array([[1, 1.], [1., 1.]]) y1 = np.array([1, 1]) alphas, active, coef_path = linear_model.lars_path(X1, y1) assert_array_almost_equal(coef_path.T, [[0, 0], [1, 0]]) def test_rank_deficient_design(): # consistency test that checks that LARS Lasso is handling rank # deficient input data (with n_features < rank) in the same way # as coordinate descent Lasso y = [5, 0, 5] for X in ([[5, 0], [0, 5], [10, 10]], [[10, 10, 0], [1e-32, 0, 0], [0, 0, 1]], ): # To be able to use the coefs to compute the objective function, # we need to turn off normalization lars = linear_model.LassoLars(.1, normalize=False) coef_lars_ = lars.fit(X, y).coef_ obj_lars = (1. / (2. * 3.) * linalg.norm(y - np.dot(X, coef_lars_)) ** 2 + .1 * linalg.norm(coef_lars_, 1)) coord_descent = linear_model.Lasso(.1, tol=1e-6, normalize=False) coef_cd_ = coord_descent.fit(X, y).coef_ obj_cd = ((1. / (2. * 3.)) * linalg.norm(y - np.dot(X, coef_cd_)) ** 2 + .1 * linalg.norm(coef_cd_, 1)) assert_less(obj_lars, obj_cd * (1. + 1e-8)) def test_lasso_lars_vs_lasso_cd(verbose=False): # Test that LassoLars and Lasso using coordinate descent give the # same results. X = 3 * diabetes.data alphas, _, lasso_path = linear_model.lars_path(X, y, method='lasso') lasso_cd = linear_model.Lasso(fit_intercept=False, tol=1e-8) for c, a in zip(lasso_path.T, alphas): if a == 0: continue lasso_cd.alpha = a lasso_cd.fit(X, y) error = linalg.norm(c - lasso_cd.coef_) assert_less(error, 0.01) # similar test, with the classifiers for alpha in np.linspace(1e-2, 1 - 1e-2, 20): clf1 = linear_model.LassoLars(alpha=alpha, normalize=False).fit(X, y) clf2 = linear_model.Lasso(alpha=alpha, tol=1e-8, normalize=False).fit(X, y) err = linalg.norm(clf1.coef_ - clf2.coef_) assert_less(err, 1e-3) # same test, with normalized data X = diabetes.data alphas, _, lasso_path = linear_model.lars_path(X, y, method='lasso') lasso_cd = linear_model.Lasso(fit_intercept=False, normalize=True, tol=1e-8) for c, a in zip(lasso_path.T, alphas): if a == 0: continue lasso_cd.alpha = a lasso_cd.fit(X, y) error = linalg.norm(c - lasso_cd.coef_) assert_less(error, 0.01) def test_lasso_lars_vs_lasso_cd_early_stopping(verbose=False): # Test that LassoLars and Lasso using coordinate descent give the # same results when early stopping is used. # (test : before, in the middle, and in the last part of the path) alphas_min = [10, 0.9, 1e-4] for alphas_min in alphas_min: alphas, _, lasso_path = linear_model.lars_path(X, y, method='lasso', alpha_min=0.9) lasso_cd = linear_model.Lasso(fit_intercept=False, tol=1e-8) lasso_cd.alpha = alphas[-1] lasso_cd.fit(X, y) error = linalg.norm(lasso_path[:, -1] - lasso_cd.coef_) assert_less(error, 0.01) alphas_min = [10, 0.9, 1e-4] # same test, with normalization for alphas_min in alphas_min: alphas, _, lasso_path = linear_model.lars_path(X, y, method='lasso', alpha_min=0.9) lasso_cd = linear_model.Lasso(fit_intercept=True, normalize=True, tol=1e-8) lasso_cd.alpha = alphas[-1] lasso_cd.fit(X, y) error = linalg.norm(lasso_path[:, -1] - lasso_cd.coef_) assert_less(error, 0.01) def test_lasso_lars_path_length(): # Test that the path length of the LassoLars is right lasso = linear_model.LassoLars() lasso.fit(X, y) lasso2 = linear_model.LassoLars(alpha=lasso.alphas_[2]) lasso2.fit(X, y) assert_array_almost_equal(lasso.alphas_[:3], lasso2.alphas_) # Also check that the sequence of alphas is always decreasing assert_true(np.all(np.diff(lasso.alphas_) < 0)) def test_lasso_lars_vs_lasso_cd_ill_conditioned(): # Test lasso lars on a very ill-conditioned design, and check that # it does not blow up, and stays somewhat close to a solution given # by the coordinate descent solver # Also test that lasso_path (using lars_path output style) gives # the same result as lars_path and previous lasso output style # under these conditions. rng = np.random.RandomState(42) # Generate data n, m = 70, 100 k = 5 X = rng.randn(n, m) w = np.zeros((m, 1)) i = np.arange(0, m) rng.shuffle(i) supp = i[:k] w[supp] = np.sign(rng.randn(k, 1)) * (rng.rand(k, 1) + 1) y = np.dot(X, w) sigma = 0.2 y += sigma * rng.rand(*y.shape) y = y.squeeze() lars_alphas, _, lars_coef = linear_model.lars_path(X, y, method='lasso') _, lasso_coef2, _ = linear_model.lasso_path(X, y, alphas=lars_alphas, tol=1e-6, fit_intercept=False) assert_array_almost_equal(lars_coef, lasso_coef2, decimal=1) def test_lasso_lars_vs_lasso_cd_ill_conditioned2(): # Create an ill-conditioned situation in which the LARS has to go # far in the path to converge, and check that LARS and coordinate # descent give the same answers # Note it used to be the case that Lars had to use the drop for good # strategy for this but this is no longer the case with the # equality_tolerance checks X = [[1e20, 1e20, 0], [-1e-32, 0, 0], [1, 1, 1]] y = [10, 10, 1] alpha = .0001 def objective_function(coef): return (1. / (2. * len(X)) * linalg.norm(y - np.dot(X, coef)) ** 2 + alpha * linalg.norm(coef, 1)) lars = linear_model.LassoLars(alpha=alpha, normalize=False) assert_warns(ConvergenceWarning, lars.fit, X, y) lars_coef_ = lars.coef_ lars_obj = objective_function(lars_coef_) coord_descent = linear_model.Lasso(alpha=alpha, tol=1e-10, normalize=False) cd_coef_ = coord_descent.fit(X, y).coef_ cd_obj = objective_function(cd_coef_) assert_less(lars_obj, cd_obj * (1. + 1e-8)) def test_lars_add_features(): # assure that at least some features get added if necessary # test for 6d2b4c # Hilbert matrix n = 5 H = 1. / (np.arange(1, n + 1) + np.arange(n)[:, np.newaxis]) clf = linear_model.Lars(fit_intercept=False).fit( H, np.arange(n)) assert_true(np.all(np.isfinite(clf.coef_))) def test_lars_n_nonzero_coefs(verbose=False): lars = linear_model.Lars(n_nonzero_coefs=6, verbose=verbose) lars.fit(X, y) assert_equal(len(lars.coef_.nonzero()[0]), 6) # The path should be of length 6 + 1 in a Lars going down to 6 # non-zero coefs assert_equal(len(lars.alphas_), 7) def test_multitarget(): # Assure that estimators receiving multidimensional y do the right thing X = diabetes.data Y = np.vstack([diabetes.target, diabetes.target ** 2]).T n_targets = Y.shape[1] for estimator in (linear_model.LassoLars(), linear_model.Lars()): estimator.fit(X, Y) Y_pred = estimator.predict(X) Y_dec = estimator.decision_function(X) assert_array_almost_equal(Y_pred, Y_dec) alphas, active, coef, path = (estimator.alphas_, estimator.active_, estimator.coef_, estimator.coef_path_) for k in range(n_targets): estimator.fit(X, Y[:, k]) y_pred = estimator.predict(X) assert_array_almost_equal(alphas[k], estimator.alphas_) assert_array_almost_equal(active[k], estimator.active_) assert_array_almost_equal(coef[k], estimator.coef_) assert_array_almost_equal(path[k], estimator.coef_path_) assert_array_almost_equal(Y_pred[:, k], y_pred) def test_lars_cv(): # Test the LassoLarsCV object by checking that the optimal alpha # increases as the number of samples increases. # This property is not actually garantied in general and is just a # property of the given dataset, with the given steps chosen. old_alpha = 0 lars_cv = linear_model.LassoLarsCV() for length in (400, 200, 100): X = diabetes.data[:length] y = diabetes.target[:length] lars_cv.fit(X, y) np.testing.assert_array_less(old_alpha, lars_cv.alpha_) old_alpha = lars_cv.alpha_ def test_lasso_lars_ic(): # Test the LassoLarsIC object by checking that # - some good features are selected. # - alpha_bic > alpha_aic # - n_nonzero_bic < n_nonzero_aic lars_bic = linear_model.LassoLarsIC('bic') lars_aic = linear_model.LassoLarsIC('aic') rng = np.random.RandomState(42) X = diabetes.data y = diabetes.target X = np.c_[X, rng.randn(X.shape[0], 4)] # add 4 bad features lars_bic.fit(X, y) lars_aic.fit(X, y) nonzero_bic = np.where(lars_bic.coef_)[0] nonzero_aic = np.where(lars_aic.coef_)[0] assert_greater(lars_bic.alpha_, lars_aic.alpha_) assert_less(len(nonzero_bic), len(nonzero_aic)) assert_less(np.max(nonzero_bic), diabetes.data.shape[1]) # test error on unknown IC lars_broken = linear_model.LassoLarsIC('<unknown>') assert_raises(ValueError, lars_broken.fit, X, y) def test_no_warning_for_zero_mse(): # LassoLarsIC should not warn for log of zero MSE. y = np.arange(10, dtype=float) X = y.reshape(-1, 1) lars = linear_model.LassoLarsIC(normalize=False) assert_no_warnings(lars.fit, X, y) assert_true(np.any(np.isinf(lars.criterion_))) def test_lars_path_readonly_data(): # When using automated memory mapping on large input, the # fold data is in read-only mode # This is a non-regression test for: # https://github.com/scikit-learn/scikit-learn/issues/4597 splitted_data = train_test_split(X, y, random_state=42) with TempMemmap(splitted_data) as (X_train, X_test, y_train, y_test): # The following should not fail despite copy=False _lars_path_residues(X_train, y_train, X_test, y_test, copy=False)
bsd-3-clause
fengzhyuan/scikit-learn
sklearn/covariance/__init__.py
389
1157
""" The :mod:`sklearn.covariance` module includes methods and algorithms to robustly estimate the covariance of features given a set of points. The precision matrix defined as the inverse of the covariance is also estimated. Covariance estimation is closely related to the theory of Gaussian Graphical Models. """ from .empirical_covariance_ import empirical_covariance, EmpiricalCovariance, \ log_likelihood from .shrunk_covariance_ import shrunk_covariance, ShrunkCovariance, \ ledoit_wolf, ledoit_wolf_shrinkage, \ LedoitWolf, oas, OAS from .robust_covariance import fast_mcd, MinCovDet from .graph_lasso_ import graph_lasso, GraphLasso, GraphLassoCV from .outlier_detection import EllipticEnvelope __all__ = ['EllipticEnvelope', 'EmpiricalCovariance', 'GraphLasso', 'GraphLassoCV', 'LedoitWolf', 'MinCovDet', 'OAS', 'ShrunkCovariance', 'empirical_covariance', 'fast_mcd', 'graph_lasso', 'ledoit_wolf', 'ledoit_wolf_shrinkage', 'log_likelihood', 'oas', 'shrunk_covariance']
bsd-3-clause
rajeshb/SelfDrivingCar
T1P5-Vehicle-Tracking/lesson_functions.py
1
15834
import matplotlib.image as mpimg import numpy as np import cv2 from skimage.feature import hog from scipy.ndimage.measurements import label # Define a function to return HOG features and visualization def get_hog_features(img, orient, pix_per_cell, cell_per_block, vis=False, feature_vec=True): # Call with two outputs if vis==True if vis == True: features, hog_image = hog(img, orientations=orient, pixels_per_cell=(pix_per_cell, pix_per_cell), cells_per_block=(cell_per_block, cell_per_block), transform_sqrt=True, visualise=vis, feature_vector=feature_vec) return features, hog_image # Otherwise call with one output else: features = hog(img, orientations=orient, pixels_per_cell=(pix_per_cell, pix_per_cell), cells_per_block=(cell_per_block, cell_per_block), transform_sqrt=True, visualise=vis, feature_vector=feature_vec) return features # Define a function to compute binned color features def bin_spatial(img, size=(32, 32)): # Use cv2.resize().ravel() to create the feature vector features = cv2.resize(img, size).ravel() # Return the feature vector return features # Define a function to compute color histogram features # FIXED, AFTER imread() of PNGs: NEED TO CHANGE bins_range if reading .png files with mpimg! def color_hist(img, nbins=32, bins_range=(0, 256)): # Compute the histogram of the color channels separately channel1_hist = np.histogram(img[:,:,0], bins=nbins, range=bins_range) channel2_hist = np.histogram(img[:,:,1], bins=nbins, range=bins_range) channel3_hist = np.histogram(img[:,:,2], bins=nbins, range=bins_range) # Concatenate the histograms into a single feature vector hist_features = np.concatenate((channel1_hist[0], channel2_hist[0], channel3_hist[0])) # Return the individual histograms, bin_centers and feature vector return hist_features # Define a function to extract features from a list of images # Have this function call bin_spatial() and color_hist() def extract_features(imgs, file_type = 'jpg', color_space='RGB', spatial_size=(32, 32), hist_bins=32, orient=9, pix_per_cell=8, cell_per_block=2, hog_channel=0, spatial_feat=True, hist_feat=True, hog_feat=True): # Create a list to append feature vectors to features = [] # Iterate through the list of images for file in imgs: file_features = [] # Read in each one by one image = mpimg.imread(file) # FIX for "NEED TO CHANGE bins_range if reading .png files with mpimg!" if file_type == 'png': image = (image * 255).astype(np.uint8) # apply color conversion if other than 'RGB' if color_space != 'RGB': if color_space == 'HSV': feature_image = cv2.cvtColor(image, cv2.COLOR_RGB2HSV) elif color_space == 'LUV': feature_image = cv2.cvtColor(image, cv2.COLOR_RGB2LUV) elif color_space == 'HLS': feature_image = cv2.cvtColor(image, cv2.COLOR_RGB2HLS) elif color_space == 'YUV': feature_image = cv2.cvtColor(image, cv2.COLOR_RGB2YUV) elif color_space == 'YCrCb': feature_image = cv2.cvtColor(image, cv2.COLOR_RGB2YCrCb) else: feature_image = np.copy(image) if spatial_feat == True: spatial_features = bin_spatial(feature_image, size=spatial_size) file_features.append(spatial_features) if hist_feat == True: # Apply color_hist() hist_features = color_hist(feature_image, nbins=hist_bins) file_features.append(hist_features) if hog_feat == True: # Call get_hog_features() with vis=False, feature_vec=True if hog_channel == 'ALL': hog_features = [] for channel in range(feature_image.shape[2]): hog_features.append(get_hog_features(feature_image[:,:,channel], orient, pix_per_cell, cell_per_block, vis=False, feature_vec=True)) hog_features = np.ravel(hog_features) else: hog_features = get_hog_features(feature_image[:,:,hog_channel], orient, pix_per_cell, cell_per_block, vis=False, feature_vec=True) # Append the new feature vector to the features list file_features.append(hog_features) features.append(np.concatenate(file_features)) # Return list of feature vectors return features # Define a function that takes # start and stop positions in both x and y, # window size (x and y dimensions), # and overlap fraction (for both x and y) def slide_window(x_start_stop=[None, None], y_start_stop=[None, None], xy_window=(64, 64), xy_overlap=(0.5, 0.5)): # If x and/or y start/stop positions not defined, set to image size if x_start_stop[0] == None: x_start_stop[0] = 0 if x_start_stop[1] == None: x_start_stop[1] = 1280 if y_start_stop[0] == None: y_start_stop[0] = 0 if y_start_stop[1] == None: y_start_stop[1] = 720 # Compute the span of the region to be searched xspan = x_start_stop[1] - x_start_stop[0] yspan = y_start_stop[1] - y_start_stop[0] # Compute the number of pixels per step in x/y nx_pix_per_step = np.int(xy_window[0]*(1 - xy_overlap[0])) ny_pix_per_step = np.int(xy_window[1]*(1 - xy_overlap[1])) # Compute the number of windows in x/y nx_buffer = np.int(xy_window[0]*(xy_overlap[0])) ny_buffer = np.int(xy_window[1]*(xy_overlap[1])) nx_windows = np.int((xspan-nx_buffer)/nx_pix_per_step) ny_windows = np.int((yspan-ny_buffer)/ny_pix_per_step) # Initialize a list to append window positions to window_list = [] # Loop through finding x and y window positions # Note: you could vectorize this step, but in practice # you'll be considering windows one by one with your # classifier, so looping makes sense for ys in range(ny_windows): for xs in range(nx_windows): # Calculate window position startx = xs*nx_pix_per_step + x_start_stop[0] endx = startx + xy_window[0] starty = ys*ny_pix_per_step + y_start_stop[0] endy = starty + xy_window[1] # Append window position to list window_list.append(((startx, starty), (endx, endy))) # Return the list of windows return window_list # Define a function to draw bounding boxes def draw_boxes(img, bboxes, color=(0, 0, 255), thick=6): # Make a copy of the image imcopy = np.copy(img) # Iterate through the bounding boxes for bbox in bboxes: # Draw a rectangle given bbox coordinates cv2.rectangle(imcopy, bbox[0], bbox[1], color, thick) # Return the image copy with boxes drawn return imcopy # Define a function to extract features from a single image window # This function is very similar to extract_features() # just for a single image rather than list of images def single_img_features(img, color_space='RGB', spatial_size=(32, 32), hist_bins=32, orient=9, pix_per_cell=8, cell_per_block=2, hog_channel=0, spatial_feat=True, hist_feat=True, hog_feat=True): #1) Define an empty list to receive features img_features = [] #2) Apply color conversion if other than 'RGB' if color_space != 'RGB': if color_space == 'HSV': feature_image = cv2.cvtColor(img, cv2.COLOR_RGB2HSV) elif color_space == 'LUV': feature_image = cv2.cvtColor(img, cv2.COLOR_RGB2LUV) elif color_space == 'HLS': feature_image = cv2.cvtColor(img, cv2.COLOR_RGB2HLS) elif color_space == 'YUV': feature_image = cv2.cvtColor(img, cv2.COLOR_RGB2YUV) elif color_space == 'YCrCb': feature_image = cv2.cvtColor(img, cv2.COLOR_RGB2YCrCb) else: feature_image = np.copy(img) #3) Compute spatial features if flag is set if spatial_feat == True: spatial_features = bin_spatial(feature_image, size=spatial_size) #4) Append features to list img_features.append(spatial_features) #5) Compute histogram features if flag is set if hist_feat == True: hist_features = color_hist(feature_image, nbins=hist_bins) #6) Append features to list img_features.append(hist_features) #7) Compute HOG features if flag is set if hog_feat == True: if hog_channel == 'ALL': hog_features = [] for channel in range(feature_image.shape[2]): hog_features.extend(get_hog_features(feature_image[:,:,channel], orient, pix_per_cell, cell_per_block, vis=False, feature_vec=True)) else: hog_features = get_hog_features(feature_image[:,:,hog_channel], orient, pix_per_cell, cell_per_block, vis=False, feature_vec=True) #8) Append features to list img_features.append(hog_features) #9) Return concatenated array of features return np.concatenate(img_features) # Define a function you will pass an image # and the list of windows to be searched (output of slide_windows()) def search_windows(img, windows, clf, scaler, color_space='RGB', spatial_size=(32, 32), hist_bins=32, hist_range=(0, 256), orient=9, pix_per_cell=8, cell_per_block=2, hog_channel=0, spatial_feat=True, hist_feat=True, hog_feat=True): #1) Create an empty list to receive positive detection windows on_windows = [] #2) Iterate over all windows in the list for window in windows: #3) Extract the test window from original image test_img = cv2.resize(img[window[0][1]:window[1][1], window[0][0]:window[1][0]], (64, 64)) #4) Extract features for that window using single_img_features() features = single_img_features(test_img, color_space=color_space, spatial_size=spatial_size, hist_bins=hist_bins, orient=orient, pix_per_cell=pix_per_cell, cell_per_block=cell_per_block, hog_channel=hog_channel, spatial_feat=spatial_feat, hist_feat=hist_feat, hog_feat=hog_feat) #5) Scale extracted features to be fed to classifier test_features = scaler.transform(np.array(features).reshape(1, -1)) #6) Predict using your classifier prediction = clf.predict(test_features) #7) If positive (prediction == 1) then save the window if prediction == 1: on_windows.append(window) #8) Return windows for positive detections return on_windows def add_heat(heatmap, bbox_list): # Iterate through list of bboxes for box in bbox_list: # Add += 1 for all pixels inside each bbox # Assuming each "box" takes the form ((x1, y1), (x2, y2)) heatmap[box[0][1]:box[1][1], box[0][0]:box[1][0]] += 1 # Return updated heatmap return heatmap def apply_threshold(heatmap, threshold): # Zero out pixels below the threshold heatmap[heatmap <= threshold] = 0 # Return thresholded map return heatmap def draw_labeled_bboxes(img, labels): # Iterate through all detected cars for car_number in range(1, labels[1]+1): # Find pixels with each car_number label value nonzero = (labels[0] == car_number).nonzero() # Identify x and y values of those pixels nonzeroy = np.array(nonzero[0]) nonzerox = np.array(nonzero[1]) # Define a bounding box based on min/max x and y bbox = ((np.min(nonzerox), np.min(nonzeroy)), (np.max(nonzerox), np.max(nonzeroy))) # Draw the box on the image cv2.rectangle(img, bbox[0], bbox[1], (0,0,255), 6) # Return the image return img # Define a single function that can extract features using hog sub-sampling and make predictions def find_cars(img, ystart, ystop, scale, svc, X_scaler, orient, pix_per_cell, cell_per_block, spatial_size, hist_bins): draw_img = np.copy(img) #img = img.astype(np.float32)/255 img_tosearch = img[ystart:ystop,:,:] ctrans_tosearch = cv2.cvtColor(img_tosearch, cv2.COLOR_RGB2YCrCb) if scale != 1: imshape = ctrans_tosearch.shape ctrans_tosearch = cv2.resize(ctrans_tosearch, (np.int(imshape[1]/scale), np.int(imshape[0]/scale))) ch1 = ctrans_tosearch[:,:,0] ch2 = ctrans_tosearch[:,:,1] ch3 = ctrans_tosearch[:,:,2] # Define blocks and steps as above nxblocks = (ch1.shape[1] // pix_per_cell)-1 nyblocks = (ch1.shape[0] // pix_per_cell)-1 nfeat_per_block = orient*cell_per_block**2 # 64 was the orginal sampling rate, with 8 cells and 8 pix per cell window = 64 nblocks_per_window = (window // pix_per_cell)-1 cells_per_step = 2 # Instead of overlap, define how many cells to step nxsteps = (nxblocks - nblocks_per_window) // cells_per_step nysteps = (nyblocks - nblocks_per_window) // cells_per_step # Compute individual channel HOG features for the entire image hog1 = get_hog_features(ch1, orient, pix_per_cell, cell_per_block, feature_vec=False) hog2 = get_hog_features(ch2, orient, pix_per_cell, cell_per_block, feature_vec=False) hog3 = get_hog_features(ch3, orient, pix_per_cell, cell_per_block, feature_vec=False) window_list = [] for xb in range(nxsteps): for yb in range(nysteps): ypos = yb*cells_per_step xpos = xb*cells_per_step # Extract HOG for this patch hog_feat1 = hog1[ypos:ypos+nblocks_per_window, xpos:xpos+nblocks_per_window].ravel() hog_feat2 = hog2[ypos:ypos+nblocks_per_window, xpos:xpos+nblocks_per_window].ravel() hog_feat3 = hog3[ypos:ypos+nblocks_per_window, xpos:xpos+nblocks_per_window].ravel() hog_features = np.hstack((hog_feat1, hog_feat2, hog_feat3)) xleft = xpos*pix_per_cell ytop = ypos*pix_per_cell # Extract the image patch subimg = cv2.resize(ctrans_tosearch[ytop:ytop+window, xleft:xleft+window], (64,64)) # Get color features spatial_features = bin_spatial(subimg, size=spatial_size) hist_features = color_hist(subimg, nbins=hist_bins) # Scale features and make a prediction test_features = X_scaler.transform(np.hstack((spatial_features, hist_features, hog_features)).reshape(1, -1)) #test_features = X_scaler.transform(np.hstack((shape_feat, hist_feat)).reshape(1, -1)) test_prediction = svc.predict(test_features) if test_prediction == 1: xbox_left = np.int(xleft*scale) ytop_draw = np.int(ytop*scale) win_draw = np.int(window*scale) startx = xbox_left starty = ytop_draw+ystart endx = xbox_left+win_draw endy = ytop_draw+win_draw+ystart window_list.append(((startx, starty), (endx, endy))) return window_list
mit
UCBerkeleySETI/breakthrough
APF/Tutorial/poly_curve_order_fit_github.py
1
3151
import matplotlib.pyplot as plt import numpy as np import pyfits as pf def get_coeffs(file_name): # open order coefficients and read values coeff_array = np.zeros((79,5)) with open(file_name, "r") as text: lines = text.read().splitlines() for i in range(len(lines)): a0 = float(lines[i][6:13].strip()) a1 = float(lines[i][17:26].strip()) a2 = float(lines[i][27:39].strip()) a3 = float(lines[i][40:52].strip()) a4 = float(lines[i][54:].strip()) coeffs = np.array([a0,a1,a2,a3,a4]) coeff_array[i] += coeffs return coeff_array def plot_with_polys(raw_array, coeff_array): plt.imshow(raw_array, cmap = "gray", origin = "lower", aspect = "auto", vmin = np.median(raw_array), vmax = np.median(raw_array) *1.1) plt.title("Raw image with polynomial functions overplotted") x = np.arange(0,4608) for i in range(coeff_array[:,0].size): a0 = coeff_array[i,0] a1 = coeff_array[i,1] a2 = coeff_array[i,2] a3 = coeff_array[i,3] a4 = coeff_array[i,4] plt.plot(x, a0 + a1*x + a2*x**2 + a3*x**3 + a4*x**4) def reduce_raw_data(image, coeff_array, bias): x = np.arange(0, 4608) y_values = np.zeros((79,4608)) reduced_image = np.zeros((79,4608)) for i in range(coeff_array[:,0].size): a0 = coeff_array[i,0] a1 = coeff_array[i,1] a2 = coeff_array[i,2] a3 = coeff_array[i,3] a4 = coeff_array[i,4] for j in range(x.size): y = a0 + a1*x[j] + a2*x[j]**2 + a3*x[j]**3 + a4*x[j]**4 y_values[i,j] = y y = int(round(y)) reduced_image[i,j] = int(np.sum(image[y-1:y+2,j], axis = 0)-3*bias) return reduced_image, y_values if __name__ == "__main__": # opening the APF Data and plotting the data as a 2D array apf_file = pf.open('ucb-amp194.fits') image = np.fliplr(np.rot90(apf_file[0].data)) # ^ flips and rotates the original array by 90 degrees # to make it correct (as far as website photo goes) header = apf_file[0].header # Calculate the bias bias = np.median(image[-30:]) # get reduced image apf_reduced = pf.open('ramp.194.fits') header_red = apf_reduced[0].header image_red = apf_reduced[0].data # creates an array of polynomial coefficients for each order coeff_array = get_coeffs("order_coefficients.txt") # plots reduced data array with overlaying polynomial functions plt.figure(figsize=(12,8)) plot_with_polys(image, coeff_array) # extracting each order and creating a reduced image to plot reduced_image, y_values = reduce_raw_data(image, coeff_array, bias) plt.figure(figsize=(12,8)) plt.subplot(2, 1, 1) plt.imshow(reduced_image, cmap = "gray", origin = "lower", aspect = "auto", vmin = np.median(reduced_image), vmax = np.median(reduced_image) *1.1) plt.title("Reduced Image through Polyfit Technique") plt.subplot(2, 1, 2) plt.title("Reduced Image File") plt.imshow(image_red, cmap = "gray", origin = "lower", aspect = "auto", vmin = np.median(image_red), vmax = np.median(image_red) *1.1) plt.figure(figsize=(12,8)) plt.subplot(2, 1, 1) plt.plot(reduced_image[53]) plt.title("Reduced Image (Polyfit) H-alpha") plt.subplot(2, 1, 2) plt.plot(image_red[53]) plt.title("Reduced Image File H-alpha") plt.show()
gpl-3.0
nmayorov/scikit-learn
examples/linear_model/plot_sgd_comparison.py
112
1819
""" ================================== Comparing various online solvers ================================== An example showing how different online solvers perform on the hand-written digits dataset. """ # Author: Rob Zinkov <rob at zinkov dot com> # License: BSD 3 clause import numpy as np import matplotlib.pyplot as plt from sklearn import datasets from sklearn.model_selection import train_test_split from sklearn.linear_model import SGDClassifier, Perceptron from sklearn.linear_model import PassiveAggressiveClassifier from sklearn.linear_model import LogisticRegression heldout = [0.95, 0.90, 0.75, 0.50, 0.01] rounds = 20 digits = datasets.load_digits() X, y = digits.data, digits.target classifiers = [ ("SGD", SGDClassifier()), ("ASGD", SGDClassifier(average=True)), ("Perceptron", Perceptron()), ("Passive-Aggressive I", PassiveAggressiveClassifier(loss='hinge', C=1.0)), ("Passive-Aggressive II", PassiveAggressiveClassifier(loss='squared_hinge', C=1.0)), ("SAG", LogisticRegression(solver='sag', tol=1e-1, C=1.e4 / X.shape[0])) ] xx = 1. - np.array(heldout) for name, clf in classifiers: print("training %s" % name) rng = np.random.RandomState(42) yy = [] for i in heldout: yy_ = [] for r in range(rounds): X_train, X_test, y_train, y_test = \ train_test_split(X, y, test_size=i, random_state=rng) clf.fit(X_train, y_train) y_pred = clf.predict(X_test) yy_.append(1 - np.mean(y_pred == y_test)) yy.append(np.mean(yy_)) plt.plot(xx, yy, label=name) plt.legend(loc="upper right") plt.xlabel("Proportion train") plt.ylabel("Test Error Rate") plt.show()
bsd-3-clause
lixun910/pysal
pysal/lib/io/geotable/utils.py
3
2349
from ...cg.shapes import asShape as pShape from ...common import requires as _requires from warnings import warn @_requires('geopandas') def to_df(df, geom_col='geometry', **kw): """ Convert a Geopandas dataframe into a normal pandas dataframe with a column containing PySAL shapes. Arguments --------- df : geopandas.GeoDataFrame a geopandas dataframe (or pandas dataframe) with a column containing geo-interfaced shapes geom_col: str string denoting which column in the df contains the geometry **kw : keyword options options passed directly to pandas.DataFrame(...,**kw) See Also -------- pandas.DataFrame """ import pandas as pd from geopandas import GeoDataFrame, GeoSeries df[geom_col] = df[geom_col].apply(pShape) if isinstance(df, (GeoDataFrame, GeoSeries)): df = pd.DataFrame(df, **kw) return df @_requires('geopandas') def to_gdf(df, geom_col='geometry', **kw): """ Convert a pandas dataframe with geometry column to a GeoPandas dataframe Arguments --------- df : pandas.DataFrame a pandas dataframe with a column containing geo-interfaced shapes geom_col: str string denoting which column in the df contains the geometry **kw : keyword options options passed directly to geopandas.GeoDataFrame(...,**kw) See Also -------- geopandas.GeoDataFrame """ from geopandas import GeoDataFrame from shapely.geometry import asShape as sShape df[geom_col] = df[geom_col].apply(sShape) return GeoDataFrame(df, geometry=geom_col, **kw) def insert_metadata(df, obj, name=None, inplace=True, overwrite=False): if not inplace: new = df.copy(deep=True) insert_metadata(new, obj, name=name, inplace=True) return new if name is None: name = type(obj).__name__ if hasattr(df, name): if overwrite: warn('Overwriting attribute {}! This may break the dataframe!'.format(name)) else: raise Exception('Dataframe already has attribute {}. Cowardly refusing ' 'to break dataframe. '.format(name)) df._metadata.append(name) df.__setattr__(name, obj)
bsd-3-clause
tony810430/flink
flink-python/pyflink/table/tests/test_row_based_operation.py
2
16850
################################################################################ # Licensed to the Apache Software Foundation (ASF) under one # or more contributor license agreements. See the NOTICE file # distributed with this work for additional information # regarding copyright ownership. The ASF licenses this file # to you under the Apache License, Version 2.0 (the # "License"); you may not use this file except in compliance # with the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. ################################################################################ from pandas.util.testing import assert_frame_equal from pyflink.common import Row from pyflink.table import expressions as expr, ListView from pyflink.table.types import DataTypes from pyflink.table.udf import udf, udtf, udaf, AggregateFunction, TableAggregateFunction, udtaf from pyflink.testing import source_sink_utils from pyflink.testing.test_case_utils import PyFlinkBlinkBatchTableTestCase, \ PyFlinkBlinkStreamTableTestCase class RowBasedOperationTests(object): def test_map(self): t = self.t_env.from_elements( [(1, 2, 3), (2, 1, 3), (1, 5, 4), (1, 8, 6), (2, 3, 4)], DataTypes.ROW( [DataTypes.FIELD("a", DataTypes.TINYINT()), DataTypes.FIELD("b", DataTypes.SMALLINT()), DataTypes.FIELD("c", DataTypes.INT())])) table_sink = source_sink_utils.TestAppendSink( ['a', 'b'], [DataTypes.BIGINT(), DataTypes.BIGINT()]) self.t_env.register_table_sink("Results", table_sink) func = udf(lambda x: Row(a=x + 1, b=x * x), result_type=DataTypes.ROW( [DataTypes.FIELD("a", DataTypes.BIGINT()), DataTypes.FIELD("b", DataTypes.BIGINT())])) func2 = udf(lambda x: Row(x.a + 1, x.b * 2), result_type=DataTypes.ROW( [DataTypes.FIELD("a", DataTypes.BIGINT()), DataTypes.FIELD("b", DataTypes.BIGINT())])) t.map(func(t.b)).alias("a", "b") \ .map(func(t.a)) \ .map(func2) \ .execute_insert("Results") \ .wait() actual = source_sink_utils.results() self.assert_equals( actual, ["+I[5, 18]", "+I[4, 8]", "+I[8, 72]", "+I[11, 162]", "+I[6, 32]"]) def test_map_with_pandas_udf(self): t = self.t_env.from_elements( [(1, Row(2, 3)), (2, Row(1, 3)), (1, Row(5, 4)), (1, Row(8, 6)), (2, Row(3, 4))], DataTypes.ROW( [DataTypes.FIELD("a", DataTypes.TINYINT()), DataTypes.FIELD("b", DataTypes.ROW([DataTypes.FIELD("c", DataTypes.INT()), DataTypes.FIELD("d", DataTypes.INT())]))])) table_sink = source_sink_utils.TestAppendSink( ['a', 'b'], [DataTypes.BIGINT(), DataTypes.BIGINT()]) self.t_env.register_table_sink("Results", table_sink) def func(x): import pandas as pd res = pd.concat([x.a, x.c + x.d], axis=1) return res def func2(x): return x * 2 def func3(x): assert isinstance(x, Row) return x pandas_udf = udf(func, result_type=DataTypes.ROW( [DataTypes.FIELD("c", DataTypes.BIGINT()), DataTypes.FIELD("d", DataTypes.BIGINT())]), func_type='pandas') pandas_udf_2 = udf(func2, result_type=DataTypes.ROW( [DataTypes.FIELD("c", DataTypes.BIGINT()), DataTypes.FIELD("d", DataTypes.BIGINT())]), func_type='pandas') general_udf = udf(func3, result_type=DataTypes.ROW( [DataTypes.FIELD("c", DataTypes.BIGINT()), DataTypes.FIELD("d", DataTypes.BIGINT())])) t.map(pandas_udf).map(pandas_udf_2).map(general_udf).execute_insert("Results").wait() actual = source_sink_utils.results() self.assert_equals( actual, ["+I[4, 8]", "+I[2, 10]", "+I[2, 28]", "+I[2, 18]", "+I[4, 14]"]) def test_flat_map(self): t = self.t_env.from_elements( [(1, "2,3"), (2, "1"), (1, "5,6,7")], DataTypes.ROW( [DataTypes.FIELD("a", DataTypes.TINYINT()), DataTypes.FIELD("b", DataTypes.STRING())])) table_sink = source_sink_utils.TestAppendSink( ['a', 'b', 'c', 'd', 'e', 'f'], [DataTypes.BIGINT(), DataTypes.STRING(), DataTypes.BIGINT(), DataTypes.STRING(), DataTypes.BIGINT(), DataTypes.STRING()]) self.t_env.register_table_sink("Results", table_sink) @udtf(result_types=[DataTypes.INT(), DataTypes.STRING()]) def split(x): for s in x.b.split(","): yield x.a, s t.flat_map(split).alias("a", "b") \ .flat_map(split).alias("a", "b") \ .join_lateral(split.alias("c", "d")) \ .left_outer_join_lateral(split.alias("e", "f")) \ .execute_insert("Results") \ .wait() actual = source_sink_utils.results() self.assert_equals( actual, ["+I[1, 2, 1, 2, 1, 2]", "+I[1, 3, 1, 3, 1, 3]", "+I[2, 1, 2, 1, 2, 1]", "+I[1, 5, 1, 5, 1, 5]", "+I[1, 6, 1, 6, 1, 6]", "+I[1, 7, 1, 7, 1, 7]"]) class BatchRowBasedOperationITTests(RowBasedOperationTests, PyFlinkBlinkBatchTableTestCase): def test_aggregate_with_pandas_udaf(self): t = self.t_env.from_elements( [(1, 2, 3), (2, 1, 3), (1, 5, 4), (1, 8, 6), (2, 3, 4)], DataTypes.ROW( [DataTypes.FIELD("a", DataTypes.TINYINT()), DataTypes.FIELD("b", DataTypes.SMALLINT()), DataTypes.FIELD("c", DataTypes.INT())])) table_sink = source_sink_utils.TestAppendSink( ['a', 'b', 'c'], [DataTypes.TINYINT(), DataTypes.FLOAT(), DataTypes.INT()]) self.t_env.register_table_sink("Results", table_sink) pandas_udaf = udaf(lambda pd: (pd.b.mean(), pd.a.max()), result_type=DataTypes.ROW( [DataTypes.FIELD("a", DataTypes.FLOAT()), DataTypes.FIELD("b", DataTypes.INT())]), func_type="pandas") t.select(t.a, t.b) \ .group_by(t.a) \ .aggregate(pandas_udaf) \ .select("*") \ .execute_insert("Results") \ .wait() actual = source_sink_utils.results() self.assert_equals(actual, ["+I[1, 5.0, 1]", "+I[2, 2.0, 2]"]) def test_aggregate_with_pandas_udaf_without_keys(self): t = self.t_env.from_elements( [(1, 2, 3), (2, 1, 3), (1, 5, 4), (1, 8, 6), (2, 3, 4)], DataTypes.ROW( [DataTypes.FIELD("a", DataTypes.TINYINT()), DataTypes.FIELD("b", DataTypes.SMALLINT()), DataTypes.FIELD("c", DataTypes.INT())])) table_sink = source_sink_utils.TestAppendSink( ['a', 'b'], [DataTypes.FLOAT(), DataTypes.INT()]) self.t_env.register_table_sink("Results", table_sink) pandas_udaf = udaf(lambda pd: Row(pd.b.mean(), pd.b.max()), result_type=DataTypes.ROW( [DataTypes.FIELD("a", DataTypes.FLOAT()), DataTypes.FIELD("b", DataTypes.INT())]), func_type="pandas") t.select(t.b) \ .aggregate(pandas_udaf.alias("a", "b")) \ .select("a, b") \ .execute_insert("Results") \ .wait() actual = source_sink_utils.results() self.assert_equals(actual, ["+I[3.8, 8]"]) def test_window_aggregate_with_pandas_udaf(self): import datetime from pyflink.table.window import Tumble t = self.t_env.from_elements( [ (1, 2, 3, datetime.datetime(2018, 3, 11, 3, 10, 0, 0)), (3, 2, 4, datetime.datetime(2018, 3, 11, 3, 10, 0, 0)), (2, 1, 2, datetime.datetime(2018, 3, 11, 3, 10, 0, 0)), (1, 3, 1, datetime.datetime(2018, 3, 11, 3, 40, 0, 0)), (1, 8, 5, datetime.datetime(2018, 3, 11, 4, 20, 0, 0)), (2, 3, 6, datetime.datetime(2018, 3, 11, 3, 30, 0, 0)) ], DataTypes.ROW( [DataTypes.FIELD("a", DataTypes.TINYINT()), DataTypes.FIELD("b", DataTypes.SMALLINT()), DataTypes.FIELD("c", DataTypes.INT()), DataTypes.FIELD("rowtime", DataTypes.TIMESTAMP(3))])) table_sink = source_sink_utils.TestAppendSink( ['a', 'b', 'c'], [ DataTypes.TIMESTAMP(3), DataTypes.FLOAT(), DataTypes.INT() ]) self.t_env.register_table_sink("Results", table_sink) pandas_udaf = udaf(lambda pd: (pd.b.mean(), pd.b.max()), result_type=DataTypes.ROW( [DataTypes.FIELD("a", DataTypes.FLOAT()), DataTypes.FIELD("b", DataTypes.INT())]), func_type="pandas") tumble_window = Tumble.over(expr.lit(1).hours) \ .on(expr.col("rowtime")) \ .alias("w") t.select(t.b, t.rowtime) \ .window(tumble_window) \ .group_by("w") \ .aggregate(pandas_udaf.alias("d", "e")) \ .select("w.rowtime, d, e") \ .execute_insert("Results") \ .wait() actual = source_sink_utils.results() self.assert_equals(actual, ["+I[2018-03-11 03:59:59.999, 2.2, 3]", "+I[2018-03-11 04:59:59.999, 8.0, 8]"]) class StreamRowBasedOperationITTests(RowBasedOperationTests, PyFlinkBlinkStreamTableTestCase): def test_aggregate(self): import pandas as pd t = self.t_env.from_elements( [(1, 2, 3), (2, 1, 3), (1, 5, 4), (1, 8, 6), (2, 3, 4)], DataTypes.ROW( [DataTypes.FIELD("a", DataTypes.BIGINT()), DataTypes.FIELD("b", DataTypes.SMALLINT()), DataTypes.FIELD("c", DataTypes.INT())])) function = CountAndSumAggregateFunction() agg = udaf(function, result_type=function.get_result_type(), accumulator_type=function.get_accumulator_type(), name=str(function.__class__.__name__)) result = t.group_by(t.a) \ .aggregate(agg.alias("c", "d")) \ .select("a, c, d") \ .to_pandas() assert_frame_equal(result.sort_values('a').reset_index(drop=True), pd.DataFrame([[1, 3, 15], [2, 2, 4]], columns=['a', 'c', 'd'])) def test_flat_aggregate(self): import pandas as pd mytop = udtaf(Top2()) t = self.t_env.from_elements([(1, 'Hi', 'Hello'), (3, 'Hi', 'hi'), (5, 'Hi2', 'hi'), (7, 'Hi', 'Hello'), (2, 'Hi', 'Hello')], ['a', 'b', 'c']) result = t.select(t.a, t.c) \ .group_by(t.c) \ .flat_aggregate(mytop.alias('a')) \ .select(t.a) \ .flat_aggregate(mytop.alias("b")) \ .select("b") \ .to_pandas() assert_frame_equal(result, pd.DataFrame([[7], [5]], columns=['b'])) def test_flat_aggregate_list_view(self): import pandas as pd my_concat = udtaf(ListViewConcatTableAggregateFunction()) self.t_env.get_config().get_configuration().set_string( "python.fn-execution.bundle.size", "2") # trigger the cache eviction in a bundle. self.t_env.get_config().get_configuration().set_string( "python.state.cache-size", "2") t = self.t_env.from_elements([(1, 'Hi', 'Hello'), (3, 'Hi', 'hi'), (3, 'Hi2', 'hi'), (3, 'Hi', 'hi'), (2, 'Hi', 'Hello'), (1, 'Hi2', 'Hello'), (3, 'Hi3', 'hi'), (3, 'Hi2', 'Hello'), (3, 'Hi3', 'hi'), (2, 'Hi3', 'Hello')], ['a', 'b', 'c']) result = t.group_by(t.c) \ .flat_aggregate(my_concat(t.b, ',').alias("b")) \ .select(t.b, t.c) \ .alias("a, c") assert_frame_equal(result.to_pandas().sort_values('c').reset_index(drop=True), pd.DataFrame([["Hi,Hi,Hi2,Hi2,Hi3", "Hello"], ["Hi,Hi,Hi2,Hi2,Hi3", "Hello"], ["Hi,Hi2,Hi,Hi3,Hi3", "hi"], ["Hi,Hi2,Hi,Hi3,Hi3", "hi"]], columns=['a', 'c'])) class CountAndSumAggregateFunction(AggregateFunction): def get_value(self, accumulator): from pyflink.common import Row return Row(accumulator[0], accumulator[1]) def create_accumulator(self): from pyflink.common import Row return Row(0, 0) def accumulate(self, accumulator, row: Row): accumulator[0] += 1 accumulator[1] += row.b def retract(self, accumulator, row: Row): accumulator[0] -= 1 accumulator[1] -= row.a def merge(self, accumulator, accumulators): for other_acc in accumulators: accumulator[0] += other_acc[0] accumulator[1] += other_acc[1] def get_accumulator_type(self): return DataTypes.ROW( [DataTypes.FIELD("a", DataTypes.BIGINT()), DataTypes.FIELD("b", DataTypes.BIGINT())]) def get_result_type(self): return DataTypes.ROW( [DataTypes.FIELD("a", DataTypes.BIGINT()), DataTypes.FIELD("b", DataTypes.BIGINT())]) class Top2(TableAggregateFunction): def emit_value(self, accumulator): yield accumulator[0] yield accumulator[1] def create_accumulator(self): return [None, None] def accumulate(self, accumulator, row: Row): if row.a is not None: if accumulator[0] is None or row.a > accumulator[0]: accumulator[1] = accumulator[0] accumulator[0] = row.a elif accumulator[1] is None or row.a > accumulator[1]: accumulator[1] = row.a def retract(self, accumulator, *args): accumulator[0] = accumulator[0] - 1 def merge(self, accumulator, accumulators): for other_acc in accumulators: self.accumulate(accumulator, other_acc[0]) self.accumulate(accumulator, other_acc[1]) def get_accumulator_type(self): return DataTypes.ARRAY(DataTypes.BIGINT()) def get_result_type(self): return DataTypes.BIGINT() class ListViewConcatTableAggregateFunction(TableAggregateFunction): def emit_value(self, accumulator): result = accumulator[1].join(accumulator[0]) yield Row(result) yield Row(result) def create_accumulator(self): return Row(ListView(), '') def accumulate(self, accumulator, *args): accumulator[1] = args[1] accumulator[0].add(args[0]) def retract(self, accumulator, *args): raise NotImplementedError def get_accumulator_type(self): return DataTypes.ROW([ DataTypes.FIELD("f0", DataTypes.LIST_VIEW(DataTypes.STRING())), DataTypes.FIELD("f1", DataTypes.BIGINT())]) def get_result_type(self): return DataTypes.ROW([DataTypes.FIELD("a", DataTypes.STRING())]) if __name__ == '__main__': import unittest try: import xmlrunner testRunner = xmlrunner.XMLTestRunner(output='target/test-reports') except ImportError: testRunner = None unittest.main(testRunner=testRunner, verbosity=2)
apache-2.0
chrinide/PyFV
pyfv/elm/plot_elm_comparison.py
1
7043
#!/usr/bin/python # -*- coding: utf-8 -*- """ ====================== ELM Classifiers Comparison ====================== A comparison of a several ELMClassifiers with different types of hidden layer activations. ELMClassifier is a classifier based on the Extreme Learning Machine, a single layer feedforward network with random hidden layer components and least squares fitting of the hidden->output weights by default [1][2] The point of this example is to illustrate the nature of decision boundaries with different hidden layer activation types and regressors. This should be taken with a grain of salt, as the intuition conveyed by these examples does not necessarily carry over to real datasets. In particular in high dimensional spaces data can more easily be separated linearly and the simplicity of classifiers such as naive Bayes and linear SVMs might lead to better generalization. The plots show training points in solid colors and testing points semi-transparent. The lower right shows the classification accuracy on the test set. References __________ .. [1] http://www.extreme-learning-machines.org .. [2] G.-B. Huang, Q.-Y. Zhu and C.-K. Siew, "Extreme Learning Machine: Theory and Applications", Neurocomputing, vol. 70, pp. 489-501, 2006. =============================================================================== Basis Functions: gaussian rbf : exp(-gamma * (||x-c||/r)^2) tanh : np.tanh(a) sinsq : np.power(np.sin(a), 2.0) tribas : np.clip(1.0 - np.fabs(a), 0.0, 1.0) hardlim : np.array(a > 0.0, dtype=float) where x : input pattern a : dot_product(x, c) + b c,r : randomly generated components Label Legend: ELM(10,tanh) :10 tanh units ELM(10,tanh,LR) :10 tanh units, LogisticRegression ELM(10,sinsq) :10 sin*sin units ELM(10,tribas) :10 tribas units ELM(10,hardlim) :10 hardlim units ELM(20,rbf(0.1)) :20 rbf units gamma=0.1 """ print __doc__ # Code source: Gael Varoqueux # Andreas Mueller # Modified for Documentation merge by Jaques Grobler # Modified for Extreme Learning Machine Classifiers by David Lambert # License: BSD import numpy as np import pylab as pl from matplotlib.colors import ListedColormap from sklearn.datasets import make_moons, make_circles, make_classification from sklearn.preprocessing import StandardScaler from sklearn.cross_validation import train_test_split from sklearn.linear_model import LogisticRegression from elm import GenELMClassifier from random_layer import RBFRandomLayer, MLPRandomLayer def get_data_bounds(X): h = .02 # step size in the mesh x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5 y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5 xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h)) return (x_min, x_max, y_min, y_max, xx, yy) def plot_data(ax, X_train, y_train, X_test, y_test, xx, yy): cm = ListedColormap(['#FF0000', '#0000FF']) # Plot the training points ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm) # and testing points ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm, alpha=0.6) ax.set_xlim(xx.min(), xx.max()) ax.set_ylim(yy.min(), yy.max()) ax.set_xticks(()) ax.set_yticks(()) def plot_contour(ax, X_train, y_train, X_test, y_test, xx, yy, Z): cm = pl.cm.RdBu cm_bright = ListedColormap(['#FF0000', '#0000FF']) ax.contourf(xx, yy, Z, cmap=cm, alpha=.8) # Plot also the training points ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright) # and testing points ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright, alpha=0.6) ax.set_xlim(xx.min(), xx.max()) ax.set_ylim(yy.min(), yy.max()) ax.set_xticks(()) ax.set_yticks(()) ax.set_title(name) ax.text(xx.max() - 0.3, yy.min() + 0.3, ('%.2f' % score).lstrip('0'), size=13, horizontalalignment='right') def make_datasets(): return [make_moons(n_samples=200, noise=0.3, random_state=0), make_circles(n_samples=200, noise=0.2, factor=0.5, random_state=1), make_linearly_separable()] def make_classifiers(): names = ["ELM(10,tanh)", "ELM(10,tanh,LR)", "ELM(10,sinsq)", "ELM(10,tribas)", "ELM(hardlim)", "ELM(20,rbf(0.1))"] nh = 10 # pass user defined transfer func sinsq = (lambda x: np.power(np.sin(x), 2.0)) srhl_sinsq = MLPRandomLayer(n_hidden=nh, activation_func=sinsq) # use internal transfer funcs srhl_tanh = MLPRandomLayer(n_hidden=nh, activation_func='tanh') srhl_tribas = MLPRandomLayer(n_hidden=nh, activation_func='tribas') srhl_hardlim = MLPRandomLayer(n_hidden=nh, activation_func='hardlim') # use gaussian RBF srhl_rbf = RBFRandomLayer(n_hidden=nh*2, rbf_width=0.1, random_state=0) log_reg = LogisticRegression() classifiers = [GenELMClassifier(hidden_layer=srhl_tanh), GenELMClassifier(hidden_layer=srhl_tanh, regressor=log_reg), GenELMClassifier(hidden_layer=srhl_sinsq), GenELMClassifier(hidden_layer=srhl_tribas), GenELMClassifier(hidden_layer=srhl_hardlim), GenELMClassifier(hidden_layer=srhl_rbf)] return names, classifiers def make_linearly_separable(): X, y = make_classification(n_samples=200, n_features=2, n_redundant=0, n_informative=2, random_state=1, n_clusters_per_class=1) rng = np.random.RandomState(2) X += 2 * rng.uniform(size=X.shape) return (X, y) ############################################################################### datasets = make_datasets() names, classifiers = make_classifiers() i = 1 figure = pl.figure(figsize=(18, 9)) # iterate over datasets for ds in datasets: # preprocess dataset, split into training and test part X, y = ds X = StandardScaler().fit_transform(X) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4, random_state=0) x_min, x_max, y_min, y_max, xx, yy = get_data_bounds(X) # plot dataset first ax = pl.subplot(len(datasets), len(classifiers) + 1, i) plot_data(ax, X_train, y_train, X_test, y_test, xx, yy) i += 1 # iterate over classifiers for name, clf in zip(names, classifiers): ax = pl.subplot(len(datasets), len(classifiers) + 1, i) clf.fit(X_train, y_train) score = clf.score(X_test, y_test) # Plot the decision boundary. For that, we will asign a color to each # point in the mesh [x_min, m_max]x[y_min, y_max]. Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()]) # Put the result into a color plot Z = Z.reshape(xx.shape) plot_contour(ax, X_train, y_train, X_test, y_test, xx, yy, Z) i += 1 figure.subplots_adjust(left=.02, right=.98) pl.show()
gpl-2.0
fbagirov/scikit-learn
sklearn/cluster/tests/test_hierarchical.py
230
19795
""" Several basic tests for hierarchical clustering procedures """ # Authors: Vincent Michel, 2010, Gael Varoquaux 2012, # Matteo Visconti di Oleggio Castello 2014 # License: BSD 3 clause from tempfile import mkdtemp import shutil from functools import partial import numpy as np from scipy import sparse from scipy.cluster import hierarchy from sklearn.utils.testing import assert_true from sklearn.utils.testing import assert_raises from sklearn.utils.testing import assert_equal from sklearn.utils.testing import assert_almost_equal from sklearn.utils.testing import assert_array_almost_equal from sklearn.utils.testing import assert_raise_message from sklearn.utils.testing import ignore_warnings from sklearn.cluster import ward_tree from sklearn.cluster import AgglomerativeClustering, FeatureAgglomeration from sklearn.cluster.hierarchical import (_hc_cut, _TREE_BUILDERS, linkage_tree) from sklearn.feature_extraction.image import grid_to_graph from sklearn.metrics.pairwise import PAIRED_DISTANCES, cosine_distances,\ manhattan_distances, pairwise_distances from sklearn.metrics.cluster import normalized_mutual_info_score from sklearn.neighbors.graph import kneighbors_graph from sklearn.cluster._hierarchical import average_merge, max_merge from sklearn.utils.fast_dict import IntFloatDict from sklearn.utils.testing import assert_array_equal from sklearn.utils.testing import assert_warns def test_linkage_misc(): # Misc tests on linkage rng = np.random.RandomState(42) X = rng.normal(size=(5, 5)) assert_raises(ValueError, AgglomerativeClustering(linkage='foo').fit, X) assert_raises(ValueError, linkage_tree, X, linkage='foo') assert_raises(ValueError, linkage_tree, X, connectivity=np.ones((4, 4))) # Smoke test FeatureAgglomeration FeatureAgglomeration().fit(X) # test hiearchical clustering on a precomputed distances matrix dis = cosine_distances(X) res = linkage_tree(dis, affinity="precomputed") assert_array_equal(res[0], linkage_tree(X, affinity="cosine")[0]) # test hiearchical clustering on a precomputed distances matrix res = linkage_tree(X, affinity=manhattan_distances) assert_array_equal(res[0], linkage_tree(X, affinity="manhattan")[0]) def test_structured_linkage_tree(): # Check that we obtain the correct solution for structured linkage trees. rng = np.random.RandomState(0) mask = np.ones([10, 10], dtype=np.bool) # Avoiding a mask with only 'True' entries mask[4:7, 4:7] = 0 X = rng.randn(50, 100) connectivity = grid_to_graph(*mask.shape) for tree_builder in _TREE_BUILDERS.values(): children, n_components, n_leaves, parent = \ tree_builder(X.T, connectivity) n_nodes = 2 * X.shape[1] - 1 assert_true(len(children) + n_leaves == n_nodes) # Check that ward_tree raises a ValueError with a connectivity matrix # of the wrong shape assert_raises(ValueError, tree_builder, X.T, np.ones((4, 4))) # Check that fitting with no samples raises an error assert_raises(ValueError, tree_builder, X.T[:0], connectivity) def test_unstructured_linkage_tree(): # Check that we obtain the correct solution for unstructured linkage trees. rng = np.random.RandomState(0) X = rng.randn(50, 100) for this_X in (X, X[0]): # With specified a number of clusters just for the sake of # raising a warning and testing the warning code with ignore_warnings(): children, n_nodes, n_leaves, parent = assert_warns( UserWarning, ward_tree, this_X.T, n_clusters=10) n_nodes = 2 * X.shape[1] - 1 assert_equal(len(children) + n_leaves, n_nodes) for tree_builder in _TREE_BUILDERS.values(): for this_X in (X, X[0]): with ignore_warnings(): children, n_nodes, n_leaves, parent = assert_warns( UserWarning, tree_builder, this_X.T, n_clusters=10) n_nodes = 2 * X.shape[1] - 1 assert_equal(len(children) + n_leaves, n_nodes) def test_height_linkage_tree(): # Check that the height of the results of linkage tree is sorted. rng = np.random.RandomState(0) mask = np.ones([10, 10], dtype=np.bool) X = rng.randn(50, 100) connectivity = grid_to_graph(*mask.shape) for linkage_func in _TREE_BUILDERS.values(): children, n_nodes, n_leaves, parent = linkage_func(X.T, connectivity) n_nodes = 2 * X.shape[1] - 1 assert_true(len(children) + n_leaves == n_nodes) def test_agglomerative_clustering(): # Check that we obtain the correct number of clusters with # agglomerative clustering. rng = np.random.RandomState(0) mask = np.ones([10, 10], dtype=np.bool) n_samples = 100 X = rng.randn(n_samples, 50) connectivity = grid_to_graph(*mask.shape) for linkage in ("ward", "complete", "average"): clustering = AgglomerativeClustering(n_clusters=10, connectivity=connectivity, linkage=linkage) clustering.fit(X) # test caching try: tempdir = mkdtemp() clustering = AgglomerativeClustering( n_clusters=10, connectivity=connectivity, memory=tempdir, linkage=linkage) clustering.fit(X) labels = clustering.labels_ assert_true(np.size(np.unique(labels)) == 10) finally: shutil.rmtree(tempdir) # Turn caching off now clustering = AgglomerativeClustering( n_clusters=10, connectivity=connectivity, linkage=linkage) # Check that we obtain the same solution with early-stopping of the # tree building clustering.compute_full_tree = False clustering.fit(X) assert_almost_equal(normalized_mutual_info_score(clustering.labels_, labels), 1) clustering.connectivity = None clustering.fit(X) assert_true(np.size(np.unique(clustering.labels_)) == 10) # Check that we raise a TypeError on dense matrices clustering = AgglomerativeClustering( n_clusters=10, connectivity=sparse.lil_matrix( connectivity.toarray()[:10, :10]), linkage=linkage) assert_raises(ValueError, clustering.fit, X) # Test that using ward with another metric than euclidean raises an # exception clustering = AgglomerativeClustering( n_clusters=10, connectivity=connectivity.toarray(), affinity="manhattan", linkage="ward") assert_raises(ValueError, clustering.fit, X) # Test using another metric than euclidean works with linkage complete for affinity in PAIRED_DISTANCES.keys(): # Compare our (structured) implementation to scipy clustering = AgglomerativeClustering( n_clusters=10, connectivity=np.ones((n_samples, n_samples)), affinity=affinity, linkage="complete") clustering.fit(X) clustering2 = AgglomerativeClustering( n_clusters=10, connectivity=None, affinity=affinity, linkage="complete") clustering2.fit(X) assert_almost_equal(normalized_mutual_info_score(clustering2.labels_, clustering.labels_), 1) # Test that using a distance matrix (affinity = 'precomputed') has same # results (with connectivity constraints) clustering = AgglomerativeClustering(n_clusters=10, connectivity=connectivity, linkage="complete") clustering.fit(X) X_dist = pairwise_distances(X) clustering2 = AgglomerativeClustering(n_clusters=10, connectivity=connectivity, affinity='precomputed', linkage="complete") clustering2.fit(X_dist) assert_array_equal(clustering.labels_, clustering2.labels_) def test_ward_agglomeration(): # Check that we obtain the correct solution in a simplistic case rng = np.random.RandomState(0) mask = np.ones([10, 10], dtype=np.bool) X = rng.randn(50, 100) connectivity = grid_to_graph(*mask.shape) agglo = FeatureAgglomeration(n_clusters=5, connectivity=connectivity) agglo.fit(X) assert_true(np.size(np.unique(agglo.labels_)) == 5) X_red = agglo.transform(X) assert_true(X_red.shape[1] == 5) X_full = agglo.inverse_transform(X_red) assert_true(np.unique(X_full[0]).size == 5) assert_array_almost_equal(agglo.transform(X_full), X_red) # Check that fitting with no samples raises a ValueError assert_raises(ValueError, agglo.fit, X[:0]) def assess_same_labelling(cut1, cut2): """Util for comparison with scipy""" co_clust = [] for cut in [cut1, cut2]: n = len(cut) k = cut.max() + 1 ecut = np.zeros((n, k)) ecut[np.arange(n), cut] = 1 co_clust.append(np.dot(ecut, ecut.T)) assert_true((co_clust[0] == co_clust[1]).all()) def test_scikit_vs_scipy(): # Test scikit linkage with full connectivity (i.e. unstructured) vs scipy n, p, k = 10, 5, 3 rng = np.random.RandomState(0) # Not using a lil_matrix here, just to check that non sparse # matrices are well handled connectivity = np.ones((n, n)) for linkage in _TREE_BUILDERS.keys(): for i in range(5): X = .1 * rng.normal(size=(n, p)) X -= 4. * np.arange(n)[:, np.newaxis] X -= X.mean(axis=1)[:, np.newaxis] out = hierarchy.linkage(X, method=linkage) children_ = out[:, :2].astype(np.int) children, _, n_leaves, _ = _TREE_BUILDERS[linkage](X, connectivity) cut = _hc_cut(k, children, n_leaves) cut_ = _hc_cut(k, children_, n_leaves) assess_same_labelling(cut, cut_) # Test error management in _hc_cut assert_raises(ValueError, _hc_cut, n_leaves + 1, children, n_leaves) def test_connectivity_propagation(): # Check that connectivity in the ward tree is propagated correctly during # merging. X = np.array([(.014, .120), (.014, .099), (.014, .097), (.017, .153), (.017, .153), (.018, .153), (.018, .153), (.018, .153), (.018, .153), (.018, .153), (.018, .153), (.018, .153), (.018, .152), (.018, .149), (.018, .144)]) connectivity = kneighbors_graph(X, 10, include_self=False) ward = AgglomerativeClustering( n_clusters=4, connectivity=connectivity, linkage='ward') # If changes are not propagated correctly, fit crashes with an # IndexError ward.fit(X) def test_ward_tree_children_order(): # Check that children are ordered in the same way for both structured and # unstructured versions of ward_tree. # test on five random datasets n, p = 10, 5 rng = np.random.RandomState(0) connectivity = np.ones((n, n)) for i in range(5): X = .1 * rng.normal(size=(n, p)) X -= 4. * np.arange(n)[:, np.newaxis] X -= X.mean(axis=1)[:, np.newaxis] out_unstructured = ward_tree(X) out_structured = ward_tree(X, connectivity=connectivity) assert_array_equal(out_unstructured[0], out_structured[0]) def test_ward_linkage_tree_return_distance(): # Test return_distance option on linkage and ward trees # test that return_distance when set true, gives same # output on both structured and unstructured clustering. n, p = 10, 5 rng = np.random.RandomState(0) connectivity = np.ones((n, n)) for i in range(5): X = .1 * rng.normal(size=(n, p)) X -= 4. * np.arange(n)[:, np.newaxis] X -= X.mean(axis=1)[:, np.newaxis] out_unstructured = ward_tree(X, return_distance=True) out_structured = ward_tree(X, connectivity=connectivity, return_distance=True) # get children children_unstructured = out_unstructured[0] children_structured = out_structured[0] # check if we got the same clusters assert_array_equal(children_unstructured, children_structured) # check if the distances are the same dist_unstructured = out_unstructured[-1] dist_structured = out_structured[-1] assert_array_almost_equal(dist_unstructured, dist_structured) for linkage in ['average', 'complete']: structured_items = linkage_tree( X, connectivity=connectivity, linkage=linkage, return_distance=True)[-1] unstructured_items = linkage_tree( X, linkage=linkage, return_distance=True)[-1] structured_dist = structured_items[-1] unstructured_dist = unstructured_items[-1] structured_children = structured_items[0] unstructured_children = unstructured_items[0] assert_array_almost_equal(structured_dist, unstructured_dist) assert_array_almost_equal( structured_children, unstructured_children) # test on the following dataset where we know the truth # taken from scipy/cluster/tests/hierarchy_test_data.py X = np.array([[1.43054825, -7.5693489], [6.95887839, 6.82293382], [2.87137846, -9.68248579], [7.87974764, -6.05485803], [8.24018364, -6.09495602], [7.39020262, 8.54004355]]) # truth linkage_X_ward = np.array([[3., 4., 0.36265956, 2.], [1., 5., 1.77045373, 2.], [0., 2., 2.55760419, 2.], [6., 8., 9.10208346, 4.], [7., 9., 24.7784379, 6.]]) linkage_X_complete = np.array( [[3., 4., 0.36265956, 2.], [1., 5., 1.77045373, 2.], [0., 2., 2.55760419, 2.], [6., 8., 6.96742194, 4.], [7., 9., 18.77445997, 6.]]) linkage_X_average = np.array( [[3., 4., 0.36265956, 2.], [1., 5., 1.77045373, 2.], [0., 2., 2.55760419, 2.], [6., 8., 6.55832839, 4.], [7., 9., 15.44089605, 6.]]) n_samples, n_features = np.shape(X) connectivity_X = np.ones((n_samples, n_samples)) out_X_unstructured = ward_tree(X, return_distance=True) out_X_structured = ward_tree(X, connectivity=connectivity_X, return_distance=True) # check that the labels are the same assert_array_equal(linkage_X_ward[:, :2], out_X_unstructured[0]) assert_array_equal(linkage_X_ward[:, :2], out_X_structured[0]) # check that the distances are correct assert_array_almost_equal(linkage_X_ward[:, 2], out_X_unstructured[4]) assert_array_almost_equal(linkage_X_ward[:, 2], out_X_structured[4]) linkage_options = ['complete', 'average'] X_linkage_truth = [linkage_X_complete, linkage_X_average] for (linkage, X_truth) in zip(linkage_options, X_linkage_truth): out_X_unstructured = linkage_tree( X, return_distance=True, linkage=linkage) out_X_structured = linkage_tree( X, connectivity=connectivity_X, linkage=linkage, return_distance=True) # check that the labels are the same assert_array_equal(X_truth[:, :2], out_X_unstructured[0]) assert_array_equal(X_truth[:, :2], out_X_structured[0]) # check that the distances are correct assert_array_almost_equal(X_truth[:, 2], out_X_unstructured[4]) assert_array_almost_equal(X_truth[:, 2], out_X_structured[4]) def test_connectivity_fixing_non_lil(): # Check non regression of a bug if a non item assignable connectivity is # provided with more than one component. # create dummy data x = np.array([[0, 0], [1, 1]]) # create a mask with several components to force connectivity fixing m = np.array([[True, False], [False, True]]) c = grid_to_graph(n_x=2, n_y=2, mask=m) w = AgglomerativeClustering(connectivity=c, linkage='ward') assert_warns(UserWarning, w.fit, x) def test_int_float_dict(): rng = np.random.RandomState(0) keys = np.unique(rng.randint(100, size=10).astype(np.intp)) values = rng.rand(len(keys)) d = IntFloatDict(keys, values) for key, value in zip(keys, values): assert d[key] == value other_keys = np.arange(50).astype(np.intp)[::2] other_values = 0.5 * np.ones(50)[::2] other = IntFloatDict(other_keys, other_values) # Complete smoke test max_merge(d, other, mask=np.ones(100, dtype=np.intp), n_a=1, n_b=1) average_merge(d, other, mask=np.ones(100, dtype=np.intp), n_a=1, n_b=1) def test_connectivity_callable(): rng = np.random.RandomState(0) X = rng.rand(20, 5) connectivity = kneighbors_graph(X, 3, include_self=False) aglc1 = AgglomerativeClustering(connectivity=connectivity) aglc2 = AgglomerativeClustering( connectivity=partial(kneighbors_graph, n_neighbors=3, include_self=False)) aglc1.fit(X) aglc2.fit(X) assert_array_equal(aglc1.labels_, aglc2.labels_) def test_connectivity_ignores_diagonal(): rng = np.random.RandomState(0) X = rng.rand(20, 5) connectivity = kneighbors_graph(X, 3, include_self=False) connectivity_include_self = kneighbors_graph(X, 3, include_self=True) aglc1 = AgglomerativeClustering(connectivity=connectivity) aglc2 = AgglomerativeClustering(connectivity=connectivity_include_self) aglc1.fit(X) aglc2.fit(X) assert_array_equal(aglc1.labels_, aglc2.labels_) def test_compute_full_tree(): # Test that the full tree is computed if n_clusters is small rng = np.random.RandomState(0) X = rng.randn(10, 2) connectivity = kneighbors_graph(X, 5, include_self=False) # When n_clusters is less, the full tree should be built # that is the number of merges should be n_samples - 1 agc = AgglomerativeClustering(n_clusters=2, connectivity=connectivity) agc.fit(X) n_samples = X.shape[0] n_nodes = agc.children_.shape[0] assert_equal(n_nodes, n_samples - 1) # When n_clusters is large, greater than max of 100 and 0.02 * n_samples. # we should stop when there are n_clusters. n_clusters = 101 X = rng.randn(200, 2) connectivity = kneighbors_graph(X, 10, include_self=False) agc = AgglomerativeClustering(n_clusters=n_clusters, connectivity=connectivity) agc.fit(X) n_samples = X.shape[0] n_nodes = agc.children_.shape[0] assert_equal(n_nodes, n_samples - n_clusters) def test_n_components(): # Test n_components returned by linkage, average and ward tree rng = np.random.RandomState(0) X = rng.rand(5, 5) # Connectivity matrix having five components. connectivity = np.eye(5) for linkage_func in _TREE_BUILDERS.values(): assert_equal(ignore_warnings(linkage_func)(X, connectivity)[1], 5) def test_agg_n_clusters(): # Test that an error is raised when n_clusters <= 0 rng = np.random.RandomState(0) X = rng.rand(20, 10) for n_clus in [-1, 0]: agc = AgglomerativeClustering(n_clusters=n_clus) msg = ("n_clusters should be an integer greater than 0." " %s was provided." % str(agc.n_clusters)) assert_raise_message(ValueError, msg, agc.fit, X)
bsd-3-clause
oxtopus/nupic
external/linux32/lib/python2.6/site-packages/matplotlib/offsetbox.py
69
17728
""" The OffsetBox is a simple container artist. The child artist are meant to be drawn at a relative position to its parent. The [VH]Packer, DrawingArea and TextArea are derived from the OffsetBox. The [VH]Packer automatically adjust the relative postisions of their children, which should be instances of the OffsetBox. This is used to align similar artists together, e.g., in legend. The DrawingArea can contain any Artist as a child. The DrawingArea has a fixed width and height. The position of children relative to the parent is fixed. The TextArea is contains a single Text instance. The width and height of the TextArea instance is the width and height of the its child text. """ import matplotlib.transforms as mtransforms import matplotlib.artist as martist import matplotlib.text as mtext import numpy as np from matplotlib.patches import bbox_artist as mbbox_artist DEBUG=False # for debuging use def bbox_artist(*args, **kwargs): if DEBUG: mbbox_artist(*args, **kwargs) # _get_packed_offsets() and _get_aligned_offsets() are coded assuming # that we are packing boxes horizontally. But same function will be # used with vertical packing. def _get_packed_offsets(wd_list, total, sep, mode="fixed"): """ Geiven a list of (width, xdescent) of each boxes, calculate the total width and the x-offset positions of each items according to *mode*. xdescent is analagous to the usual descent, but along the x-direction. xdescent values are currently ignored. *wd_list* : list of (width, xdescent) of boxes to be packed. *sep* : spacing between boxes *total* : Intended total length. None if not used. *mode* : packing mode. 'fixed', 'expand', or 'equal'. """ w_list, d_list = zip(*wd_list) # d_list is currently not used. if mode == "fixed": offsets_ = np.add.accumulate([0]+[w + sep for w in w_list]) offsets = offsets_[:-1] if total is None: total = offsets_[-1] - sep return total, offsets elif mode == "expand": sep = (total - sum(w_list))/(len(w_list)-1.) offsets_ = np.add.accumulate([0]+[w + sep for w in w_list]) offsets = offsets_[:-1] return total, offsets elif mode == "equal": maxh = max(w_list) if total is None: total = (maxh+sep)*len(w_list) else: sep = float(total)/(len(w_list)) - maxh offsets = np.array([(maxh+sep)*i for i in range(len(w_list))]) return total, offsets else: raise ValueError("Unknown mode : %s" % (mode,)) def _get_aligned_offsets(hd_list, height, align="baseline"): """ Geiven a list of (height, descent) of each boxes, align the boxes with *align* and calculate the y-offsets of each boxes. total width and the offset positions of each items according to *mode*. xdescent is analagous to the usual descent, but along the x-direction. xdescent values are currently ignored. *hd_list* : list of (width, xdescent) of boxes to be aligned. *sep* : spacing between boxes *height* : Intended total length. None if not used. *align* : align mode. 'baseline', 'top', 'bottom', or 'center'. """ if height is None: height = max([h for h, d in hd_list]) if align == "baseline": height_descent = max([h-d for h, d in hd_list]) descent = max([d for h, d in hd_list]) height = height_descent + descent offsets = [0. for h, d in hd_list] elif align in ["left","top"]: descent=0. offsets = [d for h, d in hd_list] elif align in ["right","bottom"]: descent=0. offsets = [height-h+d for h, d in hd_list] elif align == "center": descent=0. offsets = [(height-h)*.5+d for h, d in hd_list] else: raise ValueError("Unknown Align mode : %s" % (align,)) return height, descent, offsets class OffsetBox(martist.Artist): """ The OffsetBox is a simple container artist. The child artist are meant to be drawn at a relative position to its parent. """ def __init__(self, *args, **kwargs): super(OffsetBox, self).__init__(*args, **kwargs) self._children = [] self._offset = (0, 0) def set_figure(self, fig): """ Set the figure accepts a class:`~matplotlib.figure.Figure` instance """ martist.Artist.set_figure(self, fig) for c in self.get_children(): c.set_figure(fig) def set_offset(self, xy): """ Set the offset accepts x, y, tuple, or a callable object. """ self._offset = xy def get_offset(self, width, height, xdescent, ydescent): """ Get the offset accepts extent of the box """ if callable(self._offset): return self._offset(width, height, xdescent, ydescent) else: return self._offset def set_width(self, width): """ Set the width accepts float """ self.width = width def set_height(self, height): """ Set the height accepts float """ self.height = height def get_children(self): """ Return a list of artists it contains. """ return self._children def get_extent_offsets(self, renderer): raise Exception("") def get_extent(self, renderer): """ Return with, height, xdescent, ydescent of box """ w, h, xd, yd, offsets = self.get_extent_offsets(renderer) return w, h, xd, yd def get_window_extent(self, renderer): ''' get the bounding box in display space. ''' w, h, xd, yd, offsets = self.get_extent_offsets(renderer) px, py = self.get_offset(w, h, xd, yd) return mtransforms.Bbox.from_bounds(px-xd, py-yd, w, h) def draw(self, renderer): """ Update the location of children if necessary and draw them to the given *renderer*. """ width, height, xdescent, ydescent, offsets = self.get_extent_offsets(renderer) px, py = self.get_offset(width, height, xdescent, ydescent) for c, (ox, oy) in zip(self.get_children(), offsets): c.set_offset((px+ox, py+oy)) c.draw(renderer) bbox_artist(self, renderer, fill=False, props=dict(pad=0.)) class PackerBase(OffsetBox): def __init__(self, pad=None, sep=None, width=None, height=None, align=None, mode=None, children=None): """ *pad* : boundary pad *sep* : spacing between items *width*, *height* : width and height of the container box. calculated if None. *align* : alignment of boxes *mode* : packing mode """ super(PackerBase, self).__init__() self.height = height self.width = width self.sep = sep self.pad = pad self.mode = mode self.align = align self._children = children class VPacker(PackerBase): """ The VPacker has its children packed vertically. It automatically adjust the relative postisions of children in the drawing time. """ def __init__(self, pad=None, sep=None, width=None, height=None, align="baseline", mode="fixed", children=None): """ *pad* : boundary pad *sep* : spacing between items *width*, *height* : width and height of the container box. calculated if None. *align* : alignment of boxes *mode* : packing mode """ super(VPacker, self).__init__(pad, sep, width, height, align, mode, children) def get_extent_offsets(self, renderer): """ update offset of childrens and return the extents of the box """ whd_list = [c.get_extent(renderer) for c in self.get_children()] whd_list = [(w, h, xd, (h-yd)) for w, h, xd, yd in whd_list] wd_list = [(w, xd) for w, h, xd, yd in whd_list] width, xdescent, xoffsets = _get_aligned_offsets(wd_list, self.width, self.align) pack_list = [(h, yd) for w,h,xd,yd in whd_list] height, yoffsets_ = _get_packed_offsets(pack_list, self.height, self.sep, self.mode) yoffsets = yoffsets_ + [yd for w,h,xd,yd in whd_list] ydescent = height - yoffsets[0] yoffsets = height - yoffsets #w, h, xd, h_yd = whd_list[-1] yoffsets = yoffsets - ydescent return width + 2*self.pad, height + 2*self.pad, \ xdescent+self.pad, ydescent+self.pad, \ zip(xoffsets, yoffsets) class HPacker(PackerBase): """ The HPacker has its children packed horizontally. It automatically adjust the relative postisions of children in the drawing time. """ def __init__(self, pad=None, sep=None, width=None, height=None, align="baseline", mode="fixed", children=None): """ *pad* : boundary pad *sep* : spacing between items *width*, *height* : width and height of the container box. calculated if None. *align* : alignment of boxes *mode* : packing mode """ super(HPacker, self).__init__(pad, sep, width, height, align, mode, children) def get_extent_offsets(self, renderer): """ update offset of childrens and return the extents of the box """ whd_list = [c.get_extent(renderer) for c in self.get_children()] if self.height is None: height_descent = max([h-yd for w,h,xd,yd in whd_list]) ydescent = max([yd for w,h,xd,yd in whd_list]) height = height_descent + ydescent else: height = self.height - 2*self._pad # width w/o pad hd_list = [(h, yd) for w, h, xd, yd in whd_list] height, ydescent, yoffsets = _get_aligned_offsets(hd_list, self.height, self.align) pack_list = [(w, xd) for w,h,xd,yd in whd_list] width, xoffsets_ = _get_packed_offsets(pack_list, self.width, self.sep, self.mode) xoffsets = xoffsets_ + [xd for w,h,xd,yd in whd_list] xdescent=whd_list[0][2] xoffsets = xoffsets - xdescent return width + 2*self.pad, height + 2*self.pad, \ xdescent + self.pad, ydescent + self.pad, \ zip(xoffsets, yoffsets) class DrawingArea(OffsetBox): """ The DrawingArea can contain any Artist as a child. The DrawingArea has a fixed width and height. The position of children relative to the parent is fixed. """ def __init__(self, width, height, xdescent=0., ydescent=0., clip=True): """ *width*, *height* : width and height of the container box. *xdescent*, *ydescent* : descent of the box in x- and y-direction. """ super(DrawingArea, self).__init__() self.width = width self.height = height self.xdescent = xdescent self.ydescent = ydescent self.offset_transform = mtransforms.Affine2D() self.offset_transform.clear() self.offset_transform.translate(0, 0) def get_transform(self): """ Return the :class:`~matplotlib.transforms.Transform` applied to the children """ return self.offset_transform def set_transform(self, t): """ set_transform is ignored. """ pass def set_offset(self, xy): """ set offset of the container. Accept : tuple of x,y cooridnate in disokay units. """ self._offset = xy self.offset_transform.clear() self.offset_transform.translate(xy[0], xy[1]) def get_offset(self): """ return offset of the container. """ return self._offset def get_window_extent(self, renderer): ''' get the bounding box in display space. ''' w, h, xd, yd = self.get_extent(renderer) ox, oy = self.get_offset() #w, h, xd, yd) return mtransforms.Bbox.from_bounds(ox-xd, oy-yd, w, h) def get_extent(self, renderer): """ Return with, height, xdescent, ydescent of box """ return self.width, self.height, self.xdescent, self.ydescent def add_artist(self, a): 'Add any :class:`~matplotlib.artist.Artist` to the container box' self._children.append(a) a.set_transform(self.get_transform()) def draw(self, renderer): """ Draw the children """ for c in self._children: c.draw(renderer) bbox_artist(self, renderer, fill=False, props=dict(pad=0.)) class TextArea(OffsetBox): """ The TextArea is contains a single Text instance. The text is placed at (0,0) with baseline+left alignment. The width and height of the TextArea instance is the width and height of the its child text. """ def __init__(self, s, textprops=None, multilinebaseline=None, minimumdescent=True, ): """ *s* : a string to be displayed. *textprops* : property dictionary for the text *multilinebaseline* : If True, baseline for multiline text is adjusted so that it is (approximatedly) center-aligned with singleline text. *minimumdescent* : If True, the box has a minimum descent of "p". """ if textprops is None: textprops = {} if not textprops.has_key("va"): textprops["va"]="baseline" self._text = mtext.Text(0, 0, s, **textprops) OffsetBox.__init__(self) self._children = [self._text] self.offset_transform = mtransforms.Affine2D() self.offset_transform.clear() self.offset_transform.translate(0, 0) self._baseline_transform = mtransforms.Affine2D() self._text.set_transform(self.offset_transform+self._baseline_transform) self._multilinebaseline = multilinebaseline self._minimumdescent = minimumdescent def set_multilinebaseline(self, t): """ Set multilinebaseline . If True, baseline for multiline text is adjusted so that it is (approximatedly) center-aligned with singleline text. """ self._multilinebaseline = t def get_multilinebaseline(self): """ get multilinebaseline . """ return self._multilinebaseline def set_minimumdescent(self, t): """ Set minimumdescent . If True, extent of the single line text is adjusted so that it has minimum descent of "p" """ self._minimumdescent = t def get_minimumdescent(self): """ get minimumdescent. """ return self._minimumdescent def set_transform(self, t): """ set_transform is ignored. """ pass def set_offset(self, xy): """ set offset of the container. Accept : tuple of x,y cooridnate in disokay units. """ self._offset = xy self.offset_transform.clear() self.offset_transform.translate(xy[0], xy[1]) def get_offset(self): """ return offset of the container. """ return self._offset def get_window_extent(self, renderer): ''' get the bounding box in display space. ''' w, h, xd, yd = self.get_extent(renderer) ox, oy = self.get_offset() #w, h, xd, yd) return mtransforms.Bbox.from_bounds(ox-xd, oy-yd, w, h) def get_extent(self, renderer): clean_line, ismath = self._text.is_math_text(self._text._text) _, h_, d_ = renderer.get_text_width_height_descent( "lp", self._text._fontproperties, ismath=False) bbox, info = self._text._get_layout(renderer) w, h = bbox.width, bbox.height line = info[0][0] # first line _, hh, dd = renderer.get_text_width_height_descent( clean_line, self._text._fontproperties, ismath=ismath) self._baseline_transform.clear() if len(info) > 1 and self._multilinebaseline: # multi line d = h-(hh-dd) # the baseline of the first line d_new = 0.5 * h - 0.5 * (h_ - d_) self._baseline_transform.translate(0, d - d_new) d = d_new else: # single line h_d = max(h_ - d_, h-dd) if self.get_minimumdescent(): ## to have a minimum descent, #i.e., "l" and "p" have same ## descents. d = max(dd, d_) else: d = dd h = h_d + d return w, h, 0., d def draw(self, renderer): """ Draw the children """ self._text.draw(renderer) bbox_artist(self, renderer, fill=False, props=dict(pad=0.))
gpl-3.0
phoebe-project/phoebe2-docs
2.0/tutorials/general_concepts.py
1
23210
#!/usr/bin/env python # coding: utf-8 # General Concepts # ====================== # # **HOW TO RUN THIS FILE**: if you're running this in a Jupyter notebook or Google Colab session, you can click on a cell and then shift+Enter to run the cell and automatically select the next cell. Alt+Enter will run a cell and create a new cell below it. Ctrl+Enter will run a cell but keep it selected. To restart from scratch, restart the kernel/runtime. # # This tutorial introduces all the general concepts of dealing with Parameters, ParameterSets, and the Bundle. This tutorial aims to be quite complete - covering almost everything you can do with Parameters, so on first read you may just want to try to get familiar, and then return here as a reference for any details later. # # All of these tutorials assume basic comfort with Python in general - particularly with the concepts of lists, dictionaries, and objects as well as basic comfort with using the numpy and matplotlib packages. # # Setup # ---------------------------------------------- # # # Let's first make sure we have the latest version of PHOEBE 2.0 installed. (You can comment out this line if you don't use pip for your installation or don't want to update to the latest release). # In[ ]: get_ipython().system('pip install -I "phoebe>=2.0,<2.1"') # Let's get started with some basic imports # In[1]: import phoebe from phoebe import u # units import numpy as np import matplotlib.pyplot as plt # If running in IPython notebooks, you may see a "ShimWarning" depending on the version of Jupyter you are using - this is safe to ignore. # # PHOEBE 2 uses constants defined in the IAU 2015 Resolution which conflict with the constants defined in astropy. As a result, you'll see the warnings as phoebe.u and phoebe.c "hijacks" the values in astropy.units and astropy.constants. # # Whenever providing units, please make sure to use phoebe.u instead of astropy.units, otherwise the conversions may be inconsistent. # ### Logger # # Before starting any script, it is a good habit to initialize a logger and define which levels of information you want printed to the command line (clevel) and dumped to a file (flevel). # # The levels from most to least information are: # # * DEBUG # * INFO # * WARNING # * ERROR # * CRITICAL # # In[2]: logger = phoebe.logger(clevel='WARNING', flevel='DEBUG', filename='tutorial.log') # All of these arguments are optional and will default to clevel='WARNING' if not provided. There is therefore no need to provide a filename if you don't provide a value for flevel. # # So with this logger, anything with "WARNING, ERROR, or CRITICAL levels will be printed to the screen. All messages of any level will be written to a file named 'tutorial.log' in the current directory. # # Note: the logger messages are not included in the outputs shown below. # # # # Parameters # ------------------------ # # Parameters hold a single value, but need to be aware about their own types, limits, and connection with other Parameters (more on this later when we discuss ParameterSets). # # Note that generally you won't ever have to "create" or "define" your own Parameters, those will be created for you by helper functions, but we have to start somewhere... so let's create our first Parameter. # # We'll start with creating a StringParameter since it is the most generic, and then discuss and specific differences for each type of Parameter. # In[3]: param = phoebe.parameters.StringParameter(qualifier='myparameter', description='mydescription', value='myvalue') # If you ever need to know the type of a Parameter, you can always use python's built-in type functionality: # In[4]: print type(param) # If we print the parameter object we can see a summary of information # In[5]: print param # You can see here that we've defined three a few things about parameter: the qualifier, description, and value (others do exist, they just don't show up in the summary). # # These "things" can be split into two groups: tags and attributes (although in a pythonic sense, both can be accessed as attributes). Don't worry too much about this distinction - it isn't really important except for the fact that tags are shared across **all** Parameters whereas attributes are dependent on the type of the Parameter. # # The tags of a Parameter define the Parameter and how it connects to other Parameters (again, more on this when we get to ParameterSets). For now, just now that you can access a list of all the tags as follows: # In[6]: print param.meta # and that each of these is available through both a dictionary key and an object attribute. For example: # In[7]: print param['qualifier'], param.qualifier # The 'qualifier' attribute is essentially an abbreviated name for the Parameter. # # These tags will be shared across **all** Parameters, regardless of their type. # # Attributes, on the other hand, can be dependent on the type of the Parameter and tell the Parameter its rules and how to interpret its value. You can access a list of available attributes as follows: # In[8]: param.attributes # and again, each of these are available through both a dictionary key and as an object attribute. For example, all parameters have a **'description'** attribute which gives additional information about what the Parameter means: # In[9]: print param['description'], param.description # For the special case of the **'value'** attribute, there is also a get method (will become handy later when we want to be able to request the value in a specific unit). # In[10]: print param.get_value(), param['value'], param.value # The value attribute is also the only attribute that you'll likely want to change, so it also has a set method: # In[11]: param.set_value('newvalue') print param.get_value() # The **'visible_if'** attribute only comes into play when the Parameter is a member of a ParameterSet, so we'll discuss it at the end of this tutorial when we get to ParameterSets. # # The **'copy_for'** attribute is only used when the Parameter is in a particular type of ParameterSet called a Bundle (explained at the very end of this tutorial). We'll see the 'copy_for' capability in action later in the [Datasets Tutorial](datasets), but for now, just know that you can *view* this property only and cannot change it... and most of the time it will just be an empty string. # ### StringParameters # # We'll just mention StringParameters again for completeness, but we've already seen about all they can do - the value must cast to a valid string but no limits or checks are performed at all on the value. # ### ChoiceParameters # # ChoiceParameters are essentially StringParameters with one very important exception: the value **must** match one of the prescribed choices. # # Therefore, they have a 'choice' attribute and an error will be raised if trying to set the value to any string not in that list. # In[12]: param = phoebe.parameters.ChoiceParameter(qualifier='mychoiceparameter', description='mydescription', choices=['choice1', 'choice2'], value='choice1') # In[13]: print param # In[14]: print param.attributes # In[15]: print param['choices'], param.choices # In[16]: print param.get_value() # In[17]: #param.set_value('not_a_choice') # would raise a ValueError param.set_value('choice2') print param.get_value() # ### FloatParameters # # FloatParameters are probably the most common Parameter used in PHOEBE and hold both a float and a unit, with the ability to retrieve the value in any other convertible unit. # In[18]: param = phoebe.parameters.FloatParameter(qualifier='myfloatparameter', description='mydescription', default_unit=u.m, limits=[None,20], value=5) # In[19]: print param # You'll notice here a few new mentions in the summary... "Constrained by", "Constrains", and "Related to" are all referring to [constraints which will be discussed in a future tutorial](constraints). # In[20]: print param.attributes # FloatParameters have an attribute which hold the "limits" - whenever a value is set it will be checked to make sure it falls within the limits. If either the lower or upper limit is None, then there is no limit check for that extreme. # In[21]: print param['limits'], param.limits # In[22]: #param.set_value(30) # would raise a ValueError param.set_value(2) print param.get_value() # FloatParameters have an attribute which holds the "default_unit" - this is the unit in which the value is stored **and** the unit that will be provided if not otherwise overriden. # In[23]: print param['default_unit'], param.default_unit # Calling get_value will then return a float in these units # In[24]: print param.get_value() # But we can also request the value in a different unit, by passing an [astropy Unit object](http://docs.astropy.org/en/stable/units/) or its string representation. # In[25]: print param.get_value(unit=u.km), param.get_value(unit='km') # FloatParameters also have their own method to access an [astropy Quantity object](http://docs.astropy.org/en/stable/units/) that includes both the value and the unit # In[26]: print param.get_quantity(), param.get_quantity(unit=u.km) # The set_value method also accepts a unit - this doesn't change the default_unit internally, but instead converts the provided value before storing. # In[27]: param.set_value(10) print param.get_quantity() # In[28]: param.set_value(0.001*u.km) print param.get_quantity() # In[29]: param.set_value(10, unit='cm') print param.get_quantity() # If for some reason you want to change the default_unit, you can do so as well: # In[30]: param.set_default_unit(u.km) print param.get_quantity() # But note that the limits are still stored as a quantity object in the originally defined default_units # In[31]: print param.limits # ### IntParameters # # IntParameters are essentially the same as FloatParameters except they always cast to an Integer and they have no units. # In[32]: param = phoebe.parameters.IntParameter(qualifier='myintparameter', description='mydescription', limits=[0,None], value=1) # In[33]: print param # In[34]: print param.attributes # Like FloatParameters above, IntParameters still have limits # In[35]: print param['limits'], param.limits # Note that if you try to set the value to a float it will not raise an error, but will cast that value to an integer (following python rules of truncation, not rounding) # In[36]: param.set_value(1.9) print param.get_value() # ### Bool Parameters # # Boolean Parameters are even simpler - they accept True or False. # In[37]: param = phoebe.parameters.BoolParameter(qualifier='myboolparameter', description='mydescription', value=True) # In[38]: print param # In[39]: print param.attributes # Note that, like IntParameters, BoolParameters will attempt to cast anything you give it into True or False. # In[40]: param.set_value(0) print param.get_value() # In[41]: param.set_value(None) print param.get_value() # As with Python, an empty string will cast to False and a non-empty string will cast to True # In[42]: param.set_value('') print param.get_value() # In[43]: param.set_value('some_string') print param.get_value() # The only exception to this is that (unlike Python), 'true' or 'True' will cast to True and 'false' or 'False' will cast to False. # In[44]: param.set_value('False') print param.get_value() # In[45]: param.set_value('false') print param.get_value() # ### FloatArrayParameters # # FloatArrayParameters are essentially the same as FloatParameters (in that they have the same unit treatment, although obviously no limits) but hold numpy arrays rather than a single value. # # By convention in Phoebe, these will (almost) always have a pluralized qualifier. # In[46]: param = phoebe.parameters.FloatArrayParameter(qualifier='myfloatarrayparameters', description='mydescription', default_unit=u.m, value=np.array([0,1,2,3])) # In[47]: print param # In[48]: print param.attributes # In[49]: print param.get_value(unit=u.km) # FloatArrayParameters also allow for built-in interpolation... but this requires them to be a member of a Bundle, so we'll discuss this in just a bit. # ParametersSets # ---------------------------- # # ParameterSets are a collection of Parameters that can be filtered by their tags to return another ParameterSet. # # For illustration, let's create 3 random FloatParameters and combine them to make a ParameterSet. # In[50]: param1 = phoebe.parameters.FloatParameter(qualifier='param1', description='param1 description', default_unit=u.m, limits=[None,20], value=5, context='context1', kind='kind1') param2 = phoebe.parameters.FloatParameter(qualifier='param2', description='param2 description', default_unit=u.deg, limits=[0,2*np.pi], value=0, context='context2', kind='kind2') param3 = phoebe.parameters.FloatParameter(qualifier='param3', description='param3 description', default_unit=u.kg, limits=[0,2*np.pi], value=0, context='context1', kind='kind2') # In[51]: ps = phoebe.parameters.ParameterSet([param1, param2, param3]) # In[52]: print ps.to_list() # If we print a ParameterSet, we'll see a listing of all the Parameters and their values. # In[53]: print ps # ### Twigs # The string notation used for the Parameters is called a 'twig' - its simply a combination of all the tags joined with the '@' symbol and gives a very convenient way to access any Parameter. # # The order of the tags doesn't matter, and you only need to provide enough tags to produce a unique match. Since there is only one parameter with kind='kind1', we do not need to provide the extraneous context='context1' in the twig to get a match. # In[54]: print ps.get('param1@kind1') # Note that this returned the ParameterObject itself, so you can now use any of the Parameter methods or attributes we saw earlier. For example: # In[55]: print ps.get('param1@kind1').description # But we can also use set and get_value methods from the ParameterSet itself: # In[56]: ps.set_value('param1@kind1', 10) print ps.get_value('param1@kind1') # ### Tags # Each Parameter has a number of tags, and the ParameterSet has the same tags - where the value of any given tag is None if not shared by all Parameters in that ParameterSet. # # So let's just print the names of the tags again and then describe what each one means. # In[57]: print ps.meta.keys() # Most of these "metatags" act as labels - for example, you can give a component tag to each of the components for easier referencing. # # But a few of these tags are fixed and not editable: # # * qualifier: literally the name of the parameter. # * kind: tells what kind a parameter is (ie whether a component is a star or an orbit). # * context: tells what context this parameter belongs to # * twig: a shortcut to the parameter in a single string. # * uniquetwig: the minimal twig needed to reach this parameter. # * uniqueid: an internal representation used to reach this parameter # # These contexts are (you'll notice that most are represented in the tags): # # * setting # * history # * system # * component # * feature # * dataset # * constraint # * compute # * model # * fitting [not yet supported] # * feedback [not yet supported] # * plugin [not yet supported] # # One way to distinguish between context and kind is with the following question and answer: # # "What kind of **[context]** is this? It's a **[kind]** tagged **[context]**=**[tag-with-same-name-as-context]**." # # In different cases, this will then become: # # * "What kind of **component** is this? It's a **star** tagged **component**=**starA**." (context='component', kind='star', component='starA') # * "What kind of **feature** is this? It's a **spot** tagged **feature**=**spot01**." (context='feature', kind='spot', feature='spot01') # * "What kind of **dataset** is this? It's a **LC (light curve)** tagged **dataset**=**lc01**." (context='dataset', kind='LC', dataset='lc01') # * "What kind of **compute** (options) are these? They're **phoebe** (compute options) tagged **compute**=**preview**." (context='compute', kind='phoebe', compute='preview') # # # As we saw before, these tags can be accessed at the Parameter level as either a dictionary key or as an object attribute. For ParameterSets, the tags are only accessible through object attributes. # In[58]: print ps.context # This returns None since not all objects in this ParameterSet share a single context. But you can see all the options for a given tag by providing the plural version of that tag name: # In[59]: print ps.contexts # ### Filtering # # Any of the tags can also be used to filter the ParameterSet: # In[60]: print ps.filter(context='context1') # Here we were returned a ParameterSet of all Parameters that matched the filter criteria. Since we're returned another ParameterSet, we can chain additional filter calls together. # In[61]: print ps.filter(context='context1', kind='kind1') # Now we see that we have drilled down to a single Parameter. Note that a ParameterSet is still returned - filter will *always* return a ParameterSet. # # We could have accomplished the exact same thing with a single call to filter: # In[62]: print ps.filter(context='context1', kind='kind1') # If you want to access the actual Parameter, you must use get instead of (or in addition to) filter. All of the following lines do the exact same thing: # In[63]: print ps.filter(context='context1', kind='kind1').get() # In[64]: print ps.get(context='context1', kind='kind1') # Or we can use those twigs. Remember that twigs are just a combination of these tags separated by the @ symbol. You can use these for dictionary access in a ParameterSet - without needing to provide the name of the tag, and without having to worry about order. And whenever this returns a ParameterSet, these are also chainable, so the following two lines will do the same thing: # In[65]: print ps['context1@kind1'] # In[66]: print ps['context1']['kind1'] # You may notice that the final result was a Parameter, not a ParameterSet. Twig dictionary access tries to be smart - if exactly 1 Parameter is found, it will return that Parameter instead of a ParameterSet. Notice the difference between the two following lines: # In[67]: print ps['context1'] # In[68]: print ps['context1@kind1'] # Of course, once you get the Parameter you can then use dictionary keys to access any attributes of that Parameter. # In[69]: print ps['context1@kind1']['description'] # So we decided we might as well allow access to those attributes directly from the twig as well # In[70]: print ps['description@context1@kind1'] # The Bundle # ------------ # # The Bundle is nothing more than a glorified ParameterSet with some extra methods to compute models, add new components and datasets, etc. # # You can initialize an empty Bundle as follows: # In[71]: b = phoebe.Bundle() print b # and filter just as you would for a ParameterSet # In[72]: print b.filter(context='system') # ### Visible If # # As promised earlier, the 'visible_if' attribute of a Parameter controls whether its visible to a ParameterSet... but it only does anything if the Parameter belongs to a Bundle. # # Let's make a new ParameterSet in which the visibility of one parameter is dependent on the value of another. # In[73]: param1 = phoebe.parameters.ChoiceParameter(qualifier='what_is_this', choices=['matter', 'aether'], value='matter', context='context1') param2 = phoebe.parameters.FloatParameter(qualifier='mass', default_unit=u.kg, value=5, visible_if='what_is_this:matter', context='context1') b = phoebe.Bundle([param1, param2]) # In[74]: print b.filter() # It doesn't make much sense to need to define a mass if this thing isn't baryonic. So if we change the value of 'what_is_this' to 'aether' then the 'mass' Parameter will temporarily hide itself. # In[75]: b.set_value('what_is_this', 'aether') print b.filter() # ### FloatArrayParameters: interpolation # # As mentioned earlier, when a part of a Bundle, FloatArrayParameters can handle simple linear interpolation with respect to another FloatArrayParameter in the same Bundle. # In[76]: xparam = phoebe.parameters.FloatArrayParameter(qualifier='xs', default_unit=u.d, value=np.linspace(0,1,10), context='context1') yparam = phoebe.parameters.FloatArrayParameter(qualifier='ys', default_unit=u.m, value=np.linspace(0,1,10)**2, context='context1') b = phoebe.Bundle([xparam, yparam]) # In[77]: b.filter('ys').get().twig # In[78]: b['ys'].get_value() # Now we can interpolate the 'ys' param for any given value of 'xs' # In[79]: b['ys'].interp_value(xs=0) # In[80]: b['ys'].interp_value(xs=0.2) # **NOTE**: interp_value does not (yet) support passing a unit.. it will always return a value (not a quantity) and will always be in the default_unit. # Next # ---------- # # Next up: let's [build a system](building_a_system.ipynb) #
gpl-3.0
h-mayorquin/camp_india_2016
tutorials/LTPinnetworks2/Step1d_weight_distributions.py
1
5120
#!/usr/bin/env python ''' Author: Aditya Gilra, Jun 2016. (with inputs from Matthieu Gilson) in Brian2rc3 for CAMP 2016. ''' #import modules and functions to be used from brian2 import * # importing brian also does: # 'from pylab import *' which imports: # matplot like commands into the namespace, further # also can use np. for numpy and mpl. for matplotlib stand_alone = True if stand_alone: set_device('cpp_standalone', build_on_run=False) else: #prefs.codegen.target = 'numpy' prefs.codegen.target = 'weave' #prefs.codegen.target = 'cython' import random import time # http://stackoverflow.com/questions/31057197/should-i-use-random-seed-or-numpy-random-seed-to-control-random-number-gener np.random.seed(0) # set seed for reproducibility of simulations random.seed(0) # set seed for reproducibility of simulations # ########################################### # Simulation parameters # ########################################### simdt = 0.1*ms simtime = 10.0*second defaultclock.dt = simdt # set Brian's sim time step simdtraw = simdt/second # convert to value in seconds # ########################################### # Neuron model # ########################################### taudelay = 0.75*ms # synaptic delay tauA = 1*ms # synaptic epsp tauA tauB = 5*ms # synaptic epsp tauB eqs_neurons=''' dA/dt=-A/tauA : 1 dB/dt=-B/tauB : 1 rho_out = (A-B)/(tauA-tauB) : Hz ''' # ########################################### # Network parameters: numbers # ########################################### Ninp = 2000 # Number of neurons per pool nu0 = 10*Hz # spiking rate of inputs # ########################################### # Network parameters: synaptic plasticity # ########################################### eta = 1e-2 # learning rate (as in paper) Apre_tau = 17*ms # STDP Apre (LTP) time constant Apost_tau = 34*ms # STDP Apost (LTD) time constant stdp_eqns = ''' w : 1 dApre/dt=-Apre/Apre_tau : 1 (event-driven) dApost/dt=-Apost/Apost_tau : 1 (event-driven) ''' w0 = 0.05 # reference weight Apre0 = w0 # incr in Apre (LTP), on pre-spikes; # at spike coincidence, delta w = -Apre0*eta Apost0 = Apre0 * Apre_tau / Apost_tau # incr in Apost (LTD) on post spike beta = 50 # LTP decay factor alpha = 5 # LTD curvature factor std_noise = 2.0 # std deviation of noise pre_eqns = 'Apre+=Apre0; w = clip(w - eta*Apost*log(1+w/w0*alpha)/log(1+alpha)*(randn()*std_noise+1),0,inf)' post_eqns = 'Apost+=Apost0; w = clip(w + eta*Apre*exp(-w/w0/beta), 0,inf)' winit = w0 # initial weights are from 0 to winit # ########################################### # Initialize neuron (sub)groups # ########################################### # post-synaptic neuron P=NeuronGroup(1,model=eqs_neurons,\ threshold='rand()<rho_out*dt',method='euler') # ########################################### # Stimuli # ########################################### Pinp1 = PoissonGroup(Ninp,rates=nu0) # ########################################### # Connecting the network # ########################################### con = Synapses(Pinp1,P,stdp_eqns,\ on_pre='A+=w*0.1;B+=w*0.1;'+pre_eqns,on_post=post_eqns, method='euler') con.connect(True) con.delay = uniform(size=(Ninp,))*1.*ms + 4.*ms con.w = uniform(size=(Ninp,))*2*winit # ########################################### # Setting up monitors # ########################################### sm = SpikeMonitor(P) sminp1 = SpikeMonitor(Pinp1) # Population monitor popm = PopulationRateMonitor(P) popminp1 = PopulationRateMonitor(Pinp1) # voltage monitor sm_rho = StateMonitor(P,'rho_out',record=[0]) # weights monitor wm = StateMonitor(con,'w',record=range(Ninp), dt=simtime/100.) # ########################################### # Simulate # ########################################### # a simple run would not include the monitors net = Network(collect()) # collects Brian2 objects in current context print "Setup complete, running for",simtime,"at dt =",simdtraw,"s." t1 = time.time() net.run(simtime,report='text') device.build(directory='output', compile=True, run=True, debug=False) # ########################################### # Make plots # ########################################### # always convert spikemon.t and spikemon.i to array-s before indexing # spikemon.i[] indexing is extremely slow! spiket = array(sm.t/second) # take spiketimes of all neurons spikei = array(sm.i) fig = figure() subplot(131) plot(popm.t/second,popm.smooth_rate(width=50.*ms,window="gaussian")/Hz,',-') xlabel('time (s)') ylabel('post-rate (Hz)') # weight evolution subplot(132) plot(wm.t/second,transpose(wm.w[:20,:]),',-') xlabel('time (s)') ylabel("weight (arb)") yticks([0,1,2]) title('weights evolution') subplot(133) hist(wm.w[:,-1],bins=50,edgecolor='none') xlabel('weight') ylabel('count') show()
mit
tiagoantao/genomics-notebooks
src/parameter.py
1
7816
# -*- coding: utf-8 -*- ''' .. module:: genomics :synopsis: PopGen classes with simulations :noindex: :copyright: Copyright 2014 by Tiago Antao :license: GNU Affero, see LICENSE for details .. moduleauthor:: Tiago Antao <[email protected]> ''' from collections import defaultdict import numpy as np from sklearn.decomposition import PCA as pca import simuOpt simuOpt.setOptions(gui=False, quiet=True) import simuPOP as sp from simuPOP import sampling def _get_sub_sample(pop, size, sub_pop=None): '''Gets a subsample of individuals.''' if sub_pop is None: pop_s = pop else: pop_s = pop.extractSubPops(subPops=[sub_pop]) if size is None: return pop_s pop_s = sampling.drawRandomSample(pop_s, sizes=size) return pop_s class Parameter: '''A simulation parameter. Absctract super-class.''' def __init__(self, do_structured=False): self.name = None self.desc = None self.do_structured = do_structured self._sample_size = None self._simupop_stats = [] self._info_fields = [] self._pop = None def _get_values(self, pop): '''Returns the parameter values for a certain subpopulation. Implemented on concrete class. ''' raise NotImplementedError('Needs to be implemented') def get_values(self, pop, sub_pop=None): '''Returns the parameter values for a certain subpopulation.''' if self.do_structured: pop_ = _get_sub_sample(pop, self.sample_size, sub_pop) else: pop_ = _get_sub_sample(pop, self.sample_size) ind_values = self._get_values(pop_) return ind_values @property def pop(self, pop): '''Population''' self._pop = pop @pop.setter def pop(self, value): '''Population setter.''' self._pop = value @property def simupop_stats(self): '''Statistics that simupop needs to compute for this parameter. This is normally added to evolve postOps.''' return self._simupop_stats @property def sample_size(self): '''Parameter sample size.''' return self._sample_size @sample_size.setter def sample_size(self, value): '''Sample size setter.''' self._sample_size = value @property def info_fields(self): '''Fields that need to be available on the Population object''' return self._info_fields @info_fields.setter def info_fields(self, value): '''Info_fields setter.''' self._info_fields = value class ObsHe(Parameter): '''Observed Heterozygosity''' def __init__(self): Parameter.__init__(self) self.name = 'ObsHe' self.desc = 'Observed Heterozygozity' def _get_values(self, pop): stat = sp.Stat(heteroFreq=True) stat.apply(pop) loci = list(pop.dvars().heteroFreq.keys()) loci.sort() return [pop.dvars().heteroFreq[l] for l in loci] class ExpHe(Parameter): '''Expected Heterozygosity''' def __init__(self, **kwargs): Parameter.__init__(self, kwargs) self.name = 'ExpHe' self.desc = 'Expected Heterozygozity' def _get_values(self, pop): stat = sp.Stat(alleleFreq=True) stat.apply(pop) freqs = pop.dvars().alleleFreq loci = list(freqs.keys()) loci.sort() exp_he = [] for locus in loci: afreqs = freqs[locus] exp_ho = 0 for freq in afreqs.values(): exp_ho += freq * freq exp_he.append(1 - exp_ho) return exp_he class NumAlleles(Parameter): '''Number of Alleles''' def __init__(self, **kwargs): Parameter.__init__(self, kwargs) self.name = 'NumAlleles' self.desc = 'Number of Alleles' def _get_values(self, pop): stat = sp.Stat(alleleFreq=True) stat.apply(pop) anum = pop.dvars().alleleNum loci = list(anum.keys()) loci.sort() anums = [len(anum[l]) for l in loci] return anums class LDNe(Parameter): '''Estimating Ne according to LD (Waples)''' def __init__(self, pcrit=0.02, **kwargs): Parameter.__init__(self, kwargs) self.name = 'LDNe' self.desc = 'LDNe' self.pcrit = pcrit def _get_values(self, pop): stat = sp.Stat(effectiveSize=sp.ALL_AVAIL, vars='Ne_LD') stat.apply(pop) ne_est = pop.dvars().Ne_LD return ne_est[self.pcrit] class FreqDerived(Parameter): '''Frequency of the derived allele.''' def __init__(self, **kwargs): Parameter.__init__(self, kwargs) self.name = 'FreqDerived' self.desc = 'Frequency of the Derived Allele' def _get_values(self, pop): stat = sp.Stat(alleleFreq=True) stat.apply(pop) anum = pop.dvars().alleleFreq loci = list(anum.keys()) loci.sort() anums = [anum[l][1] for l in loci] return anums class StructuredParameter(Parameter): '''A parameter that is applied to population structure.''' def __init__(self, **kwargs): kwargs['do_structured'] = True Parameter.__init__(self, kwargs) class FST(StructuredParameter): '''Mean FST.''' def __init__(self, **kwargs): StructuredParameter.__init__(self) self.name = 'FST' self.desc = 'FST' def _get_values(self, pop): stat = sp.Stat(structure=sp.ALL_AVAIL) stat.apply(pop) my_fst = pop.dvars().F_st return [my_fst] class fst(StructuredParameter): '''FST per locus.''' def __init__(self): StructuredParameter.__init__(self) self.name = 'fst' self.desc = 'FST per locus' def _get_values(self, pop): st = sp.Stat(structure=sp.ALL_AVAIL, vars=['f_st']) st.apply(pop) fsts = pop.dvars().f_st loci = list(fsts.keys()) return [fsts[l] for l in loci] class IndividualParameter(Parameter): '''A Parameter that returns a value per individual''' def __init__(self): Parameter.__init__(self) class PCA(IndividualParameter): '''Principal Components Analysis.''' def __init__(self): IndividualParameter.__init__(self) self.info_fields = ['ind_id'] def _get_values(self, pop): nsp = pop.numSubPop() all_alleles = [] for subpop in range(nsp): for ind in pop.individuals(subPop=subpop): geno = ind.genotype() n_markers = len(geno) // 2 for mi in range(n_markers): if len(all_alleles) <= mi: all_alleles.append(set()) a1 = geno[mi] a2 = geno[mi + n_markers] all_alleles[mi].add(a1) all_alleles[mi].add(a2) for i, alleles in enumerate(all_alleles): all_alleles[i] = sorted(list(alleles)) inds = defaultdict(list) for mi in range(n_markers): for subpop in range(nsp): for i, ind in enumerate(pop.individuals(subPop=subpop)): geno = ind.genotype() a1 = geno[mi] a2 = geno[mi + n_markers] for a in all_alleles[mi]: inds[(subpop, i)].append([a1, a2].count(a)) ind_order = sorted(list(inds.keys())) arr = [] for ind in ind_order: arr.append(inds[ind]) my_pca = pca(n_components=2) X = np.array(arr) my_pca.fit(X) X_r = my_pca.transform(X) my_components = {} for i, ind in enumerate(ind_order): my_components[ind] = X_r[i] return my_components
agpl-3.0
jhlch/sparklingpandas
sparklingpandas/pcontext.py
1
13246
"""Provide an easy interface for loading data into L{DataFrame}s for Spark. """ # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You under the Apache License, Version 2.0 # (the "License"); you may not use this file except in compliance with # the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # from sparklingpandas.utils import add_pyspark_path add_pyspark_path() import pandas from StringIO import StringIO as sio from pyspark.context import SparkContext from sparklingpandas.dataframe import DataFrame, _normalize_index_names class PSparkContext(): """This is a thin wrapper around SparkContext from PySpark which makes it easy to load data into L{DataFrame}s.""" def __init__(self, spark_context, sql_ctx=None): """Initialize a PSparkContext with the associacted spark context, and Spark SQL context if provided. This context is usef to load data into L{DataFrame}s. Parameters ---------- spark_context: SparkContext Initialized and configured spark context. If you are running in the PySpark shell, this is already created as "sc". sql_ctx: SQLContext, optional Initialized and configured SQL context, if not provided Sparkling Panda's will create one. Returns ------- Correctly initialized SparklingPandasContext. """ self.spark_ctx = spark_context if sql_ctx: self.sql_ctx = sql_ctx else: print "No sql context provided, creating" from pyspark.sql import SQLContext self.sql_ctx = SQLContext(self.spark_ctx) @classmethod def simple(cls, *args, **kwargs): """Takes the same arguments as SparkContext and constructs a PSparkContext""" return PSparkContext(SparkContext(*args, **kwargs)) def read_csv(self, file_path, use_whole_file=False, names=None, skiprows=0, *args, **kwargs): """Read a CSV file in and parse it into Pandas DataFrames. By default, the first row from the first partition of that data is parsed and used as the column names for the data from. If no 'names' param is provided we parse the first row of the first partition of data and use it for column names. Parameters ---------- file_path: string Path to input. Any valid file path in Spark works here, eg: 'file:///my/path/in/local/file/system' or 'hdfs:/user/juliet/' use_whole_file: boolean Whether of not to use the whole file. names: list of strings, optional skiprows: integer, optional indicates how many rows of input to skip. This will only be applied to the first partition of the data (so if #skiprows > #row in first partition this will not work). Generally this shouldn't be an issue for small values of skiprows. No other value of header is supported. All additional parameters available in pandas.read_csv() are usable here. Returns ------- A SparklingPandas DataFrame that contains the data from the specified file. """ def csv_file(partition_number, files): # pylint: disable=unexpected-keyword-arg file_count = 0 for _, contents in files: # Only skip lines on the first file if partition_number == 0 and file_count == 0 and _skiprows > 0: yield pandas.read_csv( sio(contents), *args, header=None, names=mynames, skiprows=_skiprows, **kwargs) else: file_count += 1 yield pandas.read_csv( sio(contents), *args, header=None, names=mynames, **kwargs) def csv_rows(partition_number, rows): # pylint: disable=unexpected-keyword-arg in_str = "\n".join(rows) if partition_number == 0: return iter([ pandas.read_csv( sio(in_str), *args, header=None, names=mynames, skiprows=_skiprows, **kwargs)]) else: # could use .iterows instead? return iter([pandas.read_csv(sio(in_str), *args, header=None, names=mynames, **kwargs)]) # If we need to peak at the first partition and determine the column # names mynames = None _skiprows = skiprows if names: mynames = names else: # In the future we could avoid this expensive call. first_line = self.spark_ctx.textFile(file_path).first() frame = pandas.read_csv(sio(first_line), **kwargs) # pylint sees frame as a tuple despite it being a DataFrame mynames = list(frame.columns) _skiprows += 1 # Do the actual load if use_whole_file: return self.from_pandas_rdd( self.spark_ctx.wholeTextFiles(file_path) .mapPartitionsWithIndex(csv_file)) else: return self.from_pandas_rdd( self.spark_ctx.textFile(file_path) .mapPartitionsWithIndex(csv_rows)) def parquetFile(self, *paths): """Loads a Parquet file, returning the result as a L{DataFrame}. Parameters ---------- paths: string, variable length The path(s) of the parquet files to load. Should be Hadoop style paths (e.g. hdfs://..., file://... etc.). Returns ------- A L{DataFrame} of the contents of the parquet files. """ return self.from_spark_rdd(self.sql_ctx.parquetFile(paths)) def jsonFile(self, path, schema=None, sampling_ratio=1.0): """Loads a text file storing one JSON object per line as a L{DataFrame}. Parameters ---------- path: string The path of the json files to load. Should be Hadoop style paths (e.g. hdfs://..., file://... etc.). schema: StructType, optional If you know the schema of your input data you can specify it. The schema is specified using Spark SQL's schema format. If not specified will sample the json records to determine the schema. Spark SQL's schema format is documented (somewhat) in the "Programmatically Specifying the Schema" of the Spark SQL programming guide at: http://bit.ly/sparkSQLprogrammingGuide sampling_ratio: int, default=1.0 Percentage of the records to sample when infering schema. Defaults to all records for safety, but you may be able to set to a lower ratio if the same fields are present accross records or your input is of sufficient size. Returns ------- A L{DataFrame} of the contents of the json files. """ schema_rdd = self.sql_ctx.jsonFile(path, schema, sampling_ratio) return self.from_spark_rdd(schema_rdd) def from_pd_data_frame(self, local_df): """Make a Sparkling Pandas dataframe from a local Pandas DataFrame. The intend use is for testing or joining distributed data with local data. The types are re-infered, so they may not match. Parameters ---------- local_df: Pandas DataFrame The data to turn into a distributed Sparkling Pandas DataFrame. See http://bit.ly/pandasDataFrame for docs. Returns ------- A Sparkling Pandas DataFrame. """ def frame_to_rows(frame): """Convert a Pandas DataFrame into a list of Spark SQL Rows""" # TODO: Convert to row objects directly? return [r.tolist() for r in frame.to_records()] schema = list(local_df.columns) index_names = list(local_df.index.names) index_names = _normalize_index_names(index_names) schema = index_names + schema rows = self.spark_ctx.parallelize(frame_to_rows(local_df)) sp_df = DataFrame.from_schema_rdd( self.sql_ctx.createDataFrame( rows, schema=schema, # Look at all the rows, should be ok since coming from # a local dataset samplingRatio=1)) sp_df._index_names = index_names return sp_df def sql(self, query): """Perform a SQL query and create a L{DataFrame} of the result. The SQL query is run using Spark SQL. This is not intended for querying arbitrary databases, but rather querying Spark SQL tables. Parameters ---------- query: string The SQL query to pass to Spark SQL to execute. Returns ------- Sparkling Pandas DataFrame. """ return DataFrame.from_spark_rdd(self.sql_ctx.sql(query), self.sql_ctx) def table(self, table): """Returns the provided Spark SQL table as a L{DataFrame} Parameters ---------- table: string The name of the Spark SQL table to turn into a L{DataFrame} Returns ------- Sparkling Pandas DataFrame. """ return DataFrame.from_spark_rdd(self.sql_ctx.table(table), self.sql_ctx) def from_spark_rdd(self, spark_rdd): """ Translates a Spark DataFrame into a Sparkling Pandas Dataframe. Currently, no checking or validation occurs. Parameters ---------- spark_rdd: Spark DataFrame Input Spark DataFrame. Returns ------- Sparkling Pandas DataFrame. """ return DataFrame.from_spark_rdd(spark_rdd, self.sql_ctx) def DataFrame(self, elements, *args, **kwargs): """Create a Sparkling Pandas DataFrame for the provided elements, following the same API as constructing a Panda's DataFrame. Note: since elements is local this is only useful for distributing dataframes which are small enough to fit on a single machine anyways. Parameters ---------- elements: numpy ndarray (structured or homogeneous), dict, or Pandas DataFrame. Input elements to use with the DataFrame. Additional parameters as defined by L{pandas.DataFrame}. Returns ------- Sparkling Pandas DataFrame.""" return self.from_pd_data_frame(pandas.DataFrame( elements, *args, **kwargs)) def from_pandas_rdd(self, pandas_rdd): """Create a Sparkling Pandas DataFrame from the provided RDD which is comprised of Panda's DataFrame. Note: the current version drops index information. Parameters ---------- pandas_rdd: RDD[pandas.DataFrame] Returns ------- Sparkling Pandas DataFrame.""" return DataFrame.fromDataFrameRDD(pandas_rdd, self.sql_ctx) def read_json(self, file_path, *args, **kwargs): """Read a json file in and parse it into Pandas DataFrames. If no names is provided we use the first row for the names. Currently, it is not possible to skip the first n rows of a file. Headers are provided in the json file and not specified separately. Parameters ---------- file_path: string Path to input. Any valid file path in Spark works here, eg: 'my/path/in/local/file/system' or 'hdfs:/user/juliet/' Other than skipRows, all additional parameters available in pandas.read_csv() are usable here. Returns ------- A SparklingPandas DataFrame that contains the data from the specified file. """ def json_file_to_df(files): """ Transforms a JSON file into a list of data""" for _, contents in files: yield pandas.read_json(sio(contents), *args, **kwargs) return self.from_pandas_rdd(self.spark_ctx.wholeTextFiles(file_path) .mapPartitions(json_file_to_df)) def stop(self): """Stop the underlying SparkContext """ self.spark_ctx.stop()
apache-2.0
shangwuhencc/shogun
examples/undocumented/python_modular/graphical/util.py
26
2670
""" Utilities for matplotlib examples """ import pylab from numpy import ones, array, double, meshgrid, reshape, linspace, \ concatenate, ravel, pi, sinc from numpy.random import randn, rand from modshogun import BinaryLabels, RegressionLabels, RealFeatures, SparseRealFeatures QUITKEY='q' NUM_EXAMPLES=100 DISTANCE=2 def quit (event): if event.key==QUITKEY or event.key==QUITKEY.upper(): pylab.close() def set_title (title): quitmsg=" (press '"+QUITKEY+"' to quit)" complete=title+quitmsg manager=pylab.get_current_fig_manager() # now we have to wrap the toolkit if hasattr(manager, 'window'): if hasattr(manager.window, 'setCaption'): # QT manager.window.setCaption(complete) if hasattr(manager.window, 'set_title'): # GTK manager.window.set_title(complete) elif hasattr(manager.window, 'title'): # TK manager.window.title(complete) def get_realdata(positive=True): if positive: return randn(2, NUM_EXAMPLES)+DISTANCE else: return randn(2, NUM_EXAMPLES)-DISTANCE def get_realfeatures(pos, neg): arr=array((pos, neg)) features = concatenate(arr, axis=1) return RealFeatures(features) def get_labels(raw=False, type='binary'): data = concatenate(array( (-ones(NUM_EXAMPLES, dtype=double), ones(NUM_EXAMPLES, dtype=double)) )) if raw: return data else: if type == 'binary': return BinaryLabels(data) if type == 'regression': return RegressionLabels(data) return None def compute_output_plot_isolines(classifier, kernel=None, train=None, sparse=False, pos=None, neg=None, regression=False): size=100 if pos is not None and neg is not None: x1_max=max(1.2*pos[0,:]) x1_min=min(1.2*neg[0,:]) x2_min=min(1.2*neg[1,:]) x2_max=max(1.2*pos[1,:]) x1=linspace(x1_min, x1_max, size) x2=linspace(x2_min, x2_max, size) else: x1=linspace(-5, 5, size) x2=linspace(-5, 5, size) x, y=meshgrid(x1, x2) dense=RealFeatures(array((ravel(x), ravel(y)))) if sparse: test=SparseRealFeatures() test.obtain_from_simple(dense) else: test=dense if kernel and train: kernel.init(train, test) else: classifier.set_features(test) labels = None if regression: labels=classifier.apply().get_labels() else: labels=classifier.apply().get_values() z=labels.reshape((size, size)) return x, y, z def get_sinedata(): x=4*rand(1, NUM_EXAMPLES)-DISTANCE x.sort() y=sinc(pi*x)+0.1*randn(1, NUM_EXAMPLES) return x, y def compute_output_plot_isolines_sine(classifier, kernel, train, regression=False): x=4*rand(1, 500)-2 x.sort() test=RealFeatures(x) kernel.init(train, test) if regression: y=classifier.apply().get_labels() else: y=classifier.apply().get_values() return x, y
gpl-3.0
pprett/statsmodels
statsmodels/sandbox/km_class.py
5
11704
#a class for the Kaplan-Meier estimator import numpy as np from math import sqrt import matplotlib.pyplot as plt class KAPLAN_MEIER(object): def __init__(self, data, timesIn, groupIn, censoringIn): raise RuntimeError('Newer version of Kaplan-Meier class available in survival2.py') #store the inputs self.data = data self.timesIn = timesIn self.groupIn = groupIn self.censoringIn = censoringIn def fit(self): #split the data into groups based on the predicting variable #get a set of all the groups groups = list(set(self.data[:,self.groupIn])) #create an empty list to store the data for different groups groupList = [] #create an empty list for each group and add it to groups for i in range(len(groups)): groupList.append([]) #iterate through all the groups in groups for i in range(len(groups)): #iterate though the rows of dataArray for j in range(len(self.data)): #test if this row has the correct group if self.data[j,self.groupIn] == groups[i]: #add the row to groupList groupList[i].append(self.data[j]) #create an empty list to store the times for each group timeList = [] #iterate through all the groups for i in range(len(groupList)): #create an empty list times = [] #iterate through all the rows of the group for j in range(len(groupList[i])): #get a list of all the times in the group times.append(groupList[i][j][self.timesIn]) #get a sorted set of the times and store it in timeList times = list(sorted(set(times))) timeList.append(times) #get a list of the number at risk and events at each time #create an empty list to store the results in timeCounts = [] #create an empty list to hold points for plotting points = [] #create a list for points where censoring occurs censoredPoints = [] #iterate trough each group for i in range(len(groupList)): #initialize a variable to estimate the survival function survival = 1 #initialize a variable to estimate the variance of #the survival function varSum = 0 #initialize a counter for the number at risk riskCounter = len(groupList[i]) #create a list for the counts for this group counts = [] ##create a list for points to plot x = [] y = [] #iterate through the list of times for j in range(len(timeList[i])): if j != 0: if j == 1: #add an indicator to tell if the time #starts a new group groupInd = 1 #add (0,1) to the list of points x.append(0) y.append(1) #add the point time to the right of that x.append(timeList[i][j-1]) y.append(1) #add the point below that at survival x.append(timeList[i][j-1]) y.append(survival) #add the survival to y y.append(survival) else: groupInd = 0 #add survival twice to y y.append(survival) y.append(survival) #add the time twice to x x.append(timeList[i][j-1]) x.append(timeList[i][j-1]) #add each censored time, number of censorings and #its survival to censoredPoints censoredPoints.append([timeList[i][j-1], censoringNum,survival,groupInd]) #add the count to the list counts.append([timeList[i][j-1],riskCounter, eventCounter,survival, sqrt(((survival)**2)*varSum)]) #increment the number at risk riskCounter += -1*(riskChange) #initialize a counter for the change in the number at risk riskChange = 0 #initialize a counter to zero eventCounter = 0 #intialize a counter to tell when censoring occurs censoringCounter = 0 censoringNum = 0 #iterate through the observations in each group for k in range(len(groupList[i])): #check of the observation has the given time if (groupList[i][k][self.timesIn]) == (timeList[i][j]): #increment the number at risk counter riskChange += 1 #check if this is an event or censoring if groupList[i][k][self.censoringIn] == 1: #add 1 to the counter eventCounter += 1 else: censoringNum += 1 #check if there are any events at this time if eventCounter != censoringCounter: censoringCounter = eventCounter #calculate the estimate of the survival function survival *= ((float(riskCounter) - eventCounter)/(riskCounter)) try: #calculate the estimate of the variance varSum += (eventCounter)/((riskCounter) *(float(riskCounter)- eventCounter)) except ZeroDivisionError: varSum = 0 #append the last row to counts counts.append([timeList[i][len(timeList[i])-1], riskCounter,eventCounter,survival, sqrt(((survival)**2)*varSum)]) #add the last time once to x x.append(timeList[i][len(timeList[i])-1]) x.append(timeList[i][len(timeList[i])-1]) #add the last survival twice to y y.append(survival) #y.append(survival) censoredPoints.append([timeList[i][len(timeList[i])-1], censoringNum,survival,1]) #add the list for the group to al ist for all the groups timeCounts.append(np.array(counts)) points.append([x,y]) #returns a list of arrays, where each array has as it columns: the time, #the number at risk, the number of events, the estimated value of the #survival function at that time, and the estimated standard error at #that time, in that order self.results = timeCounts self.points = points self.censoredPoints = censoredPoints def plot(self): x = [] #iterate through the groups for i in range(len(self.points)): #plot x and y plt.plot(np.array(self.points[i][0]),np.array(self.points[i][1])) #create lists of all the x and y values x += self.points[i][0] for j in range(len(self.censoredPoints)): #check if censoring is occuring if (self.censoredPoints[j][1] != 0): #if this is the first censored point if (self.censoredPoints[j][3] == 1) and (j == 0): #calculate a distance beyond 1 to place it #so all the points will fit dx = ((1./((self.censoredPoints[j][1])+1.)) *(float(self.censoredPoints[j][0]))) #iterate through all the censored points at this time for k in range(self.censoredPoints[j][1]): #plot a vertical line for censoring plt.vlines((1+((k+1)*dx)), self.censoredPoints[j][2]-0.03, self.censoredPoints[j][2]+0.03) #if this censored point starts a new group elif ((self.censoredPoints[j][3] == 1) and (self.censoredPoints[j-1][3] == 1)): #calculate a distance beyond 1 to place it #so all the points will fit dx = ((1./((self.censoredPoints[j][1])+1.)) *(float(self.censoredPoints[j][0]))) #iterate through all the censored points at this time for k in range(self.censoredPoints[j][1]): #plot a vertical line for censoring plt.vlines((1+((k+1)*dx)), self.censoredPoints[j][2]-0.03, self.censoredPoints[j][2]+0.03) #if this is the last censored point elif j == (len(self.censoredPoints) - 1): #calculate a distance beyond the previous time #so that all the points will fit dx = ((1./((self.censoredPoints[j][1])+1.)) *(float(self.censoredPoints[j][0]))) #iterate through all the points at this time for k in range(self.censoredPoints[j][1]): #plot a vertical line for censoring plt.vlines((self.censoredPoints[j-1][0]+((k+1)*dx)), self.censoredPoints[j][2]-0.03, self.censoredPoints[j][2]+0.03) #if this is a point in the middle of the group else: #calcuate a distance beyond the current time #to place the point, so they all fit dx = ((1./((self.censoredPoints[j][1])+1.)) *(float(self.censoredPoints[j+1][0]) - self.censoredPoints[j][0])) #iterate through all the points at this time for k in range(self.censoredPoints[j][1]): #plot a vetical line for censoring plt.vlines((self.censoredPoints[j][0]+((k+1)*dx)), self.censoredPoints[j][2]-0.03, self.censoredPoints[j][2]+0.03) #set the size of the plot so it extends to the max x and above 1 for y plt.xlim((0,np.max(x))) plt.ylim((0,1.05)) #label the axes plt.xlabel('time') plt.ylabel('survival') plt.show() def show_results(self): #start a string that will be a table of the results resultsString = '' #iterate through all the groups for i in range(len(self.results)): #label the group and header resultsString += ('Group {0}\n\n'.format(i) + 'Time At Risk Events Survival Std. Err\n') for j in self.results[i]: #add the results to the string resultsString += ( '{0:<9d}{1:<12d}{2:<11d}{3:<13.4f}{4:<6.4f}\n'.format( int(j[0]),int(j[1]),int(j[2]),j[3],j[4])) print(resultsString)
bsd-3-clause
NDKoehler/DataScienceBowl2017_7th_place
dsb3_networks/nodule_segmentation/LIDC-annotations_2_nodule-seg_annotations/LIDC_preprocessing/5_cluster_nodules_per_slice/cluster_nodules_expert_panel_2d.py
2
5278
import os,sys import numpy import SimpleITK import matplotlib.pyplot as plt import pandas as pd import cv2 import numpy as np from sklearn.cluster import DBSCAN def sitk_show_opencv(slice_array, nodule_position_lst): diff = np.max(slice_array) - np.min(slice_array) slice_array = slice_array - np.min(slice_array) slice_array = slice_array / float(diff) for nodule_position in nodule_position_lst: cv2.rectangle(slice_array,(nodule_position[0]-5,nodule_position[1]-5),(nodule_position[0]+5,nodule_position[1]+5), (255,0,0),1) cv2.imshow("view nodule",slice_array) cv2.waitKey(0) nodule_info_df = pd.read_csv("/media/philipp/qnap/LIDC/preprocessing/4_get_nodule_info_per_slice/dataframe_nodules_gt3mm.csv",sep="\t") xml_paths_unblinded_read = np.genfromtxt("/media/philipp/qnap/LIDC/preprocessing/2_get_xml_paths_unblinded_read/xml_path_lst_unblinded_read.csv", dtype=str) original_spacing_df = pd.read_csv("/media/philipp/qnap/LIDC/preprocessing/3_save_dicom_metadata/dicom_metadata.csv",header=0,sep="\t") min_experts = 1 max_dist = 5 # max_distance in millimeters verified_nodules_radiologist_id = [] verified_nodules_nodule_id = [] verified_nodules_dcm_path = [] verified_nodules_x_center = [] verified_nodules_y_center = [] verified_nodules_sliceIdx = [] verified_nodules_x_min = [] verified_nodules_x_max = [] verified_nodules_y_min = [] verified_nodules_y_max = [] for counter, xml_path in enumerate(xml_paths_unblinded_read): print (counter+1,len(xml_paths_unblinded_read)) dcm_path = os.path.dirname(os.path.abspath(xml_path)) dcm_path = dcm_path.split('/') dcm_path[2] = "philipp" dcm_path = '/'.join(dcm_path) this_spacing_df = original_spacing_df[original_spacing_df['dcm_path'] == dcm_path] if(len(this_spacing_df) != 1): # if dcm_path does not exist in dcm_path_df: maxbe wrong username? print "dcm_path not found in /media/philipp/qnap/LIDC/preprocessing/3_write_original_spacing_info/original_spacings.csv" print "wrong username?" sys.exit() x_spacing = this_spacing_df["x_spacing"].values[0] y_spacing = this_spacing_df["y_spacing"].values[0] epsilon = int(max_dist/np.max(x_spacing,y_spacing)) nodules_in_dcm = nodule_info_df[nodule_info_df["dcm_path"] == dcm_path] sliceIdx_set = list(set(nodules_in_dcm["sliceIdx"].values)) sliceIdx_set = [x for x in sliceIdx_set if x >= 0] # delete negative slice Ids (warum existieren die???) for sliceIdx in sliceIdx_set: nodules_in_slice = nodules_in_dcm[nodules_in_dcm["sliceIdx"] == sliceIdx] radiologist_id_arr = nodules_in_slice["radiologist_id"].values x_center_arr = nodules_in_slice["x_center"].values y_center_arr = nodules_in_slice["y_center"].values x_min_arr = nodules_in_slice["x_min"].values x_max_arr = nodules_in_slice["x_max"].values y_min_arr = nodules_in_slice["y_min"].values y_max_arr = nodules_in_slice["y_max"].values nodule_positions = np.asarray(zip(x_center_arr, y_center_arr)) db = DBSCAN(eps=epsilon, min_samples=min_experts).fit(nodule_positions) labels = db.labels_ for cluster_id in list(set(labels)): if(cluster_id != -1): cluster_nodules_radiologist_id = radiologist_id_arr[labels == cluster_id] cluster_nodules_x_center = x_center_arr[labels == cluster_id] cluster_nodules_y_center = y_center_arr[labels == cluster_id] cluster_nodules_x_min = x_min_arr[labels == cluster_id] cluster_nodules_x_max = x_max_arr[labels == cluster_id] cluster_nodules_y_min = y_min_arr[labels == cluster_id] cluster_nodules_y_max = y_max_arr[labels == cluster_id] if(len(set(cluster_nodules_radiologist_id)) >= min_experts ): #check ob alle markierungen tatsaechlich von UNTERSCHIEDLICHEN radiologen kommen! string = "" for rad in cluster_nodules_radiologist_id: string += str(rad) verified_nodules_radiologist_id += [string] verified_nodules_nodule_id += ["merged"] verified_nodules_dcm_path += [dcm_path] verified_nodules_x_center += [int(np.mean(cluster_nodules_x_center))] verified_nodules_y_center += [int(np.mean(cluster_nodules_y_center))] verified_nodules_sliceIdx += [sliceIdx] verified_nodules_x_min += [np.min(cluster_nodules_x_min)] verified_nodules_x_max += [np.max(cluster_nodules_x_max)] verified_nodules_y_min += [np.min(cluster_nodules_y_min)] verified_nodules_y_max += [np.max(cluster_nodules_y_max)] #print len(verified_nodules_radiologist_id), len(verified_nodules_nodule_id), len(verified_nodules_x_min) #print '---------------------------------------------------' print len(verified_nodules_radiologist_id) df = pd.DataFrame() df.insert(0,"radiologist_id",verified_nodules_radiologist_id) df.insert(1,"nodule_id",verified_nodules_nodule_id) df.insert(2,"dcm_path",verified_nodules_dcm_path) df.insert(3,"x_center",verified_nodules_x_center) df.insert(4,"y_center",verified_nodules_y_center) df.insert(5,"sliceIdx",verified_nodules_sliceIdx) df.insert(6,"x_min",verified_nodules_x_min) df.insert(7,"x_max",verified_nodules_x_max) df.insert(8,"y_min",verified_nodules_y_min) df.insert(9,"y_max",verified_nodules_y_max) df.to_csv('nodules_gt3mm_min'+str(min_experts)+'.csv', sep = '\t')
mit
waynenilsen/statsmodels
statsmodels/tools/pca.py
25
31232
"""Principal Component Analysis Author: josef-pktd Modified by Kevin Sheppard """ from __future__ import print_function, division import numpy as np import pandas as pd from statsmodels.compat.python import range from statsmodels.compat.numpy import nanmean def _norm(x): return np.sqrt(np.sum(x * x)) class PCA(object): """ Principal Component Analysis Parameters ---------- data : array-like Variables in columns, observations in rows ncomp : int, optional Number of components to return. If None, returns the as many as the smaller of the number of rows or columns in data standardize: bool, optional Flag indicating to use standardized data with mean 0 and unit variance. standardized being True implies demean. Using standardized data is equivalent to computing principal components from the correlation matrix of data demean : bool, optional Flag indicating whether to demean data before computing principal components. demean is ignored if standardize is True. Demeaning data but not standardizing is equivalent to computing principal components from the covariance matrix of data normalize : bool , optional Indicates whether th normalize the factors to have unit inner product. If False, the loadings will have unit inner product. weights : array, optional Series weights to use after transforming data according to standardize or demean when computing the principal components. gls : bool, optional Flag indicating to implement a two-step GLS estimator where in the first step principal components are used to estimate residuals, and then the inverse residual variance is used as a set of weights to estimate the final principal components. Setting gls to True requires ncomp to be less then the min of the number of rows or columns method : str, optional Sets the linear algebra routine used to compute eigenvectors 'svd' uses a singular value decomposition (default). 'eig' uses an eigenvalue decomposition of a quadratic form 'nipals' uses the NIPALS algorithm and can be faster than SVD when ncomp is small and nvars is large. See notes about additional changes when using NIPALS tol : float, optional Tolerance to use when checking for convergence when using NIPALS max_iter : int, optional Maximum iterations when using NIPALS missing : string Method for missing data. Choices are 'drop-row' - drop rows with missing values 'drop-col' - drop columns with missing values 'drop-min' - drop either rows or columns, choosing by data retention 'fill-em' - use EM algorithm to fill missing value. ncomp should be set to the number of factors required tol_em : float Tolerance to use when checking for convergence of the EM algorithm max_em_iter : int Maximum iterations for the EM algorithm Attributes ---------- factors : array or DataFrame nobs by ncomp array of of principal components (scores) scores : array or DataFrame nobs by ncomp array of of principal components - identical to factors loadings : array or DataFrame ncomp by nvar array of principal component loadings for constructing the factors coeff : array or DataFrame nvar by ncomp array of principal component loadings for constructing the projections projection : array or DataFrame nobs by var array containing the projection of the data onto the ncomp estimated factors rsquare : array or Series ncomp array where the element in the ith position is the R-square of including the fist i principal components. Note: values are calculated on the transformed data, not the original data ic : array or DataFrame ncomp by 3 array containing the Bai and Ng (2003) Information criteria. Each column is a different criteria, and each row represents the number of included factors. eigenvals : array or Series nvar array of eigenvalues eigenvecs : array or DataFrame nvar by nvar array of eigenvectors weights : array nvar array of weights used to compute the principal components, normalized to unit length transformed_data : array Standardized, demeaned and weighted data used to compute principal components and related quantities cols : array Array of indices indicating columns used in the PCA rows : array Array of indices indicating rows used in the PCA Methods ------- plot_scree Scree plot of the eigenvalues plot_rsquare Individual series R-squared plotted against the number of factors project Compute projection for a given number of factors Examples -------- Basic PCA using the correlation matrix of the data >>> import numpy as np >>> from statsmodels.tools.pca import PCA >>> x = np.random.randn(100)[:, None] >>> x = x + np.random.randn((100, 100)) >>> pc = PCA(x) Note that the principal components are computed using a SVD and so the correlation matrix is never constructed, unless method='eig'. PCA using the covariance matrix of the data >>> pc = PCA(x, standardize=False) Limiting the number of factors returned to 1 computed using NIPALS >>> pc = PCA(x, ncomp=1, method='nipals') >>> pc.factors.shape (100, 1) Notes ----- The default options perform principal component analysis on the demeanded, unit variance version of data. Setting standardize to False will instead onle demean, and setting both standardized and demean to False will not alter the data. Once the data have been transformed, the following relationships hold when the number of components (ncomp) is the same as tne minimum of the number of observation or the number of variables. .. math: X' X = V \\Lambda V' .. math: F = X V .. math: X = F V' where X is the `data`, F is the array of principal components (`factors` or `scores`), and V is the array of eigenvectors (`loadings`) and V' is the array of factor coefficients (`coeff`). When weights are provided, the principal components are computed from the modified data .. math: \\Omega^{-\\frac{1}{2}} X where :math:`\\Omega` is a diagonal matrix composed of the weights. For example, when using the GLS version of PCA, the elements of :math:`\\Omega` will be the inverse of the variances of the residuals from .. math: X - F V' where the number of factors is less than the rank of X .. [1] J. Bai and S. Ng, "Determining the number of factors in approximate factor models," Econometrica, vol. 70, number 1, pp. 191-221, 2002 """ def __init__(self, data, ncomp=None, standardize=True, demean=True, normalize=True, gls=False, weights=None, method='svd', missing=None, tol=5e-8, max_iter=1000, tol_em=5e-8, max_em_iter=100, ): self._index = None self._columns = [] if isinstance(data, pd.DataFrame): self._index = data.index self._columns = data.columns self.data = np.asarray(data) # Store inputs self._gls = gls self._normalize = normalize self._tol = tol if not 0 < self._tol < 1: raise ValueError('tol must be strictly between 0 and 1') self._max_iter = max_iter self._max_em_iter = max_em_iter self._tol_em = tol_em # Prepare data self._standardize = standardize self._demean = demean self._nobs, self._nvar = self.data.shape if weights is None: weights = np.ones(self._nvar) else: weights = np.array(weights).flatten() if weights.shape[0] != self._nvar: raise ValueError('weights should have nvar elements') weights = weights / np.sqrt((weights ** 2.0).mean()) self.weights = weights # Check ncomp against maximum min_dim = min(self._nobs, self._nvar) self._ncomp = min_dim if ncomp is None else ncomp if self._ncomp > min_dim: import warnings warn = 'The requested number of components is more than can be ' \ 'computed from data. The maximum number of components is ' \ 'the minimum of the number of observations or variables' warnings.warn(warn) self._ncomp = min_dim self._method = method if self._method == 'eig': self._compute_eig = self._compute_using_eig elif self._method == 'svd': self._compute_eig = self._compute_using_svd elif self._method == 'nipals': self._compute_eig = self._compute_using_nipals else: raise ValueError('method is not known.') self.rows = np.arange(self._nobs) self.cols = np.arange(self._nvar) # Handle missing self._missing = missing self._adjusted_data = self.data if missing is not None: self._adjust_missing() # Update size self._nobs, self._nvar = self._adjusted_data.shape if self._ncomp == np.min(self.data.shape): self._ncomp = np.min(self._adjusted_data.shape) elif self._ncomp > np.min(self._adjusted_data.shape): raise ValueError('When adjusting for missing values, user ' 'provided ncomp must be no larger than the ' 'smallest dimension of the ' 'missing-value-adjusted data size.') # Attributes and internal values self._tss = 0.0 self._ess = None self.transformed_data = None self._mu = None self._sigma = None self._ess_indiv = None self._tss_indiv = None self.scores = self.factors = None self.loadings = None self.coeff = None self.eigenvals = None self.eigenvecs = None self.projection = None self.rsquare = None self.ic = None # Prepare data self.transformed_data = self._prepare_data() # Perform the PCA self._pca() if gls: self._compute_gls_weights() self.transformed_data = self._prepare_data() self._pca() # Final calculations self._compute_rsquare_and_ic() if self._index is not None: self._to_pandas() def _adjust_missing(self): """ Implements alternatives for handling missing values """ def keep_col(x): index = np.logical_not(np.any(np.isnan(x), 0)) return x[:, index], index def keep_row(x): index = np.logical_not(np.any(np.isnan(x), 1)) return x[index, :], index if self._missing == 'drop-col': self._adjusted_data, index = keep_col(self.data) self.cols = np.where(index)[0] self.weights = self.weights[index] elif self._missing == 'drop-row': self._adjusted_data, index = keep_row(self.data) self.rows = np.where(index)[0] elif self._missing == 'drop-min': drop_col, drop_col_index = keep_col(self.data) drop_col_size = drop_col.size drop_row, drop_row_index = keep_row(self.data) drop_row_size = drop_row.size if drop_row_size > drop_col_size: self._adjusted_data = drop_row self.rows = np.where(drop_row_index)[0] else: self._adjusted_data = drop_col self.weights = self.weights[drop_col_index] self.cols = np.where(drop_col_index)[0] elif self._missing == 'fill-em': self._adjusted_data = self._fill_missing_em() else: raise ValueError('missing method is not known.') # Check adjusted data size if self._adjusted_data.size == 0: raise ValueError('Removal of missing values has eliminated all data.') def _compute_gls_weights(self): """ Computes GLS weights based on percentage of data fit """ errors = self.transformed_data - np.asarray(self.projection) if self._ncomp == self._nvar: raise ValueError('gls can only be used when ncomp < nvar ' 'so that residuals have non-zero variance') var = (errors ** 2.0).mean(0) weights = 1.0 / var weights = weights / np.sqrt((weights ** 2.0).mean()) nvar = self._nvar eff_series_perc = (1.0 / sum((weights / weights.sum()) ** 2.0)) / nvar if eff_series_perc < 0.1: eff_series = int(np.round(eff_series_perc * nvar)) import warnings warn = 'Many series are being down weighted by GLS. Of the ' \ '{original} series, the GLS estimates are based on only ' \ '{effective} (effective) ' \ 'series.'.format(original=nvar, effective=eff_series) warnings.warn(warn) self.weights = weights def _pca(self): """ Main PCA routine """ self._compute_eig() self._compute_pca_from_eig() self.projection = self.project() def __repr__(self): string = self.__str__() string = string[:-1] string += ', id: ' + hex(id(self)) + ')' return string def __str__(self): string = 'Principal Component Analysis(' string += 'nobs: ' + str(self._nobs) + ', ' string += 'nvar: ' + str(self._nvar) + ', ' if self._standardize: kind = 'Standardize (Correlation)' elif self._demean: kind = 'Demean (Covariance)' else: kind = 'None' string += 'transformation: ' + kind + ', ' if self._gls: string += 'GLS, ' string += 'normalization: ' + str(self._normalize) + ', ' string += 'number of components: ' + str(self._ncomp) + ', ' string += 'method: ' + 'Eigenvalue' if self._method == 'eig' else 'SVD' string += ')' return string def _prepare_data(self): """ Standardize or demean data. """ adj_data = self._adjusted_data if np.all(np.isnan(adj_data)): return np.empty(adj_data.shape[1]).fill(np.nan) self._mu = nanmean(adj_data, axis=0) self._sigma = np.sqrt(nanmean((adj_data - self._mu) ** 2.0, axis=0)) if self._standardize: data = (adj_data - self._mu) / self._sigma elif self._demean: data = (adj_data - self._mu) else: data = adj_data return data / np.sqrt(self.weights) def _compute_using_svd(self): """SVD method to compute eigenvalues and eigenvecs""" x = self.transformed_data u, s, v = np.linalg.svd(x) self.eigenvals = s ** 2.0 self.eigenvecs = v.T def _compute_using_eig(self): """ Eigenvalue decomposition method to compute eigenvalues and eigenvectors """ x = self.transformed_data self.eigenvals, self.eigenvecs = np.linalg.eigh(x.T.dot(x)) def _compute_using_nipals(self): """ NIPALS implementation to compute small number of eigenvalues and eigenvectors """ x = self.transformed_data if self._ncomp > 1: x = x + 0.0 # Copy tol, max_iter, ncomp = self._tol, self._max_iter, self._ncomp vals = np.zeros(self._ncomp) vecs = np.zeros((self._nvar, self._ncomp)) for i in range(ncomp): max_var_ind = np.argmax(x.var(0)) factor = x[:, [max_var_ind]] _iter = 0 diff = 1.0 while diff > tol and _iter < max_iter: vec = x.T.dot(factor) / (factor.T.dot(factor)) vec = vec / np.sqrt(vec.T.dot(vec)) factor_last = factor factor = x.dot(vec) / (vec.T.dot(vec)) diff = _norm(factor - factor_last) / _norm(factor) _iter += 1 vals[i] = (factor ** 2).sum() vecs[:, [i]] = vec if ncomp > 1: x -= factor.dot(vec.T) self.eigenvals = vals self.eigenvecs = vecs def _fill_missing_em(self): """ EM algorithm to fill missing values """ non_missing = np.logical_not(np.isnan(self.data)) # If nothing missing, return without altering the data if np.all(non_missing): return self.data # 1. Standardized data as needed data = self.transformed_data = self._prepare_data() ncomp = self._ncomp # 2. Check for all nans col_non_missing = np.sum(non_missing, 1) row_non_missing = np.sum(non_missing, 0) if np.any(col_non_missing < ncomp) or np.any(row_non_missing < ncomp): raise ValueError('Implementation requires that all columns and ' 'all rows have at least ncomp non-missing values') # 3. Get mask mask = np.isnan(data) # 4. Compute mean mu = nanmean(data, 0) # 5. Replace missing with mean projection = np.ones((self._nobs, 1)) * mu projection_masked = projection[mask] data[mask] = projection_masked # 6. Compute eigenvalues and fit diff = 1.0 _iter = 0 while diff > self._tol_em and _iter < self._max_em_iter: last_projection_masked = projection_masked # Set transformed data to compute eigenvalues self.transformed_data = data # Call correct eig function here self._compute_eig() # Call function to compute factors and projection self._compute_pca_from_eig() projection = self.project(transform=False, unweight=False) projection_masked = projection[mask] data[mask] = projection_masked delta = last_projection_masked - projection_masked diff = _norm(delta) / _norm(projection_masked) _iter += 1 # Must copy to avoid overwriting original data since replacing values data = self._adjusted_data + 0.0 projection = self.project() data[mask] = projection[mask] return data def _compute_pca_from_eig(self): """ Compute relevant statistics after eigenvalues have been computed """ # Ensure sorted largest to smallest vals, vecs = self.eigenvals, self.eigenvecs indices = np.argsort(vals) indices = indices[::-1] vals = vals[indices] vecs = vecs[:, indices] if (vals <= 0).any(): # Discard and warn num_good = vals.shape[0] - (vals <= 0).sum() if num_good < self._ncomp: import warnings warn = 'Only {num:d} eigenvalues are positive. The is the ' \ 'maximum number of components that can be extracted.' warnings.warn(warn.format(num=num_good)) self._ncomp = num_good vals[num_good:] = np.finfo(np.float64).tiny # Use ncomp for the remaining calculations vals = vals[:self._ncomp] vecs = vecs[:, :self._ncomp] self.eigenvals, self.eigenvecs = vals, vecs # Select correct number of components to return self.scores = self.factors = self.transformed_data.dot(vecs) self.loadings = vecs self.coeff = vecs.T if self._normalize: self.coeff = (self.coeff.T * np.sqrt(vals)).T self.factors /= np.sqrt(vals) self.scores = self.factors def _compute_rsquare_and_ic(self): """ Final statistics to compute """ # TSS and related calculations # TODO: This needs careful testing, with and without weights, gls, standardized and demean weights = self.weights ss_data = self.transformed_data * np.sqrt(weights) self._tss_indiv = np.sum(ss_data ** 2, 0) self._tss = np.sum(self._tss_indiv) self._ess = np.zeros(self._ncomp + 1) self._ess_indiv = np.zeros((self._ncomp + 1, self._nvar)) for i in range(self._ncomp + 1): # Projection in the same space as transformed_data projection = self.project(ncomp=i, transform=False, unweight=False) indiv_rss = (projection ** 2).sum(axis=0) rss = indiv_rss.sum() self._ess[i] = self._tss - rss self._ess_indiv[i, :] = self._tss_indiv - indiv_rss self.rsquare = 1.0 - self._ess / self._tss # Information Criteria ess = self._ess invalid = ess <= 0 # Prevent log issues of 0 if invalid.any(): last_obs = (np.where(invalid)[0]).min() ess = ess[:last_obs] log_ess = np.log(ess) r = np.arange(ess.shape[0]) nobs, nvar = self._nobs, self._nvar sum_to_prod = (nobs + nvar) / (nobs * nvar) min_dim = min(nobs, nvar) penalties = np.array([sum_to_prod * np.log(1.0 / sum_to_prod), sum_to_prod * np.log(min_dim), np.log(min_dim) / min_dim]) penalties = penalties[:, None] ic = log_ess + r * penalties self.ic = ic.T def project(self, ncomp=None, transform=True, unweight=True): """ Project series onto a specific number of factors Parameters ---------- ncomp : int, optional Number of components to use. If omitted, all components initially computed are used. Returns ------- projection : array nobs by nvar array of the projection onto ncomp factors transform : bool Flag indicating whether to return the projection in the original space of the data (True, default) or in the space of the standardized/demeaned data unweight : bool Flag indicating whether to undo the effects of the estimation weights Notes ----- """ # Projection needs to be scaled/shifted based on inputs ncomp = self._ncomp if ncomp is None else ncomp if ncomp > self._ncomp: raise ValueError('ncomp must be smaller than the number of ' 'components computed.') factors = np.asarray(self.factors) coeff = np.asarray(self.coeff) projection = factors[:, :ncomp].dot(coeff[:ncomp, :]) if transform or unweight: projection *= np.sqrt(self.weights) if transform: # Remove the weights, which do not depend on transformation if self._standardize: projection *= self._sigma if self._standardize or self._demean: projection += self._mu if self._index is not None: projection = pd.DataFrame(projection, columns=self._columns, index=self._index) return projection def _to_pandas(self): """ Returns pandas DataFrames for all values """ index = self._index # Principal Components num_zeros = np.ceil(np.log10(self._ncomp)) comp_str = 'comp_{0:0' + str(int(num_zeros)) + 'd}' cols = [comp_str.format(i) for i in range(self._ncomp)] df = pd.DataFrame(self.factors, columns=cols, index=index) self.scores = self.factors = df # Projections df = pd.DataFrame(self.projection, columns=self._columns, index=index) self.projection = df # Weights df = pd.DataFrame(self.coeff, index=cols, columns=self._columns) self.coeff = df # Loadings df = pd.DataFrame(self.loadings, index=self._columns, columns=cols) self.loadings = df # eigenvals self.eigenvals = pd.Series(self.eigenvals) self.eigenvals.name = 'eigenvals' # eigenvecs vec_str = comp_str.replace('comp', 'eigenvec') cols = [vec_str.format(i) for i in range(self.eigenvecs.shape[1])] self.eigenvecs = pd.DataFrame(self.eigenvecs, columns=cols) # R2 self.rsquare = pd.Series(self.rsquare) self.rsquare.index.name = 'ncomp' self.rsquare.name = 'rsquare' # IC self.ic = pd.DataFrame(self.ic, columns=['IC_p1', 'IC_p2', 'IC_p3']) self.ic.index.name = 'ncomp' def plot_scree(self, ncomp=None, log_scale=True, cumulative=False, ax=None): """ Plot of the ordered eigenvalues Parameters ---------- ncomp : int, optional Number of components ot include in the plot. If None, will included the same as the number of components computed log_scale : boot, optional Flag indicating whether ot use a log scale for the y-axis cumulative : bool, optional Flag indicating whether to plot the eigenvalues or cumulative eigenvalues ax : Matplotlib axes instance, optional An axes on which to draw the graph. If omitted, new a figure is created Returns ------- fig : figure Handle to the figure """ import statsmodels.graphics.utils as gutils fig, ax = gutils.create_mpl_ax(ax) ncomp = self._ncomp if ncomp is None else ncomp vals = np.asarray(self.eigenvals) vals = vals[:self._ncomp] if cumulative: vals = np.cumsum(vals) if log_scale: ax.set_yscale('log') ax.plot(np.arange(ncomp), vals[: ncomp], 'bo') ax.autoscale(tight=True) xlim = np.array(ax.get_xlim()) sp = xlim[1] - xlim[0] xlim += 0.02 * np.array([-sp, sp]) ax.set_xlim(xlim) ylim = np.array(ax.get_ylim()) scale = 0.02 if log_scale: sp = np.log(ylim[1] / ylim[0]) ylim = np.exp(np.array([np.log(ylim[0]) - scale * sp, np.log(ylim[1]) + scale * sp])) else: sp = ylim[1] - ylim[0] ylim += scale * np.array([-sp, sp]) ax.set_ylim(ylim) ax.set_title('Scree Plot') ax.set_ylabel('Eigenvalue') ax.set_xlabel('Component Number') fig.tight_layout() return fig def plot_rsquare(self, ncomp=None, ax=None): """ Box plots of the individual series R-square against the number of PCs Parameters ---------- ncomp : int, optional Number of components ot include in the plot. If None, will plot the minimum of 10 or the number of computed components ax : Matplotlib axes instance, optional An axes on which to draw the graph. If omitted, new a figure is created Returns ------- fig : figure Handle to the figure """ import statsmodels.graphics.utils as gutils fig, ax = gutils.create_mpl_ax(ax) ncomp = 10 if ncomp is None else ncomp ncomp = min(ncomp, self._ncomp) # R2s in rows, series in columns r2s = 1.0 - self._ess_indiv / self._tss_indiv r2s = r2s[1:] r2s = r2s[:ncomp] ax.boxplot(r2s.T) ax.set_title('Individual Input $R^2$') ax.set_ylabel('$R^2$') ax.set_xlabel('Number of Included Principal Components') return fig def pca(data, ncomp=None, standardize=True, demean=True, normalize=True, gls=False, weights=None, method='svd'): """ Principal Component Analysis Parameters ---------- data : array Variables in columns, observations in rows. ncomp : int, optional Number of components to return. If None, returns the as many as the smaller to the number of rows or columns of data. standardize: bool, optional Flag indicating to use standardized data with mean 0 and unit variance. standardized being True implies demean. demean : bool, optional Flag indicating whether to demean data before computing principal components. demean is ignored if standardize is True. normalize : bool , optional Indicates whether th normalize the factors to have unit inner product. If False, the loadings will have unit inner product. weights : array, optional Series weights to use after transforming data according to standardize or demean when computing the principal components. gls : bool, optional Flag indicating to implement a two-step GLS estimator where in the first step principal components are used to estimate residuals, and then the inverse residual variance is used as a set of weights to estimate the final principal components method : str, optional Determines the linear algebra routine uses. 'eig', the default, uses an eigenvalue decomposition. 'svd' uses a singular value decomposition. Returns ------- factors : array or DataFrame nobs by ncomp array of of principal components (also known as scores) loadings : array or DataFrame ncomp by nvar array of principal component loadings for constructing the factors projection : array or DataFrame nobs by var array containing the projection of the data onto the ncomp estimated factors rsquare : array or Series ncomp array where the element in the ith position is the R-square of including the fist i principal components. The values are calculated on the transformed data, not the original data. ic : array or DataFrame ncomp by 3 array containing the Bai and Ng (2003) Information criteria. Each column is a different criteria, and each row represents the number of included factors. eigenvals : array or Series nvar array of eigenvalues eigenvecs : array or DataFrame nvar by nvar array of eigenvectors Notes ----- This is a simple function wrapper around the PCA class. See PCA for more information and additional methods. """ pc = PCA(data, ncomp=ncomp, standardize=standardize, demean=demean, normalize=normalize, gls=gls, weights=weights, method=method) return (pc.factors, pc.loadings, pc.projection, pc.rsquare, pc.ic, pc.eigenvals, pc.eigenvecs)
bsd-3-clause
BhallaLab/benchmarks
moose_nrn_equivalence_testing/comparision_with_simple_HH_model_additional_mechanism/loader_moose.py
2
5681
"""loader_moose.py: Load a SWC file in MOOSE. """ __author__ = "Dilawar Singh" __copyright__ = "Copyright 2015, Dilawar Singh and NCBS Bangalore" __credits__ = ["NCBS Bangalore"] __license__ = "GNU GPL" __version__ = "1.0.0" __maintainer__ = "Dilawar Singh" __email__ = "[email protected]" __status__ = "Development" import numpy as np import pylab import moose import time import moose.utils as mu from moose import neuroml from PyQt4 import Qt, QtCore, QtGui import matplotlib.pyplot as plt import sys sys.path.append('/opt/moose/Demos/util') import rdesigneur as rd import os from moose.neuroml.ChannelML import ChannelML # Global variable to log query to database. db_query_ = {} PI = 3.14159265359 frameRunTime = 0.001 FaradayConst = 96845.34 modelName = None simulator = 'moose' ncompts = 0 nchans = 0 _args = None _records = {} import logging logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s', datefmt='%m-%d %H:%M', filename='moose.log', filemode='w') # define a Handler which writes INFO messages or higher to the sys.stderr console = logging.StreamHandler() console.setLevel(logging.INFO) # set a format which is simpler for console use formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s') # tell the handler to use this format console.setFormatter(formatter) # add the handler to the root logger logging.getLogger('').addHandler(console) _logger = logging.getLogger('') def makePlot( cell ): fig = plt.figure( figsize = ( 10, 12 ) ) chans = ['hd', 'kdr', 'na3', 'nax', 'kap', 'kad'] compts = cell.compartments epos = cell.electrotonicDistanceFromSoma gpos = cell.geometricalDistanceFromSoma combo = list(zip( gpos, compts )) #combo.sort( key=lambda c:c[1].x) combo.sort( key= lambda c:c[0] ) for i in chans: x = [] y = [] for j in combo: area = j[1].length * j[1].diameter * PI #x.append( j[1].x ) x.append( j[0] ) if moose.exists( j[1].path + '/' + i ): elm = moose.element( j[1].path + '/' + i ) y.append( elm.Gbar / area ) else: y.append( 0.0 ) pylab.plot( x, y, '-bo', label = i ) pylab.legend() pylab.show() def saveData( outfile ): clock = moose.Clock('/clock') assert clock yvec = None for k in _records: if "soma" in k: yvec = _records[k].vector xvec = np.linspace(0, clock.currentTime, len(yvec)) with open(outfile, "wb") as f: f.write("%s,%s\n" % ('time', 'soma')) for i, t in enumerate(xvec): f.write("%s,%s\n" % (t, yvec[i])) _logger.debug("Done writing to file %s" % outfile) def loadModel(filename, chanProto, chanDistrib, passiveDistrib): """Load the model and insert channels """ global modelName global nchans, ncompts # Load in the swc file. modelName = "elec" cellProto = [ ( filename, modelName ) ] rdes = rd.rdesigneur( cellProto = cellProto , combineSegments = True , passiveDistrib = passiveDistrib , chanProto = chanProto , chanDistrib = chanDistrib ) rdes.buildModel('/model') compts = moose.wildcardFind( "/model/%s/#[ISA=CompartmentBase]"%modelName ) setupStimuls( compts[0] ) for compt in compts: vtab = moose.Table( '%s/vm' % compt.path ) moose.connect( vtab, 'requestOut', compt, 'getVm' ) _records[compt.path] = vtab nchans = len(set([x.path for x in moose.wildcardFind('/model/elec/##[TYPE=ZombieHHChannel]')]) ) _logger.info("Total channels: %s" % nchans) return _records def setupStimuls(compt): command = moose.PulseGen('%s/command' % compt.path) command.level[0] = 1e-9 command.delay[0] = 0 command.width[0] = 0.1 m = moose.connect(command, 'output', compt, 'injectMsg') def plots(filter='soma'): global _records global _args toPlot = [] tables = {} for k in _records: if filter in k: toPlot.append(k) for k in toPlot: tables[k] = _records[k] mu.plotRecords(tables, subplot=True) #, outfile=_args.plots) plt.show() def countSpike(): import count_spike global db_query_ soma = None for k in _records.keys(): if "soma" in k.lower(): soma = _records[k].vector break if len(soma) > 0: nSpikes, meanDT, varDT = count_spike.spikes_characterization( soma ) db_query_['number_of_spikes'] = nSpikes db_query_['mean_spike_interval'] = meanDT db_query_['variance_spike_interval'] = varDT _logger.info("[MOOSE] Spike characteristics:") _logger.info("\t num_spikes: {}, mean_dt: {}, var_dt: {}".format( nSpikes, meanDT, varDT) ) def main(args): global _args _args = args global ncompts, nchans loadModel(args.swc_file, args) moose.reinit() compts = moose.wildcardFind( "/model/%s/#[ISA=CompartmentBase]" % modelName ) ncompts = len(compts) startt = time.time() moose.start(args.sim_time) t = time.time() - startt db_query_['simulator'] = 'moose' db_query_['number_of_compartments'] = ncompts db_query_['number_of_channels'] = nchans db_query_['simulation_time'] = args.sim_time db_query_['run_time'] = t db_query_['dt'] = args.sim_dt db_query_['model_name'] = args.swc_file countSpike() dbEntry(db_query_) saveData(outfile="_data/moose.csv")
gpl-2.0
timodonnell/pyopen
setup.py
1
1181
try: from setuptools import setup except ImportError: from distutils.core import setup version = "0.0.7" setup( name="pyopen", version=version, author="Tim O'Donnell", author_email="[email protected]", packages=["pyopen", "pyopen.loaders"], url="https://github.com/timodonnell/pyopen", license="Apache License", description="launch an interactive ipython session with specified files opened and parsed", long_description=open('README.rst').read(), download_url='https://github.com/timodonnell/pyopen/tarball/%s' % version, entry_points={ 'console_scripts': [ 'pyopen = pyopen.command:run', ] }, classifiers=[ "Development Status :: 1 - Planning", "Intended Audience :: Developers", "Programming Language :: Python :: 2", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.4", ], install_requires=[ "humanize", "traitlets", "six", "xlrd", "requests", "tables", "pandas>=0.16.1", "nose>=1.3.1", ] )
apache-2.0
marbiouk/dsmtools
Tools/IntertidalToolsSpeciesPatternsAroundIslands.py
1
25308
#!/usr/bin/env python import arcpy import os from math import radians, sin, cos, sqrt import gc import time import csv import pandas as pd class IntertidalToolsSpeciesPatternsAroundIslands(object): """This class has the methods you need to define to use your code as an ArcGIS Python Tool.""" def __init__(self): """Define the tool (tool name is the name of the class).""" self.label = "Species distribution patterns around islands" self.description = """Orientation of species distributions for G. Williams""" self.canRunInBackground = True self.category = "Intertidal Tools" # Use your own category here, or an existing one. def getParameterInfo(self): # You can define a tool to have no parameters params = [] # Input Island Line - Demarks the area in which we will spatially bootstrap input_line = arcpy.Parameter(name="input_line_folder", displayName="Input Island Line", datatype="DEFeatureClass", parameterType="Required", direction="Input", ) input_line.value = "D:/2016/Corals/IndividualIslands_ByYear_Lines/TUT.shp" params.append(input_line) # Input Island Points - Original points that will be sampled by the spatial bootstrap input_points = arcpy.Parameter(name="input_points", displayName="Input Island Points", datatype="DEFeatureClass", parameterType="Required", direction="Input", ) input_points.value = "D:/2016/Corals/IndividualIslands_ByYear_Points/TUT_ALL.shp" params.append(input_points) # Select attribute column for the calculation attribute_process = arcpy.Parameter(name="attribute_1", displayName="Column to process", datatype="Field", parameterType="Required", direction="Input") attribute_process.value = "CORAL,CCA,MACROALGAE" params.append(attribute_process) # Select attribute column for the calculation flag_field = arcpy.Parameter(name="flag_field", displayName="Flag field", datatype="Field", parameterType="Required", direction="Input") # Derived parameter flag_field.parameterDependencies = [input_points.name] flag_field.value = "Flag" params.append(flag_field) # Distance to draw polygon - in metres distance = arcpy.Parameter(name="distance", displayName="Distance to capture sample points", datatype="GPDouble", parameterType="Required", direction="Input", ) distance.value = 100000 params.append(distance) # Angle to capture patterns within circle - in degrees angle = arcpy.Parameter(name="angle", displayName="Angle for search", datatype="GPLong", parameterType="Required", direction="Input", ) angle.value = 10 params.append(angle) # Output feature class output_directory = arcpy.Parameter(name="output_directory", displayName="Output directory", datatype="DEWorkspace", parameterType="Optional", direction="Output", ) output_directory.value = "D:/2016/Corals/IndividualIslands_ByYear_GP/TUT_ALL" params.append(output_directory) clean_up = arcpy.Parameter(name="clean_up", displayName="Delete temporary files?", datatype="GPBoolean", parameterType="Required", direction="Input", ) clean_up.value = "False" params.append(clean_up) return params def isLicensed(self): """Set whether tool is licensed to execute.""" return True def updateMessages(self, parameters): """Modify the messages created by internal validation for each tool parameter. This method is called after internal validation.""" return def execute(self, parameters, messages): arcpy.env.overwriteOutput = True arcpy.CheckOutExtension('Spatial') arcpy.AddMessage("Orientation of species distributions") for param in parameters: arcpy.AddMessage("Parameter: %s = %s" % (param.name, param.valueAsText)) # Read in variables for the tool input_line = parameters[0].valueAsText input_points = parameters[1].valueAsText attribute_process = parameters[2].valueAsText flag_field = parameters[3].valueAsText distance = parameters[4].value angle = parameters[5].value output_directory = parameters[6].valueAsText clean_up = parameters[7].valueAsText # Make output directory if it does not exist output_directory.strip() arcpy.AddMessage(output_directory) if not os.path.exists(str(output_directory)): os.makedirs(output_directory) arcpy.env.workspace = output_directory # 0 Describe files to set coordinate systems desc_input = arcpy.Describe(input_points) coord_system = desc_input.spatialReference arcpy.env.outputCoordinateSystem = coord_system # 1 Convert island line to a polygon - numpy work around due to lack of license if not arcpy.Exists(os.path.join(output_directory, "Island_Poly.shp")): def polygon_to_line_no_gap(input_line_, output_polygon): array = arcpy.da.FeatureClassToNumPyArray(input_line_, ["SHAPE@X", "SHAPE@Y"], spatial_reference=coord_system, explode_to_points=True) if array.size == 0: arcpy.AddError("Line has no features, check to ensure it is OK") else: array2 = arcpy.Array() for x, y in array: pnt = arcpy.Point(x, y) array2.add(pnt) polygon = arcpy.Polygon(array2) arcpy.CopyFeatures_management(polygon, output_polygon) return polygon_to_line_no_gap(input_line, os.path.join(output_directory, "Island_Poly.shp")) # 2 Create Fishnet for random sampling of points within the cells of the net extent = arcpy.Describe(input_points).extent origin_coord = str(extent.XMin) + " " + str(extent.YMin) y_coord = str(extent.XMin) + " " + str(extent.YMin + 1) corner_coord = str(extent.XMax) + " " + str(extent.YMax) island_area = 0 with arcpy.da.SearchCursor(os.path.join(output_directory,"Island_Poly.shp"), "SHAPE@") as rows: for row in rows: island_area += row[0].getArea("GEODESIC", "SQUAREKILOMETERS") island_area_polygon = sqrt(island_area * 0.1) * 100 arcpy.AddMessage( "....fishnet size is: " + str(round(island_area_polygon,2)) + " m x " + str(round(island_area_polygon,2)) + " m. Island area is: " + str(round(island_area,0)) + " km2.") arcpy.CreateFishnet_management(out_feature_class=os.path.join(output_directory,"Fishnet.shp"), origin_coord=origin_coord, y_axis_coord=y_coord, cell_width=island_area_polygon, cell_height=island_area_polygon, number_rows="", number_columns="", corner_coord=corner_coord, labels="", template="", geometry_type="POLYGON" ) arcpy.Intersect_analysis(in_features=os.path.join(output_directory,"Fishnet.shp") + " #;" + os.path.join(output_directory,"Island_Poly.shp") + " #", out_feature_class=os.path.join(output_directory,"FishClip.shp"), join_attributes="ONLY_FID", cluster_tolerance="-1 Unknown", output_type="INPUT") arcpy.DefineProjection_management(os.path.join(output_directory,"FishClip.shp"), coord_system) arcpy.AddField_management(os.path.join(output_directory,"FishClip.shp"), "Shape_Area", "DOUBLE") arcpy.CalculateField_management(os.path.join(output_directory,"FishClip.shp"), "Shape_Area", "!SHAPE.AREA@SQUAREMETERS!", "PYTHON_9.3") maxvalue = arcpy.SearchCursor(os.path.join(output_directory,"FishClip.shp"), "", "", "", "Shape_Area" + " D").next().getValue("Shape_Area") maxvalue = str(int(maxvalue-1)) where = '"Shape_Area" > ' + "%s" %maxvalue arcpy.Select_analysis(in_features=os.path.join(output_directory,"FishClip.shp"), out_feature_class=os.path.join(output_directory,"FishClipInner.shp"), where_clause=where ) # 3 Create n random points within the cells of the fishnet arcpy.CreateRandomPoints_management(out_path=output_directory, out_name="RndPts.shp", constraining_feature_class=os.path.join(output_directory,"FishClipInner.shp"), constraining_extent="0 0 250 250", number_of_points_or_field="5", minimum_allowed_distance="0 Meters", create_multipoint_output="POINT", multipoint_size="0") arcpy.DefineProjection_management(os.path.join(output_directory,"RndPts.shp"), coord_system) else: arcpy.AddMessage("....skipping building polygons as they already exist") # 3 Create spatial bootstrapping circle polygons rows = arcpy.SearchCursor(os.path.join(output_directory,"RndPts.shp")) desc = arcpy.Describe(os.path.join(output_directory,"RndPts.shp")) shapefieldname = desc.ShapeFieldName if not arcpy.Exists(os.path.join(output_directory,"SectorPoly.shp")): arcpy.AddMessage("....now conducting spatial bootstrap.") featureclass = os.path.join(output_directory, "SectorPoly.shp") arcpy.CreateFeatureclass_management(os.path.dirname(featureclass), os.path.basename(featureclass), "Polygon") arcpy.AddField_management(featureclass, str("FID_Fishne"), "TEXT", "", "", "150") arcpy.AddField_management(featureclass, "BEARING", "SHORT", "", "", "4") arcpy.DeleteField_management(featureclass, ["Id"]) arcpy.DefineProjection_management(featureclass, coord_system) finalfeatureclass = os.path.join(output_directory,"Final.shp") arcpy.CreateFeatureclass_management(os.path.dirname(finalfeatureclass), os.path.basename(finalfeatureclass), "Polygon") arcpy.AddField_management(finalfeatureclass, str("FID_Fishne"), "TEXT", "", "", "150") arcpy.AddField_management(finalfeatureclass, "BEARING", "SHORT", "", "", "4") arcpy.DeleteField_management(finalfeatureclass, ["Id"]) arcpy.DefineProjection_management(finalfeatureclass, coord_system) featureclass_in_mem = arcpy.CreateFeatureclass_management("in_memory", "featureclass_in_mem", "Polygon") arcpy.AddField_management(featureclass_in_mem, "OriginID", "TEXT", "", "", "150") arcpy.AddField_management(featureclass_in_mem, "BEARING", "SHORT", "", "", "4") arcpy.DeleteField_management(featureclass_in_mem, ["Id"]) arcpy.DefineProjection_management(featureclass_in_mem, coord_system) for row in rows: angles = range(0, 360, angle) feat = row.getValue(shapefieldname) columnValue = row.getValue(str("FID")) pnt = feat.getPart() origin_x = pnt.X origin_y = pnt.Y for ang in angles: angleorigin = float(int(ang)) # Point 1 (disp_x, disp_y) = (distance * sin(radians(angleorigin)), distance * cos(radians(angleorigin))) (end_x, end_y) = (origin_x + disp_x, origin_y + disp_y) # Point 2 anglestep = float(int(ang) + int(angle)) (disp2_x, disp2_y) = (distance * sin(radians(anglestep)), distance * cos(radians(anglestep))) (end2_x, end2_y) = (origin_x + disp2_x, origin_y + disp2_y) # Create a polygon geometry array = arcpy.Array([arcpy.Point(origin_x, origin_y), arcpy.Point(end_x, end_y), arcpy.Point(end2_x, end2_y), ]) polygon = arcpy.Polygon(array) with arcpy.da.InsertCursor(featureclass_in_mem, ['OriginID', 'BEARING', 'SHAPE@']) as cur: cur.insertRow([columnValue, ang, polygon]) array.removeAll() arcpy.CopyFeatures_management(r"in_memory\featureclass_in_mem",featureclass) else: arcpy.AddMessage("....using previous spatial bootstrap.") arcpy.AddMessage("....now joining with observations") query = '"' + str(flag_field) + '" = ' + str(0) arcpy.MakeFeatureLayer_management(input_points, "input_points_query_sub") arcpy.Select_analysis("input_points_query_sub", r"in_memory/input_points_query", query) count_records = arcpy.GetCount_management(r"in_memory/input_points_query").getOutput(0) arcpy.AddMessage("....total number of records to process: " + str(count_records)) if int(count_records) > 500: arcpy.AddMessage("....spatial join will fail due to memory error, working around this limitation...") count_records = arcpy.GetCount_management(os.path.join(output_directory, "SectorPoly.shp")).getOutput(0) query_1_range = '"' + str("FID") + '" <= ' + str(int(count_records) / 4) query_2_range = '"' + str("FID") + '" > ' + str(int(count_records) / 4) + ' And "' + str("FID") + '" < ' + str(int(count_records) / 2) query_3_range = '"' + str("FID") + '" >= ' + str(int(count_records) / 2) + ' And "' + str("FID") + '" < ' + str(int(count_records) / 2 + int(count_records) / 4) query_4_range = '"' + str("FID") + '" >= ' + str(int(count_records) / 2 + int(count_records) / 4) query_list = [query_1_range, query_2_range, query_3_range, query_4_range] count = 1 for i in query_list: if not arcpy.Exists(os.path.join(output_directory, "SectorPoly" + str(count) + ".shp")): arcpy.Select_analysis(os.path.join(output_directory, "SectorPoly.shp"), os.path.join(output_directory, "SectorPoly" + str(count) + ".shp"), i) arcpy.SpatialJoin_analysis(os.path.join(output_directory, "SectorPoly" + str(count) + ".shp"), r"in_memory/input_points_query", os.path.join(output_directory, "SpatialJoin" + str(count) + ".shp"), "JOIN_ONE_TO_MANY", "KEEP_ALL", "", "INTERSECT") with arcpy.da.UpdateCursor(os.path.join(output_directory, "SpatialJoin" + str(count) + ".shp"), "Join_Count") as cursor: for row in cursor: if row[0] == 0: cursor.deleteRow() if not arcpy.Exists(os.path.join(output_directory, "SpatialJoin" + str(count) + ".csv")): dbf2csv(os.path.join(output_directory, "SpatialJoin" + str(count) + ".dbf"), os.path.join(output_directory, "SpatialJoin" + str(count) + ".csv")) count += 1 else: arcpy.SpatialJoin_analysis(os.path.join(output_directory, "SectorPoly.shp"), r"in_memory/input_points_query", r"in_memory/points_SpatialJoin", "JOIN_ONE_TO_MANY", "KEEP_ALL", "", "INTERSECT") with arcpy.da.UpdateCursor(r"in_memory/points_SpatialJoin", "Join_Count") as cursor: for row in cursor: if row[0] == 0: cursor.deleteRow() arcpy.CopyFeatures_management(r"in_memory/points_SpatialJoin",os.path.join(output_directory, os.path.splitext(os.path.basename(input_points))[0] + "_join.shp")) attribute_process = attribute_process.split(",") if arcpy.Exists(r"in_memory/points_SpatialJoin"): for i in attribute_process: arcpy.AddMessage("....calculating statistics for " + str(i)) stats = [[i, "MEAN"], [i, "STD"]] arcpy.Statistics_analysis(r"in_memory/points_SpatialJoin", os.path.join(output_directory, os.path.splitext(os.path.basename(input_points))[0] + "_" + i +".dbf"), stats, "BEARING") else: header_saved = False if not arcpy.Exists(os.path.join(output_directory, "SpatialJoin_Merge" + ".csv")): with open(os.path.join(output_directory, "SpatialJoin_Merge" + ".csv"), 'wb') as fout: for num in range(1,5): with open(os.path.join(output_directory, "SpatialJoin" + str(num) + ".csv")) as fin: header = next(fin) if not header_saved: fout.write(header) header_saved = True for line in fin: fout.write(line) for i in attribute_process: arcpy.AddMessage("....calculating statistics for " + str(i) + " using pandas1.") chunks = pd.read_csv(os.path.join(output_directory, "SpatialJoin_Merge" + ".csv"), chunksize=100000) pieces = [x.groupby('BEARING', as_index=False)[i].agg(['count', 'mean', 'std']) for x in chunks] result = pd.concat(pieces) result.columns = result.columns.droplevel(0) result = result.reset_index() name_mean = "MEAN_" + str(i) name_std = "STD_" + str(i) result.rename(columns={'count': 'FREQUENCY'}, inplace=True) result.rename(columns={'mean': name_mean[0:10]}, inplace=True) result.rename(columns={'std': name_std[0:10]}, inplace=True) f = {'FREQUENCY':['sum'], name_mean[0:10]:['mean'], name_std[0:10]:['mean']} result_2 = result.groupby('BEARING').agg(f) result_2 = result_2.reset_index() result_2 = result_2[['BEARING', 'FREQUENCY', name_mean[0:10], name_std[0:10]]] result_2.to_csv(os.path.join(output_directory, os.path.splitext(os.path.basename(input_points))[0] + "_" + i +".csv"), index=False) if os.path.exists(os.path.join(output_directory, os.path.splitext(os.path.basename(input_points))[0] + "_" + i +".csv")): with open(os.path.join(output_directory, os.path.splitext(os.path.basename(input_points))[0] + "_" + i +".csv"), "r") as f: reader = list(csv.reader(f, delimiter=",")) reader.pop(1) reader.pop(1) with open(os.path.join(output_directory, os.path.splitext(os.path.basename(input_points))[0] + "_" + i +".csv"), "w") as out: writer = csv.writer(out, delimiter=",") for row in reader: writer.writerow(row) result = arcpy.TableToDBASE_conversion(os.path.join(output_directory, os.path.splitext(os.path.basename(input_points))[0] + "_" + i +".csv"), output_directory) try: arcpy.Delete_management(r"in_memory/points_SpatialJoin") arcpy.Delete_management(r"in_memory/input_points_query") except: pass if clean_up == "true": arcpy.Delete_management(os.path.join(output_directory,"Island_Line.shp")) arcpy.CopyFeatures_management(os.path.join(output_directory,"Island_Poly.shp"),os.path.join(output_directory, os.path.splitext(os.path.basename(input_points))[0] + "_poly.shp")) arcpy.Delete_management(os.path.join(output_directory,"Island_Poly.shp")) arcpy.Delete_management(os.path.join(output_directory,"SectorPoly.shp")) arcpy.Delete_management(os.path.join(output_directory,"Fishnet.shp")) arcpy.Delete_management(os.path.join(output_directory,"Fishnet_label.shp")) arcpy.Delete_management(os.path.join(output_directory,"FishClip.shp")) arcpy.Delete_management(os.path.join(output_directory,"FishClipInner.shp")) arcpy.Delete_management(os.path.join(output_directory,"RndPts.shp")) if int(count_records) > 500: arcpy.Delete_management(os.path.join(output_directory, "SectorPoly1" + ".shp")) arcpy.Delete_management(os.path.join(output_directory, "SectorPoly2" + ".shp")) arcpy.Delete_management(os.path.join(output_directory, "SectorPoly3" + ".shp")) arcpy.Delete_management(os.path.join(output_directory, "SectorPoly4" + ".shp")) arcpy.Delete_management(os.path.join(output_directory, "SpatialJoin1" + ".shp")) arcpy.Delete_management(os.path.join(output_directory, "SpatialJoin2" + ".shp")) arcpy.Delete_management(os.path.join(output_directory, "SpatialJoin3" + ".shp")) arcpy.Delete_management(os.path.join(output_directory, "SpatialJoin4" + ".shp")) arcpy.AddMessage("....completed: " + os.path.splitext(os.path.basename(input_points))[0] + ".") arcpy.CheckInExtension('Spatial') return def dbf2csv(dbfpath, csvpath): ''' To convert .dbf file or any shapefile/featureclass to csv file Inputs: dbfpath: full path to .dbf file [input] or featureclass csvpath: full path to .csv file [output] edited from http://gis.stackexchange.com/questions/93303/bulk-convert-dbf-to-csv-in-a-folder-arcgis-10-1-using-python ''' #import csv rows = arcpy.SearchCursor(dbfpath) csvFile = csv.writer(open(csvpath, 'wb')) #output csv fieldnames = [f.name for f in arcpy.ListFields(dbfpath)] csvFile.writerow(fieldnames) for row in rows: rowlist = [] for field in fieldnames: rowlist.append(row.getValue(field)) csvFile.writerow(rowlist) def main(): tool = IntertidalToolsSpeciesPatternsAroundIslands() tool.execute(tool.getParameterInfo(), None) if __name__=='__main__': main()
mit
kaushik94/sympy
sympy/external/importtools.py
3
7520
"""Tools to assist importing optional external modules.""" from __future__ import print_function, division import sys from distutils.version import LooseVersion # Override these in the module to change the default warning behavior. # For example, you might set both to False before running the tests so that # warnings are not printed to the console, or set both to True for debugging. WARN_NOT_INSTALLED = None # Default is False WARN_OLD_VERSION = None # Default is True def __sympy_debug(): # helper function from sympy/__init__.py # We don't just import SYMPY_DEBUG from that file because we don't want to # import all of sympy just to use this module. import os debug_str = os.getenv('SYMPY_DEBUG', 'False') if debug_str in ('True', 'False'): return eval(debug_str) else: raise RuntimeError("unrecognized value for SYMPY_DEBUG: %s" % debug_str) if __sympy_debug(): WARN_OLD_VERSION = True WARN_NOT_INSTALLED = True def import_module(module, min_module_version=None, min_python_version=None, warn_not_installed=None, warn_old_version=None, module_version_attr='__version__', module_version_attr_call_args=None, __import__kwargs={}, catch=()): """ Import and return a module if it is installed. If the module is not installed, it returns None. A minimum version for the module can be given as the keyword argument min_module_version. This should be comparable against the module version. By default, module.__version__ is used to get the module version. To override this, set the module_version_attr keyword argument. If the attribute of the module to get the version should be called (e.g., module.version()), then set module_version_attr_call_args to the args such that module.module_version_attr(*module_version_attr_call_args) returns the module's version. If the module version is less than min_module_version using the Python < comparison, None will be returned, even if the module is installed. You can use this to keep from importing an incompatible older version of a module. You can also specify a minimum Python version by using the min_python_version keyword argument. This should be comparable against sys.version_info. If the keyword argument warn_not_installed is set to True, the function will emit a UserWarning when the module is not installed. If the keyword argument warn_old_version is set to True, the function will emit a UserWarning when the library is installed, but cannot be imported because of the min_module_version or min_python_version options. Note that because of the way warnings are handled, a warning will be emitted for each module only once. You can change the default warning behavior by overriding the values of WARN_NOT_INSTALLED and WARN_OLD_VERSION in sympy.external.importtools. By default, WARN_NOT_INSTALLED is False and WARN_OLD_VERSION is True. This function uses __import__() to import the module. To pass additional options to __import__(), use the __import__kwargs keyword argument. For example, to import a submodule A.B, you must pass a nonempty fromlist option to __import__. See the docstring of __import__(). This catches ImportError to determine if the module is not installed. To catch additional errors, pass them as a tuple to the catch keyword argument. Examples ======== >>> from sympy.external import import_module >>> numpy = import_module('numpy') >>> numpy = import_module('numpy', min_python_version=(2, 7), ... warn_old_version=False) >>> numpy = import_module('numpy', min_module_version='1.5', ... warn_old_version=False) # numpy.__version__ is a string >>> # gmpy does not have __version__, but it does have gmpy.version() >>> gmpy = import_module('gmpy', min_module_version='1.14', ... module_version_attr='version', module_version_attr_call_args=(), ... warn_old_version=False) >>> # To import a submodule, you must pass a nonempty fromlist to >>> # __import__(). The values do not matter. >>> p3 = import_module('mpl_toolkits.mplot3d', ... __import__kwargs={'fromlist':['something']}) >>> # matplotlib.pyplot can raise RuntimeError when the display cannot be opened >>> matplotlib = import_module('matplotlib', ... __import__kwargs={'fromlist':['pyplot']}, catch=(RuntimeError,)) """ # keyword argument overrides default, and global variable overrides # keyword argument. warn_old_version = (WARN_OLD_VERSION if WARN_OLD_VERSION is not None else warn_old_version or True) warn_not_installed = (WARN_NOT_INSTALLED if WARN_NOT_INSTALLED is not None else warn_not_installed or False) import warnings # Check Python first so we don't waste time importing a module we can't use if min_python_version: if sys.version_info < min_python_version: if warn_old_version: warnings.warn("Python version is too old to use %s " "(%s or newer required)" % ( module, '.'.join(map(str, min_python_version))), UserWarning, stacklevel=2) return # PyPy 1.6 has rudimentary NumPy support and importing it produces errors, so skip it if module == 'numpy' and '__pypy__' in sys.builtin_module_names: return try: mod = __import__(module, **__import__kwargs) ## there's something funny about imports with matplotlib and py3k. doing ## from matplotlib import collections ## gives python's stdlib collections module. explicitly re-importing ## the module fixes this. from_list = __import__kwargs.get('fromlist', tuple()) for submod in from_list: if submod == 'collections' and mod.__name__ == 'matplotlib': __import__(module + '.' + submod) except ImportError: if warn_not_installed: warnings.warn("%s module is not installed" % module, UserWarning, stacklevel=2) return except catch as e: if warn_not_installed: warnings.warn( "%s module could not be used (%s)" % (module, repr(e)), stacklevel=2) return if min_module_version: modversion = getattr(mod, module_version_attr) if module_version_attr_call_args is not None: modversion = modversion(*module_version_attr_call_args) if LooseVersion(modversion) < LooseVersion(min_module_version): if warn_old_version: # Attempt to create a pretty string version of the version from ..core.compatibility import string_types if isinstance(min_module_version, string_types): verstr = min_module_version elif isinstance(min_module_version, (tuple, list)): verstr = '.'.join(map(str, min_module_version)) else: # Either don't know what this is. Hopefully # it's something that has a nice str version, like an int. verstr = str(min_module_version) warnings.warn("%s version is too old to use " "(%s or newer required)" % (module, verstr), UserWarning, stacklevel=2) return return mod
bsd-3-clause
snowicecat/umich-eecs445-f16
lecture07_naive-bayes/Lec07.py
2
5343
# plotting from matplotlib import pyplot as plt; from matplotlib import colors import matplotlib as mpl; from mpl_toolkits.mplot3d import Axes3D if "bmh" in plt.style.available: plt.style.use("bmh"); # matplotlib objects from matplotlib import mlab; from matplotlib import gridspec; # scientific import numpy as np; import scipy as scp; from scipy import linalg import scipy.stats; # table display import pandas as pd from IPython.display import display # python import random; # warnings import warnings warnings.filterwarnings("ignore") # rise config from notebook.services.config import ConfigManager cm = ConfigManager() cm.update('livereveal', { 'theme': 'simple', 'start_slideshow_at': 'selected', 'transition':'fade', 'scroll': False }); def lin_reg_classifier(means, covs, n, outliers): """ Least Squares for Classification. :Parameters: - `means`: means of multivariate normal distributions used to generate data. - `covs`: terms of variance-covariance matrix used to determine spread of simulated data. - `n`: number of samples. - `outliers`: user-specified outliers to be added to the second simulated dataset. """ # generate data x1, y1 = np.random.multivariate_normal(means[0], covs[0], n[0]).T x2, y2 = np.random.multivariate_normal(means[1], covs[1], n[1]).T # add targets class_1 = [1]*n[0] + [0]*n[1] class_2 = [0]*n[0] + [1]*n[1] T = np.mat([class_1, class_2]).T # add intercept and merge data ones = np.ones(n[0]+n[1]) a = np.hstack((x1,x2)) b = np.hstack((y1,y2)) X = np.mat([ones, a, b]).T # obtain weights w_t = np.dot(T.T, np.linalg.pinv(X).T) # obtain decision line decision_line_int = -(w_t.item((0,0)) - w_t.item((1,0)))/(w_t.item((0,2)) - w_t.item((1,2))) decision_line_slope = - (w_t.item((0,1)) - w_t.item((1,1)))/(w_t.item((0,2)) - w_t.item((1,2))) # add outliers to the second set of simulated data extract_x = [] extract_y = [] for i in outliers: extract_x.append(i[0]) extract_y.append(i[1]) x2_out = np.hstack((x2, extract_x)) y2_out = np.hstack((y2, extract_y)) class_1_out = [1]*n[0] + [0]*n[1] + [0]*len(outliers) class_2_out = [0]*n[0] + [1]*n[1] + [1]*len(outliers) T_out = np.array([class_1_out, class_2_out]).T ones_out = np.ones(n[0]+n[1]+len(outliers)) a_out = np.hstack((x1,x2_out)) b_out = np.hstack((y1,y2_out)) X_out = np.array([ones_out, a_out, b_out]).T # obtain revised weights and decision line w_t_out = np.dot(T_out.T, np.linalg.pinv(X_out).T) decision_line_int_out = -(w_t_out[0][0] - w_t_out[1][0])/(w_t_out[0][2] - w_t_out[1][2]) decision_line_slope_out = - (w_t_out[0][1] - w_t_out[1][1])/(w_t_out[0][2] - w_t_out[1][2]) # plot results x = np.linspace(np.min(a_out)-3 , np.max(a_out)+3, 100) fig, (ax1, ax2) = plt.subplots(1, 2, sharex=False, sharey=True) plt.suptitle('Least Squares for Classification') ax1.plot(x, decision_line_int+decision_line_slope*x, 'k', linewidth=2) ax1.plot(x1, y1, 'go', x2, y2, 'bs', alpha=0.4) ax2.plot(x, decision_line_int_out+decision_line_slope_out*x, 'k', linewidth=2) ax2.plot(x1, y1, 'go', x2, y2, 'bs', alpha=0.4) for i in range(len(outliers)): ax2.plot(outliers[i][0], outliers[i][1], 'bs', alpha=0.4) fig.set_size_inches(15, 5, forward=True) ax1.set_xlim([np.min(a_out)-1, np.max(a_out)+1,]) ax2.set_xlim([np.min(a_out)-1, np.max(a_out)+1]) ax1.set_ylim([np.min(b_out)-1, np.max(b_out)+1,]) ax2.set_ylim([np.min(b_out)-1, np.max(b_out)+1]) ax1.set_xlabel('X1') ax2.set_xlabel('X1') ax1.set_ylabel('X2') plt.show() def generate_gda(means, covs, num_samples): num_classes = len(means); num_samples //= num_classes; # cheat and draw equal number of samples from each gaussian samples = [ np.random.multivariate_normal(means[c],covs[c],num_samples).T for c in range(num_classes) ]; return np.concatenate(samples, axis=1); def plot_decision_contours(means, covs): # plt fig = plt.figure(figsize=(10,6)); ax = fig.gca(); # generate samples data_x,data_y = generate_gda(means, covs, 1000); ax.plot(data_x, data_y, 'x'); # dimensions min_x, max_x = -10,10; min_y, max_y = -10,10; # grid delta = 0.025 x = np.arange(min_x, max_x, delta); y = np.arange(min_y, max_y, delta); X, Y = np.meshgrid(x, y); # bivariate difference of gaussians mu1,mu2 = means; sigma1, sigma2 = covs; Z1 = mlab.bivariate_normal(X, Y, sigmax=sigma1[0][0], sigmay=sigma1[1][1], mux=mu1[0], muy=mu1[1], sigmaxy=sigma1[0][1]); Z2 = mlab.bivariate_normal(X, Y, sigmax=sigma2[0][0], sigmay=sigma2[1][1], mux=mu2[0], muy=mu2[1], sigmaxy=sigma2[0][1]); Z = Z2 - Z1; # contour plot ax.contour(X, Y, Z, levels=np.linspace(np.min(Z),np.max(Z),10)); cs = ax.contour(X, Y, Z, levels=[0], c="k", linewidths=5); plt.clabel(cs, fontsize=10, inline=1, fmt='%1.3f') # plot settings ax.set_xlim((min_x,max_x)); ax.set_ylim((min_y,max_y)); # ax.set_title("Gaussian Discriminant Analysis: $P(y=1 | x) - P(y=0 | x)$", fontsize=20) ax.set_title("Countours: $P(y=1 | x) - P(y=0 | x)$", fontsize=20)
mit
JeanKossaifi/scikit-learn
examples/calibration/plot_calibration_curve.py
225
5903
""" ============================== Probability Calibration curves ============================== When performing classification one often wants to predict not only the class label, but also the associated probability. This probability gives some kind of confidence on the prediction. This example demonstrates how to display how well calibrated the predicted probabilities are and how to calibrate an uncalibrated classifier. The experiment is performed on an artificial dataset for binary classification with 100.000 samples (1.000 of them are used for model fitting) with 20 features. Of the 20 features, only 2 are informative and 10 are redundant. The first figure shows the estimated probabilities obtained with logistic regression, Gaussian naive Bayes, and Gaussian naive Bayes with both isotonic calibration and sigmoid calibration. The calibration performance is evaluated with Brier score, reported in the legend (the smaller the better). One can observe here that logistic regression is well calibrated while raw Gaussian naive Bayes performs very badly. This is because of the redundant features which violate the assumption of feature-independence and result in an overly confident classifier, which is indicated by the typical transposed-sigmoid curve. Calibration of the probabilities of Gaussian naive Bayes with isotonic regression can fix this issue as can be seen from the nearly diagonal calibration curve. Sigmoid calibration also improves the brier score slightly, albeit not as strongly as the non-parametric isotonic regression. This can be attributed to the fact that we have plenty of calibration data such that the greater flexibility of the non-parametric model can be exploited. The second figure shows the calibration curve of a linear support-vector classifier (LinearSVC). LinearSVC shows the opposite behavior as Gaussian naive Bayes: the calibration curve has a sigmoid curve, which is typical for an under-confident classifier. In the case of LinearSVC, this is caused by the margin property of the hinge loss, which lets the model focus on hard samples that are close to the decision boundary (the support vectors). Both kinds of calibration can fix this issue and yield nearly identical results. This shows that sigmoid calibration can deal with situations where the calibration curve of the base classifier is sigmoid (e.g., for LinearSVC) but not where it is transposed-sigmoid (e.g., Gaussian naive Bayes). """ print(__doc__) # Author: Alexandre Gramfort <[email protected]> # Jan Hendrik Metzen <[email protected]> # License: BSD Style. import matplotlib.pyplot as plt from sklearn import datasets from sklearn.naive_bayes import GaussianNB from sklearn.svm import LinearSVC from sklearn.linear_model import LogisticRegression from sklearn.metrics import (brier_score_loss, precision_score, recall_score, f1_score) from sklearn.calibration import CalibratedClassifierCV, calibration_curve from sklearn.cross_validation import train_test_split # Create dataset of classification task with many redundant and few # informative features X, y = datasets.make_classification(n_samples=100000, n_features=20, n_informative=2, n_redundant=10, random_state=42) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.99, random_state=42) def plot_calibration_curve(est, name, fig_index): """Plot calibration curve for est w/o and with calibration. """ # Calibrated with isotonic calibration isotonic = CalibratedClassifierCV(est, cv=2, method='isotonic') # Calibrated with sigmoid calibration sigmoid = CalibratedClassifierCV(est, cv=2, method='sigmoid') # Logistic regression with no calibration as baseline lr = LogisticRegression(C=1., solver='lbfgs') fig = plt.figure(fig_index, figsize=(10, 10)) ax1 = plt.subplot2grid((3, 1), (0, 0), rowspan=2) ax2 = plt.subplot2grid((3, 1), (2, 0)) ax1.plot([0, 1], [0, 1], "k:", label="Perfectly calibrated") for clf, name in [(lr, 'Logistic'), (est, name), (isotonic, name + ' + Isotonic'), (sigmoid, name + ' + Sigmoid')]: clf.fit(X_train, y_train) y_pred = clf.predict(X_test) if hasattr(clf, "predict_proba"): prob_pos = clf.predict_proba(X_test)[:, 1] else: # use decision function prob_pos = clf.decision_function(X_test) prob_pos = \ (prob_pos - prob_pos.min()) / (prob_pos.max() - prob_pos.min()) clf_score = brier_score_loss(y_test, prob_pos, pos_label=y.max()) print("%s:" % name) print("\tBrier: %1.3f" % (clf_score)) print("\tPrecision: %1.3f" % precision_score(y_test, y_pred)) print("\tRecall: %1.3f" % recall_score(y_test, y_pred)) print("\tF1: %1.3f\n" % f1_score(y_test, y_pred)) fraction_of_positives, mean_predicted_value = \ calibration_curve(y_test, prob_pos, n_bins=10) ax1.plot(mean_predicted_value, fraction_of_positives, "s-", label="%s (%1.3f)" % (name, clf_score)) ax2.hist(prob_pos, range=(0, 1), bins=10, label=name, histtype="step", lw=2) ax1.set_ylabel("Fraction of positives") ax1.set_ylim([-0.05, 1.05]) ax1.legend(loc="lower right") ax1.set_title('Calibration plots (reliability curve)') ax2.set_xlabel("Mean predicted value") ax2.set_ylabel("Count") ax2.legend(loc="upper center", ncol=2) plt.tight_layout() # Plot calibration cuve for Gaussian Naive Bayes plot_calibration_curve(GaussianNB(), "Naive Bayes", 1) # Plot calibration cuve for Linear SVC plot_calibration_curve(LinearSVC(), "SVC", 2) plt.show()
bsd-3-clause
GunoH/intellij-community
python/helpers/pycharm_matplotlib_backend/backend_interagg.py
10
3831
import base64 import matplotlib import os import sys from matplotlib._pylab_helpers import Gcf from matplotlib.backend_bases import FigureManagerBase, ShowBase from matplotlib.backends.backend_agg import FigureCanvasAgg from matplotlib.figure import Figure from datalore.display import debug, display, SHOW_DEBUG_INFO PY3 = sys.version_info[0] >= 3 index = int(os.getenv("PYCHARM_MATPLOTLIB_INDEX", 0)) rcParams = matplotlib.rcParams class Show(ShowBase): def __call__(self, **kwargs): debug("show() called with args %s" % kwargs) managers = Gcf.get_all_fig_managers() if not managers: debug("Error: Managers list in `Gcf.get_all_fig_managers()` is empty") return for manager in managers: manager.show(**kwargs) def mainloop(self): pass show = Show() # from pyplot API def draw_if_interactive(): if matplotlib.is_interactive(): figManager = Gcf.get_active() if figManager is not None: figManager.canvas.show() else: debug("Error: Figure manager `Gcf.get_active()` is None") # from pyplot API def new_figure_manager(num, *args, **kwargs): FigureClass = kwargs.pop('FigureClass', Figure) figure = FigureClass(*args, **kwargs) return new_figure_manager_given_figure(num, figure) # from pyplot API def new_figure_manager_given_figure(num, figure): canvas = FigureCanvasInterAgg(figure) manager = FigureManagerInterAgg(canvas, num) return manager # from pyplot API class FigureCanvasInterAgg(FigureCanvasAgg): def __init__(self, figure): FigureCanvasAgg.__init__(self, figure) def show(self): FigureCanvasAgg.draw(self) if matplotlib.__version__ < '1.2': buffer = self.tostring_rgb(0, 0) else: buffer = self.tostring_rgb() if len(set(buffer)) <= 1: # do not plot empty debug("Error: Buffer FigureCanvasAgg.tostring_rgb() is empty") return render = self.get_renderer() width = int(render.width) debug("Image width: %d" % width) is_interactive = os.getenv("PYCHARM_MATPLOTLIB_INTERACTIVE", False) if is_interactive: debug("Using interactive mode (Run with Python Console)") debug("Plot index = %d" % index) else: debug("Using non-interactive mode (Run without Python Console)") plot_index = index if is_interactive else -1 display(DisplayDataObject(plot_index, width, buffer)) def draw(self): FigureCanvasAgg.draw(self) is_interactive = os.getenv("PYCHARM_MATPLOTLIB_INTERACTIVE", False) if is_interactive and matplotlib.is_interactive(): self.show() else: debug("Error: calling draw() in non-interactive mode won't show a plot. Try to 'Run with Python Console'") class FigureManagerInterAgg(FigureManagerBase): def __init__(self, canvas, num): FigureManagerBase.__init__(self, canvas, num) global index index += 1 self.canvas = canvas self._num = num self._shown = False def show(self, **kwargs): self.canvas.show() Gcf.destroy(self._num) class DisplayDataObject: def __init__(self, plot_index, width, image_bytes): self.plot_index = plot_index self.image_width = width self.image_bytes = image_bytes def _repr_display_(self): image_bytes_base64 = base64.b64encode(self.image_bytes) if PY3: image_bytes_base64 = image_bytes_base64.decode() body = { 'plot_index': self.plot_index, 'image_width': self.image_width, 'image_base64': image_bytes_base64 } return ('pycharm-plot-image', body)
apache-2.0
dyoung418/tensorflow
tensorflow/examples/learn/iris_run_config.py
76
2565
# Copyright 2016 The TensorFlow Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Example of DNNClassifier for Iris plant dataset, with run config.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function import numpy as np from sklearn import datasets from sklearn import metrics from sklearn import model_selection import tensorflow as tf X_FEATURE = 'x' # Name of the input feature. def main(unused_argv): # Load dataset. iris = datasets.load_iris() x_train, x_test, y_train, y_test = model_selection.train_test_split( iris.data, iris.target, test_size=0.2, random_state=42) # You can define you configurations by providing a RunConfig object to # estimator to control session configurations, e.g. tf_random_seed. run_config = tf.estimator.RunConfig().replace(tf_random_seed=1) # Build 3 layer DNN with 10, 20, 10 units respectively. feature_columns = [ tf.feature_column.numeric_column( X_FEATURE, shape=np.array(x_train).shape[1:])] classifier = tf.estimator.DNNClassifier( feature_columns=feature_columns, hidden_units=[10, 20, 10], n_classes=3, config=run_config) # Train. train_input_fn = tf.estimator.inputs.numpy_input_fn( x={X_FEATURE: x_train}, y=y_train, num_epochs=None, shuffle=True) classifier.train(input_fn=train_input_fn, steps=200) # Predict. test_input_fn = tf.estimator.inputs.numpy_input_fn( x={X_FEATURE: x_test}, y=y_test, num_epochs=1, shuffle=False) predictions = classifier.predict(input_fn=test_input_fn) y_predicted = np.array(list(p['class_ids'] for p in predictions)) y_predicted = y_predicted.reshape(np.array(y_test).shape) # Score with sklearn. score = metrics.accuracy_score(y_test, y_predicted) print('Accuracy (sklearn): {0:f}'.format(score)) # Score with tensorflow. scores = classifier.evaluate(input_fn=test_input_fn) print('Accuracy (tensorflow): {0:f}'.format(scores['accuracy'])) if __name__ == '__main__': tf.app.run()
apache-2.0
joshloyal/scikit-learn
examples/ensemble/plot_ensemble_oob.py
58
3265
""" ============================= OOB Errors for Random Forests ============================= The ``RandomForestClassifier`` is trained using *bootstrap aggregation*, where each new tree is fit from a bootstrap sample of the training observations :math:`z_i = (x_i, y_i)`. The *out-of-bag* (OOB) error is the average error for each :math:`z_i` calculated using predictions from the trees that do not contain :math:`z_i` in their respective bootstrap sample. This allows the ``RandomForestClassifier`` to be fit and validated whilst being trained [1]. The example below demonstrates how the OOB error can be measured at the addition of each new tree during training. The resulting plot allows a practitioner to approximate a suitable value of ``n_estimators`` at which the error stabilizes. .. [1] T. Hastie, R. Tibshirani and J. Friedman, "Elements of Statistical Learning Ed. 2", p592-593, Springer, 2009. """ import matplotlib.pyplot as plt from collections import OrderedDict from sklearn.datasets import make_classification from sklearn.ensemble import RandomForestClassifier, ExtraTreesClassifier # Author: Kian Ho <[email protected]> # Gilles Louppe <[email protected]> # Andreas Mueller <[email protected]> # # License: BSD 3 Clause print(__doc__) RANDOM_STATE = 123 # Generate a binary classification dataset. X, y = make_classification(n_samples=500, n_features=25, n_clusters_per_class=1, n_informative=15, random_state=RANDOM_STATE) # NOTE: Setting the `warm_start` construction parameter to `True` disables # support for parallelized ensembles but is necessary for tracking the OOB # error trajectory during training. ensemble_clfs = [ ("RandomForestClassifier, max_features='sqrt'", RandomForestClassifier(warm_start=True, oob_score=True, max_features="sqrt", random_state=RANDOM_STATE)), ("RandomForestClassifier, max_features='log2'", RandomForestClassifier(warm_start=True, max_features='log2', oob_score=True, random_state=RANDOM_STATE)), ("RandomForestClassifier, max_features=None", RandomForestClassifier(warm_start=True, max_features=None, oob_score=True, random_state=RANDOM_STATE)) ] # Map a classifier name to a list of (<n_estimators>, <error rate>) pairs. error_rate = OrderedDict((label, []) for label, _ in ensemble_clfs) # Range of `n_estimators` values to explore. min_estimators = 15 max_estimators = 175 for label, clf in ensemble_clfs: for i in range(min_estimators, max_estimators + 1): clf.set_params(n_estimators=i) clf.fit(X, y) # Record the OOB error for each `n_estimators=i` setting. oob_error = 1 - clf.oob_score_ error_rate[label].append((i, oob_error)) # Generate the "OOB error rate" vs. "n_estimators" plot. for label, clf_err in error_rate.items(): xs, ys = zip(*clf_err) plt.plot(xs, ys, label=label) plt.xlim(min_estimators, max_estimators) plt.xlabel("n_estimators") plt.ylabel("OOB error rate") plt.legend(loc="upper right") plt.show()
bsd-3-clause
mugizico/scikit-learn
examples/preprocessing/plot_robust_scaling.py
221
2702
#!/usr/bin/python # -*- coding: utf-8 -*- """ ========================================================= Robust Scaling on Toy Data ========================================================= Making sure that each Feature has approximately the same scale can be a crucial preprocessing step. However, when data contains outliers, :class:`StandardScaler <sklearn.preprocessing.StandardScaler>` can often be mislead. In such cases, it is better to use a scaler that is robust against outliers. Here, we demonstrate this on a toy dataset, where one single datapoint is a large outlier. """ from __future__ import print_function print(__doc__) # Code source: Thomas Unterthiner # License: BSD 3 clause import matplotlib.pyplot as plt import numpy as np from sklearn.preprocessing import StandardScaler, RobustScaler # Create training and test data np.random.seed(42) n_datapoints = 100 Cov = [[0.9, 0.0], [0.0, 20.0]] mu1 = [100.0, -3.0] mu2 = [101.0, -3.0] X1 = np.random.multivariate_normal(mean=mu1, cov=Cov, size=n_datapoints) X2 = np.random.multivariate_normal(mean=mu2, cov=Cov, size=n_datapoints) Y_train = np.hstack([[-1]*n_datapoints, [1]*n_datapoints]) X_train = np.vstack([X1, X2]) X1 = np.random.multivariate_normal(mean=mu1, cov=Cov, size=n_datapoints) X2 = np.random.multivariate_normal(mean=mu2, cov=Cov, size=n_datapoints) Y_test = np.hstack([[-1]*n_datapoints, [1]*n_datapoints]) X_test = np.vstack([X1, X2]) X_train[0, 0] = -1000 # a fairly large outlier # Scale data standard_scaler = StandardScaler() Xtr_s = standard_scaler.fit_transform(X_train) Xte_s = standard_scaler.transform(X_test) robust_scaler = RobustScaler() Xtr_r = robust_scaler.fit_transform(X_train) Xte_r = robust_scaler.fit_transform(X_test) # Plot data fig, ax = plt.subplots(1, 3, figsize=(12, 4)) ax[0].scatter(X_train[:, 0], X_train[:, 1], color=np.where(Y_train > 0, 'r', 'b')) ax[1].scatter(Xtr_s[:, 0], Xtr_s[:, 1], color=np.where(Y_train > 0, 'r', 'b')) ax[2].scatter(Xtr_r[:, 0], Xtr_r[:, 1], color=np.where(Y_train > 0, 'r', 'b')) ax[0].set_title("Unscaled data") ax[1].set_title("After standard scaling (zoomed in)") ax[2].set_title("After robust scaling (zoomed in)") # for the scaled data, we zoom in to the data center (outlier can't be seen!) for a in ax[1:]: a.set_xlim(-3, 3) a.set_ylim(-3, 3) plt.tight_layout() plt.show() # Classify using k-NN from sklearn.neighbors import KNeighborsClassifier knn = KNeighborsClassifier() knn.fit(Xtr_s, Y_train) acc_s = knn.score(Xte_s, Y_test) print("Testset accuracy using standard scaler: %.3f" % acc_s) knn.fit(Xtr_r, Y_train) acc_r = knn.score(Xte_r, Y_test) print("Testset accuracy using robust scaler: %.3f" % acc_r)
bsd-3-clause
spennihana/h2o-3
h2o-py/tests/testdir_algos/gbm/pyunit_weights_gbm.py
6
9236
from __future__ import print_function from builtins import zip from builtins import range import sys sys.path.insert(1,"../../../") import h2o from tests import pyunit_utils import random from h2o.estimators.gbm import H2OGradientBoostingEstimator def weights_check(): def check_same(data1, data2, min_rows_scale): gbm1_regression = H2OGradientBoostingEstimator(min_rows=20, ntrees=5, seed=20, max_depth=4) gbm1_regression.train(x=["displacement", "power", "weight", "acceleration", "year"], y="economy", training_frame=data1) gbm2_regression = H2OGradientBoostingEstimator(min_rows=20*min_rows_scale, ntrees=5, seed=20, max_depth=4) gbm2_regression.train(x=["displacement", "power", "weight", "acceleration", "year"], y="economy", training_frame=data2, weights_column="weights") gbm1_binomial = H2OGradientBoostingEstimator(min_rows=20, distribution="bernoulli", ntrees=5, seed=20, max_depth=4) gbm1_binomial.train(x=["displacement", "power", "weight", "acceleration", "year"], y="economy_20mpg", training_frame=data1) gbm2_binomial = H2OGradientBoostingEstimator(min_rows=20*min_rows_scale, distribution="bernoulli", ntrees=5, seed=20, max_depth=4) gbm2_binomial.train(x=["displacement", "power", "weight", "acceleration", "year"], y="economy_20mpg", training_frame=data2, weights_column="weights") gbm1_multinomial = H2OGradientBoostingEstimator(min_rows=20, distribution="multinomial", ntrees=5, seed=20, max_depth=4) gbm1_multinomial.train(x=["displacement", "power", "weight", "acceleration", "year"], y="cylinders", training_frame=data1) gbm2_multinomial = H2OGradientBoostingEstimator(min_rows=20*min_rows_scale, distribution="multinomial", ntrees=5, seed=20, max_depth=4) gbm2_multinomial.train(x=["displacement", "power", "weight", "acceleration", "year"], y="cylinders", weights_column="weights", training_frame=data2) reg1_mse = gbm1_regression.mse() reg2_mse = gbm2_regression.mse() bin1_auc = gbm1_binomial.auc() bin2_auc = gbm2_binomial.auc() mul1_mse = gbm1_multinomial.mse() mul2_mse = gbm2_multinomial.mse() print("MSE (regresson) no weights vs. weights: {0}, {1}".format(reg1_mse, reg2_mse)) print("AUC (binomial) no weights vs. weights: {0}, {1}".format(bin1_auc, bin2_auc)) print("MSE (multinomial) no weights vs. weights: {0}, {1}".format(mul1_mse, mul2_mse)) assert abs(reg1_mse - reg2_mse) < 1e-5 * reg1_mse, "Expected mse's to be the same, but got {0}, and {1}".format(reg1_mse, reg2_mse) assert abs(bin1_auc - bin2_auc) < 3e-3 * bin1_auc, "Expected auc's to be the same, but got {0}, and {1}".format(bin1_auc, bin2_auc) assert abs(mul1_mse - mul1_mse) < 1e-6 * mul1_mse, "Expected auc's to be the same, but got {0}, and {1}".format(mul1_mse, mul2_mse) h2o_cars_data = h2o.import_file(pyunit_utils.locate("smalldata/junit/cars_20mpg.csv")) h2o_cars_data["economy_20mpg"] = h2o_cars_data["economy_20mpg"].asfactor() h2o_cars_data["cylinders"] = h2o_cars_data["cylinders"].asfactor() # uniform weights same as no weights random.seed(2222) weight = 3 # random.randint(1,10) # PY3 hackt uniform_weights = [[weight]] *406 h2o_uniform_weights = h2o.H2OFrame(uniform_weights) h2o_uniform_weights.set_names(["weights"]) h2o_data_uniform_weights = h2o_cars_data.cbind(h2o_uniform_weights) print("Checking that using uniform weights is equivalent to no weights:") print() check_same(h2o_cars_data, h2o_data_uniform_weights, weight) # zero weights same as removed observations zero_weights = [[1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0]] # [[0 if random.randint(0,1) else 1 for r in range(406)]] h2o_zero_weights = h2o.H2OFrame(list(zip(*zero_weights))) h2o_zero_weights.set_names(["weights"]) h2o_data_zero_weights = h2o_cars_data.cbind(h2o_zero_weights) h2o_data_zeros_removed = h2o_cars_data[h2o_zero_weights["weights"] == 1] print("Checking that using some zero weights is equivalent to removing those observations:") print() check_same(h2o_data_zeros_removed, h2o_data_zero_weights, 1) # doubled weights same as doubled observations doubled_weights = [[1, 1, 1, 2, 2, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 2, 2, 1, 1, 2, 2, 1, 1, 1, 1, 2, 1, 2, 2, 2, 2, 2, 2, 2, 1, 2, 1, 2, 2, 2, 1, 1, 2, 2, 1, 2, 2, 1, 2, 1, 1, 2, 2, 2, 1, 1, 2, 1, 2, 2, 2, 1, 1, 2, 1, 2, 2, 1, 1, 1, 2, 2, 2, 1, 2, 1, 2, 2, 1, 1, 1, 1, 2, 1, 1, 2, 2, 1, 2, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 2, 1, 2, 1, 1, 2, 2, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 2, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 2, 1, 2, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 2, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 2, 1, 2, 2, 2, 1, 1, 1, 1, 1, 2, 2, 1, 2, 1, 1, 1, 1, 1, 2, 2, 1, 2, 2, 2, 2, 2, 1, 1, 2, 2, 2, 1, 2, 2, 2, 1, 1, 2, 1, 2, 2, 1, 1, 2, 2, 2, 1, 2, 1, 1, 1, 2, 1, 2, 1, 1, 2, 1, 1, 1, 2, 1, 2, 2, 2, 2, 1, 2, 1, 1, 1, 2, 1, 2, 2, 2, 2, 1, 1, 1, 2, 1, 1, 2, 2, 1, 1, 1, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 1, 1, 2, 2, 1, 2, 2, 2, 1, 2, 1, 2, 2, 2, 1, 2, 1, 2, 1, 2, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 1, 2, 1, 1, 1, 2, 2, 1, 2, 2, 2, 2, 2, 1, 2, 1, 1, 1, 1, 2, 1, 1, 2, 2, 2, 1, 1, 2, 2, 2, 1, 2, 1, 2, 2, 2, 2, 1, 2, 1, 2, 1, 2, 2, 1, 2, 2, 1, 2, 1, 2, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 2, 2, 1, 1, 2, 1]] # [[1 if random.randint(0,1) else 2 for r in range(406)]] h2o_doubled_weights = h2o.H2OFrame(list(zip(*doubled_weights))) h2o_doubled_weights.set_names(["weights"]) h2o_data_doubled_weights = h2o_cars_data.cbind(h2o_doubled_weights) doubled_data = h2o.as_list(h2o_cars_data, use_pandas=False) colnames = doubled_data.pop(0) for idx, w in enumerate(doubled_weights[0]): if w == 2: doubled_data.append(doubled_data[idx]) h2o_data_doubled = h2o.H2OFrame(doubled_data) h2o_data_doubled.set_names(list(colnames)) h2o_data_doubled["economy_20mpg"] = h2o_data_doubled["economy_20mpg"].asfactor() h2o_data_doubled["cylinders"] = h2o_data_doubled["cylinders"].asfactor() h2o_data_doubled_weights["economy_20mpg"] = h2o_data_doubled_weights["economy_20mpg"].asfactor() h2o_data_doubled_weights["cylinders"] = h2o_data_doubled_weights["cylinders"].asfactor() print("Checking that doubling some weights is equivalent to doubling those observations:") print() check_same(h2o_data_doubled, h2o_data_doubled_weights, 1) # TODO: random weights # TODO: all zero weights??? # TODO: negative weights??? if __name__ == "__main__": pyunit_utils.standalone_test(weights_check) else: weights_check()
apache-2.0
0x0all/nupic
external/linux32/lib/python2.6/site-packages/matplotlib/fontconfig_pattern.py
72
6429
""" A module for parsing and generating fontconfig patterns. See the `fontconfig pattern specification <http://www.fontconfig.org/fontconfig-user.html>`_ for more information. """ # Author : Michael Droettboom <[email protected]> # License : matplotlib license (PSF compatible) # This class is defined here because it must be available in: # - The old-style config framework (:file:`rcsetup.py`) # - The traits-based config framework (:file:`mpltraits.py`) # - The font manager (:file:`font_manager.py`) # It probably logically belongs in :file:`font_manager.py`, but # placing it in any of these places would have created cyclical # dependency problems, or an undesired dependency on traits even # when the traits-based config framework is not used. import re from matplotlib.pyparsing import Literal, ZeroOrMore, \ Optional, Regex, StringEnd, ParseException, Suppress family_punc = r'\\\-:,' family_unescape = re.compile(r'\\([%s])' % family_punc).sub family_escape = re.compile(r'([%s])' % family_punc).sub value_punc = r'\\=_:,' value_unescape = re.compile(r'\\([%s])' % value_punc).sub value_escape = re.compile(r'([%s])' % value_punc).sub class FontconfigPatternParser: """A simple pyparsing-based parser for fontconfig-style patterns. See the `fontconfig pattern specification <http://www.fontconfig.org/fontconfig-user.html>`_ for more information. """ _constants = { 'thin' : ('weight', 'light'), 'extralight' : ('weight', 'light'), 'ultralight' : ('weight', 'light'), 'light' : ('weight', 'light'), 'book' : ('weight', 'book'), 'regular' : ('weight', 'regular'), 'normal' : ('weight', 'normal'), 'medium' : ('weight', 'medium'), 'demibold' : ('weight', 'demibold'), 'semibold' : ('weight', 'semibold'), 'bold' : ('weight', 'bold'), 'extrabold' : ('weight', 'extra bold'), 'black' : ('weight', 'black'), 'heavy' : ('weight', 'heavy'), 'roman' : ('slant', 'normal'), 'italic' : ('slant', 'italic'), 'oblique' : ('slant', 'oblique'), 'ultracondensed' : ('width', 'ultra-condensed'), 'extracondensed' : ('width', 'extra-condensed'), 'condensed' : ('width', 'condensed'), 'semicondensed' : ('width', 'semi-condensed'), 'expanded' : ('width', 'expanded'), 'extraexpanded' : ('width', 'extra-expanded'), 'ultraexpanded' : ('width', 'ultra-expanded') } def __init__(self): family = Regex(r'([^%s]|(\\[%s]))*' % (family_punc, family_punc)) \ .setParseAction(self._family) size = Regex(r"([0-9]+\.?[0-9]*|\.[0-9]+)") \ .setParseAction(self._size) name = Regex(r'[a-z]+') \ .setParseAction(self._name) value = Regex(r'([^%s]|(\\[%s]))*' % (value_punc, value_punc)) \ .setParseAction(self._value) families =(family + ZeroOrMore( Literal(',') + family) ).setParseAction(self._families) point_sizes =(size + ZeroOrMore( Literal(',') + size) ).setParseAction(self._point_sizes) property =( (name + Suppress(Literal('=')) + value + ZeroOrMore( Suppress(Literal(',')) + value) ) | name ).setParseAction(self._property) pattern =(Optional( families) + Optional( Literal('-') + point_sizes) + ZeroOrMore( Literal(':') + property) + StringEnd() ) self._parser = pattern self.ParseException = ParseException def parse(self, pattern): """ Parse the given fontconfig *pattern* and return a dictionary of key/value pairs useful for initializing a :class:`font_manager.FontProperties` object. """ props = self._properties = {} try: self._parser.parseString(pattern) except self.ParseException, e: raise ValueError("Could not parse font string: '%s'\n%s" % (pattern, e)) self._properties = None return props def _family(self, s, loc, tokens): return [family_unescape(r'\1', str(tokens[0]))] def _size(self, s, loc, tokens): return [float(tokens[0])] def _name(self, s, loc, tokens): return [str(tokens[0])] def _value(self, s, loc, tokens): return [value_unescape(r'\1', str(tokens[0]))] def _families(self, s, loc, tokens): self._properties['family'] = [str(x) for x in tokens] return [] def _point_sizes(self, s, loc, tokens): self._properties['size'] = [str(x) for x in tokens] return [] def _property(self, s, loc, tokens): if len(tokens) == 1: if tokens[0] in self._constants: key, val = self._constants[tokens[0]] self._properties.setdefault(key, []).append(val) else: key = tokens[0] val = tokens[1:] self._properties.setdefault(key, []).extend(val) return [] parse_fontconfig_pattern = FontconfigPatternParser().parse def generate_fontconfig_pattern(d): """ Given a dictionary of key/value pairs, generates a fontconfig pattern string. """ props = [] families = '' size = '' for key in 'family style variant weight stretch file size'.split(): val = getattr(d, 'get_' + key)() if val is not None and val != []: if type(val) == list: val = [value_escape(r'\\\1', str(x)) for x in val if x is not None] if val != []: val = ','.join(val) props.append(":%s=%s" % (key, val)) return ''.join(props)
gpl-3.0
josephcslater/scipy
tools/refguide_check.py
4
29462
#!/usr/bin/env python """ refguide_check.py [OPTIONS] [-- ARGS] Check for a Scipy submodule whether the objects in its __all__ dict correspond to the objects included in the reference guide. Example of usage:: $ python refguide_check.py optimize Note that this is a helper script to be able to check if things are missing; the output of this script does need to be checked manually. In some cases objects are left out of the refguide for a good reason (it's an alias of another function, or deprecated, or ...) Another use of this helper script is to check validity of code samples in docstrings. This is different from doctesting [we do not aim to have scipy docstrings doctestable!], this is just to make sure that code in docstrings is valid python:: $ python refguide_check.py --doctests optimize """ from __future__ import print_function import sys import os import re import copy import inspect import warnings import doctest import tempfile import io import docutils.core from docutils.parsers.rst import directives import shutil import glob from doctest import NORMALIZE_WHITESPACE, ELLIPSIS, IGNORE_EXCEPTION_DETAIL from argparse import ArgumentParser from pkg_resources import parse_version import sphinx import numpy as np sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'doc', 'sphinxext')) from numpydoc.docscrape_sphinx import get_doc_object if parse_version(sphinx.__version__) >= parse_version('1.5'): # Enable specific Sphinx directives from sphinx.directives import SeeAlso, Only directives.register_directive('seealso', SeeAlso) directives.register_directive('only', Only) else: # Remove sphinx directives that don't run without Sphinx environment. # Sphinx < 1.5 installs all directives on import... directives._directives.pop('versionadded', None) directives._directives.pop('versionchanged', None) directives._directives.pop('moduleauthor', None) directives._directives.pop('sectionauthor', None) directives._directives.pop('codeauthor', None) directives._directives.pop('toctree', None) BASE_MODULE = "scipy" PUBLIC_SUBMODULES = [ 'cluster', 'cluster.hierarchy', 'cluster.vq', 'constants', 'fftpack', 'fftpack.convolve', 'integrate', 'interpolate', 'io', 'io.arff', 'io.wavfile', 'linalg', 'linalg.blas', 'linalg.lapack', 'linalg.interpolative', 'misc', 'ndimage', 'odr', 'optimize', 'signal', 'sparse', 'sparse.csgraph', 'sparse.linalg', 'spatial', 'spatial.distance', 'special', 'stats', 'stats.mstats', ] # Docs for these modules are included in the parent module OTHER_MODULE_DOCS = { 'fftpack.convolve': 'fftpack', 'io.wavfile': 'io', 'io.arff': 'io', } # these names are known to fail doctesting and we like to keep it that way # e.g. sometimes pseudocode is acceptable etc DOCTEST_SKIPLIST = set([ 'scipy.stats.kstwobign', # inaccurate cdf or ppf 'scipy.stats.levy_stable', 'scipy.special.sinc', # comes from numpy 'scipy.misc.who', # comes from numpy 'io.rst', # XXX: need to figure out how to deal w/ mat files ]) # these names are not required to be present in ALL despite being in # autosummary:: listing REFGUIDE_ALL_SKIPLIST = [ r'scipy\.sparse\.csgraph', r'scipy\.sparse\.linalg', r'scipy\.spatial\.distance', r'scipy\.linalg\.blas\.[sdczi].*', r'scipy\.linalg\.lapack\.[sdczi].*', ] # these names are not required to be in an autosummary:: listing # despite being in ALL REFGUIDE_AUTOSUMMARY_SKIPLIST = [ r'scipy\.special\..*_roots', # old aliases for scipy.special.*_roots r'scipy\.linalg\.solve_lyapunov' # deprecated name ] HAVE_MATPLOTLIB = False def short_path(path, cwd=None): """ Return relative or absolute path name, whichever is shortest. """ if not isinstance(path, str): return path if cwd is None: cwd = os.getcwd() abspath = os.path.abspath(path) relpath = os.path.relpath(path, cwd) if len(abspath) <= len(relpath): return abspath return relpath def find_names(module, names_dict): # Refguide entries: # # - 3 spaces followed by function name, and maybe some spaces, some # dashes, and an explanation; only function names listed in # refguide are formatted like this (mostly, there may be some false # positives) # # - special directives, such as data and function # # - (scipy.constants only): quoted list # patterns = [ r"^\s\s\s([a-z_0-9A-Z]+)(\s+-+.*)?$", r"^\.\. (?:data|function)::\s*([a-z_0-9A-Z]+)\s*$" ] if module.__name__ == 'scipy.constants': patterns += ["^``([a-z_0-9A-Z]+)``"] patterns = [re.compile(pattern) for pattern in patterns] module_name = module.__name__ for line in module.__doc__.splitlines(): res = re.search(r"^\s*\.\. (?:currentmodule|module):: ([a-z0-9A-Z_.]+)\s*$", line) if res: module_name = res.group(1) continue for pattern in patterns: res = re.match(pattern, line) if res is not None: name = res.group(1) entry = '.'.join([module_name, name]) names_dict.setdefault(module_name, set()).add(name) break def get_all_dict(module): """Return a copy of the __all__ dict with irrelevant items removed.""" if hasattr(module, "__all__"): all_dict = copy.deepcopy(module.__all__) else: all_dict = copy.deepcopy(dir(module)) all_dict = [name for name in all_dict if not name.startswith("_")] for name in ['absolute_import', 'division', 'print_function']: try: all_dict.remove(name) except ValueError: pass # Modules are almost always private; real submodules need a separate # run of refguide_check. all_dict = [name for name in all_dict if not inspect.ismodule(getattr(module, name, None))] deprecated = [] not_deprecated = [] for name in all_dict: f = getattr(module, name, None) if callable(f) and is_deprecated(f): deprecated.append(name) else: not_deprecated.append(name) others = set(dir(module)).difference(set(deprecated)).difference(set(not_deprecated)) return not_deprecated, deprecated, others def compare(all_dict, others, names, module_name): """Return sets of objects only in __all__, refguide, or completely missing.""" only_all = set() for name in all_dict: if name not in names: for pat in REFGUIDE_AUTOSUMMARY_SKIPLIST: if re.match(pat, module_name + '.' + name): break else: only_all.add(name) only_ref = set() missing = set() for name in names: if name not in all_dict: for pat in REFGUIDE_ALL_SKIPLIST: if re.match(pat, module_name + '.' + name): if name not in others: missing.add(name) break else: only_ref.add(name) return only_all, only_ref, missing def is_deprecated(f): with warnings.catch_warnings(record=True) as w: warnings.simplefilter("error") try: f(**{"not a kwarg":None}) except DeprecationWarning: return True except: pass return False def check_items(all_dict, names, deprecated, others, module_name, dots=True): num_all = len(all_dict) num_ref = len(names) output = "" output += "Non-deprecated objects in __all__: %i\n" % num_all output += "Objects in refguide: %i\n\n" % num_ref only_all, only_ref, missing = compare(all_dict, others, names, module_name) dep_in_ref = set(only_ref).intersection(deprecated) only_ref = set(only_ref).difference(deprecated) if len(dep_in_ref) > 0: output += "Deprecated objects in refguide::\n\n" for name in sorted(deprecated): output += " " + name + "\n" if len(only_all) == len(only_ref) == len(missing) == 0: if dots: output_dot('.') return [(None, True, output)] else: if len(only_all) > 0: output += "ERROR: objects in %s.__all__ but not in refguide::\n\n" % module_name for name in sorted(only_all): output += " " + name + "\n" output += "\nThis issue can be fixed by adding these objects to\n" output += "the function listing in __init__.py for this module\n" if len(only_ref) > 0: output += "ERROR: objects in refguide but not in %s.__all__::\n\n" % module_name for name in sorted(only_ref): output += " " + name + "\n" output += "\nThis issue should likely be fixed by removing these objects\n" output += "from the function listing in __init__.py for this module\n" output += "or adding them to __all__.\n" if len(missing) > 0: output += "ERROR: missing objects::\n\n" for name in sorted(missing): output += " " + name + "\n" if dots: output_dot('F') return [(None, False, output)] def validate_rst_syntax(text, name, dots=True): if text is None: if dots: output_dot('E') return False, "ERROR: %s: no documentation" % (name,) ok_unknown_items = set([ 'mod', 'currentmodule', 'autosummary', 'data', 'obj', 'versionadded', 'versionchanged', 'module', 'class', 'ref', 'func', 'toctree', 'moduleauthor', 'sectionauthor', 'codeauthor', 'eq', 'doi', 'DOI', 'arXiv', 'arxiv' ]) # Run through docutils error_stream = io.StringIO() def resolve(name, is_label=False): return ("http://foo", name) token = '<RST-VALIDATE-SYNTAX-CHECK>' docutils.core.publish_doctree( text, token, settings_overrides = dict(halt_level=5, traceback=True, default_reference_context='title-reference', default_role='emphasis', link_base='', resolve_name=resolve, stylesheet_path='', raw_enabled=0, file_insertion_enabled=0, warning_stream=error_stream)) # Print errors, disregarding unimportant ones error_msg = error_stream.getvalue() errors = error_msg.split(token) success = True output = "" for error in errors: lines = error.splitlines() if not lines: continue m = re.match(r'.*Unknown (?:interpreted text role|directive type) "(.*)".*$', lines[0]) if m: if m.group(1) in ok_unknown_items: continue m = re.match(r'.*Error in "math" directive:.*unknown option: "label"', " ".join(lines), re.S) if m: continue output += name + lines[0] + "::\n " + "\n ".join(lines[1:]).rstrip() + "\n" success = False if not success: output += " " + "-"*72 + "\n" for lineno, line in enumerate(text.splitlines()): output += " %-4d %s\n" % (lineno+1, line) output += " " + "-"*72 + "\n\n" if dots: output_dot('.' if success else 'F') return success, output def output_dot(msg='.', stream=sys.stderr): stream.write(msg) stream.flush() def check_rest(module, names, dots=True): """ Check reStructuredText formatting of docstrings Returns: [(name, success_flag, output), ...] """ try: skip_types = (dict, str, unicode, float, int) except NameError: # python 3 skip_types = (dict, str, float, int) results = [] if module.__name__[6:] not in OTHER_MODULE_DOCS: results += [(module.__name__,) + validate_rst_syntax(inspect.getdoc(module), module.__name__, dots=dots)] for name in names: full_name = module.__name__ + '.' + name obj = getattr(module, name, None) if obj is None: results.append((full_name, False, "%s has no docstring" % (full_name,))) continue elif isinstance(obj, skip_types): continue if inspect.ismodule(obj): text = inspect.getdoc(obj) else: try: text = str(get_doc_object(obj)) except: import traceback results.append((full_name, False, "Error in docstring format!\n" + traceback.format_exc())) continue m = re.search("([\x00-\x09\x0b-\x1f])", text) if m: msg = ("Docstring contains a non-printable character %r! " "Maybe forgot r\"\"\"?" % (m.group(1),)) results.append((full_name, False, msg)) continue try: src_file = short_path(inspect.getsourcefile(obj)) except TypeError: src_file = None if src_file: file_full_name = src_file + ':' + full_name else: file_full_name = full_name results.append((full_name,) + validate_rst_syntax(text, file_full_name, dots=dots)) return results ### Doctest helpers #### # the namespace to run examples in DEFAULT_NAMESPACE = {'np': np} # the namespace to do checks in CHECK_NAMESPACE = { 'np': np, 'assert_allclose': np.testing.assert_allclose, 'assert_equal': np.testing.assert_equal, # recognize numpy repr's 'array': np.array, 'matrix': np.matrix, 'int64': np.int64, 'uint64': np.uint64, 'int8': np.int8, 'int32': np.int32, 'float64': np.float64, 'dtype': np.dtype, 'nan': np.nan, 'NaN': np.nan, 'inf': np.inf, 'Inf': np.inf,} class DTRunner(doctest.DocTestRunner): DIVIDER = "\n" def __init__(self, item_name, checker=None, verbose=None, optionflags=0): self._item_name = item_name doctest.DocTestRunner.__init__(self, checker=checker, verbose=verbose, optionflags=optionflags) def _report_item_name(self, out, new_line=False): if self._item_name is not None: if new_line: out("\n") self._item_name = None def report_start(self, out, test, example): self._checker._source = example.source return doctest.DocTestRunner.report_start(self, out, test, example) def report_success(self, out, test, example, got): if self._verbose: self._report_item_name(out, new_line=True) return doctest.DocTestRunner.report_success(self, out, test, example, got) def report_unexpected_exception(self, out, test, example, exc_info): self._report_item_name(out) return doctest.DocTestRunner.report_unexpected_exception( self, out, test, example, exc_info) def report_failure(self, out, test, example, got): self._report_item_name(out) return doctest.DocTestRunner.report_failure(self, out, test, example, got) class Checker(doctest.OutputChecker): obj_pattern = re.compile('at 0x[0-9a-fA-F]+>') int_pattern = re.compile('^[0-9]+L?$') vanilla = doctest.OutputChecker() rndm_markers = {'# random', '# Random', '#random', '#Random', "# may vary"} stopwords = {'plt.', '.hist', '.show', '.ylim', '.subplot(', 'set_title', 'imshow', 'plt.show', 'ax.axis', 'plt.plot(', '.bar(', '.title', '.ylabel', '.xlabel', 'set_ylim', 'set_xlim', '# reformatted'} def __init__(self, parse_namedtuples=True, ns=None, atol=1e-8, rtol=1e-2): self.parse_namedtuples = parse_namedtuples self.atol, self.rtol = atol, rtol if ns is None: self.ns = dict(CHECK_NAMESPACE) else: self.ns = ns def check_output(self, want, got, optionflags): # cut it short if they are equal if want == got: return True # skip stopwords in source if any(word in self._source for word in self.stopwords): return True # skip random stuff if any(word in want for word in self.rndm_markers): return True # skip function/object addresses if self.obj_pattern.search(got): return True # ignore comments (e.g. signal.freqresp) if want.lstrip().startswith("#"): return True # python 2 long integers are equal to python 3 integers if self.int_pattern.match(want) and self.int_pattern.match(got): if want.rstrip("L\r\n") == got.rstrip("L\r\n"): return True # try the standard doctest try: if self.vanilla.check_output(want, got, optionflags): return True except Exception: pass # OK then, convert strings to objects try: a_want = eval(want, dict(self.ns)) a_got = eval(got, dict(self.ns)) except: if not self.parse_namedtuples: return False # suppose that "want" is a tuple, and "got" is smth like # MoodResult(statistic=10, pvalue=0.1). # Then convert the latter to the tuple (10, 0.1), # and then compare the tuples. try: num = len(a_want) regex = ('[\w\d_]+\(' + ', '.join(['[\w\d_]+=(.+)']*num) + '\)') grp = re.findall(regex, got.replace('\n', ' ')) if len(grp) > 1: # no more than one for now return False # fold it back to a tuple got_again = '(' + ', '.join(grp[0]) + ')' return self.check_output(want, got_again, optionflags) except Exception: return False # ... and defer to numpy try: return self._do_check(a_want, a_got) except Exception: # heterog tuple, eg (1, np.array([1., 2.])) try: return all(self._do_check(w, g) for w, g in zip(a_want, a_got)) except (TypeError, ValueError): return False def _do_check(self, want, got): # This should be done exactly as written to correctly handle all of # numpy-comparable objects, strings, and heterogenous tuples try: if want == got: return True except Exception: pass return np.allclose(want, got, atol=self.atol, rtol=self.rtol) def _run_doctests(tests, full_name, verbose, doctest_warnings): """Run modified doctests for the set of `tests`. Returns: list of [(success_flag, output), ...] """ flags = NORMALIZE_WHITESPACE | ELLIPSIS | IGNORE_EXCEPTION_DETAIL runner = DTRunner(full_name, checker=Checker(), optionflags=flags, verbose=verbose) output = [] success = True def out(msg): output.append(msg) class MyStderr(object): """Redirect stderr to the current stdout""" def write(self, msg): if doctest_warnings: sys.stdout.write(msg) else: out(msg) # Run tests, trying to restore global state afterward old_printoptions = np.get_printoptions() old_errstate = np.seterr() old_stderr = sys.stderr cwd = os.getcwd() tmpdir = tempfile.mkdtemp() sys.stderr = MyStderr() try: os.chdir(tmpdir) # try to ensure random seed is NOT reproducible np.random.seed(None) for t in tests: t.filename = short_path(t.filename, cwd) fails, successes = runner.run(t, out=out) if fails > 0: success = False finally: sys.stderr = old_stderr os.chdir(cwd) shutil.rmtree(tmpdir) np.set_printoptions(**old_printoptions) np.seterr(**old_errstate) return success, output def check_doctests(module, verbose, ns=None, dots=True, doctest_warnings=False): """Check code in docstrings of the module's public symbols. Returns: list of [(item_name, success_flag, output), ...] """ if ns is None: ns = dict(DEFAULT_NAMESPACE) # Loop over non-deprecated items results = [] for name in get_all_dict(module)[0]: full_name = module.__name__ + '.' + name if full_name in DOCTEST_SKIPLIST: continue try: obj = getattr(module, name) except AttributeError: import traceback results.append((full_name, False, "Missing item!\n" + traceback.format_exc())) continue finder = doctest.DocTestFinder() try: tests = finder.find(obj, name, globs=dict(ns)) except: import traceback results.append((full_name, False, "Failed to get doctests!\n" + traceback.format_exc())) continue success, output = _run_doctests(tests, full_name, verbose, doctest_warnings) if dots: output_dot('.' if success else 'F') results.append((full_name, success, "".join(output))) if HAVE_MATPLOTLIB: import matplotlib.pyplot as plt plt.close('all') return results def check_doctests_testfile(fname, verbose, ns=None, dots=True, doctest_warnings=False): """Check code in a text file. Mimic `check_doctests` above, differing mostly in test discovery. (which is borrowed from stdlib's doctest.testfile here, https://github.com/python-git/python/blob/master/Lib/doctest.py) Returns: list of [(item_name, success_flag, output), ...] Notes ----- We also try to weed out pseudocode: * We maintain a list of exceptions which signal pseudocode, * We split the text file into "blocks" of code separated by empty lines and/or intervening text. * If a block contains a marker, the whole block is then assumed to be pseudocode. It is then not being doctested. The rationale is that typically, the text looks like this: blah <BLANKLINE> >>> from numpy import some_module # pseudocode! >>> func = some_module.some_function >>> func(42) # still pseudocode 146 <BLANKLINE> blah <BLANKLINE> >>> 2 + 3 # real code, doctest it 5 """ results = [] if ns is None: ns = dict(DEFAULT_NAMESPACE) _, short_name = os.path.split(fname) if short_name in DOCTEST_SKIPLIST: return results full_name = fname text = open(fname).read() PSEUDOCODE = set(['some_function', 'some_module', 'import example', 'ctypes.CDLL', # likely need compiling, skip it 'integrate.nquad(func,' # ctypes integrate tutotial ]) # split the text into "blocks" and try to detect and omit pseudocode blocks. parser = doctest.DocTestParser() good_parts = [] for part in text.split('\n\n'): tests = parser.get_doctest(part, ns, fname, fname, 0) if any(word in ex.source for word in PSEUDOCODE for ex in tests.examples): # omit it pass else: # `part` looks like a good code, let's doctest it good_parts += [part] # Reassemble the good bits and doctest them: good_text = '\n\n'.join(good_parts) tests = parser.get_doctest(good_text, ns, fname, fname, 0) success, output = _run_doctests([tests], full_name, verbose, doctest_warnings) if dots: output_dot('.' if success else 'F') results.append((full_name, success, "".join(output))) if HAVE_MATPLOTLIB: import matplotlib.pyplot as plt plt.close('all') return results def init_matplotlib(): global HAVE_MATPLOTLIB try: import matplotlib matplotlib.use('Agg') HAVE_MATPLOTLIB = True except ImportError: HAVE_MATPLOTLIB = False def main(argv): parser = ArgumentParser(usage=__doc__.lstrip()) parser.add_argument("module_names", metavar="SUBMODULES", default=[], nargs='*', help="Submodules to check (default: all public)") parser.add_argument("--doctests", action="store_true", help="Run also doctests") parser.add_argument("-v", "--verbose", action="count", default=0) parser.add_argument("--doctest-warnings", action="store_true", help="Enforce warning checking for doctests") parser.add_argument("--skip-tutorial", action="store_true", help="Skip running doctests in the tutorial.") args = parser.parse_args(argv) modules = [] names_dict = {} if args.module_names: args.skip_tutorial = True else: args.module_names = list(PUBLIC_SUBMODULES) os.environ['SCIPY_PIL_IMAGE_VIEWER'] = 'true' module_names = list(args.module_names) for name in list(module_names): if name in OTHER_MODULE_DOCS: name = OTHER_MODULE_DOCS[name] if name not in module_names: module_names.append(name) for submodule_name in module_names: module_name = BASE_MODULE + '.' + submodule_name __import__(module_name) module = sys.modules[module_name] if submodule_name not in OTHER_MODULE_DOCS: find_names(module, names_dict) if submodule_name in args.module_names: modules.append(module) dots = True success = True results = [] print("Running checks for %d modules:" % (len(modules),)) if args.doctests or not args.skip_tutorial: init_matplotlib() for module in modules: if dots: if module is not modules[0]: sys.stderr.write(' ') sys.stderr.write(module.__name__ + ' ') sys.stderr.flush() all_dict, deprecated, others = get_all_dict(module) names = names_dict.get(module.__name__, set()) mod_results = [] mod_results += check_items(all_dict, names, deprecated, others, module.__name__) mod_results += check_rest(module, set(names).difference(deprecated), dots=dots) if args.doctests: mod_results += check_doctests(module, (args.verbose >= 2), dots=dots, doctest_warnings=args.doctest_warnings) for v in mod_results: assert isinstance(v, tuple), v results.append((module, mod_results)) if dots: sys.stderr.write("\n") sys.stderr.flush() if not args.skip_tutorial: base_dir = os.path.join(os.path.abspath(os.path.dirname(__file__)), '..') tut_path = os.path.join(base_dir, 'doc', 'source', 'tutorial', '*.rst') print('\nChecking tutorial files at %s:' % os.path.relpath(tut_path, os.getcwd())) for filename in sorted(glob.glob(tut_path)): if dots: sys.stderr.write('\n') sys.stderr.write(os.path.split(filename)[1] + ' ') sys.stderr.flush() tut_results = check_doctests_testfile(filename, (args.verbose >= 2), dots=dots, doctest_warnings=args.doctest_warnings) def scratch(): pass # stub out a "module", see below scratch.__name__ = filename results.append((scratch, tut_results)) if dots: sys.stderr.write("\n") sys.stderr.flush() # Report results all_success = True for module, mod_results in results: success = all(x[1] for x in mod_results) all_success = all_success and success if success and args.verbose == 0: continue print("") print("=" * len(module.__name__)) print(module.__name__) print("=" * len(module.__name__)) print("") for name, success, output in mod_results: if name is None: if not success or args.verbose >= 1: print(output.strip()) print("") elif not success or (args.verbose >= 2 and output.strip()): print(name) print("-"*len(name)) print("") print(output.strip()) print("") if all_success: print("\nOK: refguide and doctests checks passed!") sys.exit(0) else: print("\nERROR: refguide or doctests have errors") sys.exit(1) if __name__ == '__main__': main(argv=sys.argv[1:])
bsd-3-clause
abimannans/scikit-learn
examples/model_selection/plot_learning_curve.py
250
4171
""" ======================== Plotting Learning Curves ======================== On the left side the learning curve of a naive Bayes classifier is shown for the digits dataset. Note that the training score and the cross-validation score are both not very good at the end. However, the shape of the curve can be found in more complex datasets very often: the training score is very high at the beginning and decreases and the cross-validation score is very low at the beginning and increases. On the right side we see the learning curve of an SVM with RBF kernel. We can see clearly that the training score is still around the maximum and the validation score could be increased with more training samples. """ print(__doc__) import numpy as np import matplotlib.pyplot as plt from sklearn import cross_validation from sklearn.naive_bayes import GaussianNB from sklearn.svm import SVC from sklearn.datasets import load_digits from sklearn.learning_curve import learning_curve def plot_learning_curve(estimator, title, X, y, ylim=None, cv=None, n_jobs=1, train_sizes=np.linspace(.1, 1.0, 5)): """ Generate a simple plot of the test and traning learning curve. Parameters ---------- estimator : object type that implements the "fit" and "predict" methods An object of that type which is cloned for each validation. title : string Title for the chart. X : array-like, shape (n_samples, n_features) Training vector, where n_samples is the number of samples and n_features is the number of features. y : array-like, shape (n_samples) or (n_samples, n_features), optional Target relative to X for classification or regression; None for unsupervised learning. ylim : tuple, shape (ymin, ymax), optional Defines minimum and maximum yvalues plotted. cv : integer, cross-validation generator, optional If an integer is passed, it is the number of folds (defaults to 3). Specific cross-validation objects can be passed, see sklearn.cross_validation module for the list of possible objects n_jobs : integer, optional Number of jobs to run in parallel (default 1). """ plt.figure() plt.title(title) if ylim is not None: plt.ylim(*ylim) plt.xlabel("Training examples") plt.ylabel("Score") train_sizes, train_scores, test_scores = learning_curve( estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes) train_scores_mean = np.mean(train_scores, axis=1) train_scores_std = np.std(train_scores, axis=1) test_scores_mean = np.mean(test_scores, axis=1) test_scores_std = np.std(test_scores, axis=1) plt.grid() plt.fill_between(train_sizes, train_scores_mean - train_scores_std, train_scores_mean + train_scores_std, alpha=0.1, color="r") plt.fill_between(train_sizes, test_scores_mean - test_scores_std, test_scores_mean + test_scores_std, alpha=0.1, color="g") plt.plot(train_sizes, train_scores_mean, 'o-', color="r", label="Training score") plt.plot(train_sizes, test_scores_mean, 'o-', color="g", label="Cross-validation score") plt.legend(loc="best") return plt digits = load_digits() X, y = digits.data, digits.target title = "Learning Curves (Naive Bayes)" # Cross validation with 100 iterations to get smoother mean test and train # score curves, each time with 20% data randomly selected as a validation set. cv = cross_validation.ShuffleSplit(digits.data.shape[0], n_iter=100, test_size=0.2, random_state=0) estimator = GaussianNB() plot_learning_curve(estimator, title, X, y, ylim=(0.7, 1.01), cv=cv, n_jobs=4) title = "Learning Curves (SVM, RBF kernel, $\gamma=0.001$)" # SVC is more expensive so we do a lower number of CV iterations: cv = cross_validation.ShuffleSplit(digits.data.shape[0], n_iter=10, test_size=0.2, random_state=0) estimator = SVC(gamma=0.001) plot_learning_curve(estimator, title, X, y, (0.7, 1.01), cv=cv, n_jobs=4) plt.show()
bsd-3-clause