one_to_one() - Code Metrics - andycasey/AnniesLasso - Measure and Improve Code Quality continuously with Scrutinizer

one_to_one() F
last analyzed 2018-05-24 08:09 UTC

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

105

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	1	Features	0

Metric	Value
cc	9
c	1
b	1
f	0
dl	0
loc	105
rs	3.1304

How to fix Long Method

#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""
Plotting utilities for The Cannon.
"""

from __future__ import (division, print_function, absolute_import,
                        unicode_literals)

__all__ = ["theta", "scatter", "one_to_one"]

import logging
import numpy as np

logger = logging.getLogger(__name__)

try:
    import matplotlib.pyplot as plt
    from matplotlib.ticker import MaxNLocator

except ImportError:
    logger.warn("Could not import matplotlib; plotting functionality disabled")    


def theta(model, indices=None, label_terms=None, show_label_terms=True,
    normalize=True, common_axis=False, latex_label_names=None, xlim=None, 
    **kwargs):
    """
    Plot the spectral derivates (:math:`\boldsymbol{\theta}` coefficiets) from a
    trained model.

    :param model:
        A trained CannonModel object.

    :param indices: [optional]
        The indices of :math:`\boldsymbol{\theta}` to plot. By default all
        coefficients will be shown.

    :param label_terms: [optional]:
        Specify the label terms to show coefficients for. This is similar to
        specifying the `indices`, except you don't have to calculate the position
        of each label name.

        For example, specifying ``indices=0`` and ``label_terms=['TEFF', 'MG_H']``
        would show the first :math:`\theta` value (mean flux), as well as the
        :math:`\theta` coefficients that correspond to the linear terms of
        ``'TEFF'`` and ``'MG_H'``.

        Note that label_terms is specific to the model vectorizer.
        The vectorizer must be able to identify the label term by the inputs
        provided (e.g., a polynomial vectorizer will recognize ``'TEFF'`` is the
        linear coefficient of ``'TEFF'``, but ``'TEFF'`` on its own may not be
        recognisable to a vectorizer that uses sine and cosine functions.)
    
    :param show_label_terms: [optional]
        Show the label terms on the right hand side of each axis.

    :param normalize: [optional]
        Normalize each coefficient between [-1, 1], except for the first theta
        coefficient (mean flux).

    :param common_axis: [optional]
        Show all spectral derivatives on a single axes.

    :param latex_label_names: [optional]
        A list containing the label names as LaTeX representations.

    :param xlim: [optional]
        The x-limits to apply to all axes.

    :returns:
        A figure showing the spectral derivatives.
    """

    if not model.is_trained:
        raise ValueError("model needs to be trained first")

    if latex_label_names is None:
        label_names = model.vectorizer.label_names
    else:
        label_names = latex_label_names

    if indices is None and label_terms is None:
        label_indices = np.arange(model.theta.shape[1])
    else:
        label_indices = []
        if indices is not None:
            label_indices.extend(np.array(indices).astype(int).flatten())
        if label_terms is not None:
            raise NotImplementedError

    label_indices = np.array(label_indices)

    if len(set(label_indices)) < label_indices.size:
        logger.warn("Removing duplicate label indices")
        label_indices = np.unique(label_indices)

    K = len(label_indices)

    fig, axes = plt.subplots(K)
    axes = np.array([axes]).flatten()

    if common_axis:
        raise NotImplementedError

    if model.dispersion is None:
        x = np.arange(model.theta.shape[0])
    else:
        x = model.dispersion

    plot_kwds = dict(c="b", lw=1)
    plot_kwds.update(kwargs.get("plot_kwds", {}))

    for i, (ax, label_index) in enumerate(zip(axes, label_indices)):

        y = model.theta.T[label_index].copy()
        scale = np.max(np.abs(y)) if normalize and label_index != 0 else 1.0

        ax.plot(x, y/scale, **plot_kwds)

        if normalize and label_index != 0:
            ax.set_ylim(-1.2, 1.2)
            ax.set_yticks([-1, 1])
            ylabel = r"$\theta_{{{0}}}/\max{{|\theta_{{{0}}}|}}$".format(label_index)

        else:
            ylabel = r"$\theta_{{{0}}}$".format(label_index)
            ax.yaxis.set_major_locator(MaxNLocator(3))


        ax.set_ylabel(ylabel, rotation=0, verticalalignment="center")
        ax.yaxis.labelpad = 30

        if show_label_terms:
            rhs_ylabel = model.vectorizer.get_human_readable_label_term(label_index,
                label_names=label_names, mul='\cdot', pow='^')
            ax_rhs = ax.twinx()
            if latex_label_names is not None:
                rhs_ylabel = r"${}$".format(rhs_ylabel)

            ax_rhs.set_ylabel(rhs_ylabel, rotation=0, verticalalignment="center")
            ax_rhs.yaxis.labelpad = 30
            ax_rhs.set_yticks([])


        if ax.is_last_row():
            if model.dispersion is None:
                xlabel = r"${\rm Pixel}$"
            else:
                xlabel = r"${\rm Wavelength},$ $({\rm AA})$"
            ax.set_xlabel(xlabel)

        else:
            ax.set_xticklabels([])

        # Set RHS label.
        ax.xaxis.set_major_locator(MaxNLocator(6))

        ax.set_xlim(xlim)

    fig.tight_layout()
    fig.subplots_adjust(hspace=0.10)

    return fig


def scatter(model, ax=None, **kwargs):
    """
    Plot the noise residuals (:math:`s`) at each pixel.

    :param model:
        A trained CannonModel object.

    :returns:
        A figure showing the noise residuals at every pixel.
    """

    if not model.is_trained:
        raise ValueError("model needs to be trained first")

    fig = None
    if ax is None:
        fig, ax = plt.subplots()

    if model.dispersion is None:
        x = np.arange(model.s2.size)
    else:
        x = model.dispersion

    plot_kwds = dict(lw=1, c="b")
    plot_kwds.update(kwargs.pop("plot_kwds", {}))

    ax.plot(x, model.s2**0.5, **plot_kwds)

    if model.dispersion is None:
        ax.set_xlabel(r"${\rm Pixel}$")
    else:
        ax.set_xlabel(r"${\rm Wavelength}$ $[{\rm \AA}]$")

    ax.set_ylim(0, ax.get_ylim()[1])
    ax.set_ylabel(r"${\rm Scatter},$ $s$")

    ax.xaxis.set_major_locator(MaxNLocator(6))
    ax.yaxis.set_major_locator(MaxNLocator(6))

    if fig is not None:
        fig.tight_layout()
    else:
        fig = ax.figure

    return fig


def one_to_one(model, test_labels, cov=None, latex_label_names=None,
    show_statistics=True, **kwargs):
    """
    Plot a one-to-one comparison of the training set labels, and the test set
    labels inferred from the training set spectra.

    :param model:
        A trained CannonModel object.

    :param test_labels:
        An array of test labels, inferred from the training set spectra.

    :param cov: [optional]
        The covariance matrix returned for all test labels.

    :param latex_label_names: [optional]
        A list of label names in LaTeX representation.

    :param show_statistics: [optional]
        Show the mean and standard deviation of residuals in each axis.
    """

    if model.training_set_labels.shape != test_labels.shape:
        raise ValueError(
            "test labels must have the same shape as training set labels")

    N, K = test_labels.shape
    if cov is not None and cov.shape != (N, K, K):
        raise ValueError(
            "shape mis-match in covariance matrix ({N}, {K}, {K}) != {shape}"\
            .format(N=N, K=K, shape=cov.shape))

    factor = 2.0           
    lbdim = 0.30 * factor
    tdim = 0.25 * factor
    rdim = 0.10 * factor
    wspace = 0.05
    hspace = 0.35
    yspace = factor * K + factor * (K - 1.) * hspace
    xspace = factor

    xdim = lbdim + xspace + rdim
    ydim = lbdim + yspace + tdim

    fig, axes = plt.subplots(K, figsize=(xdim, ydim))
    
    l, b = (lbdim / xdim, lbdim / ydim)
    t, r = ((lbdim + yspace) / ydim, ((lbdim + xspace) / xdim))

    fig.subplots_adjust(left=l, bottom=b, right=r, top=t, wspace=wspace, hspace=hspace)

    axes = np.array([axes]).flatten()

    scatter_kwds = dict(s=1, c="k", alpha=0.5)
    scatter_kwds.update(kwargs.get("scatter_kwds", {}))

    errorbar_kwds = dict(fmt=None, ecolor="k", alpha=0.5, capsize=0)
    errorbar_kwds.update(kwargs.get("errorbar_kwds", {}))

    for i, ax in enumerate(axes):

        x = model.training_set_labels[:, i]
        y = test_labels[:, i]

        ax.scatter(x, y, **scatter_kwds)
        if cov is not None:
            yerr = cov[:, i, i]**0.5
            ax.errorbar(x, y, yerr=yerr, **errorbar_kwds)

        # Set x-axis limits and y-axis limits the same
        limits = np.array([ax.get_xlim(), ax.get_ylim()])
        limits = (np.min(limits), np.max(limits))
        
        ax.plot(limits, limits, c="#666666", linestyle=":", zorder=-1)
        ax.set_xlim(limits)
        ax.set_ylim(limits)

        label_name = model.vectorizer.label_names[i]

        if latex_label_names is not None:
            try:
                label_name = r"${}$".format(latex_label_names[i])
            except:
                logger.warn(
                    "Could not access latex label name for index {} ({})"\
                    .format(i, label_name))

        ax.set_title(label_name)

        ax.xaxis.set_major_locator(MaxNLocator(4))
        ax.yaxis.set_major_locator(MaxNLocator(4))

        # Show mean and sigma.
        if show_statistics:
            diff = y - x
            mu = np.median(diff)
            sigma = np.std(diff)
            ax.text(0.05, 0.85, r"$\mu = {0:.2f}$".format(mu),
                transform=ax.transAxes)
            ax.text(0.05, 0.75, r"$\sigma = {0:.2f}$".format(sigma),
                transform=ax.transAxes)
        
        ax.set_aspect(1.0)

    return fig


1			#!/usr/bin/env python
2			# -- coding: utf-8 --
3
4			"""
5			Plotting utilities for The Cannon.
6			"""
7
8			from __future__ import (division, print_function, absolute_import,
9			unicode_literals)
10
11			__all__ = ["theta", "scatter", "one_to_one"]
12
13			import logging
14			import numpy as np
15
16			logger = logging.getLogger(__name__)
17
18			try:
19			import matplotlib.pyplot as plt
20			from matplotlib.ticker import MaxNLocator
21
22			except ImportError:
23			logger.warn("Could not import matplotlib; plotting functionality disabled")
24
25
26			def theta(model, indices=None, label_terms=None, show_label_terms=True,
27			normalize=True, common_axis=False, latex_label_names=None, xlim=None,
28			**kwargs):
29			"""
30			Plot the spectral derivates (:math:`\boldsymbol{\theta}` coefficiets) from a
31			trained model.
32
33			:param model:
34			A trained CannonModel object.
35
36			:param indices: [optional]
37			The indices of :math:`\boldsymbol{\theta}` to plot. By default all
38			coefficients will be shown.
39
40			:param label_terms: [optional]:
41			Specify the label terms to show coefficients for. This is similar to
42			specifying the `indices`, except you don't have to calculate the position
43			of each label name.
44
45			For example, specifying ``indices=0`` and ``label_terms=['TEFF', 'MG_H']``
46			would show the first :math:`\theta` value (mean flux), as well as the
47			:math:`\theta` coefficients that correspond to the linear terms of
48			``'TEFF'`` and ``'MG_H'``.
49
50			Note that label_terms is specific to the model vectorizer.
51			The vectorizer must be able to identify the label term by the inputs
52			provided (e.g., a polynomial vectorizer will recognize ``'TEFF'`` is the
53			linear coefficient of ``'TEFF'``, but ``'TEFF'`` on its own may not be
54			recognisable to a vectorizer that uses sine and cosine functions.)
55
56			:param show_label_terms: [optional]
57			Show the label terms on the right hand side of each axis.
58
59			:param normalize: [optional]
60			Normalize each coefficient between [-1, 1], except for the first theta
61			coefficient (mean flux).
62
63			:param common_axis: [optional]
64			Show all spectral derivatives on a single axes.
65
66			:param latex_label_names: [optional]
67			A list containing the label names as LaTeX representations.
68
69			:param xlim: [optional]
70			The x-limits to apply to all axes.
71
72			:returns:
73			A figure showing the spectral derivatives.
74			"""
75
76			if not model.is_trained:
77			raise ValueError("model needs to be trained first")
78
79			if latex_label_names is None:
80			label_names = model.vectorizer.label_names
81			else:
82			label_names = latex_label_names
83
84			if indices is None and label_terms is None:
85			label_indices = np.arange(model.theta.shape[1])
86			else:
87			label_indices = []
88			if indices is not None:
89			label_indices.extend(np.array(indices).astype(int).flatten())
90			if label_terms is not None:
91			raise NotImplementedError
92
93			label_indices = np.array(label_indices)
94
95			if len(set(label_indices)) < label_indices.size:
96			logger.warn("Removing duplicate label indices")
97			label_indices = np.unique(label_indices)
98
99			K = len(label_indices)
100
101			fig, axes = plt.subplots(K)
102			axes = np.array([axes]).flatten()
103
104			if common_axis:
105			raise NotImplementedError
106
107			if model.dispersion is None:
108			x = np.arange(model.theta.shape[0])
109			else:
110			x = model.dispersion
111
112			plot_kwds = dict(c="b", lw=1)
113			plot_kwds.update(kwargs.get("plot_kwds", {}))
114
115			for i, (ax, label_index) in enumerate(zip(axes, label_indices)):
116
117			y = model.theta.T[label_index].copy()
118			scale = np.max(np.abs(y)) if normalize and label_index != 0 else 1.0
119
120			ax.plot(x, y/scale, **plot_kwds)
121
122			if normalize and label_index != 0:
123			ax.set_ylim(-1.2, 1.2)
124			ax.set_yticks([-1, 1])
125			ylabel = r"$\theta_{{{0}}}/\max{{\|\theta_{{{0}}}\|}}$".format(label_index)
126
127			else:
128			ylabel = r"$\theta_{{{0}}}$".format(label_index)
129			ax.yaxis.set_major_locator(MaxNLocator(3))
130
131
132			ax.set_ylabel(ylabel, rotation=0, verticalalignment="center")
133			ax.yaxis.labelpad = 30
134
135			if show_label_terms:
136			rhs_ylabel = model.vectorizer.get_human_readable_label_term(label_index,
137			label_names=label_names, mul='\cdot', pow='^')
138			ax_rhs = ax.twinx()
139			if latex_label_names is not None:
140			rhs_ylabel = r"${}$".format(rhs_ylabel)
141
142			ax_rhs.set_ylabel(rhs_ylabel, rotation=0, verticalalignment="center")
143			ax_rhs.yaxis.labelpad = 30
144			ax_rhs.set_yticks([])
145
146
147			if ax.is_last_row():
148			if model.dispersion is None:
149			xlabel = r"${\rm Pixel}$"
150			else:
151			xlabel = r"${\rm Wavelength},$ $({\rm AA})$"
152			ax.set_xlabel(xlabel)
153
154			else:
155			ax.set_xticklabels([])
156
157			# Set RHS label.
158			ax.xaxis.set_major_locator(MaxNLocator(6))
159
160			ax.set_xlim(xlim)
161
162			fig.tight_layout()
163			fig.subplots_adjust(hspace=0.10)
164
165			return fig
166
167
168			def scatter(model, ax=None, **kwargs):
169			"""
170			Plot the noise residuals (:math:`s`) at each pixel.
171
172			:param model:
173			A trained CannonModel object.
174
175			:returns:
176			A figure showing the noise residuals at every pixel.
177			"""
178
179			if not model.is_trained:
180			raise ValueError("model needs to be trained first")
181
182			fig = None
183			if ax is None:
184			fig, ax = plt.subplots()
185
186			if model.dispersion is None:
187			x = np.arange(model.s2.size)
188			else:
189			x = model.dispersion
190
191			plot_kwds = dict(lw=1, c="b")
192			plot_kwds.update(kwargs.pop("plot_kwds", {}))
193
194			ax.plot(x, model.s20.5, plot_kwds)
195
196			if model.dispersion is None:
197			ax.set_xlabel(r"${\rm Pixel}$")
198			else:
199			ax.set_xlabel(r"${\rm Wavelength}$ $[{\rm \AA}]$")
200
201			ax.set_ylim(0, ax.get_ylim()[1])
202			ax.set_ylabel(r"${\rm Scatter},$ $s$")
203
204			ax.xaxis.set_major_locator(MaxNLocator(6))
205			ax.yaxis.set_major_locator(MaxNLocator(6))
206
207			if fig is not None:
208			fig.tight_layout()
209			else:
210			fig = ax.figure
211
212			return fig
213
214
215			def one_to_one(model, test_labels, cov=None, latex_label_names=None,
216			show_statistics=True, **kwargs):
217			"""
218			Plot a one-to-one comparison of the training set labels, and the test set
219			labels inferred from the training set spectra.
220
221			:param model:
222			A trained CannonModel object.
223
224			:param test_labels:
225			An array of test labels, inferred from the training set spectra.
226
227			:param cov: [optional]
228			The covariance matrix returned for all test labels.
229
230			:param latex_label_names: [optional]
231			A list of label names in LaTeX representation.
232
233			:param show_statistics: [optional]
234			Show the mean and standard deviation of residuals in each axis.
235			"""
236
237			if model.training_set_labels.shape != test_labels.shape:
238			raise ValueError(
239			"test labels must have the same shape as training set labels")
240
241			N, K = test_labels.shape
242			if cov is not None and cov.shape != (N, K, K):
243			raise ValueError(
244			"shape mis-match in covariance matrix ({N}, {K}, {K}) != {shape}"\
245			.format(N=N, K=K, shape=cov.shape))
246
247			factor = 2.0
248			lbdim = 0.30 * factor
249			tdim = 0.25 * factor
250			rdim = 0.10 * factor
251			wspace = 0.05
252			hspace = 0.35
253			yspace = factor * K + factor * (K - 1.) * hspace
254			xspace = factor
255
256			xdim = lbdim + xspace + rdim
257			ydim = lbdim + yspace + tdim
258
259			fig, axes = plt.subplots(K, figsize=(xdim, ydim))
260
261			l, b = (lbdim / xdim, lbdim / ydim)
262			t, r = ((lbdim + yspace) / ydim, ((lbdim + xspace) / xdim))
263
264			fig.subplots_adjust(left=l, bottom=b, right=r, top=t, wspace=wspace, hspace=hspace)
265
266			axes = np.array([axes]).flatten()
267
268			scatter_kwds = dict(s=1, c="k", alpha=0.5)
269			scatter_kwds.update(kwargs.get("scatter_kwds", {}))
270
271			errorbar_kwds = dict(fmt=None, ecolor="k", alpha=0.5, capsize=0)
272			errorbar_kwds.update(kwargs.get("errorbar_kwds", {}))
273
274			for i, ax in enumerate(axes):
275
276			x = model.training_set_labels[:, i]
277			y = test_labels[:, i]
278
279			ax.scatter(x, y, **scatter_kwds)
280			if cov is not None:
281			yerr = cov[:, i, i]**0.5
282			ax.errorbar(x, y, yerr=yerr, **errorbar_kwds)
283
284			# Set x-axis limits and y-axis limits the same
285			limits = np.array([ax.get_xlim(), ax.get_ylim()])
286			limits = (np.min(limits), np.max(limits))
287
288			ax.plot(limits, limits, c="#666666", linestyle=":", zorder=-1)
289			ax.set_xlim(limits)
290			ax.set_ylim(limits)
291
292			label_name = model.vectorizer.label_names[i]
293
294			if latex_label_names is not None:
295			try:
296			label_name = r"${}$".format(latex_label_names[i])
297			except:
298			logger.warn(
299			"Could not access latex label name for index {} ({})"\
300			.format(i, label_name))
301
302			ax.set_title(label_name)
303
304			ax.xaxis.set_major_locator(MaxNLocator(4))
305			ax.yaxis.set_major_locator(MaxNLocator(4))
306
307			# Show mean and sigma.
308			if show_statistics:
309			diff = y - x
310			mu = np.median(diff)
311			sigma = np.std(diff)
312			ax.text(0.05, 0.85, r"$\mu = {0:.2f}$".format(mu),
313			transform=ax.transAxes)
314			ax.text(0.05, 0.75, r"$\sigma = {0:.2f}$".format(sigma),
315			transform=ax.transAxes)
316
317			ax.set_aspect(1.0)
318
319			return fig
320

andycasey / AnniesLasso

one_to_one() F last analyzed 2018-05-24 08:09 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

one_to_one() F
last analyzed 2018-05-24 08:09 UTC