Example #1
0
def get_function_signature(function, method=True):
    wrapped = getattr(function, '_original_function', None)
    if wrapped is None:
        signature = generic_utils.getargspec(function)
    else:
        signature = generic_utils.getargspec(wrapped)
    defaults = signature.defaults
    if method:
        args = signature.args[1:]
    else:
        args = signature.args
    if defaults:
        kwargs = zip(args[-len(defaults):], defaults)
        args = args[:-len(defaults)]
    else:
        kwargs = []
    st = '%s.%s(' % (clean_module_name(function.__module__), function.__name__)

    for a in args:
        st += str(a) + ', '
    for a, v in kwargs:
        if isinstance(v, str):
            v = '\'' + v + '\''
        st += str(a) + '=' + str(v) + ', '
    if kwargs or args:
        signature = st[:-2] + ')'
    else:
        signature = st + ')'
    return post_process_signature(signature)
 def __init__(self,
              x,
              y,
              image_data_generator,
              batch_size=32,
              shuffle=False,
              sample_weight=None,
              seed=None,
              data_format=None,
              save_to_dir=None,
              save_prefix='',
              save_format='png',
              subset=None,
              dtype=None):
     if data_format is None:
         data_format = backend.image_data_format()
     kwargs = {}
     if 'dtype' in generic_utils.getargspec(
             image.NumpyArrayIterator.__init__).args:
         if dtype is None:
             dtype = backend.floatx()
         kwargs['dtype'] = dtype
     super(NumpyArrayIterator, self).__init__(x,
                                              y,
                                              image_data_generator,
                                              batch_size=batch_size,
                                              shuffle=shuffle,
                                              sample_weight=sample_weight,
                                              seed=seed,
                                              data_format=data_format,
                                              save_to_dir=save_to_dir,
                                              save_prefix=save_prefix,
                                              save_format=save_format,
                                              subset=subset,
                                              **kwargs)
def img_to_array(img, data_format=None, dtype=None):
    if data_format is None:
        data_format = backend.image_data_format()
    if 'dtype' in generic_utils.getargspec(image.img_to_array).args:
        if dtype is None:
            dtype = backend.floatx()
        return image.img_to_array(img, data_format=data_format, dtype=dtype)
    return image.img_to_array(img, data_format=data_format)
 def __init__(
         self,
         contrast_stretching=False,  # additional
         histogram_equalization=False,  # additional
         adaptive_equalization=False,  # additional
         featurewise_center=False,
         samplewise_center=False,
         featurewise_std_normalization=False,
         samplewise_std_normalization=False,
         zca_whitening=False,
         zca_epsilon=1e-6,
         rotation_range=0,
         width_shift_range=0.,
         height_shift_range=0.,
         brightness_range=None,
         shear_range=0.,
         zoom_range=0.,
         channel_shift_range=0.,
         fill_mode='nearest',
         cval=0.,
         horizontal_flip=False,
         vertical_flip=False,
         rescale=None,
         preprocessing_function=None,
         data_format=None,
         validation_split=0.0,
         dtype=None):
     if data_format is None:
         data_format = backend.image_data_format()
     kwargs = {}
     if 'dtype' in generic_utils.getargspec(
             image.ImageDataGenerator.__init__).args:
         if dtype is None:
             dtype = backend.floatx()
         kwargs['dtype'] = dtype
     super(ImageDataGenerator, self).__init__(
         featurewise_center=featurewise_center,
         samplewise_center=samplewise_center,
         featurewise_std_normalization=featurewise_std_normalization,
         samplewise_std_normalization=samplewise_std_normalization,
         zca_whitening=zca_whitening,
         zca_epsilon=zca_epsilon,
         rotation_range=rotation_range,
         width_shift_range=width_shift_range,
         height_shift_range=height_shift_range,
         brightness_range=brightness_range,
         shear_range=shear_range,
         zoom_range=zoom_range,
         channel_shift_range=channel_shift_range,
         fill_mode=fill_mode,
         cval=cval,
         horizontal_flip=horizontal_flip,
         vertical_flip=vertical_flip,
         rescale=rescale,
         preprocessing_function=preprocessing_function,
         data_format=data_format,
         validation_split=validation_split,
         **kwargs)
def array_to_img(x, data_format=None, scale=True, dtype=None):
    if data_format is None:
        data_format = backend.image_data_format()
    if 'dtype' in generic_utils.getargspec(image.array_to_img).args:
        if dtype is None:
            dtype = backend.floatx()
        return image.array_to_img(x,
                                  data_format=data_format,
                                  scale=scale,
                                  dtype=dtype)
    return image.array_to_img(x, data_format=data_format, scale=scale)
 def __init__(self,
              directory,
              image_data_generator,
              target_size=(256, 256),
              color_mode='rgb',
              classes=None,
              class_mode='categorical',
              batch_size=32,
              shuffle=True,
              seed=None,
              data_format=None,
              save_to_dir=None,
              save_prefix='',
              save_format='png',
              follow_links=False,
              subset=None,
              interpolation='nearest',
              dtype=None):
     if data_format is None:
         data_format = backend.image_data_format()
     kwargs = {}
     if 'dtype' in generic_utils.getargspec(
             image.ImageDataGenerator.__init__).args:
         if dtype is None:
             dtype = backend.floatx()
         kwargs['dtype'] = dtype
     super(DirectoryIterator, self).__init__(directory,
                                             image_data_generator,
                                             target_size=target_size,
                                             color_mode=color_mode,
                                             classes=classes,
                                             class_mode=class_mode,
                                             batch_size=batch_size,
                                             shuffle=shuffle,
                                             seed=seed,
                                             data_format=data_format,
                                             save_to_dir=save_to_dir,
                                             save_prefix=save_prefix,
                                             save_format=save_format,
                                             follow_links=follow_links,
                                             subset=subset,
                                             interpolation=interpolation,
                                             **kwargs)