test scripts

Author: haneul

client.py

@@ -12,6 +12,10 @@ def __init__(self, proxy, clientID):
     def do_predict(self, line):
         cls = self.proxy.predict(self.clientID, line.strip())
         print(cls)
+
+    def do_change(self, line):
+        cmd = line.strip().split()
+        res = self.proxy.change(self.clientID, cmd[0], cmd[1], bool(cmd[2]))
 
     def do_EOF(self, line):
         return True 
@@ -32,7 +36,7 @@ def main():
         exit(0)
 
     proxy = xmlrpclib.ServerProxy("http://localhost:8000/")
-    clientID = proxy.register(args.model, args.pretrained)
+    clientID = proxy.register(args.model, args.pretrained, False)
     dnncmd = DNNCmd(proxy, clientID)
     dnncmd.cmdloop()
     proxy.unregister(clientID)

server.py

@@ -12,7 +12,7 @@
 clients = {}
 import numpy as np
 import uuid
-def register(model_file, pretrained):
+def register(model_file, pretrained, split=False):
     net = caffe.Classifier(model_file, pretrained,
                            mean=np.load(caffe_dir + '/python/caffe/imagenet/ilsvrc_2012_mean.npy'),
                            channel_swap=(2,1,0),
@@ -22,15 +22,36 @@ def register(model_file, pretrained):
     net.set_phase_test()
     net.set_mode_gpu()
     clientID = str(uuid.uuid1())
-    clients[clientID] = net
+    clients[clientID] = (net, split)
+    return clientID
+
+def change(clientID, model_file, pretrained, split):
+    net = caffe.Classifier(model_file, pretrained,
+                           mean=np.load(caffe_dir + '/python/caffe/imagenet/ilsvrc_2012_mean.npy'),
+                           channel_swap=(2,1,0),
+                           raw_scale=255,
+                           image_dims=(256, 256)) 
+         
+    net.set_phase_test()
+    net.set_mode_gpu()
+    clients[clientID] = (net, split)
     return clientID
 
 def predict(clientID, image_file):
     input_image = caffe.io.load_image(image_file)
-    net = clients[clientID]
-    prediction = net.predict([input_image])
-    i = prediction[0].argmax()
-    return words[i]
+    net = clients[clientID][0]
+    split = clients[clientID][1]
+    prediction = net.forward_all(data=np.asarray([net.preprocess('data', input_image)]))
+    if(split):
+        import cStringIO
+        output = cStringIO.StringIO()
+        np.save(output, prediction["pool5"])
+        proxy = xmlrpclib.ServerProxy("http://localhost:8001/") 
+        r = proxy.predict(xmlrpclib.Binary(output.getvalue()))
+        return r
+    else:
+        i = prediction["prob"].argmax()
+        return words[i]
 
 def unregister(clientID):
     del clients[clientID]
@@ -43,6 +64,7 @@ def unregister(clientID):
 server = SimpleXMLRPCServer(("localhost", 8000))
 print "Listening on port 8000..."
 server.register_function(register, 'register')
+server.register_function(change, 'change')
 server.register_function(predict, 'predict')
 server.register_function(unregister, 'unregister')
 

sp_client.py

@@ -0,0 +1,25 @@
+import caffe
+import numpy as np
+import xmlrpclib
+
+MODEL_FILE =  "./models/caffe1.prototxt"
+PRETRAINED =  "./models/caffemodel1"
+caffe_dir = "../caffe"
+IMAGE_FILE = "../cat.jpg"
+net1 = caffe.Classifier(MODEL_FILE, PRETRAINED,
+                   mean=np.load(caffe_dir + '/python/caffe/imagenet/ilsvrc_2012_mean.npy'),
+                   channel_swap=(2,1,0),
+                   raw_scale=255,
+                   image_dims=(256, 256)) 
+
+net1.set_phase_test()
+net1.set_mode_gpu()
+input_image = caffe.io.load_image(IMAGE_FILE)
+out = net1.forward_all(data=np.asarray([net1.preprocess('data', input_image)]))
+proxy = xmlrpclib.ServerProxy("http://localhost:8001/") 
+import cStringIO
+output = cStringIO.StringIO()
+np.save(output, out["pool5"])
+#print(proxy.predict(xmlrpclib.Binary(out["pool5"])))
+print(proxy.predict(xmlrpclib.Binary(output.getvalue())))
+

sp_server.py

@@ -0,0 +1,39 @@
+from SimpleXMLRPCServer import SimpleXMLRPCServer
+import xmlrpclib
+
+import caffe
+
+caffe_dir = "../caffe"
+
+with open("synset_words.txt") as f:
+    words = f.readlines()
+words = map(lambda x: x.strip(), words)
+
+MODEL_FILE2 =  "./models/caffe2.prototxt"
+PRETRAINED2 =  "./models/caffemodel2"
+net2 = caffe.Net(MODEL_FILE2, PRETRAINED2)
+net2.set_phase_test()
+net2.set_mode_gpu()
+#out2 = net2.forward_all(**out)
+
+clients = {}
+import numpy as np
+import uuid
+    
+def predict(data):
+    import cStringIO
+    inputdata = cStringIO.StringIO(data.data)
+    bn = np.load(inputdata)
+    out2 = net2.forward_all(**{"pool5":bn})
+    i = out2['prob'][0].argmax(axis=0)
+    return words[i]
+
+#MODEL_FILE = caffe_dir + "/models/bvlc_reference_caffenet/deploy.prototxt"
+#PRETRAINED = caffe_dir + "/models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel"
+#IMAGE_FILE = "images/cat.png"
+
+server = SimpleXMLRPCServer(("localhost", 8001))
+print "Listening on port 8001..."
+server.register_function(predict, 'predict')
+
+server.serve_forever()

test.py

@@ -1,3 +1,4 @@
+import sys
 #from memory_profiler import profile
 #@profile
 def main():
@@ -20,8 +21,10 @@ def main():
     net.set_phase_test()
     net.set_mode_gpu()
     input_image = caffe.io.load_image(IMAGE_FILE)
-    prediction = net.predict([input_image])
-    i = prediction[0].argmax()
+    #prediction = net.predict([input_image])
+    prediction = net.forward_all(data=np.asarray([net.preprocess('data', input_image)]))
+
+    i = prediction["prob"].argmax()
     print(i)
     print(words[i])
 #    del net
@@ -30,5 +33,77 @@ def main():
 #    print(i)
 #    print(words[i])
 
-main()
+SETTINGS = {
+    "imagenet": {
+        "model_file": "tlc/var2.6.Model.prototxt",
+        "pretrained": "tlc/var2.6.Model.caffemodel",
+        "image_dims": (256, 256),
+        "input_dims": [224, 224],
+        "oversample": False,
+    },
+    "deepface": {
+        "model_file": "tlc/faces/var5.5.Model.prototxt",
+        "pretrained": "tlc/faces/var5.5.Model.caffemodel",
+        #"model_file": "tlc/faces/faces.var5.rm6.prototxt",
+        #"pretrained": "tlc/faces/faces.var5.rm6.caffemodel",
+        "image_dims": (152, 152),
+        "input_dims": [152, 152],
+        "oversample": False,
+    },
+    "test": {
+        "model_file": "test.prototxt",
+        "pretrained": "test.caffemodel",
+        "image_dims": (3, 3),
+        "input_dims": [3, 3],
+        "oversample": False,
+    }
+}
+
+def main_tlc():
+    import caffe
+    import numpy as np
+    import skimage.io
+    np.set_printoptions(threshold='nan')
+
+    options = SETTINGS["imagenet"]
+    #IMAGE_FILE = "../cat.jpg"
+    IMAGE_FILE = "../fish.jpg"
+    mean = np.zeros([3] + list(options['input_dims']))
+    mean.fill(128.0)
+    #with open("synset_words.txt") as f:
+    #    words = f.readlines()
+    #words = map(lambda x: x.strip(), words)
+   
+    net = caffe.Classifier(options["model_file"], options["pretrained"],
+                           mean=mean, input_scale=0.0078125,
+                           image_dims=options["image_dims"])
+    sys.stderr.write("model file: %s\n" % options["model_file"])
+    sys.stderr.write("pretrained: %s\n" % options["pretrained"])
+
+    net.set_phase_test()
+    net.set_mode_gpu()
+    #net.set_mode_cpu()
+    """
+    with open("rawinput.txt") as f:
+        content = f.read()
+        rawinput = content.strip(' ,\t\r\n').split(',')
+        rawinput = map(lambda x: eval(x), rawinput)
+    rawinput = np.asarray(rawinput).reshape([1,3] + options['input_dims'])
+    prediction = net.predict_raw(rawinput)
+    return
+    """
+
+    input_image = skimage.io.imread(IMAGE_FILE)
+    prediction = net.predict([input_image], oversample=True)
+    #prediction = net.forward_all(data=np.asarray([net.preprocess('data', input_image)]))
+    #return
+    label = prediction.argmax()
+    #for i,v in enumerate(prediction[0]):
+    #    print i, v
+    print label
+    #print words[label]
+    #print input_image
+
+#main()
+main_tlc()
 

test_split.py

@@ -0,0 +1,24 @@
+import caffe
+import numpy as np
+from util import predict
+
+caffe_dir = "../caffe"
+MODEL_FILE = caffe_dir + "/models/bvlc_reference_caffenet/deploy.prototxt"
+PRETRAINED = caffe_dir + "/models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel"
+IMAGE_FILE = "../cat.png"
+with open("synset_words.txt") as f:
+    words = f.readlines()
+words = map(lambda x: x.strip(), words)
+
+net = caffe.Classifier(MODEL_FILE, PRETRAINED,
+                   mean=np.load(caffe_dir + '/python/caffe/imagenet/ilsvrc_2012_mean.npy'),
+                   channel_swap=(2,1,0),
+                   raw_scale=255,
+                   image_dims=(256, 256)) 
+net.set_phase_test()
+net.set_mode_gpu()
+input_image = caffe.io.load_image(IMAGE_FILE)
+#print(list(net._layer_names))
+predict([input_image], (256, 256), net.crop_dims, net) 
+#r = net.forward_all([input_image])
+