img_file = request.session.get('image_file')
json.dumps(str(my_imagefield)) 

this should work for storing the image in the memory

or using base64

import base64
img_file = request.session.get('image_file')
with open(img_file , "wb") as fh:
    fh.write(base64.decodebytes(img_data))

If I had to do this, I would use one of:

message image {
    int width = 1;
    int height = 2;
    bytes image_data = 3;
}

message image {
    int width = 1;
    int height = 2;
    bytes red_data = 3;
    bytes green_data = 4;
    bytes blue_data = 5;
}

Or possibly use an intermediate ScanRow message, composed either of interleaved R, G, B bytes or separated R, G, B bytes. The first version is likely going to be fastest to generate and display.

you can't serialize the object, because it's an Image. You have to serialize the string representation of it's path.

The easiest way of achiving it is to call it's str() method when you what to serialize it.

json.dumps(unicode(my_imagefield)) # py2
json.dumps(str(my_imagefield)) # py3

should work.

You can send uint16_t array from c side as is, and use ctypes module to access it in python code.

Sending c code:

#include <stdint.h>
#include <stdio.h>
#include <zmq.h>

#define IMAGE_SIZE (256 * 256)

unsigned checksum(uint16_t* data, int len) {
    unsigned s = 0;
    for (int i = 0; i < len; ++i) {
        s += data[i];
    }
    return s;
}

int main() {
    uint16_t image[IMAGE_SIZE];
    printf("image checksum: %i\n", checksum(image, IMAGE_SIZE));

    void* context = zmq_ctx_new();
    void* push = zmq_socket(context, ZMQ_PUSH);
    zmq_connect(push, "tcp://127.0.0.1:5555");
    zmq_send(push, image, IMAGE_SIZE * sizeof(uint16_t), 0);
    zmq_close(push);
    zmq_ctx_destroy(context);
    return 0;
}

Receiving python code:

from ctypes import c_uint16
import zmq

IMAGE_SIZE = 256 * 256
Image = c_uint16 * IMAGE_SIZE # corresponds to uint16_t[IMAGE_SIZE]

context = zmq.Context(1)
pull = zmq.Socket(context, zmq.PULL)
pull.bind("tcp://127.0.0.1:5555")
message = pull.recv()

image = Image.from_buffer_copy(message)

# This should print the same number as the sending code
# Note that it is different from sum(message)
print(sum(image))

Description for the issue

The origin of the exception was a KeyError, because of this statement

images_data = validated_data.pop('images')

This is because the validated data has no key images. This means the images input doesn't validate the image inputs from postman.

Django post request store InMemmoryUpload in request.FILES, so we use it for fetching files. also, you want multiple image upload at once. So, you have to use different image_names while your image upload (in postman).

Change your serializer to like this:

class TaskSerializer(serializers.HyperlinkedModelSerializer):
    user = serializers.ReadOnlyField(source='user.username')
    images = TaskImageSerializer(source='taskimage_set', many=True, read_only=True)

    class Meta:
        model = Task
        fields = ('id', 'title', 'user', 'images')

    def create(self, validated_data):
        images_data = self.context.get('view').request.FILES
        task = Task.objects.create(title=validated_data.get('title', 'no-title'),
                                   user_id=1)
        for image_data in images_data.values():
            TaskImage.objects.create(task=task, image=image_data)
        return task

I don't know about your view, but I'd like to use ModelViewSet preferrable view class

class Upload(ModelViewSet):
    serializer_class = TaskSerializer
    queryset = Task.objects.all()

Postman console:

DRF result:

{
        "id": 12,
        "title": "This Is Task Title",
        "user": "admin",
        "images": [
            {
                "image": "http://127.0.0.1:8000/media/Screenshot_from_2017-12-20_07-18-43_tNIbUXV.png"
            },
            {
                "image": "http://127.0.0.1:8000/media/game-of-thrones-season-valar-morghulis-wallpaper-1366x768_3bkMk78.jpg"
            },
            {
                "image": "http://127.0.0.1:8000/media/IMG_212433_lZ2Mijj.jpg"
            }
        ]
    }

UPDATE

This is the answer for your comment.

In django reverse foreignKey are capturing using _set. see this official doc. Here, Task and TaskImage are in OneToMany relationship, so if you have one Task instance, you could get all related TaskImage instance by this reverse look-up feature.

Here is the example:

task_instance = Task.objects.get(id=1)
task_img_set_all = task_instance.taskimage_set.all()

Here this task_img_set_all will be equal to TaskImage.objects.filter(task_id=1)

You must be careful about the datatypes.

If you read a binary image, you get bytes. If you encode these bytes in base64, you get ... bytes again! (see documentation on b64encode)

json can't handle raw bytes, that's why you get the error.

I have just written some example, with comments, I hope it helps:

from base64 import b64encode
from json import dumps

ENCODING = 'utf-8'
IMAGE_NAME = 'spam.jpg'
JSON_NAME = 'output.json'

# first: reading the binary stuff
# note the 'rb' flag
# result: bytes
with open(IMAGE_NAME, 'rb') as open_file:
    byte_content = open_file.read()

# second: base64 encode read data
# result: bytes (again)
base64_bytes = b64encode(byte_content)

# third: decode these bytes to text
# result: string (in utf-8)
base64_string = base64_bytes.decode(ENCODING)

# optional: doing stuff with the data
# result here: some dict
raw_data = {IMAGE_NAME: base64_string}

# now: encoding the data to json
# result: string
json_data = dumps(raw_data, indent=2)

# finally: writing the json string to disk
# note the 'w' flag, no 'b' needed as we deal with text here
with open(JSON_NAME, 'w') as another_open_file:
    another_open_file.write(json_data)

Image-processing is CPU-expensive. So, the performance first:

ZeroMQ shall allow one to enjoy a Zero-Copy modus operandi, so prevent any adverse operations, that spoil that.

Having used just a generic OpenCV Camera, not the RPi / PiCamera, I always prefer to take individual Camera-frames ( not a sequence ) on the acquisition side under a controlled event-loop.

Camera gets a known, fixed-geometry picture ( in OpenCV a numpy.ndarray 3D-structure [X,Y,[B,G,R]] ), so the fastest and the most straightforward serialisation is using a struct.pack( CONST_FRAME_STRUCT_MASK, aFrame ) on sender-side and struct.unpack( CONST_FRAME_STRUCT_MASK, aMessage ) on the receiver(s)-side(s).

Yes, struct.pack() was so far a fastest way, even when documentation offers other means ( a flexibility comes at an additional cost, which is not justified ):

import numpy

def send_array( socket, A, flags = 0, copy = True, track = False ):
    """send a numpy array with metadata"""
    md = dict( dtype = str( A.dtype ),
               shape =      A.shape,
               )
    pass;  socket.send_json( md, flags | zmq.SNDMORE )
    return socket.send(      A,  flags, copy = copy, track = track )

def recv_array( socket, flags = 0, copy = True, track = False ):
    """recv a numpy array"""
    md = socket.recv_json( flags = flags )
    msg = socket.recv(     flags = flags, copy = copy, track = track )
    buf = buffer( msg )
    pass;  A = numpy.frombuffer( buf, dtype = md['dtype'] )
    return A.reshape(                         md['shape'] )

Any color-conversion and similar source-side transformations may consume +150 ~ 180 [ms], so try to avoid any and all un-necessary color-space or reshape or similar non-core conversions, as these adversely increase the accumulated pipeline latency envelope.

Using struct.pack() also avoids any kind of size-mismatches, so what you load onto a binary payload landing pad, is exactly what you receive on the receiver(s) side(s).

If indeed keen to have also a JSON-related overheads around the message core-data, then rather setup a two-socket paradigm, both having ZMQ_CONFLATE == 1, where the first moves struct-payloads and the second JSON-decorated telemetry.

If RPi permits, the zmq.Context( nIOthreads ) may further increase the data-pumping throughput on both sides with nIOthreads >= 2, and additional JSON_socket.setsockopt( ZMQ_AFFINITY, 1 ); VIDEO_socket.setsockopt( ZMQ_AFFINITY, 0 ) mapping can separate / distribute the workload to ride each on a different, separate IOthread.

You can convert the Image object into data then you can pickle it:

image = {
    'pixels': im.tostring(),
    'size': im.size,
    'mode': im.mode,
}

And back to an Image:

im = Image.fromstring(image['mode'], image['size'], image['pixels'])

NOTE: As astex mentioned, if you're using Pillow (which is recommended instead of PIL), the tostring() method is deprecated for tobytes(). Likewise with fromstring() for frombytes().