def update_line(self, line_fit: np.array, line_fitx: np.array,
line_fity: np.array):
"""
Updates the line.
:param line_fit: polynom of the current line
:param line_fitx: x values of the current line
"""
# update lane fit
if line_fit.any():
self.detected = True
self.recent_fits.append(line_fit)
if len(self.recent_fits) > N:
self.recent_fits.pop(0)
self.current_fit = line_fit
self.best_fit = np.average(self.recent_fits, axis=0)
else:
self.detected = False
# update line pxs
if line_fitx.any():
self.recent_xfitted.append(line_fitx)
if len(self.recent_xfitted) > N:
self.recent_xfitted.pop(0)
self.bestx = np.average(self.recent_xfitted, axis=0)
self.diffs = np.sum(self.bestx - line_fitx)
# calc radius
self.radius_of_curvature = crv.cal_rad(self.bestx, line_fity)
self.line_base_pos = None
self.allx = line_fitx
self.ally = line_fity
def apply_plasticity(self, delta_t: float, yield_stress_model,
plasticity_criterion, mask_mesh: np.array):
"""
Apply plasticity treatment if criterion is activated :
- compute yield stress
- tests plasticity criterion
- compute plastic strain rate for plastic cells
:param delta_t: time step
:param yield_stress_model: model to compute the yield stress
:param plasticity_criterion: model for the plasticity criterion
:param mask_mesh: mask cells in projectile or target
"""
# La méthode apply_plastic_corrector_on_deviatoric_stress_tensor modifie
# la variable dev_stress_new et doit donc être appelée à la fin de
# l'étape du calcul de plasticité pour conserver la prédiction élastique dans
# le calcul du taux de déformation plastique, plasticité cumulée, ...
# 1) Compute yield stress
self.cells.compute_yield_stress(yield_stress_model, mask_mesh)
if mask_mesh.any() and self.cells.enriched.any():
self.cells.compute_enriched_yield_stress(yield_stress_model)
# 2) Get plastic cells (verification of the plasticity criterion)
# Criterion is tested for both classical and enriched cells
self._get_plastic_cells(plasticity_criterion, mask_mesh)
# Get plastic cells either in projectile or in target
mask = np.logical_and(mask_mesh, self.__plastic_cells) # pylint: disable=assignment-from-no-return
# 3) Plasticity treatment for classical plastic cells and left part of enriched cells
self.cells.apply_plasticity(mask, delta_t)
# 4) Plasticity treatment for enriched plastic cells (right part)
self.cells.apply_plasticity_enr(mask_mesh, delta_t)
def sample_discrete_distribution(bin_centres : np.array,
bin_weights : np.array,
size : int = 1) -> np.array:
if not bin_weights.any():
return np.zeros(size)
return np.random.choice(bin_centres,
p = bin_weights,
size = size)
def _scale_distribution(post: np.array, support: np.array) -> np.array:
"""Scale the distribution to have a maximum of 1, and a minimum of 0.
:param post: Values of the KDE cross-section
:param support: Support of the KDE cross-section
:return: The scaled distribution
"""
post[np.abs(post) < 1e-8] = 0 # Rule of thumb
if post.any(): # If there is any value
a = integrate.simps(y=np.abs(post),
x=support) # Integrate the absolute values
post *= 1 / a # Scale the distribution
return post
def histogramThresholding(self, image: np.array,
hist: np.array) -> np.array:
if hist.any() == None:
hist = self.histogram(image)
bins = len(hist)
histogramStart = 0
while hist[histogramStart] < 5:
histogramStart += 1
histogramEnd = bins - 1
while hist[histogramEnd] < 5:
histogramEnd -= 1
maxVal = 255.0
histogramCenter = int(
round(np.average(np.linspace(0, maxVal, bins), weights=hist)))
left = np.sum(hist[histogramStart:histogramCenter])
right = np.sum(hist[histogramCenter:histogramEnd + 1])
while histogramStart < histogramEnd:
if left > right:
left -= hist[histogramStart]
histogramStart += 1
else:
right -= hist[histogramEnd]
histogramEnd -= 1
calculatedCenter = int(round((histogramEnd + histogramStart) / 2))
if calculatedCenter < histogramCenter:
left -= hist[histogramCenter]
right += hist[histogramCenter]
elif calculatedCenter > histogramCenter:
left += hist[histogramCenter]
right -= hist[histogramCenter]
histogramCenter = calculatedCenter
imageCopy = image.copy()
imageCopy[imageCopy > histogramCenter] = 255
imageCopy[imageCopy < histogramCenter] = 0
imageCopy = imageCopy.astype(np.uint8)
return imageCopy.reshape(image.shape)
def it_sampling(
pdf,
num_samples: int = 1,
lower_bd=-np.inf,
upper_bd=np.inf,
k: int = None,
cdf_y: np.array = None,
return_cdf: bool = False,
):
"""Sample from an arbitrary, un-normalized PDF.
:param pdf: function, float -> float The probability density function (not necessarily normalized). Must take floats
or ints as input, and return floats as an output.
:param num_samples: The number of samples to be generated.
:param lower_bd: Lower bound of the support of the pdf. This parameter allows one to manually establish cutoffs for
the density.
:param upper_bd: Upper bound of the support of the pdf.
:param k: Step number between lower_bd and upper_bd
:param cdf_y: precomputed values of the CDF
:param return_cdf: Option to return the computed CDF values
:return: samples: An array of samples from the provided PDF, with support between lower_bd and upper_bd.
"""
if k is None:
k = 200 # Default step size
if cdf_y is None:
cdf = get_cdf(pdf) # CDF of the pdf
cdf_y = cdf(np.linspace(lower_bd, upper_bd, k)) # CDF values
if return_cdf:
return cdf_y
else:
if cdf_y.any():
seeds = uniform(0, 1, num_samples) # Uniformly distributed seeds
simple_samples = np.interp(x=seeds, xp=cdf_y, fp=pdf.x) # Samples
else:
simple_samples = np.zeros(num_samples) # Samples
return simple_samples
def update_gradients(self,
predicted: np.array,
real: np.array,
input_center_word: int,
sampling_ids: np.array = None) -> None:
"""
:param predicted: output of model, untreated
:param real: kind of one-hot vector with all the context words having a one, normalized
:param sampling_ids: ids for negative sampling, shouldn't be set if you used softmax in forward
:param input_center_word: index of input center word, not a vector
"""
if sampling_ids.any():
real = real.reshape(predicted.shape)
center_grad = np.matmul(
self.embedding_matrix_context_grad[sampling_ids].T,
(predicted - real))
self.embedding_matrix_center_grad[sampling_ids] += center_grad.T
context_grad = np.outer((predicted - real),
self._center_embedding(input_center_word))
self.embedding_matrix_context_grad[sampling_ids] += context_grad
return None
center_grad = np.matmul(self.embedding_matrix_context.T,
(predicted - real).reshape(
self.vocabulary_size, 1))
self.embedding_matrix_center_grad[
input_center_word] += center_grad.reshape(self.hidden_size)
context_grad = np.matmul(
(predicted - real).reshape(1, self.vocabulary_size),
self.embedding_matrix_center)
self.embedding_matrix_context_grad[
input_center_word] += context_grad.reshape(self.hidden_size)
def inverse_cdf(x: np.array, y: np.array, percentile: float) -> float:
if not y.any():
return np.inf
return x[inverse_cdf_index(y, percentile)]
def collective_feature_efficiency(X: numpy.array,
y: numpy.array,
min_resid: float = 0.1,
n_jobs: int = None) -> float:
"""
Collective feature efficiency.
C4 starts by identifying the feature with highest correlation to the output.
All examples with asmall residual value (|εi|≤0.1) after a linear fit between this feature and the target attribute are removed.
Then, the most correlated feature to the remaining data points is found and the previous process is repeated until all features have been analyzed or no example remains.
Parameters
----------
X : numpy.array
2d-array with features columns.
y : numpy.array
Array of response values.
min_resid : float, optional (default=0.1)
Minimum residual value for observation remotion.
n_jobs : int or None, optional (default=None)
The number of jobs to run in parallel. None means 1 unless. -1 means using all processors.
Return
------
float:
The number of observations that put residuos lower than 0.1
over total number of observations.
"""
# check if is dataframe
X = (X.values if isinstance(X, pandas.DataFrame) else X)
# check if y is dataframe or series
y = (y.values if isinstance(y, pandas.DataFrame)
or isinstance(y, pandas.Series) else y)
# initial parameters
A = list(range(X.shape[1]))
n = X.shape[0]
mcol = X.shape[1]
num_cores = multiprocessing.cpu_count()
n_jobs = (1 if not n_jobs else
(num_cores if
(num_cores < n_jobs) or (n_jobs == -1) else n_jobs))
def calculateCorr(x_j: numpy.array, y: numpy.array, j: int,
A: list) -> tuple:
"""Calculate absolute Spearman correlation for x_j in set A."""
corr = (abs(spearmanr(x_j, y)[0]) if j in A else .0)
return (j, corr)
while A and X.any():
pos_rho_list = Parallel(n_jobs=n_jobs)(
delayed(calculateCorr)(X[:, j], y, j, A) for j in range(mcol))
rho_list = [t[1] for t in sorted(pos_rho_list)]
if sum(rho_list) == .0:
break
m = numpy.ndarray.argmax(numpy.array(rho_list))
A.remove(m)
model = LinearRegression()
x_j = X[:, m].reshape((-1, 1))
y = y.reshape((-1, 1))
model.fit(x_j, y)
resid = y - model.predict(x_j)
id_remove = abs(resid.flatten()) > min_resid
X = X[id_remove, :]
y = y[id_remove]
return len(y) / n
def populate_explorer_with_points(self, point_index: np.array,
linenames: np.array,
point_times: np.array, beam: np.array,
x: np.array, y: np.array, z: np.array,
tvu: np.array, status: np.array,
id: np.array):
"""
Show the attributes for each point, where each point is in its own row. All the inputs are of the same size,
where size equals the number of points
Parameters
----------
point_index
point index for the points, corresponds to the index of the point in the 3dview selected points
linenames
multibeam file name that the points come from
point_times
time of the soundings/points
beam
beam number of the points
x
easting of the points
y
northing of the points
z
depth of the points
tvu
total vertical uncertainty of the points
status
rejected/amplitude/phase return qualifier of the points
id
data container that the points come from
"""
self.setSortingEnabled(False)
if self.mode != 'point':
self.set_mode('point')
self.clear_explorer_data()
if z.any():
converted_status = np.full(status.shape[0], '', dtype=object)
converted_status[np.where(status == 0)[0]] = 'amplitude'
converted_status[np.where(status == 1)[0]] = 'phase'
converted_status[np.where(status == 2)[0]] = 'rejected'
for cnt, idx in enumerate(point_index):
next_row = self.rowCount()
self.insertRow(next_row)
self.setItem(next_row, 0, QtWidgets.QTableWidgetItem(str(idx)))
self.setItem(next_row, 1,
QtWidgets.QTableWidgetItem(linenames[cnt]))
formattedtime = datetime.fromtimestamp(
float(point_times[cnt]), tz=timezone.utc).strftime('%c')
self.setItem(next_row, 2,
QtWidgets.QTableWidgetItem(str(formattedtime)))
self.setItem(next_row, 3,
QtWidgets.QTableWidgetItem(str(int(beam[cnt]))))
self.setItem(next_row, 4,
QtWidgets.QTableWidgetItem(str(x[cnt])))
self.setItem(next_row, 5,
QtWidgets.QTableWidgetItem(str(y[cnt])))
self.setItem(next_row, 6,
QtWidgets.QTableWidgetItem(str(round(z[cnt], 3))))
self.setItem(
next_row, 7,
QtWidgets.QTableWidgetItem(str(round(tvu[cnt], 3))))
self.setItem(
next_row, 8,
QtWidgets.QTableWidgetItem(str(converted_status[cnt])))
self.setItem(next_row, 9,
QtWidgets.QTableWidgetItem(str(id[cnt])))
self.setSortingEnabled(True)
