Will numpy.float32 help?

>>>PI=3.1415926535897
>>> print PI*PI
9.86960440109
>>> PI32=numpy.float32(PI)
>>> print PI32*PI32
9.86961

If you want to do math operation on float32, convert the operands to float32 may help you.

The problem is that you do not do any type conversion of the numpy array. You calculate a float32 variable and put it as an entry into a float64 numpy array. numpy then converts it properly back to float64

Try someting like this:

a = np.zeros(4,dtype="float64") 
print a.dtype
print type(a[0])
a = np.float32(a)
print a.dtype
print type(a[0])

The output (tested with python 2.7)

float64
<type 'numpy.float64'>
float32
<type 'numpy.float32'>

a is in your case the array tree.tree_.threshold

If memory is a problem, and if you know the size of the field ahead of time, you probably don't want to read the entire file in the first place. Something like this is probably more appropriate:

#allocate memory (np.empty would work too and be marginally faster, 
#                 but probably not worth mentioning).
a=np.zeros((3000,300),dtype=np.float32)  
with open(filename) as f:
    for i,line in enumerate(f):
        a[i,:]=map(np.float32,line.split()) 

from a couple quick (and surprising) tests on my machine, it appears that the map may not even be necessary:

a=np.zeros((3000,300),dtype=np.float32)  
with open(filename) as f:
    for i,line in enumerate(f):
        a[i,:]=line.split() 

This might not be the fastest, but certainly it'll be the most memory efficient way to do it.

Some tests:

import numpy as np

def func1():   #No map -- And pretty speedy :-).
    a=np.zeros((3000,300),dtype=np.float32)
    with open('junk.txt') as f:
        for i,line in enumerate(f):
            a[i,:]=line.split()

def func2():
    a=np.zeros((3000,300),dtype=np.float32)
    with open('junk.txt') as f:
        for i,line in enumerate(f):
            a[i,:]=map(np.float32,line.split())

def func3():
    a=np.zeros((3000,300),dtype=np.float32)
    with open('junk.txt') as f:
        for i,line in enumerate(f):
            a[i,:]=map(float,line.split())

import timeit

print timeit.timeit('func1()',setup='from __main__ import func1',number=3)  #1.36s
print timeit.timeit('func2()',setup='from __main__ import func2',number=3)  #11.53s
print timeit.timeit('func3()',setup='from __main__ import func3',number=3)  #1.72s

1. If the dataframe (say df) wholly consists of float64 dtypes, you can do:

df = df.astype('float32')

2. Only if some columns are float64, then you'd have to select those columns and change their dtype:

# Select columns with 'float64' dtype  
float64_cols = list(df.select_dtypes(include='float64'))

# The same code again calling the columns
df[float64_cols] = df[float64_cols].astype('float32')

Not that I am aware of. You either need to specify the dtype explicitly when you call the constructor for any array, or cast an array to float32 (use the ndarray.astype method) before passing it to your GPU code (I take it this is what the question pertains to?). If it is the GPU case you are really worried about, I favor the latter - it can become very annoying to try and keep everything in single precision without an extremely thorough understanding of the numpy broadcasting rules and very carefully designed code.

Another alternative might be to create your own methods which overload the standard numpy constructors (so numpy.zeros, numpy.ones, numpy.empty). That should go pretty close to keeping everything in float32.

You could use struct as follows:

import struct

f = int('01000001101011000111101011100001', 2)
print struct.unpack('f', struct.pack('I', f))[0]

f = int('11000001101011000111101011100001', 2)
print struct.unpack('f', struct.pack('I', f))[0]

Giving you an output of:

21.5599994659
-21.5599994659

It all depends on how the integer is represented though.