def fit(self, coordinates, data, weights=None):
"""
Fit the gridder to the given 3-component vector data.
The data region is captured and used as default for the
:meth:`~verde.Vector3D.grid` and :meth:`~verde.Vector3D.scatter`
methods.
All input arrays must have the same shape.
Parameters
----------
coordinates : tuple of arrays
Arrays with the coordinates of each data point. Should be in the
following order: (easting, northing, vertical, ...). Only easting
and northing will be used, all subsequent coordinates will be
ignored.
data : tuple of array
A tuple ``(east_component, north_component, up_component)`` of
arrays with the vector data values at each point.
weights : None or tuple array
If not None, then the weights assigned to each data point. Must be
one array per data component. Typically, this should be 1 over the
data uncertainty squared.
Returns
-------
self
Returns this estimator instance for chaining operations.
"""
coordinates, data, weights = check_fit_input(coordinates,
data,
weights,
unpack=False)
if len(data) != 3:
raise ValueError(
"Need three data components. Only {} given.".format(len(data)))
# Capture the data region to use as a default when gridding.
self.region_ = get_region(coordinates[:2])
self.force_coords_ = self._get_force_coordinates(coordinates)
if any(w is not None for w in weights):
weights = np.concatenate([i.ravel() for i in weights])
else:
weights = None
self._check_weighted_exact_solution(weights)
if self.flip_vertical:
data = list(data)
data[-1] *= -data[-1]
data = tuple(data)
data = np.concatenate([i.ravel() for i in data])
jacobian = vector3d_jacobian(coordinates[:2],
self.force_coords_,
self.poisson,
self.depth,
fudge=self.fudge)
self.force_ = self._estimate_forces(jacobian, data, weights)
return self
def fit(self, coordinates, data, weights=None):
"""
Fit the coefficients of the equivalent sources.
The fitting process is carried out through the gradient-boosting
algorithm.
The data region is captured and used as default for the
:meth:`~harmonica.EquivalentSourcesGB.grid` method.
All input arrays must have the same shape.
Parameters
----------
coordinates : tuple of arrays
Arrays with the coordinates of each data point. Should be in the
following order: (``easting``, ``northing``, ``upward``, ...).
Only ``easting``, ``northing``, and ``upward`` will be used, all
subsequent coordinates will be ignored.
data : array
The data values of each data point.
weights : None or array
If not None, then the weights assigned to each data point.
Typically, this should be 1 over the data uncertainty squared.
Returns
-------
self
Returns this estimator instance for chaining operations.
"""
coordinates, data, weights = vdb.check_fit_input(coordinates, data, weights)
coordinates, data, weights = cast_fit_input(
coordinates, data, weights, self.dtype
)
# Capture the data region to use as a default when gridding.
self.region_ = get_region(coordinates[:2])
# Ravel coordinates, data and weights to 1d-arrays
coordinates = vdb.n_1d_arrays(coordinates, 3)
data = data.ravel()
if weights is not None:
weights = weights.ravel()
# Build point sources
if self.points is None:
self.points_ = self._build_points(coordinates)
else:
self.points_ = tuple(
p.astype(self.dtype) for p in vdb.n_1d_arrays(self.points, 3)
)
# Initialize coefficients
self.coefs_ = np.zeros_like(self.points_[0])
# Fit coefficients through gradient boosting
self._gradient_boosting(coordinates, data, weights)
return self
def fit(self, coordinates, data, weights=None):
"""
Fit the gridder to the given 2-component vector data.
The data region is captured and used as default for the
:meth:`~erizo.Elastic2D.grid` and :meth:`~erizo.Elastic2D.scatter`
methods.
All input arrays must have the same shape.
Parameters
----------
coordinates : tuple of arrays
Arrays with the coordinates of each data point. Should be in the
following order: (easting, northing, vertical, ...). Only easting
and northing will be used, all subsequent coordinates will be
ignored.
data : tuple of array
A tuple ``(east_component, north_component)`` of arrays with the
vector data values at each point.
weights : None or tuple array
If not None, then the weights assigned to each data point. Must be
one array per data component. Typically, this should be 1 over the
data uncertainty squared.
Returns
-------
self
Returns this estimator instance for chaining operations.
"""
coordinates, data, weights = check_fit_input(coordinates,
data,
weights,
unpack=False)
if len(data) != 2:
raise ValueError("Need two data components. Only {} given.".format(
len(data)))
# Capture the data region to use as a default when gridding.
self.region_ = get_region(coordinates[:2])
if any(w is not None for w in weights):
weights = np.concatenate([i.ravel() for i in weights])
else:
weights = None
warn_weighted_exact_solution(self, weights)
data = np.concatenate([i.ravel() for i in data])
if self.force_coords is None:
self.force_coords = tuple(i.copy()
for i in n_1d_arrays(coordinates, n=2))
jacobian = self.jacobian(coordinates[:2], self.force_coords)
self.force_ = least_squares(jacobian, data, weights, self.damping)
return self
def fit(self, coordinates, data, weights=None):
"""
Fit the coefficients of the equivalent layer.
The data region is captured and used as default for the
:meth:`~harmonica.EQLHarmonic.grid` and
:meth:`~harmonica.EQLHarmonic.scatter` methods.
All input arrays must have the same shape.
Parameters
----------
coordinates : tuple of arrays
Arrays with the coordinates of each data point. Should be in the
following order: (``easting``, ``northing``, ``upward``, ...).
Only ``easting``, ``northing``, and ``upward`` will be used, all
subsequent coordinates will be ignored.
data : array
The data values of each data point.
weights : None or array
If not None, then the weights assigned to each data point.
Typically, this should be 1 over the data uncertainty squared.
Returns
-------
self
Returns this estimator instance for chaining operations.
"""
coordinates, data, weights = vdb.check_fit_input(
coordinates, data, weights)
# Capture the data region to use as a default when gridding.
self.region_ = vd.get_region(coordinates[:2])
coordinates = vdb.n_1d_arrays(coordinates, 3)
if self.points is None:
self.points_ = (
coordinates[0],
coordinates[1],
coordinates[2] - self.relative_depth,
)
else:
self.points_ = vdb.n_1d_arrays(self.points, 3)
jacobian = self.jacobian(coordinates, self.points_)
self.coefs_ = vdb.least_squares(jacobian, data, weights, self.damping)
return self
def fit(self, coordinates, data, weights=None):
"""
Fit the gridder to the given 3-component vector data.
The data region is captured and used as default for the
:meth:`~verde.VectorSpline3D.grid` and :meth:`~verde.VectorSpline3D.scatter`
methods.
All input arrays must have the same shape.
Parameters
----------
coordinates : tuple of arrays
Arrays with the coordinates of each data point. Should be in the
following order: (easting, northing, vertical, ...). Only easting
and northing will be used, all subsequent coordinates will be
ignored.
data : tuple of array
A tuple ``(east_component, north_component, up_component)`` of
arrays with the vector data values at each point.
weights : None or tuple array
If not None, then the weights assigned to each data point. Must be
one array per data component. Typically, this should be 1 over the
data uncertainty squared.
Returns
-------
self
Returns this estimator instance for chaining operations.
"""
coordinates, data, weights = check_fit_input(coordinates,
data,
weights,
unpack=False)
if len(data) != 3:
raise ValueError(
"Need three data components. Only {} given.".format(len(data)))
# Capture the data region to use as a default when gridding.
self.region_ = get_region(coordinates[:2])
if any(w is not None for w in weights):
weights = np.concatenate([i.ravel() for i in weights])
else:
weights = None
data = np.concatenate([i.ravel() for i in data])
if self.force_coords is None:
self.force_coords = tuple(i.copy()
for i in n_1d_arrays(coordinates, n=2))
else:
self.force_coords = n_1d_arrays(self.force_coords, n=2)
if self.depth_scale is None:
self._depth_scale = np.zeros_like(self.force_coords[0])
elif self.depth_scale == "nearest":
points = np.transpose(self.force_coords)
nndist = np.median(KDTree(points).query(points, k=20)[0], axis=1)
self._depth_scale = nndist - nndist.min()
else:
self._depth_scale = self.depth_scale
jacobian = self.jacobian(coordinates[:2], self.force_coords)
self.force_ = least_squares(jacobian, data, weights, self.damping)
return self
def fit(self, coordinates, data, weights=None):
"""
Fit the coefficients of the equivalent layer.
The source coefficients are iteratively fitted.
A regular set of rolling windows with a 50% of overlap is defined along
the entire data region. On each iteration, one window is randomly
selected and then all the coefficients of the sources that fall inside
that window are fitted using the data points that also fall inside it.
Then the field produced by these sources is computed and removed from
the data to obtain a residue. The next iteration follows the same way,
randomly choosing another window, but now the fit is done on the
residue.
The data region is captured and used as default for the
:meth:`~harmonica.EQLHarmonic.grid` and
:meth:`~harmonica.EQLHarmonic.scatter` methods.
All input arrays must have the same shape.
Parameters
----------
coordinates : tuple of arrays
Arrays with the coordinates of each data point. Should be in the
following order: (easting, northing, upward, ...).
Only easting, northing, and upward will be used, all subsequent
coordinates will be ignored.
data : array
The data values of each data point.
weights : None or array
If not None, then the weights assigned to each data point.
Typically, this should be 1 over the data uncertainty squared.
Returns
-------
self
Returns this estimator instance for chaining operations.
"""
coordinates, data, weights = vdb.check_fit_input(
coordinates, data, weights)
# Capture the data region to use as a default when gridding.
self.region_ = vd.get_region(coordinates[:2])
# Ravel coordinates, data and weights to 1d-arrays
coordinates = vdb.n_1d_arrays(coordinates, 3)
data = data.ravel()
if weights is not None:
weights = weights.ravel()
# Define self.points_ if warm_start is False and gridder is not
# already fitted
if not self.warm_start or not hasattr(self, "coefs_"):
if self.points is None:
self.points_ = (
coordinates[0],
coordinates[1],
coordinates[2] - self.relative_depth,
)
else:
self.points_ = vdb.n_1d_arrays(self.points, 3)
# Initialize coefficients and residue arrays
if self.warm_start and hasattr(self, "coefs_"):
residue = data - self.predict(coordinates)
else:
self.coefs_ = np.zeros(self.points_[0].size)
residue = data.copy()
# Fit coefficients through gradient boosting
self._gradient_boosting(coordinates, residue, weights)
return self
