Develop Reference

Numpy np.interp in tensorlflow

I'm looking for function for linear interpolation in tensorflow similar to np.interp(..)
I'm aware that tensorflow is able to receive any numpy function and apply it on tensors but
np.interp is only activated on single object and as far as I checked couldn't be broadcasted.
so is there any efficient way to apply it using tensoflow ?
Thank you

I know this is a late answer, but google brought me here, so my answer might be useful for others.
You can use the interp_regular_1d_grid from tensorflow probability.
It works in a similar fashion as numpy.interp(), but consult the documentation for exact functionality.

How to migrate NumPy preprocessing into a TensorFlow graph?

I'm using TensorFlow for machine learning on Ogg and MIDI data, but a lot of preprocessing is done in NumPy (with feed_dict:s), and I'd like to migrate as much of it as possible into the computational graph in order to simplify production deployment (Google Cloud ML, or maybe self-hosted TensorFlow Serving). How would I go about this? Are there ways of converting NumPy to TensorFlow operations automatically?

Most of the Numpy functions have their TensorFlow equivalent documented in array_ops.
For the more mathematical operations, have a look at math_ops.
Finally, if you have more specific queries or are unable to convert some Numpy code to TensorFlow, you should always try to search StackOverflow Q/A or ask a question here. (Have a look at this for a good example of such a question).
Unrelated - If you face difficulties carrying out some matrix manipulation, try to look at the existing Numpy Q/A on StackOverflow. They can easily be applied to TensorFlow using the APIs above.

Python: matrix completion functions/library?

Are there functions in python that will fill out missing values in a matrix for you, by using collaborative filtering (ex. alternating minimization algorithm, etc). Or does one need to implement such functions from scratch?
[EDIT]: Although this isn't a matrix-completion example, but just to illustrate a similar situation, I know there is an svd() function in Matlab that takes a matrix as input and automatically outputs the singular value decomposition (svd) of it. I'm looking for something like that in Python, hopefully a built-in function, but even a good library out there would be great.

Check out numpy's linalg library to find a python SVD implementation

There is a library fancyimpute. Also, sklearn NMF

Why do NumPy and SciPy have a lot of the same functions? Which should I prefer? [duplicate]

This question already has answers here:
Closed 10 years ago.
The community reviewed whether to reopen this question 11 months ago and left it closed:
Duplicate This question has been answered, is not unique, and doesn’t differentiate itself from another question.
Possible Duplicate:
Relationship between scipy and numpy
For instance, NumPy has window functions bartlett, blackman, hamming, hanning, kaiser, while SciPy has these and several more, but they seem to produce identical output.
NumPy has numpy.fft.fft2(a, s=None, axes=(-2, -1)).
SciPy has scipy.fftpack.fft2(x, shape=None, axes=(-2, -1), overwrite_x=0).
Why are there duplicates? Just for backwards compatibility? If so, why are they defined differently in different places? Which should I prefer when writing something new?

From the SciPy FAQ:
In an ideal world, NumPy would contain nothing but the array data type and the most basic
operations: indexing, sorting, reshaping, basic elementwise functions, et cetera. All
numerical code would reside in SciPy. However, one of NumPy’s important goals is
compatibility, so NumPy tries to retain all features supported by either of its
predecessors. Thus NumPy contains some linear algebra functions, even though these more
properly belong in SciPy. In any case, SciPy contains more fully-featured versions of the
linear algebra modules, as well as many other numerical algorithms. If you are doing
scientific computing with python, you should probably install both NumPy and SciPy. Most new > features belong in SciPy rather than NumPy.
So yes, the duplicates are for backwards compatibility. In general, they give the same result. However, as the FAQ states, new features are usually implemented into SciPy, but not necessarily NumPy. This includes bug fixes. I have found, for example, that numpy.linalg.eig returned incorrect eigenvalues for a complex matrix, whereas scipy.linalg.eig returned correct ones.
In general, I prefer stick with the "ideal world" scenario from the FAQ: I use NumPy for the basic array manipulations, and SciPy for all my linear algebra. This way I don't run into any surprises.

OpenGL matrix math utilities for Python?

Before I do it myself, are there any Python libraries available for OpenGL-specific/compatible matrix math on 4x4 matrices? Basically, I need about the feature set offered by Android's android.opengl.Matrix class.

I created the library Pyrr to provide all the maths features you need for Core OpenGL.
It features matrices, vectors and quaternions and basic support for other primitives (rectangles, rays, lines, etc).
It has both a procedural API and, more recently, an Object Oriented API which is very powerful.
It's available on PyPi pip install pyrr and from the github link above.
Feedback, issues and new features are welcome!

You can use numpy to generate data that is compatible with OpenGL. Many of the PyOpenGL calls can take numpy data structures directly (assuming it's the correct type). Additionally, numpy arrays are typically well arranged in memory, and so you can do what you want with the data (and it's easy to check how they are arranged).

PyGLM might be something to look at as well. The author claims to be 2x to 10x as fast as numpy.
It is based on the popular OpenGL Mathematics, C++ header only, library.

If you already know what you want in OpenGL, why not use PyOpenGL? I believe all the functionality you want should be there, and here are some docs on doing matrix transformations and interfacing with NumPy.