We Keep Coding

Chumpy minimization of gaussian pyramid leads to dimension mismatch

I am attempting to minimize an energy function between a rendered 3d scene and an image with opendr as in the example given in the OpenDR Paper
I have essentially copied the code from the paper, but used my own image and 3d object. Here is the code to create the renderer:
V = ch.array(m.v)
rn = TexturedRenderer()
rn.frustum = {'near': 1., 'far': 1., 'width': 350, 'height': 500}
rn.camera = ProjectPoints(v=m.v, t=np.array([0, 0, 1]), rt=np.zeros(3), f=[450, 450],
c=[350/2, 500/2], k=np.zeros(5))
rn.set(v=m.v, f=m.f, texture_image =img, ft=m.ft, vt=m.vt, bgcolor=ch.zeros(3))
A = SphericalHarmonics(vn=VertNormals(v=V, f=rn.f), components=ch.array([4,0,0,0]),
light_color=ch.array([1,1,1]))
rn.set(vc = A)
where m is the mesh of the object loaded with opendr's load_mesh. And then I calculate the energy and use ch.minimize just as in the paper:
translation, rotation = ch.array([0,0,4]), ch.zeros(3)
rn.v = translation + m.v.dot(Rodrigues(rotation))
# Create the energy
difference = rn - load_image(img_file)
E = gaussian_pyramid(difference, n_levels=5, normalization='SSE')
# Minimize the energy
light_parms = A.components
ch.minimize(E, x0=[translation])
ch.minimize(E, x0=[translation, rotation, light_parms])
I've confirmed the renderer and the image shape are both 500x350x3. It always returns a dimension mismatch which occurs in a scipy sparse matmul operation that occurs when the state is updated in the minimize_dogleg function of chumpy. I've modified the file to output the shapes of the matrices in the matmul operation through the iterations and with n=5 the shapes it returns are
(129978, 519912) (519912, 525000)
(31992, 127452) (127452, 129978)
(7686, 30744) (30744, 31992)
(1800, 7080) (7080, 7686)
(378, 1512) (1512, 1800)
(256, 256) (105279, 3)
with the last one being where it returns the error. I've altered the number of pyramids and the results are the same and the final shapes of the two matrices are also always the same (unless I go too high then it gives a different error because the matrix becomes too small). One thing I notice is that the error always occurs at n_levels + 1 iterations which seems odd to me as I would think it stops at n_levels, but I have little understanding of what's actually happening in the minimization. For a little extra context the mesh has 35093 vertices E has a length of 686970. Is there anyone that could assist me as to what exactly is happening here or how the minimize is functioning and why the error is occurring on n_levels + 1 iterations.

The problem was fixed by instead using the opendr version from https://github.com/polmorenoc/opendr as opposed to the mattloper version

Resampling 2-d array using Fourier transform method

I have a question on the resampling 2-d array.
Sometimes, the original size of the geoscience data should be transformed to other size. If the ratio for each axis is equal, the task is simple, in which np.reshape allow a 2-d array of 100x100 to 50x50 without data loss. The code is shown as:
## creat a original data
xc1, xc2, yc1, yc2 = 100, 110, 35, 45
XSIZE,YSIZE=100,100
lon,lat = np.linspace(xc1,xc2,XSIZE),np.linspace(yc1,yc2,YSIZE)
pop = np.random.uniform(low=1000, high=50000, size=(XSIZE*YSIZE,)).reshape(YSIZE,XSIZE)
## reshape
shape = np.array(pop.shape, dtype=float)
coarseness = 2 # the new shape is in 50 x 50
new_shape = coarseness * np.ceil(shape/coarseness).astype(int)
zp_pop = np.zeros(new_shape)
zp_pop[:int(shape[0]), :int(shape[1])] = pop
temp = zp_pop.reshape((new_shape[0] // coarseness, coarseness,
new_shape[1] // coarseness, coarseness))
coarse_pop = np.sum(temp, axis=(1,3))
print (pop.sum())
print (coarse_pop.sum())
However, when the coarse factor is different for each axis, this method can not be implemented. I turned to apply other method. Here is an example I tried to use FFT to generate a 60*80 array as output
from scipy import fftpack
pop_fft = fftpack.fft2(pop,shape = (60,80))
pop_res = fftpack.ifft2(pop_fft).real
print(pop.sum())
print(pop_res.sum())
254208134.8356425
122048754.13639387
The data loss was significant. Thus, I posted my issue here. Maybe the resampling function I used was not correct. Or there are some better approach to deal with this situation. Any advices or comments are highly appreciated!

When you set up the 'coarse array' yourself you sum over adjacent entries, instead of computing the average or interpolating.
This way the sum over all elements in the coarse and original array are identical str((coarse_pop.sum()-pop.sum())/(0.5*(pop.sum()+coarse_pop.sum()))) gives '-1.1638426077573779e-16' only a tiny numerical error.
if you compare the mean of the fftpack resampled coarse array it matches up:
print(pop.mean())
print(pop_res.mean())
25606.832220313503
25496.03271480075
alternatively you can correct for the number of elements yourself:
print(pop.sum())
print(pop_res.sum()*100*100/(60*80))
256068322.20313504
254960327.14800745
I don't know about your problem but the fftpack way of downsampling the array makes more sense to me. if it's not what you want you can apply the prefactor to the original array, like pop_fft = fftpack.fft2(pop*100*100/(60*80),shape = (60,80))

How should I modify the test data for SVM method to be able to use the `precomputed` kernel function without error?

I am using sklearn.svm.SVR for a "regression task" which I want to use my "customized kernel method". Here is the dataset samples and the code:
index density speed label
0 14 58.844020 77.179139
1 29 67.624946 78.367394
2 44 77.679100 79.143744
3 59 79.361877 70.048869
4 74 72.529289 74.499239
.... and so on
from sklearn import svm
import pandas as pd
import numpy as np
density = np.random.randint(0,100, size=(3000, 1))
speed = np.random.randint(20,80, size=(3000, 1)) + np.random.random(size=(3000, 1))
label = np.random.randint(20,80, size=(3000, 1)) + np.random.random(size=(3000, 1))
d = np.hstack((a,b,c))
data = pd.DataFrame(d, columns=['density', 'speed', 'label'])
data.density = data.density.astype(dtype=np.int32)
def my_kernel(X,Y):
return np.dot(X,X.T)
svr = svm.SVR(kernel=my_kernel)
x = data[['density', 'speed']].iloc[:2000]
y = data['label'].iloc[:2000]
x_t = data[['density', 'speed']].iloc[2000:3000]
y_t = data['label'].iloc[2000:3000]
svr.fit(x,y)
y_preds = svr.predict(x_t)
the problem happens in the last line svm.predict which says:
X.shape[1] = 1000 should be equal to 2000, the number of samples at training time
I searched the web to find a way to deal with the problem but many questions alike (like {1}, {2}, {3}) were left unanswered.
Actually, I had used SVM methods with rbf, sigmoid, ... before and the code was working just fine but this was my first time using customized kernels and I suspected that it must be the reason why this error happened.
So after a little research and reading documentation I found out that when using precomputed kernels, the shape of the matrix for SVR.predict() must be like [n_samples_test, n_samples_train] shape.
I wonder how to modify x_test in order to get predictions and everything works just fine with no problem like when we don't use customized kernels?
If possible please describe "the reason that why the inputs for svm.predict function in precomputed kernel differentiates with the other kernels".
I really hope the unanswered questions that are related to this issue could be answered respectively.

The problem is in your kernel function, it doesn't do the job.
As the documentation https://scikit-learn.org/stable/modules/svm.html#using-python-functions-as-kernels says, "Your kernel must take as arguments two matrices of shape (n_samples_1, n_features), (n_samples_2, n_features) and return a kernel matrix of shape (n_samples_1, n_samples_2)." The sample kernel on the same page satisfies this criteria:
def my_kernel(X, Y):
return np.dot(X, Y.T)
In your function the second argument of dot is X.T and thus the output will have shape (n_samples_1, n_samples_1) which is not that is expected.

The shape does not match means the test data and train data are of not equal shape, always think about matrix or array in numpy. If you are doing any arithmetic operation you always need a similar shape. That's why we check array.shape.
[n_samples_test, n_samples_train] you can modify shapes but its not best idea.
array.shape, reshape, resize
are used for that

How to represent Word2Vec model to graph? (or convert a 1x300 numpy array to just 1x2 array)

I have a 1x300 numpy array from my Word2Vec model which is returns like this:
[ -2.55022556e-01 1.06162608e+00 -5.86191297e-01 -4.43067521e-01
4.46810514e-01 4.31743741e-01 2.16610283e-01 9.27684903e-01
-4.47879761e-01 -9.11142007e-02 3.27048987e-01 -8.05553675e-01
-8.54483843e-02 -2.85595834e-01 -2.70745698e-02 -3.08014955e-02
1.53204888e-01 3.16114485e-01 -2.82659411e-01 -2.98218042e-01
-1.03240972e-02 2.12806061e-01 1.63605273e-01 9.42423999e-01
1.20789325e+00 4.11570221e-01 -5.46323597e-01 1.95108235e-01
-4.53743488e-01 -1.28625661e-01 -7.43277609e-01 1.11551750e+00
-4.51873302e-01 -1.14495361e+00 -6.69551417e-02 6.88364863e-01
-6.01781428e-01 -2.36386538e-01 -3.64305973e-01 1.18274912e-01
2.03438237e-01 -1.01153564e+00 6.67958856e-01 1.80363625e-01
1.26524955e-01 -2.96024203e-01 -9.93479714e-02 -4.93405871e-02
1.02504417e-01 7.63318688e-02 -3.68398607e-01 3.03587675e-01
-2.90227026e-01 1.51891649e-01 -6.93689287e-03 -3.99766594e-01
-1.86124116e-01 -2.86920428e-01 2.04880714e-01 1.39914978e+00
1.84370011e-01 -4.58923727e-01 3.91094625e-01 -7.52937734e-01
3.05261135e-01 -4.55163687e-01 7.22679734e-01 -3.76093656e-01
6.05900526e-01 3.26470852e-01 4.72957864e-02 -1.18182398e-01
3.51043999e-01 -3.07209432e-01 -6.10330477e-02 4.14131492e-01
7.57511556e-02 -6.48704231e-01 1.42518353e+00 -9.20495167e-02
6.36665523e-01 5.48510313e-01 5.92754841e-01 -6.29535854e-01
-4.47180003e-01 -8.99413109e-01 -1.52441502e-01 -1.98326513e-01
4.74154204e-01 -2.07036674e-01 -6.70400202e-01 6.67807996e-01
-1.04234733e-01 7.16163218e-01 3.32825005e-01 8.20083246e-02
5.88186264e-01 4.06852067e-01 2.66174138e-01 -5.35981596e-01
3.26077454e-02 -4.04357493e-01 2.19569445e-01 -2.74264365e-01
-1.65187627e-01 -4.06753153e-01 6.12065434e-01 -1.89857081e-01
-5.56927800e-01 -6.78636551e-01 -7.52498448e-01 1.04564428e+00
5.32510102e-01 5.05628288e-01 1.95120305e-01 -6.40793025e-01
5.73082231e-02 -1.58281475e-02 -2.62718409e-01 1.74351722e-01
-6.95129633e-02 3.44214857e-01 -4.24746841e-01 -2.75907904e-01
-6.60992935e-02 -1.19041657e+00 -6.01056278e-01 5.67718685e-01
-6.47478551e-02 1.55902460e-01 -2.48480186e-01 5.56753576e-01
1.29889056e-01 3.91534269e-01 1.28707469e-01 1.29670590e-01
-6.98880851e-01 2.43386969e-01 7.70289376e-02 -1.14947490e-01
-4.31593180e-01 -6.16873622e-01 6.03831768e-01 -2.07050622e-01
1.23276520e+00 -1.67524610e-02 -4.67656374e-01 1.00281858e+00
5.17916441e-01 -7.99495637e-01 -4.22653735e-01 -1.45487636e-01
-8.71369673e-04 1.25453219e-01 -1.25869447e-02 4.66426492e-01
5.07026255e-01 -6.53024793e-01 7.53435045e-02 8.33864748e-01
3.37398499e-01 7.50920832e-01 -4.80326146e-01 -4.52838868e-01
5.92808545e-01 -3.57870340e-01 -1.07011057e-01 -1.13945460e+00
3.97635132e-01 1.23554178e-01 4.81683850e-01 5.47445454e-02
-2.18614921e-01 -2.00085923e-01 -3.73975009e-01 8.74632657e-01
6.71471596e-01 -4.01738763e-01 4.76147681e-01 -5.79257011e-01
-1.51511624e-01 1.43170074e-01 5.00052273e-01 1.46719962e-01
2.43085429e-01 5.89158475e-01 -5.25088668e-01 -2.65306592e-01
2.18211919e-01 3.83228660e-01 -2.51622144e-02 2.32621357e-01
8.06669474e-01 1.37254462e-01 4.59401071e-01 5.63044667e-01
-5.79878241e-02 2.68106610e-01 5.47239482e-01 -5.05441546e-01]
It's so frustrating to read because I just want to get a 1x2 array like [12,19] so I can represent it to graph and make a cosine distance measurement to the 1x2 array.
How to do it? Or how to represent the 1x300 Word2Vec model to a 2D graph?

There are many ways to apply "dimensionality reduction" to high-dimensional data, for aid in interpretation or graphing.
One super-simple way to reduce your 300-dimensions to just 2-dimensions, for plotting on a flat screen/paper: just discard 298 of the dimensions! You'll have something to plot – such as the point (-0.255022556, 1.06162608) if taking just the 1st 2 dimensions of your example vector.
However, starting from word2vec vectors, those won't likely be very interesting points, individually or when you start plotting multiple words. The exact axes dimensions of such vectors are unlikely to be intuitively meaningful to humans, and you're throwing 99.7% of all the meaning per vector away – and quite likely the dimensions which (in concert with each other) capture semantically-meaningful relationships.
So you'd be more likely to do some more thoughtful dimensionality-reduction. A super-simple technique would be to pick two vector-directions that are thought to be meaningful as your new X and Y axes. In the word2vec world, these wouldn't necessarily be existing vectors in the set – though they could be – but might be the difference between two vectors. (The analogy-solving power of word2vec vectors essentially comes from discovering the difference-between two vectors A and B, then applying that difference to a third vector C to find a 4th vector D, at which point D often has the same human-intuitive analogical-relationship to C as B had to A.)
For example, you might difference the word-vectors for 'man' and 'woman', to get a vector which bootstraps your new X-axis. Then difference the word-vectors for 'parent' and 'worker', to get vector which bootstraps your new Y-axis. Then, for every candidate 300-dimensional vector you want to plot, find that candidate vector's "new X" by calculating the magnitude of its projection onto your X-direction-vector. Then, find that candidate vector's "new Y" by calculating the magnitude of its projection onto your Y-direction-vector. This might result in a set of relative values that, on a 2-D chart, vaguely match human intuitions about often-observed linguisti relationships between gender and familial/workplace roles.
As #poorna-prudhvi's comment mentions, PCA and t-SNE are other techniques – which may specifically do better at preserving certain interesting qualities of the full-dimensional data. t-SNE, especially, was invented for to support machine-learning and plotting, and tries to keep the distance-relationships that existed in the higher-number-of-dimensions similar in the lower-number-of-dimensions.

In addition to #gojomo's answer, if it's only for experimenting i'd recommend using tensorflow's projector which provides a nice GUI for out of the box (approx) PCA and t-SNE.
Just use numpy.savetxt to format your vectors properly.

signal.correlate 'same'/'full' meaning?

I am wondering what the mode arguments in signal.correlate (or numpy.correlate) mean?
def crossCorrelator(sig1, sig2):
correlate = signal.correlate(sig1,sig2,mode='same')
return(correlate)
flux0 = [ 0.02006948 0.01358697 -0.06196026 -0.03842506 -0.09023056 -0.05464169 -0.02530553 -0.01937054 -0.01237411 0.03472263 0.17865012 0.27441767 0.23532932 0.16358341 0.08743969 0.12166425 0.10287468 0.13430794 0.08262321 0.0515434 0.04657624 0.09017276 0.09131331 0.04696824 -0.03901519 -0.01413654 0.05448175 0.1236946 0.09968044 -0.001584 -0.06094561 -0.02998289 -0.00113092 0.04336605 0.01105071 0.0527657 0.03825847 0.02309524]
flux1 = [-0.02946104 -0.02590192 -0.02274955 0.00485888 -0.0149776 0.01757462 0.02820086 0.0379213 0.03580811 0.06507382 0.09995243 0.12814133 0.16109725 0.12371425 0.08273643 0.09433014 0.05137761 0.04057405 -0.08171598 -0.06541216 0.00126869 0.09223577 0.06811737 0.0795967 0.08689563 0.0928949 0.09971169 0.05413958 0.05410236 0.00120439 0.02454734 0.06450544 0.01508899 -0.06100537 -0.10038889 -0.00651572 0.01095773 0.05517478]
correlation = crossCorrelator(flux0,flux1)
f, axarr = plt.subplots(2)
axarr[0].plot(np.arange(len(flux0)),flux0)
axarr[0].plot(np.arange(len(flux1)),flux1)
axarr[1].plot(np.arange(len(correlation)),correlation)
plt.show()
When I use mode 'same' the correlation array has same dimension as the fluxes for full it has double? If the len(flux0/1) is of dimension time what dimension would len(correlation) be ?
I am really more looking for a mathematical explanation, the answers I have found so far were more of technical nature...

Given two sequences (a[0], .., a[A-1]) and (b[0], .., b[B-1]) of lengths A and B, respectively, the convolution is calculated as
c[n] = sum_m a[m] * b[n-m]
If mode=="full" then the convolution is calculated for n ranging from 0 to A+B-2, so the return array has A+B-1 elements.
If mode=="same" then scipy.signal.correlate computes the convolution for n ranging from (B-1)/2 to A-1+(B-1)/2, where integer division is assumed. The return array has A elements. numpy.correlate behaves the same way only if A>=B; if A is less than B it switches the two arrays (and the returned array has B elements).
If mode=="valid" then the convolution is calculated for n ranging from min(A,B)-1 to max(A,B)-1, and therefore has max(A,B)-min(A,B)+1 elements.