# 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
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
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
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)[0]

# 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[0]))
s2 = np.sum(jh, axis=1).reshape((jh.shape[1], -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
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)[0]
result = np.fix(255.0 * counts / n_vals + 0.999).astype(int)

return {"DMDT": result} 
Example 5
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
def morista_index(points):
# Morisita Index of Dispersion

N = points.shape[1]

ims = []
for i in range(1, N):
bins, _, _ = np.histogram2d(points[0], points[1], 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[1].max() 
Example 7
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)[0] 
Example 8
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
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)[0]
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
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
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[0], y[-1]]],
bins=bins, weights=weights.flatten(), normed=False)[0].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
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
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
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
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)[0]
mi = metrics.mutual_info_score(None, None, contingency=c_xy)
return mi 
Example 16
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)[0] 
Example 17
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
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
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
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
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
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
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)[0]
p_y = np.histogram(y, bins)[0]
p_xy = np.histogram2d(x, y, bins)[0].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
def fit(self, magnitude, time, PeriodLS, Amplitude, phase_bins, mag_bins):
first_period = PeriodLS[0]
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
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
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[0]), stretch_0_to_1(proj.T[1])]).T
morista_sum = 0
N = scaled_proj.shape[0]
for i in range(self.num_bin_range[0], self.num_bin_range[1]):
bins, _, _ = np.histogram2d(scaled_proj.T[0], scaled_proj.T[1], 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[1] - self.num_bin_range[0]) 
Example 27
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
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
def make_density_map(paths, map_config):
xs = np.linspace(map_config.xs[0], map_config.xs[1], num=map_config.xres + 1)
ys = np.linspace(map_config.ys[0], map_config.ys[1], 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
def test_f32_rounding(self):
assert_equal(counts_hist.sum(), 3.)