# Python numpy.histogram2d() Examples

The following are 30 code examples for showing how to use numpy.histogram2d(). These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example.

You may check out the related API usage on the sidebar.

You may also want to check out all available functions/classes of the module , or try the search function .

Example 1
 Project: EXOSIMS   Author: dsavransky   File: SS_det_only.py    License: BSD 3-Clause "New" or "Revised" License 6 votes  def hist(self, nplan, xedges, yedges):
"""Returns completeness histogram for Monte Carlo simulation

This function uses the inherited Planet Population module.

Args:
nplan (float):
number of planets used
xedges (float ndarray):
x edge of 2d histogram (separation)
yedges (float ndarray):
y edge of 2d histogram (dMag)

Returns:
h (ndarray):
2D numpy ndarray containing completeness histogram

"""

s, dMag = self.genplans(nplan)
# get histogram
h, yedges, xedges = np.histogram2d(dMag, s.to('AU').value, bins=1000,
range=[[yedges.min(), yedges.max()], [xedges.min(), xedges.max()]])

return h, xedges, yedges 
Example 2
 Project: EXOSIMS   Author: dsavransky   File: BrownCompleteness.py    License: BSD 3-Clause "New" or "Revised" License 6 votes  def hist(self, nplan, xedges, yedges):
"""Returns completeness histogram for Monte Carlo simulation

This function uses the inherited Planet Population module.

Args:
nplan (float):
number of planets used
xedges (float ndarray):
x edge of 2d histogram (separation)
yedges (float ndarray):
y edge of 2d histogram (dMag)

Returns:
float ndarray:
2D numpy ndarray containing completeness frequencies

"""

s, dMag = self.genplans(nplan)
# get histogram
h, yedges, xedges = np.histogram2d(dMag, s.to('AU').value, bins=1000,
range=[[yedges.min(), yedges.max()], [xedges.min(), xedges.max()]])

return h, xedges, yedges 
Example 3
 Project: NeuroKit   Author: neuropsychology   File: mutual_information.py    License: MIT License 6 votes  def _mutual_information_varoquaux(x, y, bins=256, sigma=1, normalized=True):
"""Based on Gael Varoquaux's implementation: https://gist.github.com/GaelVaroquaux/ead9898bd3c973c40429."""
jh = np.histogram2d(x, y, bins=bins)

# smooth the jh with a gaussian filter of given sigma
scipy.ndimage.gaussian_filter(jh, sigma=sigma, mode="constant", output=jh)

# compute marginal histograms
jh = jh + np.finfo(float).eps
sh = np.sum(jh)
jh = jh / sh
s1 = np.sum(jh, axis=0).reshape((-1, jh.shape))
s2 = np.sum(jh, axis=1).reshape((jh.shape, -1))

if normalized:
mi = ((np.sum(s1 * np.log(s1)) + np.sum(s2 * np.log(s2))) / np.sum(jh * np.log(jh))) - 1
else:
mi = np.sum(jh * np.log(jh)) - np.sum(s1 * np.log(s1)) - np.sum(s2 * np.log(s2))

return mi 
Example 4
 Project: feets   Author: quatrope   File: ext_dmdt.py    License: MIT License 6 votes  def fit(self, magnitude, time, dt_bins, dm_bins):
def delta_calc(idx):
t0 = time[idx]
m0 = magnitude[idx]
deltat = time[idx + 1 :] - t0
deltam = magnitude[idx + 1 :] - m0

deltat[np.where(deltat < 0)] *= -1
deltam[np.where(deltat < 0)] *= -1

return np.column_stack((deltat, deltam))

lc_len = len(time)
n_vals = int(0.5 * lc_len * (lc_len - 1))

deltas = np.vstack(tuple(delta_calc(idx) for idx in range(lc_len - 1)))

deltat = deltas[:, 0]
deltam = deltas[:, 1]

bins = [dt_bins, dm_bins]
counts = np.histogram2d(deltat, deltam, bins=bins, normed=False)
result = np.fix(255.0 * counts / n_vals + 0.999).astype(int)

return {"DMDT": result} 
Example 5
 Project: typhon   Author: atmtools   File: geographical.py    License: MIT License 6 votes  def gridded_mean(lat, lon, data, grid):
"""Grid data along latitudes and longitudes

Args:
lat: Grid points along latitudes as 1xN dimensional array.
lon: Grid points along longitudes as 1xM dimensional array.
data: The data as NxM numpy array.
grid: A tuple with two numpy arrays, consisting of latitude and
longitude grid points.

Returns:
Two matrices in grid form: the mean and the number of points of data.
"""
grid_sum, _, _ = np.histogram2d(lat, lon, grid, weights=data)
grid_number, _, _ = np.histogram2d(lat, lon, grid)

return grid_sum / grid_number, grid_number 
Example 6
 Project: scattertext   Author: JasonKessler   File: OptimalProjection.py    License: Apache License 2.0 6 votes  def morista_index(points):
# Morisita Index of Dispersion

N = points.shape

ims = []
for i in range(1, N):
bins, _, _ = np.histogram2d(points, points, i)

# I_M  = Q * (\sum_{k=1}^{Q}{n_k * (n_k - 1)})/(N * (N _ 1))

# Eqn 1.
I_M = Q * np.sum(np.ravel(bins) * (np.ravel(bins) - 1)) / (N * (N - 1))
ims.append([i, I_M])

return np.array(ims).T.max() 
Example 7
 Project: vnpy_crypto   Author: birforce   File: discrete_model.py    License: MIT License 6 votes  def pred_table(self, threshold=.5):
"""
Prediction table

Parameters
----------
threshold : scalar
Number between 0 and 1. Threshold above which a prediction is
considered 1 and below which a prediction is considered 0.

Notes
------
pred_table[i,j] refers to the number of times "i" was observed and
the model predicted "j". Correct predictions are along the diagonal.
"""
model = self.model
actual = model.endog
pred = np.array(self.predict() > threshold, dtype=float)
bins = np.array([0, 0.5, 1])
return np.histogram2d(actual, pred, bins=bins) 
Example 8
 Project: bonnet   Author: PRBonn   File: abstract_net.py    License: GNU General Public License v3.0 6 votes  def pix_histogram(self, mask, lbl):
'''
get individual mask and label and create 2d hist
'''
# flatten label and cast
flat_label = lbl.flatten().astype(np.uint32)
# get the histogram
histrange = np.array([[-0.5, self.num_classes - 0.5],
[-0.5, self.num_classes - 0.5]], dtype='float64')
np.array(flat_label),
bins=self.num_classes,
range=histrange)
return h_now 
Example 9
 Project: spinalcordtoolbox   Author: neuropoly   File: sct_maths.py    License: MIT License 6 votes  def mutual_information(x, y, nbins=32, normalized=False):
"""
Compute mutual information
:param x: 1D numpy.array : flatten data from an image
:param y: 1D numpy.array : flatten data from an image
:param nbins: number of bins to compute the contingency matrix (only used if normalized=False)
:return: float non negative value : mutual information
"""
import sklearn.metrics
if normalized:
mi = sklearn.metrics.normalized_mutual_info_score(x, y)
else:
c_xy = np.histogram2d(x, y, nbins)
mi = sklearn.metrics.mutual_info_score(None, None, contingency=c_xy)
# mi = adjusted_mutual_info_score(None, None, contingency=c_xy)
return mi 
Example 10
 Project: thewalrus   Author: XanaduAI   File: test_samples.py    License: Apache License 2.0 6 votes  def test_displaced_two_mode_state_hafnian(self, sample_func):
"""Test the sampling routines by comparing the photon number frequencies and the exact
probability distribution of a two mode coherent state
"""
n_samples = 1000
n_cut = 6
sigma = np.identity(4)
mean = 5 * np.array([0.1, 0.25, 0.1, 0.25])
samples = sample_func(sigma, samples=n_samples, mean=mean, cutoff=n_cut)
# samples = hafnian_sample_classical_state(sigma, mean = mean, samples = n_samples)
probs = np.real_if_close(
np.array(
[
[density_matrix_element(mean, sigma, [i, j], [i, j]) for i in range(n_cut)]
for j in range(n_cut)
]
)
)
freq, _, _ = np.histogram2d(samples[:, 1], samples[:, 0], bins=np.arange(0, n_cut + 1))
rel_freq = freq / n_samples

assert np.allclose(
rel_freq, probs, rtol=rel_tol / np.sqrt(n_samples), atol=rel_tol / np.sqrt(n_samples)
) 
Example 11
 Project: flight_review   Author: PX4   File: pid_analysis.py    License: BSD 3-Clause "New" or "Revised" License 6 votes  def hist2d(self, x, y, weights, bins):   #bins[nx,ny]
### generates a 2d hist from input 1d axis for x,y. repeats them to match shape of weights X*Y (data points)
### x will be 0-100%
freqs = np.repeat(np.array([y], dtype=np.float64), len(x), axis=0)
throts = np.repeat(np.array([x], dtype=np.float64), len(y), axis=0).transpose()
throt_hist_avr, throt_scale_avr = np.histogram(x, 101, [0, 100])

hist2d = np.histogram2d(throts.flatten(), freqs.flatten(),
range=[[0, 100], [y, y[-1]]],
bins=bins, weights=weights.flatten(), normed=False).transpose()

hist2d = np.array(abs(hist2d), dtype=np.float64)
hist2d_norm = np.copy(hist2d)
hist2d_norm /=  (throt_hist_avr + 1e-9)

return {'hist2d_norm':hist2d_norm, 'hist2d':hist2d, 'throt_hist':throt_hist_avr,'throt_scale':throt_scale_avr} 
Example 12
 Project: FlowCal   Author: taborlab   File: test_gate.py    License: MIT License 6 votes  def test_gate_fraction_2_error_large_gate_fraction(self):
bins = [-0.5, 0.5, 1.5, 2.5, 3.5, 4.5]
self.assertRaises(
ValueError,
FlowCal.gate.density2d,
self.pyramid,
bins=bins,
gate_fraction=1.1,
sigma=0.0,
)

# Test implicit gating (when values exist outside specified bins)
#
# The expected behavior is that density2d() should mimic
# np.histogram2d()'s behavior: values outside the specified bins are
# ignored (in the context of a gate function, this means they are
# implicitly gated out). 
Example 13
 Project: FlowCal   Author: taborlab   File: test_gate.py    License: MIT License 6 votes  def test_sub_bin_1_mask(self):
bins = [0.5, 2.5, 4.5]
np.testing.assert_array_equal(
FlowCal.gate.density2d(
self.slope, bins=bins, gate_fraction=13.0/30, sigma=0.0,
np.array([0,0,0,0,0,0,0,0,0,0,1,1,0,0,1,1,0,0,0,0,1,1,0,1,1,
1,1,1,1,1], dtype=bool)
)

# Test bins edge case (when bin edges = values)
#
# Again, the expected behavior is that density2d() should mimic
# np.histogram2d()'s behavior which will group the right-most two values
# together in the same bin (since the last bins interval is fully closed,
# as opposed to all other bins intervals which are half-open). 
Example 14
 Project: netrd   Author: netsiphd   File: distributional_nbd.py    License: MIT License 6 votes  def spectral_distribution(points, cumulative=True):
"""
Returns the distribution of complex values (in r,theta-space).
"""

points = np.array([(np.abs(z), np.angle(z)) for z in points])
r, theta = np.split(points, 2, axis=1)

r = np.array([logr(x, r.max()) for x in r])

Z, R, THETA = np.histogram2d(
x=r[:, 0],
y=theta[:, 0],
bins=(np.linspace(0, 1, 101), np.linspace(0, np.pi, 101)),
)

if cumulative:
Z = Z.cumsum(axis=0).cumsum(axis=1)
Z = Z / Z.max()

return Z.flatten() 
Example 15
 Project: scprep   Author: KrishnaswamyLab   File: stats.py    License: GNU General Public License v3.0 6 votes  def mutual_information(x, y, bins=8):
"""Mutual information score with set number of bins

Helper function for sklearn.metrics.mutual_info_score that builds a
contingency table over a set number of bins.
Credit: Warran Weckesser <https://stackoverflow.com/a/20505476/3996580>_.

Parameters
----------
x : array-like, shape=[n_samples]
Input data (feature 1)
y : array-like, shape=[n_samples]
Input data (feature 2)
bins : int or array-like, (default: 8)
Passed to np.histogram2d to calculate a contingency table.

Returns
-------
mi : float
Mutual information between x and y.

Examples
--------
>>> import scprep
>>> mi = scprep.stats.mutual_information(data['GENE1'], data['GENE2'])
"""
x, y = _vector_coerce_two_dense(x, y)
c_xy = np.histogram2d(x, y, bins)
mi = metrics.mutual_info_score(None, None, contingency=c_xy)
return mi 
Example 16
 Project: Splunking-Crime   Author: nccgroup   File: discrete_model.py    License: GNU Affero General Public License v3.0 6 votes  def pred_table(self, threshold=.5):
"""
Prediction table

Parameters
----------
threshold : scalar
Number between 0 and 1. Threshold above which a prediction is
considered 1 and below which a prediction is considered 0.

Notes
------
pred_table[i,j] refers to the number of times "i" was observed and
the model predicted "j". Correct predictions are along the diagonal.
"""
model = self.model
actual = model.endog
pred = np.array(self.predict() > threshold, dtype=float)
bins = np.array([0, 0.5, 1])
return np.histogram2d(actual, pred, bins=bins) 
Example 17
 Project: differential-privacy-library   Author: IBM   File: test_histogram2d.py    License: MIT License 5 votes  def test_no_params(self):
x = np.array([1, 2, 3, 4, 5])
y = np.array([5, 7, 1, 5, 9])
with self.assertWarns(PrivacyLeakWarning):
res = histogram2d(x, y)
self.assertIsNotNone(res) 
Example 18
 Project: differential-privacy-library   Author: IBM   File: test_histogram2d.py    License: MIT License 5 votes  def test_no_range(self):
x = np.array([1, 2, 3, 4, 5])
y = np.array([5, 7, 1, 5, 9])
with self.assertWarns(PrivacyLeakWarning):
res = histogram2d(x, y, epsilon=1)
self.assertIsNotNone(res) 
Example 19
 Project: differential-privacy-library   Author: IBM   File: test_histogram2d.py    License: MIT License 5 votes  def test_missing_range(self):
x = np.array([1, 2, 3, 4, 5])
y = np.array([5, 7, 1, 5, 9])
with self.assertWarns(PrivacyLeakWarning):
res = histogram2d(x, y, epsilon=1, range=[(0, 10), None])
self.assertIsNotNone(res) 
Example 20
 Project: differential-privacy-library   Author: IBM   File: test_histogram2d.py    License: MIT License 5 votes  def test_same_edges(self):
x = np.array([1, 2, 3, 4, 5])
y = np.array([5, 7, 1, 5, 9])
_, edges_x, edges_y = np.histogram2d(x, y, bins=3, range=[(0, 10), (0, 10)])
_, dp_edges_x, dp_edges_y = histogram2d(x, y, epsilon=1, bins=3, range=[(0, 10), (0, 10)])

self.assertTrue((edges_x == dp_edges_x).all())
self.assertTrue((edges_y == dp_edges_y).all()) 
Example 21
 Project: differential-privacy-library   Author: IBM   File: test_histogram2d.py    License: MIT License 5 votes  def test_different_result(self):
global_seed(3141592653)
x = np.array([1, 2, 3, 4, 5])
y = np.array([5, 7, 1, 5, 9])
hist, _, _ = np.histogram2d(x, y, bins=3, range=[(0, 10), (0, 10)])
dp_hist, _, _ = histogram2d(x, y, epsilon=0.1, bins=3, range=[(0, 10), (0, 10)])

# print("Non-private histogram: %s" % hist)
# print("Private histogram: %s" % dp_hist)
self.assertTrue((hist != dp_hist).any()) 
Example 22
 Project: differential-privacy-library   Author: IBM   File: test_histogram2d.py    License: MIT License 5 votes  def test_accountant(self):
acc = BudgetAccountant(1.5, 0)

x = np.array([1, 2, 3, 4, 5])
y = np.array([5, 7, 1, 5, 9])
histogram2d(x, y, epsilon=1, bins=3, range=[(0, 10), (0, 10)], density=True, accountant=acc)

with self.assertRaises(BudgetError):
histogram2d(x, y, epsilon=1, bins=3, range=[(0, 10), (0, 10)], density=True, accountant=acc) 
Example 23
 Project: NeuroKit   Author: neuropsychology   File: mutual_information.py    License: MIT License 5 votes  def _mutual_information_nolitsa(x, y, bins=256):
"""Calculate the mutual information between two random variables.

Calculates mutual information, I = S(x) + S(y) - S(x,y), between two random variables x and y, where
S(x) is the Shannon entropy.

Based on the nolitsa package: https://github.com/manu-mannattil/nolitsa/blob/master/nolitsa/delay.py#L72

"""
p_x = np.histogram(x, bins)
p_y = np.histogram(y, bins)
p_xy = np.histogram2d(x, y, bins).flatten()

# Convert frequencies into probabilities.  Also, in the limit
# p -> 0, p*log(p) is 0.  We need to take out those.
p_x = p_x[p_x > 0] / np.sum(p_x)
p_y = p_y[p_y > 0] / np.sum(p_y)
p_xy = p_xy[p_xy > 0] / np.sum(p_xy)

# Calculate the corresponding Shannon entropies.
h_x = np.sum(p_x * np.log2(p_x))
h_y = np.sum(p_y * np.log2(p_y))
h_xy = np.sum(p_xy * np.log2(p_xy))

return h_xy - h_x - h_y

# =============================================================================
# JUNK
# ============================================================================= 
Example 24
 Project: feets   Author: quatrope   File: ext_signature.py    License: MIT License 5 votes  def fit(self, magnitude, time, PeriodLS, Amplitude, phase_bins, mag_bins):
first_period = PeriodLS
lc_yaxis = (magnitude - np.min(magnitude)) / np.float(Amplitude)

# SHIFT TO BEGIN AT MINIMUM
loc = np.argmin(lc_yaxis)
lc_phase = np.remainder(time - time[loc], first_period) / first_period

bins = (phase_bins, mag_bins)
signature = np.histogram2d(lc_phase, lc_yaxis, bins=bins, normed=True)[
0
]

return {"SignaturePhMag": signature} 
Example 25
 Project: recruit   Author: Frank-qlu   File: test_histograms.py    License: Apache License 2.0 5 votes  def test_f32_rounding(self):
# gh-4799, check that the rounding of the edges works with float32
x = np.array([276.318359, -69.593948, 21.329449], dtype=np.float32)
y = np.array([5005.689453, 4481.327637, 6010.369629], dtype=np.float32)
counts_hist, xedges, yedges = np.histogram2d(x, y, bins=100)
assert_equal(counts_hist.sum(), 3.) 
Example 26
 Project: scattertext   Author: JasonKessler   File: CategoryProjectorEvaluator.py    License: Apache License 2.0 5 votes  def evaluate(self, category_projection):
assert issubclass(type(category_projection), CategoryProjectionBase)
proj = category_projection.projection[:, [category_projection.x_dim, category_projection.y_dim]]
scaled_proj = np.array([stretch_0_to_1(proj.T), stretch_0_to_1(proj.T)]).T
morista_sum = 0
N = scaled_proj.shape
for i in range(self.num_bin_range, self.num_bin_range):
bins, _, _ = np.histogram2d(scaled_proj.T, scaled_proj.T, i)

# I_M  = Q * (\sum_{k=1}^{Q}{n_k * (n_k - 1)})/(N * (N _ 1))

# Eqn 1.
morista_sum += Q * np.sum(np.ravel(bins) * (np.ravel(bins) - 1)) / (N * (N - 1))
return morista_sum/(self.num_bin_range - self.num_bin_range) 
Example 27
 Project: lambda-packs   Author: ryfeus   File: test_function_base.py    License: MIT License 5 votes  def test_f32_rounding(self):
# gh-4799, check that the rounding of the edges works with float32
x = np.array([276.318359, -69.593948, 21.329449], dtype=np.float32)
y = np.array([5005.689453, 4481.327637, 6010.369629], dtype=np.float32)
counts_hist, xedges, yedges = np.histogram2d(x, y, bins=100)
assert_equal(counts_hist.sum(), 3.) 
Example 28
 Project: auto-alt-text-lambda-api   Author: abhisuri97   File: test_function_base.py    License: MIT License 5 votes  def test_f32_rounding(self):
# gh-4799, check that the rounding of the edges works with float32
x = np.array([276.318359, -69.593948, 21.329449], dtype=np.float32)
y = np.array([5005.689453, 4481.327637, 6010.369629], dtype=np.float32)
counts_hist, xedges, yedges = np.histogram2d(x, y, bins=100)
assert_equal(counts_hist.sum(), 3.) 
Example 29
 Project: imitation   Author: HumanCompatibleAI   File: twod_mjc_env.py    License: MIT License 5 votes  def make_density_map(paths, map_config):
xs = np.linspace(map_config.xs, map_config.xs, num=map_config.xres + 1)
ys = np.linspace(map_config.ys, map_config.ys, num=map_config.yres + 1)
y = paths[:, 0]
x = paths[:, 1]
H, xedges, yedges = np.histogram2d(y, x, bins=(xs, ys))
H = H.astype(np.float)
H = H / np.max(H)
return H.T 
Example 30
 Project: vnpy_crypto   Author: birforce   File: test_function_base.py    License: MIT License 5 votes  def test_f32_rounding(self):
# gh-4799, check that the rounding of the edges works with float32
x = np.array([276.318359, -69.593948, 21.329449], dtype=np.float32)
y = np.array([5005.689453, 4481.327637, 6010.369629], dtype=np.float32)
counts_hist, xedges, yedges = np.histogram2d(x, y, bins=100)
assert_equal(counts_hist.sum(), 3.)