Lmbda | generate lambdas from method handles | Reflection library

To answer my own question, the issue turned out to be one of vector shape. I enjoy coding in 2D, but SciPy optimization routines only work with column and row vectors that have been "flattened" to an array. Multi-dimensional matrices are fine, but column and row vectors are a bridge too far.

For example, if y is a vector of labels and y.shape is (400,1), you would need to use y.flatten() on y, which would make y.shape = (400,). Then SciPy would work with your data assuming all other dimensions made sense.

So, if your efforts to translate MATLAB machine learning code to Python have stalled, check to ensure you have flattened your row and column vectors, especially those returned by a gradient function.

To start with, the statement "I want the lambda value to be positive" makes no sense at all; Box-Cox transformation is a well-defined mathematical operation, and what it will return does not in any way depend on what we may want or prefer.

Second, according to the documentation:

If lmbda is None, find the lambda that maximizes the log-likelihood function and return it as the second output argument.

so, not any list of returned values either - only a single (optimal) value is returned.

Third, Box-Cox is not a panacea; it may very well be the case that the resulting transformation of the data is not appropriate for your case (as you imply here).

Now, it's true that according again to the SciPy documentation:

The Box-Cox transform is given by:

To achieve a good disparity map:

1. Your scene should have random texture. If the scene is highly textured you will get good disparity map.

Bad disparity map:

1. When your calibration data goes wrong. You should get your calibration data correct.
2. When your scene have repetitive patterns or un-textured your disparity is map would have lost more data. We cannot call it directly as bad map but its expected behavior.

After carefully reading the code I realized it the grad vector has to be a list and not a NumPy array. Not sure if my implementation works properly yet but the error is gone

My network does always predict the same class. What is the problem?

I had this a couple of times. Although I'm currently too lazy to go through your code, I think I can give some general hints which might also help others who have the same symptom but probably different underlying problems.

For every class i the network should be able to predict, try the following:

1. Create a dataset of only one data point of class i.
2. Fit the network to this dataset.
3. Does the network learn to predict "class i"?

If this doesn't work, there are four possible error sources:

1. Buggy training algorithm: Try a smaller model, print a lot of values which are calculated in between and see if those match your expectation.
   1. Dividing by 0: Add a small number to the denominator
   2. Logarithm of 0 / negativ number: Like dividing by 0
2. Data: It is possible that your data has the wrong type. For example, it might be necessary that your data is of type float32 but actually is an integer.
3. Model: It is also possible that you just created a model which cannot possibly predict what you want. This should be revealed when you try simpler models.
4. Initialization / Optimization: Depending on the model, your initialization and your optimization algorithm might play a crucial role. For beginners who use standard stochastic gradient descent, I would say it is mainly important to initialize the weights randomly (each weight a different value). - see also: this question / answer

See sklearn for details.

The idea is to start with a tiny training dataset (probably only one item). Then the model should be able to fit the data perfectly. If this works, you make a slightly larger dataset. Your training error should slightly go up at some point. This reveals your models capacity to model the data.

Check how often the other class(es) appear. If one class dominates the others (e.g. one class is 99.9% of the data), this is a problem. Look for "outlier detection" techniques.

• Learning rate: If your network doesn't improve and get only slightly better than random chance, try reducing the learning rate. For computer vision, a learning rate of 0.001 is often used / working. This is also relevant if you use Adam as an optimizer.
• Preprocessing: Make sure you use the same preprocessing for training and testing. You might see differences in the confusion matrix (see this question)

This is inspired by reddit:

• You forgot to apply preprocessing
• Dying ReLU
• Too small / too big learning rate
• Wrong activation function in final layer:
  • Your targets are not in sum one? -> Don't use softmax
  • Single elements of your targets are negative -> Don't use Softmax, ReLU, Sigmoid. tanh might be an option
• Too deep network: You fail to train. Try a simpler neural network first.
• Vastly unbalanced data: You might want to look into imbalanced-learn

Okay I think I maybe figured it out, sort of. There were many small problems but the biggest thing was I needed to add the compute_output_shape function which makes the layer able to modify the shape of its input as explained here: https://keras.io/layers/writing-your-own-keras-layers/

So here is the code with all the changes I made. It will compile and modify the input shape just fine. Note that this layer computes weight changes inside the layer itself and there may be some issues with that if you try to actually use the layer (I'm still ironing these out), but this is a separate issue.

You are doing the math wrong. The translation in code of the formula you want to implement is:

Let's first import the essentials, load the data and transform the series,

The disparity image seems to be correct. But for the depth/distance calculation, you should not hard code the baseline and focal length. You should rather take it from the calibration matrix. Q matrix contains the baseline. This is mainly because, the units of distance(cm/mm/m) is present in the calibration process and later stored in calibration matrices.

So I advice you to take it from the Q matrix.