I use the following command to benchmark my model:
./build/tools/caffe time -model /path/to/deploy.prototxt -weights /path/to/caffemodel -gpu all
My question is: Does the dataset make any difference? In this case my deploy file does not point to any dataset. Also the caffemodel file should not make a difference even if it is trained for just one epoch. I believe this because the number of multiplications and additions in forward pass will remain the same no matter how trained the model is. Therefore, the benchmark time should be same and accurate regardless of whatever .caffemodel file is used. Is my assumption correct?
No, the dataset doesn't make a difference in the benchmark. Infact, there is no need to give the -weights flag even. The time functionality uses dummy data for benchmarking the model present in deploy.prototxt
I am currently working with some ErlangC calculations to determine occupancy rates. I've got the functions I need working but when I start getting into higher numbers such as POWER(145,145), ~2.50242070x10^313, I get the following:
Arithmetic overflow error converting expression to data type float.
Is there anything in MsSQL I can use to handle these larger numbers? MS Excel can, but MsSQL can't?
This is really hard. Not even Excel can handle this number. Excel can handle until 145^142 = 8.2084E+306. If you try 145^143 you will get an error.
CLR data types also do not handle this number, so CLR Data Type is not an option.
As ErlangC calculations are done for traffic modeling, I would review your process to see if you are using the correct units on your formula (minutes, seconds, etc). This number is really really big to be achieved in a Call Center if this is your case.
I am going to work on uncertainty visualization. My main problem is finding/generating a 2D/3D/n-dimensional data set with uncertain data.
How do I can generate/create a data set which includes uncertain data (with and/or without label)? Is there any benchmarking data set?
After my hardly working and searching, I could find some results:
Actually, there is no a benchmarking data set with uncertainties features. One solution is adding noise to the original data set to make uncertainties due to affection of the noise.
The ideal way is application of White Gaussian Noise. Two ways are as follows:
(1) MATLAB can support this issue with the function wgn.
(2) using randn function from MATLAB.
(3) my suggestion is using Mean * randn(n,1) + Standard Deviation, which add noise in your data set with your preferred mean and Std. (Standard Deviation)
I hope that my recommendation being useful.
I've a precomputed distance matrix for all the points in my database.
I'm trying to invoke ELKI gui with following command:
/usr/share/java/elki.jar
-dbc.in xml_files.1000
-dbc.filter FixedDBIDsFilter
-dbc.startid 0
-algorithm clustering.DBSCAN
-algorithm.distancefunction external.FileBasedDoubleDistanceFunction
-distance.matrix Distance.txt
-dbscan.epsilon 1
-dbscan.minpts 10
But I keep getting following error message :
Wrong parameter format! Parameter "dbscan.epsilon" requires a distance value, but the distance was not set!
I can't figure out what am I doing wrong here...
Which version of ELKI are you using?
This error message usually indicates an issue with the distance parser used by the matrix reader.
Since ELKI supports different valued distance functions, DBSCAN cannot parse the epsilon parameter until the actual distance value type is known (which will provide the value parsing function).
Any earlier error message? If you have any earlier error (including missing required parameters), it will prevent DBSCAN from being able to parse the value.
Try setting the epsilon value last, and also try the command line. In the MiniGUI, due to the incremental way the parameters are set, these dynamic-typed parameters unfortunately can be flaky. Any patch to improve the handling of such parameters is appreciated.
What is a simple way to see if my low-pass filter is working? I'm in the process of designing a low-pass filter and would like to run tests on it in a relatively straight forward manner.
Presently I open up a WAV file and stick all the samples in a array of ints. I then run the array through the low-pass filter to create a new array. What would an easy way to check if the low-pass filter worked?
All of this is done in C.
You can use a broadband signal such as white noise to measure the frequency response:
generate white noise input signal
pass white noise signal through filter
take FFT of output from filter
compute log magnitude of FFT
plot log magnitude
Rather than coding this all up you can just dump the output from the filter to a text file and then do the analysis in e.g. MATLAB or Octave (hint: use periodogram).
Depends on what you want to test. I'm not a DSP expert, but I know there are different things one could measure about your filter (if that's what you mean by testing).
If the filter is linear then all information of the filter can be found in the impulse response. Read about it here: http://en.wikipedia.org/wiki/Linear_filter
E.g. if you take the Fourier transform of the impulse response, you'll get the frequency response. The frequency response easily tells you if the low-pass filter is worth it's name.
Maybe I underestimate your knowledge about DSP, but I recommend you to read the book on this website: http://www.dspguide.com. It's a very accessible book without difficult math. It's available as a real book, but you can also read it online for free.
EDIT: After reading it I'm convinced that every programmer that ever touches an ADC should definitely have read this book first. I discovered that I did a lot of things the difficult way in past projects that I could have done a thousand times better when I had a little bit more knowledge about DSP. Most of the times an unexperienced programmer is doing DSP without knowing it.
Create two monotone signals, one of a low frequency and one of a high frequency. Then run your filter on the two. If it works, then the low frequency signal should be unmodified whereas the high frequency signal will be filtered out.
Like Bart above mentioned.
If it's LTI system, I would insert impulse and record the samples and perform FFT using matlab and plot magnitude.
You ask why?
In time domain, you have to convolute the input x(t) with the impulse response d(t) to get the transfer function which is tedious.
y(t) = x(t) * d(t)
In frequency domain, convolution becomes simple multiplication.
y(s) = x(s) x d(s)
So, transfer function is y(s)/x(s) = d(s).
That's the reason you take FFT of impulse response to see the behavior of the filter.
You should be able to programmatically generate tones (sine waves) of various frequencies, stuff them into the input array, and then compare the signal energy by summing the squared values of the arrays (and dividing by the length, though that's mathematically not necessary here because the signals should be the same length). The ratio of the output energy to the input energy gives you the filter gain. If your LPF is working correctly, the gain should be close to 1 for low frequencies, close to 0.5 at the bandwidth frequency, and close to zero for high frequencies.
A note: There are various (but essentially the same in spirit) definitions of "bandwidth" and "gain". The method I've suggested should be relatively insensitive to the transient response of the filter because it's essentially averaging the intensity of the signal, though you could improve it by ignoring the first T samples of the input, where T is related to the filter bandwidth. Either way, make sure that the signals are long compared to the inverse of the filter bandwidth.
When I check a digital filter, I compute the magnitude response graph for the filter and plot it. I then generate a linear sweeping sine wave in code or using Audacity, and pass the sweeping sine wave through the filter (taking into account that things might get louder, so the sine wave is quiet enough not to clip) . A visual check is usually enough to assert that the filter is doing what I think it should. If you don't know how to compute the magnitude response I suspect there are tools out there that will compute it for you.
Depending on how certain you want to be, you don't even have to do that. You can just process the linear sweep and see that it attenuated the higher frequencies.