How to assign smaller array to larger in overlapping area - python

I'm trying to put a small 8x7 2D array, inside an 8x8 2D array.
Here's what I'm working with:
--> Array called 'a' with shape 8x7
a = [[ 16., 11., 10., 16., 24., 40., 51.],
[ 12., 12., 14., 19., 26., 58., 60.],
[ 14., 13., 16., 24., 40., 57., 69.],
[ 14., 17., 22., 29., 51., 87., 80.],
[ 18., 22., 37., 56., 68., 109., 103.],
[ 24., 35., 55., 64., 81., 104., 113.],
[ 49., 64., 78., 87., 103., 121., 120.],
[ 72., 92., 95., 98., 112., 100., 103.]]
--> Array called 'b' with shape 8x8
b = [[0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0.]]
So basically, what I want is:
--> Array called 'c' with shape 8x8
c = [[ 16., 11., 10., 16., 24., 40., 51., 0],
[ 12., 12., 14., 19., 26., 58., 60., 0],
[ 14., 13., 16., 24., 40., 57., 69., 0],
[ 14., 17., 22., 29., 51., 87., 80., 0],
[ 18., 22., 37., 56., 68., 109., 103., 0],
[ 24., 35., 55., 64., 81., 104., 113., 0],
[ 49., 64., 78., 87., 103., 121., 120., 0],
[ 72., 92., 95., 98., 112., 100., 103., 0]]
Is there an easy way to do this, preferably without using loops, like 'for' , 'while', 'map'
or list comprehension?
Thank you in advance!


You can just slice assign to b up to the dimensions of a:
x, y = a.shape
b[:x, :y] = a
print(b)
array([[ 16., 11., 10., 16., 24., 40., 51., 0.],
[ 12., 12., 14., 19., 26., 58., 60., 0.],
[ 14., 13., 16., 24., 40., 57., 69., 0.],
[ 14., 17., 22., 29., 51., 87., 80., 0.],
[ 18., 22., 37., 56., 68., 109., 103., 0.],
[ 24., 35., 55., 64., 81., 104., 113., 0.],
[ 49., 64., 78., 87., 103., 121., 120., 0.],
[ 72., 92., 95., 98., 112., 100., 103., 0.]])

Related

PyTorch Matrix Product

This is the standard batch matrix multiplication:
import torch
a = torch.arange(12, dtype=torch.float).view(2,3,2)
b = torch.arange(12, dtype=torch.float).view(2,3,2) - 1
c = a.matmul(b.transpose(-1,-2))
a,b,c
>>
(tensor([[[ 0., 1.],
[ 2., 3.],
[ 4., 5.]],
[[ 6., 7.],
[ 8., 9.],
[10., 11.]]]),
tensor([[[-1., 0.],
[ 1., 2.],
[ 3., 4.]],
[[ 5., 6.],
[ 7., 8.],
[ 9., 10.]]]),
tensor([[[ 0., 2., 4.],
[ -2., 8., 18.],
[ -4., 14., 32.]],
[[ 72., 98., 124.],
[ 94., 128., 162.],
[116., 158., 200.]]]))
This is the one that I have:
e = a.view(6,2)
f = b.view(6,2)
g = e.matmul(f.transpose(-1,-2))
e,f,g
>>
(tensor([[ 0., 1.],
[ 2., 3.],
[ 4., 5.],
[ 6., 7.],
[ 8., 9.],
[10., 11.]]),
tensor([[-1., 0.],
[ 1., 2.],
[ 3., 4.],
[ 5., 6.],
[ 7., 8.],
[ 9., 10.]]),
tensor([[ 0., 2., 4., 6., 8., 10.],
[ -2., 8., 18., 28., 38., 48.],
[ -4., 14., 32., 50., 68., 86.],
[ -6., 20., 46., 72., 98., 124.],
[ -8., 26., 60., 94., 128., 162.],
[-10., 32., 74., 116., 158., 200.]]))
It's obvious that g covers c. I want to know if there is an efficient way to retrieve/slice c from g. Note that such retrieving/slicing method should generalize well to any shape of a and b.

Got it. We can just slice g with fancy indexing. We just extract the matrix multiplication result within the same batch:
g = g.view(2,3,2,3)
res = g[range(2),:,range(2),:]
res

Gaussian Fit using lmfit

I am trying to fit a gaussian. I tried to fit using OriginPro and Python. The fit in OriginPro is better than that obtained through Python and I would like to do it using Python.
OriginPro:
Python:
The code I used is:
import numpy as np
import matplotlib.pyplot as plt
import lmfit
data=data
mod=lmfit.models.GaussianModel()
x=np.arange(140,510,1)
y= np.array(np.log(data[140:510]), dtype=np.float32)
idx= (np.isfinite(y))
pars = mod.guess(y[idx], x=x[idx])
out = mod.fit(y[idx], pars, x=x[idx])
plt.plot(x[idx], out.best_fit, 'r', label='Gaussian Model')
plt.plot(x,np.log(data[140:510]))
plt.show()
data:
[ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 34., 33., 30.,
25., 47., 36., 37., 33., 41., 42., 40., 49., 47., 44., 35., 0.,
0., 0., 30., 32., 37., 36., 50., 40., 30., 41., 29., 33., 34.,
42., 41., 39., 43., 34., 30., 27., 48., 38., 20., 53., 38., 32.,
41., 40., 45., 39., 34., 33., 41., 32., 41., 41., 30., 42., 41.,
33., 62., 36., 47., 44., 35., 44., 36., 40., 35., 43., 38., 36.,
48., 50., 31., 46., 50., 43., 50., 40., 35., 39., 50., 47., 46.,
35., 39., 33., 49., 43., 56., 45., 56., 0., 0., 0., 0., 42.,
41., 43., 46., 40., 40., 38., 40., 39., 49., 33., 39., 57., 51.,
51., 43., 47., 55., 67., 68., 44., 48., 0., 0., 0., 0., 0.,
48., 66., 55., 60., 63., 58., 72., 53., 62., 55., 63., 64., 60.,
61., 56., 58., 71., 51., 74., 58., 69., 61., 50., 59., 66., 57.,
56., 68., 63., 53., 70., 73., 49., 65., 56., 62., 45., 55., 0.,
0., 0., 0., 66., 53., 52., 52., 61., 42., 53., 49., 81., 67.,
63., 69., 58., 80., 74., 51., 55., 65., 68., 56., 71., 58., 59.,
84., 54., 49., 46., 69., 57., 54., 74., 68., 60., 56., 51., 58.,
47., 57., 0., 0., 0., 0., 65., 47., 59., 39., 34., 57., 45.,
43., 57., 61., 39., 52., 48., 42., 53., 41., 0., 0., 0., 0.,
48., 35., 53., 44., 46., 52., 50., 51., 44., 55., 42., 58., 53.,
42., 0., 0., 0., 0., 41., 39., 47., 46., 46., 46., 41., 44.,
49., 48., 47., 43., 46., 38., 47., 39., 29., 53., 40., 45., 43.,
41., 23., 41., 39., 46., 37., 42., 24., 40., 46., 39., 37., 49.,
47., 37., 28., 36., 34., 34., 43., 41., 48., 42., 44., 45., 43.,
45., 36., 33., 48., 39., 54., 35., 30., 42., 34., 51., 39., 50.,
36., 34., 50., 37., 48., 40., 39., 21., 41., 40., 42., 44., 48.,
42., 42., 39., 43., 57., 37., 36., 38., 34., 50., 40., 30., 29.,
38., 44., 43., 47., 35., 37., 44., 44., 32., 36., 41., 44., 28.,
43., 36., 37., 34., 37., 0., 0., 0., 0., 54., 34., 45., 0.,
0., 0., 0., 0., 44., 32., 28., 34., 42., 35., 40., 45., 42.,
47., 39., 35., 52., 34., 55., 38., 1.]
Output for fit_report:
In [37]:out.fit_report()
Out[37]: "[[Model]]\n Model(gaussian)\n[[Fit Statistics]]\n # fitting method = leastsq\n # function evals = 17\n # data points = 333\n # variables = 3\n chi-square = 12.5923742\n reduced chi-square = 0.03815871\n Akaike info crit = -1084.59201\n Bayesian info crit = -1073.16758\n[[Variables]]\n amplitude: 3590.97370 +/- 125.195985 (3.49%) (init = 781.4034)\n center: 317.738344 +/- 3.57625327 (1.13%) (init = 322.4771)\n sigma: 361.440601 +/- 13.6760525 (3.78%) (init = 181.5)\n fwhm: 851.127556 +/- 32.2046420 (3.78%) == '2.3548200*sigma'\n height: 3.96355944 +/- 0.01657428 (0.42%) == '0.3989423*amplitude/max(1e-15, sigma)'\n[[Correlations]] (unreported correlations are < 0.100)\n C(amplitude, sigma) = 0.997"
Has it got something to do with the guess function I used?

Hints give in the comments seem to be insufficient. You need to include an offset in your model. A Gaussian function goes to 0 far from the peak intensity - I don't know what OriginPro is doing, but clearly, it is modeling more than a Gaussian.
Try making a model that is a Gaussian + a Constant, as with:
import numpy as np
import matplotlib.pyplot as plt
import lmfit
data = np.array([ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
34., 33., 30., 25., 47., 36., 37., 33., 41., 42., 40.,
49., 47., 44., 35., 0., 0., 0., 30., 32., 37., 36., 50.,
40., 30., 41., 29., 33., 34., 42., 41., 39., 43., 34.,
30., 27., 48., 38., 20., 53., 38., 32., 41., 40., 45.,
39., 34., 33., 41., 32., 41., 41., 30., 42., 41., 33.,
62., 36., 47., 44., 35., 44., 36., 40., 35., 43., 38.,
36., 48., 50., 31., 46., 50., 43., 50., 40., 35., 39.,
50., 47., 46., 35., 39., 33., 49., 43., 56., 45., 56.,
0., 0., 0., 0., 42., 41., 43., 46., 40., 40., 38., 40.,
39., 49., 33., 39., 57., 51., 51., 43., 47., 55., 67.,
68., 44., 48., 0., 0., 0., 0., 0., 48., 66., 55., 60.,
63., 58., 72., 53., 62., 55., 63., 64., 60., 61., 56.,
58., 71., 51., 74., 58., 69., 61., 50., 59., 66., 57.,
56., 68., 63., 53., 70., 73., 49., 65., 56., 62., 45.,
55., 0., 0., 0., 0., 66., 53., 52., 52., 61., 42., 53.,
49., 81., 67., 63., 69., 58., 80., 74., 51., 55., 65.,
68., 56., 71., 58., 59., 84., 54., 49., 46., 69., 57.,
54., 74., 68., 60., 56., 51., 58., 47., 57., 0., 0., 0.,
0., 65., 47., 59., 39., 34., 57., 45., 43., 57., 61.,
39., 52., 48., 42., 53., 41., 0., 0., 0., 0., 48., 35.,
53., 44., 46., 52., 50., 51., 44., 55., 42., 58., 53.,
42., 0., 0., 0., 0., 41., 39., 47., 46., 46., 46., 41.,
44., 49., 48., 47., 43., 46., 38., 47., 39., 29., 53.,
40., 45., 43., 41., 23., 41., 39., 46., 37., 42., 24.,
40., 46., 39., 37., 49., 47., 37., 28., 36., 34., 34.,
43., 41., 48., 42., 44., 45., 43., 45., 36., 33., 48.,
39., 54., 35., 30., 42., 34., 51., 39., 50., 36., 34.,
50., 37., 48., 40., 39., 21., 41., 40., 42., 44., 48.,
42., 42., 39., 43., 57., 37., 36., 38., 34., 50., 40.,
30., 29., 38., 44., 43., 47., 35., 37., 44., 44., 32.,
36., 41., 44., 28., 43., 36., 37., 34., 37., 0., 0., 0.,
0., 54., 34., 45., 0., 0., 0., 0., 0., 44., 32., 28.,
34., 42., 35., 40., 45., 42., 47., 39., 35., 52., 34.,
55., 38., 1.])
data = data[140:510]
ipos = np.where(data>0)[0]
data = np.log(data[ipos])
x = np.arange(140,510,1.0)[ipos]
mod = lmfit.models.GaussianModel() + lmfit.models.ConstantModel()
pars = mod.make_params(c=data.mean(),
center=x.mean(),
sigma=x.std(),
amplitude=x.std()*data.ptp())
out = mod.fit(data, pars, x=x)
print(out.fit_report())
plt.plot(x, out.best_fit, 'r', label='Gaussian Model')
plt.plot(x, data)
plt.show()
This will print a report of
[Model]]
(Model(gaussian) + Model(constant))
[[Fit Statistics]]
# fitting method = leastsq
# function evals = 48
# data points = 333
# variables = 4
chi-square = 9.50683177
reduced chi-square = 0.02889615
Akaike info crit = -1176.19189
Bayesian info crit = -1160.95932
[[Variables]]
amplitude: 58.7086539 +/- 5.27950257 (8.99%) (init = 153.376)
center: 302.462920 +/- 2.79518589 (0.92%) (init = 322.6336)
sigma: 48.1997878 +/- 3.66967747 (7.61%) (init = 106.8759)
c: 3.64131210 +/- 0.01679060 (0.46%) (init = 3.796494)
fwhm: 113.501824 +/- 8.64142989 (7.61%) == '2.3548200*sigma'
height: 0.48592258 +/- 0.02641186 (5.44%) == '0.3989423*amplitude/max(1e-15, sigma)'
[[Correlations]] (unreported correlations are < 0.100)
C(amplitude, c) = -0.832
C(amplitude, sigma) = 0.798
C(sigma, c) = -0.664
and a plot of

Plotting 3D Bar Chart with Plotly

I want to plot a 3d bar chart like in this example but I can not or dont know how to use the code for my data. This is how my data looks like:
z = np.array([[ -10., -40., 0., 20., 10., 0., 0., 0.],
[ 0., -50., -60., -20., 20., 0., 0., 0.],
[ -60., -140., -90., -20., 20., 0., 0., 0.],
[ 190., -70., -240., 20., 20., 0., 0., 0.],
[ 430., 70., -380., -20., 20., 0., 0., 0.],
[ 170., 0., -280., -110., 20., 0., 0., 0.],
[ 20., 10., -90., -80., 20., 0., 0., 0.],
[ 20., 20., 20., 20., 20., 0., 0., 0.]])
This is how it shoud look like but with my data and a grid of 8x8:
My z-values represent the height/depth of the bins. So in total I would have 8x8 bins on this 3D plot.
I want to use Plotly because the plot will be embedded in Plotly Dash and should be interactive.
So how do I need to change my data fromat to use the code from this example or is there another possibility to get such a plot in plotly?

How to find first minimum after first peak in array?

I am trying to find the first minimum after the first peak in a data array. Here is my code:
x = array
mins = argrelextrema(x, np.less)[0]
mins_above_zero = np.where(x[mins] > 0)[0]
ag = x[mins[mins_above_zero]].argmin()
true_minimum_index = mins[ag]
pyplot.scatter(mins, x[mins])
pyplot.plot(x)
pyplot.ylim(0, 2000)
It currently picks out too many minimums.
If I have a numpy array like this:
array([ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 1., 0., 0., 0., 0., 1., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 1., 0., 1., 0.,
0., 0., 1., 1., 0., 0., 2., 0., 2., 1., 3.,
1., 2., 5., 8., 6., 55., 396., 608., 157., 40., 45.,
43., 51., 74., 89., 107., 121., 98., 111., 122., 170., 187.,
190., 229., 284., 372., 450., 457., 327., 328., 318., 288., 290.,
262., 235., 223., 177., 232., 217., 234., 261., 206., 192., 221.,
189., 181., 185., 162., 140., 144., 171., 176., 168., 213., 222.,
314., 397., 413., 429., 442., 352., 416., 439., 424., 480., 479.,
515., 522., 569., 543., 626., 666., 637., 680., 678., 747., 720.,
695., 674., 605., 490., 475., 332., 284., 252., 169., 140., 117.,
86., 71., 58., 55., 37., 45., 35., 25., 21., 16., 14.,
17., 12., 9., 7., 6., 0., 6., 6., 6., 3., 1.,
1., 4., 2., 1., 4., 0., 2., 2., 0., 1., 2.,
0., 0., 4., 0., 1., 1., 0., 0., 0., 0., 0.,
0., 1., 1., 0.])
That creates a plot like this except just with the minimum after the first peak:

Try playing with the order of argrelextrema
With your array data:
x = array
# Order 2 looks at more than just the immediate numbers around a variable
mins = argrelextrema(x, np.less, order=2)[0]
print(mins)
mins_above_zero = np.where(x[mins] > 0)[0]
ag = x[mins[mins_above_zero]].argmin()
true_minimum_index = mins[ag]
#Grabs the first relative minimum
mins = mins[0]
pyplot.scatter(mins, x[mins])
pyplot.plot(x)
pyplot.ylim(0, 2000)
Which creates:

python numpy subtract elements that are matrices

Using numpy, how can I subtract the elements of a numpy array that are matrices by each other?
a = np.array([ [ [1., 2., 3.], [4., 5., 6.], [7., 8., 9.] ],
[ [20., 21., 22.], [23., 24., 25.], [26., 27., 28.] ],
[ [30., 31., 32.], [33., 34., 35.], [36., 37., 38.] ]
])
or in plain English:
a = ([matrix1], [matrix2], [matrix3])
I want to get a np.array that calculates as follows:
[matrix1-matrix1][matrix1-matrix2][matrix1-matrix3]
[matrix2-matrix1][matrix2-matrix2][matrix2-matrix3]
[matrix3-matrix1][matrix3-matrix2][matrix3-matrix3]
Diagonal will be a matrix with zero values in the matrix.
How can I accomplish this?

Your a is a 3d array
In [258]: a = np.array([ [ [1., 2., 3.], [4., 5., 6.], [7., 8., 9.] ],
.....: [ [20., 21., 22.], [23., 24., 25.], [26., 27., 28.] ],
.....: [ [30., 31., 32.], [33., 34., 35.], [36., 37., 38.] ]
.....: ])
In [259]: a.shape
Out[259]: (3, 3, 3)
2d arrays can be accessed with indexing
In [260]: a[0,:,:]
Out[260]:
array([[ 1., 2., 3.],
[ 4., 5., 6.],
[ 7., 8., 9.]])
and a tuple of 3 2d arrays can be obtained with:
In [261]: (a[0,:,:],a[1,:,:],a[2,:,:])
Out[261]:
(array([[ 1., 2., 3.],
[ 4., 5., 6.],
[ 7., 8., 9.]]),
array([[ 20., 21., 22.],
[ 23., 24., 25.],
[ 26., 27., 28.]]),
array([[ 30., 31., 32.],
[ 33., 34., 35.],
[ 36., 37., 38.]]))
This is equivalent to your (matrix1, matrix2, matrix3) expression. I'm using 2d array instead of matrix because numpy has an array subclass called matrix, so the term can be confusing.
A way to generate your subarray cross-difference is with broadcasting. I use the None syntax to expand the dimension of a.
In [262]: a[:,None,:,:]-a[None,:,:,:]
Out[262]:
array([[[[ 0., 0., 0.],
[ 0., 0., 0.],
[ 0., 0., 0.]],
[[-19., -19., -19.],
[-19., -19., -19.],
[-19., -19., -19.]],
...
[[ 10., 10., 10.],
[ 10., 10., 10.],
[ 10., 10., 10.]],
[[ 0., 0., 0.],
[ 0., 0., 0.],
[ 0., 0., 0.]]]])
In [263]: _.shape
Out[263]: (3, 3, 3, 3)
The shape of this new array is 4d, which can be thought of as a 3x3 array of 3x3 arrays. And yes, the diagonal elements A[i,i,:,:] are all 0s.
In [264]: A=a[:,None,:,:]-a[None,:,:,:]
In [265]: A[2,2,:,:]
Out[265]:
array([[ 0., 0., 0.],
[ 0., 0., 0.],
[ 0., 0., 0.]])

Categories

Resources