def remove_background_by_median(ccd, plots=False):
"""Remove Background of a ccd spectrum image
Notes:
This function works well for images without strong sky lines. Or for
targets embedded in extended sources.
Args:
ccd (object): A ccdproc.CCDData instance.
Returns:
ccd (object): The modified ccdproc.CCDData instance.
"""
new_ccd = ccd.copy()
data = ma.masked_invalid(new_ccd.data)
# x, y = ccd.data.shape
median = ma.median(data, axis=0)
data -= median
data.set_fill_value(-np.inf)
new_ccd.data = data.filled()
# ccd.write('/user/simon/dummy_{:d}.fits'.format(g), clobber=True)
return new_ccd
python类masked_invalid()的实例源码
def __call__(self, coefs, ground_truth, Gram,
weight=None, zeronan=None):
"""Compute the Empirical OVK ridge risk.
Parameters
----------
coefs : {vector-like}, shape = [n_samples1 * n_targets]
Coefficient to optimise
ground_truth : {vector-like}
Targets samples
Gram : {LinearOperator}
Gram matrix acting on the coefs
weight: {LinearOperator}
zeronan: {LinearOperator}
Returns
-------
float : Empirical OVK ridge risk
"""
np = ground_truth.size
pred = Gram * coefs
reg = inner(coefs, pred) # reg in rkhs
vgt = masked_invalid(ground_truth)
vgt[where(vgt.mask)] = pred[where(vgt.mask)]
if weight is None or zeronan is None:
obj = norm(pred - vgt) ** 2 / (2 * np)
else:
wpred = weight * pred # sup x identity | unsup x lbda_m x L
res = zeronan * (wpred - vgt)
wip = wpred - zeronan * wpred # only unsup part of wpred
lap = inner(wip, pred) # Laplacian part x lambda_m
obj = norm(zeronan * res) ** 2 / (2 * np) # Loss
obj += lap / (2 * np) # Laplacian regularization
obj += self.lbda * reg / (2 * np) # Regulariation
return obj
def functional_grad(self, coefs, ground_truth, Gram,
weight=None, zeronan=None):
"""Compute the gradient of the Empirical OVK ridge risk.
Parameters
----------
coefs : {vector-like}, shape = [n_samples1 * n_targets]
Coefficient to optimise
ground_truth : {vector-like}
Targets samples
Gram : {LinearOperator}
Gram matrix acting on the coefs
weight: {LinearOperator}
zeronan: {LinearOperator}
Returns
-------
{vector-like} : gradient of the Empirical OVK ridge risk
"""
np = ground_truth.size
pred = Gram * coefs
vgt = masked_invalid(ground_truth)
vgt[where(vgt.mask)] = pred[where(vgt.mask)]
if weight is None or zeronan is None:
res = pred - vgt
else:
res = weight * pred - zeronan * vgt
return Gram * res / np + self.lbda * pred / np
def functional_grad_val(self, coefs, ground_truth, Gram,
weight=None, zeronan=None):
"""Compute the gradient and value of the Empirical OVK ridge risk.
Parameters
----------
coefs : {vector-like}, shape = [n_samples1 * n_targets]
Coefficient to optimise
ground_truth : {vector-like}
Targets samples
Gram : {LinearOperator}
Gram matrix acting on the coefs
L : array, shape = [n_samples_miss, n_samples_miss]
Graph Laplacian of data with missing targets (semi-supervised
learning).
Returns
-------
Tuple{float, vector-like} : Empirical OVK ridge risk and its gradient
returned as a tuple.
"""
np = ground_truth.size
pred = Gram * coefs
vgt = masked_invalid(ground_truth)
vgt[where(vgt.mask)] = pred[where(vgt.mask)]
reg = inner(coefs, pred) # reg in rkhs
if weight is None or zeronan is None:
res = pred - vgt
obj = norm(res) ** 2 / (2 * np)
else:
wpred = weight * pred # sup x identity | unsup x lbda_m x L
res = wpred - zeronan * vgt
wip = wpred - zeronan * wpred # only unsup part of wpred
lap = inner(wip, pred) # Laplacian part x lambda_m
obj = norm(zeronan * res) ** 2 / (2 * np) # Loss
obj += lap / (2 * np) # Laplacian regularization
obj += self.lbda * reg / (2 * np) # Regulariation
return obj, Gram * res / np + self.lbda * pred / np
def to_np(array):
"""Return the :class:`numpy.ndarray` contained in an
:class:`xarray.DataArray` instance.
If the :class:`xarray.DataArray` instance does not contain a *_FillValue*
or *missing_value* attribute, then this routine simply returns the
:attr:`xarray.DataArray.values` attribute. If the
:class:`xarray.DataArray` object contains a *_FillValue* or *missing_value*
attribute, then this routine returns a :class:`numpy.ma.MaskedArray`
instance, where the NaN values (used by xarray to represent missing data)
are replaced with the fill value.
If the object passed in to this routine is not an
:class:`xarray.DataArray` instance, then this routine simply returns the
passed in object. This is useful in situations where you do not know
if you have an :class:`xarray.DataArray` or a :class:`numpy.ndarray` and
simply want a :class:`numpy.ndarray` returned.
Args:
array (:class:`xarray.DataArray`, :class:`numpy.ndarray`, or any \
object): Can be any object type, but is generally
used with :class:`xarray.DataArray` or :class:`numpy.ndarray`.
Returns:
:class:`numpy.ndarray` or :class:`numpy.ma.MaskedArray`: The
extracted array or the *array* object if *array* is not a
:class:`xarray.DataArray` object..
"""
try:
fill_value = array.attrs["_FillValue"]
except AttributeError:
result = array # Not a DataArray
except KeyError:
result = array.values # Does not have missing values
else:
result = ma.masked_invalid(array.values, copy=False)
result.set_fill_value(fill_value)
return result
# Helper utilities for metadata
