d4nst / rotnet Goto Github PK

View Code? Open in Web Editor NEW

522.0 522.0 186.0 10.35 MB

Home Page: https://d4nst.github.io/2017/01/12/image-orientation/

License: MIT License

Python 2.39% Jupyter Notebook 97.61%

rotnet's People

Contributors

Stargazers

Watchers

Forkers

piperod eob haven-lau joriswillems bemoregt yaojiebao ecthros yh2866 armandcom physci seanthegreat7 we-l-ee justrypython fendaq 10183308 dhinkris cloudbreadpapa peterfox1982 mehul-gupta astrotuna201 rgitz vachan82 vbansal86 giribushan ylashin yinmingjun tklebanoff chuong-phung moyemoji moctarsamb tarmas99 iotgod dinorego mickelzhang avi-raj1 madmuffin1 kooroshmoslemi aiedward ssitb pgsrv auchinto masoud-ghodrati guyt-ds yinken80 chris-ondemand3d yf-res yashugupta786 niteshsukhwani amanapte toanloi2569 mikeliux arjunrameshv sophiatmu anu1rag joosthoppenbrouwer arpitkh101 bayethiernodiop wenfeifei gauravchats lucasbr023 sudeepname bepnye onegithuber walwi878 aravinda89 kartheekmedathati zuoxiaojiang dzienbakanae hashbanger nuronlabs umesh-kushwaha jxubb shesay-noway hronpet1 duwizerak wulin-challenge nenkoru mcdevjin 18670775011 jacksky64 blendev87 jalondono lonelypoker troublesunyc groudonthegreat duncare27 jasonxgw sunxingxingtf vibasampaio davecs1 vaskos97 leonilpark sudhanshusolterra kader1003 xinyujituan viewside wangkuiming stevenchen1976 blazeqin cob05

rotnet's Issues

val_angle_error is too high

i use your net to train my own dataset,but the val_angle_error is too high around 90%. What can i do to reduce my val_angle_error

Need more information?

Hello Daniel, first of all excellent article, I have almost the same question as the previous post but my data are device tickets.

1- I tried to increase my data since I don't have a lot using the ImageDataGenerator ( by applying width_shift_range height_shift_range,shear_range, zoom_range ) alone then use it again in the grid just by adding the rotation as you did? what do you think?

2- As 2nd step I also have to make a network that estimates the rotation but this time on 3D tickets, you propose me to bring back the 3D in 2D image and apply the same network or you have an idea ?

Thank you in advance.

the street model size is too big use thr ResNet

I use the street view model to train my own data,it has a good accuracy,but the model size is too big,its nearly 180mb,do u have any ideal to reduce the model size ,also, i used the minist model to predict the rotate angle,the model is about 30mb,but the accuracy is not good,i try to change the model,i use the model to predict,its allways have the same predict angle

requirements.txt

Hi there,

Is there a requirements.txt available?

Can we use this code to train for our custom data

Can we use these code to train custom data instead of google street view?
For Images like

If suppose image is like this

After training this model can we achieve first image output with predicted angel.

Image size for training and testing

I have images of bigger size, How to train the Rotnet model with images more than size 224*224?
If I create a new model with 224*224 images, how could I test it on bigger images?

Error rate

Dear Daniel
I downloaded pre-trained model and checked your algorithm (correcton_rotation.py) on Google Street View dataset. I took some images from dataset and check it on your algorithm. Unfortunately, neither I could see good results nor is there any statistics about precision or error rate of your algorithm.

here is some pictures as results:

Right side is rotated image as input to network
Left side is rotated image as output from estimated angle

Am I doing something wrong?

Thank you in advance for your reply.

Train with smaller classes

Hi, thank you for sharing nice programs.

The following changes to utils.py will allow training with fewer classes. Rotating with 4 classes may be especially useful for training with small data.
There seems to be something wrong in visualization (function display_example), but I was able to train four classes.

def angle_difference(x, y, nb_classes = 360):
    """
    Calculate minimum difference between two angles.
    """
    assert 360 % nb_classes == 0, 'nb_classes should be a divisor of 360'
    unit_angle = 360 // nb_classes
    return 180 - abs(abs(x - y) * unit_angle - 180)


def angle_error(y_true, y_pred):
    """
    Calculate the mean diference between the true angles
    and the predicted angles. Each angle is represented
    as a binary vector.
    """
    diff = angle_difference(K.argmax(y_true), K.argmax(y_pred), nb_classes = y_pred.shape[1])
    return K.mean(K.cast(K.abs(diff), K.floatx()))

(omitted)

@Class RotNetDataGenerator

def __init__(self, input, input_shape=None, color_mode='rgb', batch_size=64,
                one_hot=True, preprocess_func=None, rotate=True, crop_center=False,
                crop_largest_rect=False, shuffle=False, seed=None, nb_classes = 360): # nb_classes is added
        
        assert 360 % nb_classes == 0, 'nb_classes should be a divisor of 360' # inserted

        self.images = None
        self.filenames = None
        self.input_shape = input_shape
        self.color_mode = color_mode
        self.batch_size = batch_size
        self.one_hot = one_hot
        self.preprocess_func = preprocess_func
        self.rotate = rotate
        self.crop_center = crop_center
        self.crop_largest_rect = crop_largest_rect
        self.shuffle = shuffle
        self.nb_classes = nb_classes # added
        self.unit_angle = 360 // nb_classes # added
        ...

(omitted)

def _get_batches_of_transformed_samples(self, index_array):
    # create array to hold the images
    batch_x = np.zeros((len(index_array),) + self.input_shape, dtype='float32')
    # create array to hold the labels
    batch_y = np.zeros(len(index_array), dtype='float32')

    # iterate through the current batch
    for i, j in enumerate(index_array):
        if self.filenames is None:
            image = self.images[j]
        else:
            is_color = int(self.color_mode == 'rgb')
            image = cv2.imread(self.filenames[j], is_color)
            if is_color:
                image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

        if self.rotate:
            # get a random angle
            rotation_angle = self.unit_angle * np.random.randint(self.nb_classes)
        else:
            rotation_angle = 0

        # generate the rotated image
        rotated_image = generate_rotated_image(
            image,
            rotation_angle,
            size=self.input_shape[:2],
            crop_center=self.crop_center,
            crop_largest_rect=self.crop_largest_rect
        )

        # add dimension to account for the channels if the image is greyscale
        if rotated_image.ndim == 2:
            rotated_image = np.expand_dims(rotated_image, axis=2)

        # store the image and label in their corresponding batches
        batch_x[i] = rotated_image
        batch_y[i] = rotation_angle // self.unit_angle

    if self.one_hot:
        # convert the numerical labels to binary labels
        batch_y = to_categorical(batch_y, self.nb_classes) # modified
    else:
        batch_y /= self.nb_classes
    ...

(omitted)

def display_examples(model, input, num_images=5, size=None, crop_center=False,
                    crop_largest_rect=False, preprocess_func=None, save_path=None,
                    nb_classes = 360): # nb_class was added
    """
    Given a model that predicts the rotation angle of an image,
    and a NumPy array of images or a list of image paths, display
    the specified number of example images in three columns:
    Original, Rotated and Corrected.
    """
    assert 360 % nb_classes == 0, 'nb_classes should be a divisor of 360' # added
    unit_angle = 360 // nb_classes # added
    
    if isinstance(input, (np.ndarray)):
        images = input
        N, h, w = images.shape[:3]
        if not size:
            size = (h, w)
        indexes = np.random.choice(N, num_images)
        images = images[indexes, ...]
    else:
        images = []
        filenames = input
        N = len(filenames)
        indexes = np.random.choice(N, num_images)
        for i in indexes:
            image = cv2.imread(filenames[i])
            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
            images.append(image)
        images = np.asarray(images)

    x = []
    y = []
    for image in images:
        rotation_angle = np.random.randint(nb_classes) * unit_angle
        rotated_image = generate_rotated_image(
            image,
            rotation_angle,
            size=size,
            crop_center=crop_center,
            crop_largest_rect=crop_largest_rect
        )
        x.append(rotated_image)
        y.append(rotation_angle // unit_angle)

    x = np.asarray(x, dtype='float32')
    y = np.asarray(y, dtype='float32')

    if x.ndim == 3:
        x = np.expand_dims(x, axis=3)

    y = to_categorical(y, nb_classes)

    x_rot = np.copy(x)

    if preprocess_func:
        x = preprocess_func(x)

    y = np.argmax(y, axis=1)
    y_pred = np.argmax(model.predict(x), axis=1)

    plt.figure(figsize=(10.0, 2 * num_images))

    title_fontdict = {
        'fontsize': 14,
        'fontweight': 'bold'
    }

    fig_number = 0
    for rotated_image, true_angle, predicted_angle in zip(x_rot, y, y_pred):
        true_angle *= unit_angle # added
        predicted_angle *= unit_angle # added
        ...

Advice about NN design for awkward dataset

Sorry this is not an issue, I just need an advice from you.
I am using this algorithm in my program. It should determine whether had problem designing or choosing correct NN. Dataset is somewhat odd it is 110x110x4 round picture with grayish brown statues (I can email an example). I have dataset of 10000 correct oriented statues and getting more. tried resizing to 224x224x3 and removing alpha layer but didn't succeeded with many algorithms (Resnet50, mobilenet, Xception etc.)

Can you give some insight about how should I design NN or what design should I choose and how many pictures should be in dataset?
Thanks in advance

Not able usee

Thanks for providing good model for image rotation. I would like to use it. But I could not use it. I have updated imports for keras so that it is inside tensorflow. I have copied model and run it in google vertex AI and getting this error. Can you please help?

ValueError Traceback (most recent call last)

Cell In[32], line 2

  1 model_location = os.path.join('rotnet', 'models', 'rotnet_street_view_resnet50.hdf5')

----> 2 model = load_model(model_location, custom_objects={'angle_error': angle_error})

File /opt/conda/lib/python3.10/site-packages/keras/src/saving/saving_api.py:183, in load_model(filepath, custom_objects, compile, safe_mode)

176     return saving_lib.load_model(

177         filepath,

178         custom_objects=custom_objects,

179         compile=compile,

180         safe_mode=safe_mode,

181     )

182 if str(filepath).endswith((".h5", ".hdf5")):

--> 183 return legacy_h5_format.load_model_from_hdf5(filepath)

184 elif str(filepath).endswith(".keras"):

185     raise ValueError(

186         f"File not found: filepath={filepath}. "

187         "Please ensure the file is an accessible `.keras` "

188         "zip file."

189     )

File /opt/conda/lib/python3.10/site-packages/keras/src/legacy/saving/legacy_h5_format.py:133, in load_model_from_hdf5(filepath, custom_objects, compile)

130 model_config = json_utils.decode(model_config)

132 with saving_options.keras_option_scope(use_legacy_config=True):

--> 133 model = saving_utils.model_from_config(

134         model_config, custom_objects=custom_objects

135     )

137     # set weights

138     load_weights_from_hdf5_group(f["model_weights"], model)

File /opt/conda/lib/python3.10/site-packages/keras/src/legacy/saving/saving_utils.py:85, in model_from_config(config, custom_objects)

 81 # TODO(nkovela): Swap find and replace args during Keras 3.0 release

 82 # Replace keras refs with keras

 83 config = _find_replace_nested_dict(config, "keras.", "keras.")

---> 85 return serialization.deserialize_keras_object(

 86     config,

 87     module_objects=MODULE_OBJECTS.ALL_OBJECTS,

 88     custom_objects=custom_objects,

 89     printable_module_name="layer",

 90 )

File /opt/conda/lib/python3.10/site-packages/keras/src/legacy/saving/serialization.py:495, in deserialize_keras_object(identifier, module_objects, custom_objects, printable_module_name)

490 cls_config = _find_replace_nested_dict(

491     cls_config, "keras.", "keras."

492 )

494 if "custom_objects" in arg_spec.args:

--> 495 deserialized_obj = cls.from_config(

496         cls_config,

497         custom_objects={

498             **object_registration.GLOBAL_CUSTOM_OBJECTS,

499             **custom_objects,

500         },

501     )

502 else:

503     with object_registration.CustomObjectScope(custom_objects):

File /opt/conda/lib/python3.10/site-packages/keras/src/models/model.py:492, in Model.from_config(cls, config, custom_objects)

487 if is_functional_config and revivable_as_functional:

488     # Revive Functional model

489     # (but not Functional subclasses with a custom __init__)

490     from keras.src.models.functional import functional_from_config

--> 492 return functional_from_config(

493         cls, config, custom_objects=custom_objects

494     )

496 # Either the model has a custom __init__, or the config

497 # does not contain all the information necessary to

498 # revive a Functional model. This happens when the user creates

(...)

501 # In this case, we fall back to provide all config into the

502 # constructor of the class.

503 try:

File /opt/conda/lib/python3.10/site-packages/keras/src/models/functional.py:503, in functional_from_config(cls, config, custom_objects)

501 # First, we create all layers and enqueue nodes to be processed

502 for layer_data in config["layers"]:

--> 503 process_layer(layer_data)

505 # Then we process nodes in order of layer depth.

506 # Nodes that cannot yet be processed (if the inbound node

507 # does not yet exist) are re-enqueued, and the process

508 # is repeated until all nodes are processed.

509 while unprocessed_nodes:

File /opt/conda/lib/python3.10/site-packages/keras/src/models/functional.py:483, in functional_from_config..process_layer(layer_data)

479 # Instantiate layer.

480 if "module" not in layer_data:

481     # Legacy format deserialization (no "module" key)

482     # used for H5 and SavedModel formats

--> 483 layer = saving_utils.model_from_config(

484         layer_data, custom_objects=custom_objects

485     )

486 else:

487     layer = serialization_lib.deserialize_keras_object(

488         layer_data, custom_objects=custom_objects

489     )

File /opt/conda/lib/python3.10/site-packages/keras/src/legacy/saving/saving_utils.py:85, in model_from_config(config, custom_objects)

 81 # TODO(nkovela): Swap find and replace args during Keras 3.0 release

 82 # Replace keras refs with keras

 83 config = _find_replace_nested_dict(config, "keras.", "keras.")

---> 85 return serialization.deserialize_keras_object(

 86     config,

 87     module_objects=MODULE_OBJECTS.ALL_OBJECTS,

 88     custom_objects=custom_objects,

 89     printable_module_name="layer",

 90 )

File /opt/conda/lib/python3.10/site-packages/keras/src/legacy/saving/serialization.py:473, in deserialize_keras_object(identifier, module_objects, custom_objects, printable_module_name)

470 if isinstance(identifier, dict):

471     # In this case we are dealing with a Keras config dictionary.

472     config = identifier

--> 473 (cls, cls_config) = class_and_config_for_serialized_keras_object(

474         config, module_objects, custom_objects, printable_module_name

475     )

477     # If this object has already been loaded (i.e. it's shared between

478     # multiple objects), return the already-loaded object.

479     shared_object_id = config.get(SHARED_OBJECT_KEY)

File /opt/conda/lib/python3.10/site-packages/keras/src/legacy/saving/serialization.py:354, in class_and_config_for_serialized_keras_object(config, module_objects, custom_objects, printable_module_name)

350 cls = object_registration.get_registered_object(

351     class_name, custom_objects, module_objects

352 )

353 if cls is None:

--> 354 raise ValueError(

355         f"Unknown {printable_module_name}: '{class_name}'. "

356         "Please ensure you are using a `keras.utils.custom_object_scope` "

357         "and that this object is included in the scope. See "

358         "https://www.tensorflow.org/guide/keras/save_and_serialize"

359         "#registering_the_custom_object for details."

360     )

362 cls_config = config["config"]

363 # Check if `cls_config` is a list. If it is a list, return the class and the

364 # associated class configs for recursively deserialization. This case will

365 # happen on the old version of sequential model (e.g. `keras_version` ==

366 # "2.0.6"), which is serialized in a different structure, for example

367 # "{'class_name': 'Sequential',

368 #   'config': [{'class_name': 'Embedding', 'config': ...}, {}, ...]}".

ValueError: Unknown layer: 'Convolution2D'. Please ensure you are using a keras.utils.custom_object_scope and that this object is included in the scope. See https://www.tensorflow.org/guide/keras/save_and_serialize#registering_the_custom_object for details.

Bad accuracy on MNIST dataset

Commit 2a4fe4b made the accuracy on the MNIST dataset decrease from 6-7 degrees to 26-27 degrees.

The version before that commit can be used as a workaround for now: https://github.com/d4nst/RotNet/tree/1d934ba4e810806d264cbbbb94d165515887988a

Merge layer

HI, i have a problem while loading the model, this is exactly what python says:
ValueError: Unknown layer: Merge
Please, help to fix that, seems like something is not defined.

correct_rotation.py not working

Hi, I am trying to run your code but I keep getting these errors:

I am using Python 3.6.3, Cuda 8, Cudnn 6 and installed all the others dependencies using pip with exception of the MarkupSafe that was with some bugs so I compiled and installed it myself.
Do you have any idea of how can I fix it?
I am using the following image as input (resolution of 259 x 194) for your network:

Advice on network?

Hey Daniel,

I noticed the resnet50 network requires a minimum image size of 197 x 197.
I'm trying to train a model to calculate the orientation angle of the following types of images:

As you can see these images are 110x110.

I was hoping you had some advice for me, should I enlarge the images to 224x224 for example and hope for the best? Or maybe there's a different network you recommend.

As for enlarging the images, that's what I tried but resnet seems to be throwing an error at me which seems to have to do with the threading.

Epoch 1/50
Exception in thread Thread-2:
Traceback (most recent call last):
  File "C:\Python\lib\threading.py", line 916, in _bootstrap_inner
    self.run()
  File "C:\Python\lib\threading.py", line 864, in run
    self._target(*self._args, **self._kwargs)
  File "C:\Python\lib\site-packages\keras\utils\data_utils.py", line 548, in _run
    with closing(self.executor_fn(_SHARED_SEQUENCES)) as executor:
  File "C:\Python\lib\site-packages\keras\utils\data_utils.py", line 522, in <lambda>
    initargs=(seqs,))
  File "C:\Python\lib\multiprocessing\context.py", line 119, in Pool
    context=self.get_context())
  File "C:\Python\lib\multiprocessing\pool.py", line 174, in __init__
    self._repopulate_pool()
  File "C:\Python\lib\multiprocessing\pool.py", line 239, in _repopulate_pool
    w.start()
  File "C:\Python\lib\multiprocessing\process.py", line 105, in start
    self._popen = self._Popen(self)
  File "C:\Python\lib\multiprocessing\context.py", line 322, in _Popen
    return Popen(process_obj)
  File "C:\Python\lib\multiprocessing\popen_spawn_win32.py", line 65, in __init__
    reduction.dump(process_obj, to_child)
  File "C:\Python\lib\multiprocessing\reduction.py", line 60, in dump
    ForkingPickler(file, protocol).dump(obj)
TypeError: can't pickle _thread.lock objects

And after that it outputs a slightly different error and locks up completely.

Epoch 1/50
Exception in thread Thread-2:
Traceback (most recent call last):
  File "C:\Python\lib\threading.py", line 916, in _bootstrap_inner
    self.run()
  File "C:\Python\lib\threading.py", line 864, in run
    self._target(*self._args, **self._kwargs)
  File "C:\Python\lib\site-packages\keras\utils\data_utils.py", line 548, in _run
    with closing(self.executor_fn(_SHARED_SEQUENCES)) as executor:
  File "C:\Python\lib\site-packages\keras\utils\data_utils.py", line 522, in <lambda>
    initargs=(seqs,))
  File "C:\Python\lib\multiprocessing\context.py", line 119, in Pool
    context=self.get_context())
  File "C:\Python\lib\multiprocessing\pool.py", line 174, in __init__
    self._repopulate_pool()
  File "C:\Python\lib\multiprocessing\pool.py", line 239, in _repopulate_pool
    w.start()
  File "C:\Python\lib\multiprocessing\process.py", line 105, in start
    self._popen = self._Popen(self)
  File "C:\Python\lib\multiprocessing\context.py", line 322, in _Popen
    return Popen(process_obj)
  File "C:\Python\lib\multiprocessing\popen_spawn_win32.py", line 33, in __init__
    prep_data = spawn.get_preparation_data(process_obj._name)
  File "C:\Python\lib\multiprocessing\spawn.py", line 143, in get_preparation_data
    _check_not_importing_main()
  File "C:\Python\lib\multiprocessing\spawn.py", line 136, in _check_not_importing_main
    is not going to be frozen to produce an executable.''')
RuntimeError:
        An attempt has been made to start a new process before the
        current process has finished its bootstrapping phase.

        This probably means that you are not using fork to start your
        child processes and you have forgotten to use the proper idiom
        in the main module:

            if __name__ == '__main__':
                freeze_support()
                ...

        The "freeze_support()" line can be omitted if the program
        is not going to be frozen to produce an executable.

With 'locking up completely' I mean at least one of the threads stays active, but nothing is being processed.

Thank you for your time and knowledge, reading your blog was an absolute joy and taught me a lot about neural networks in general and I hope to apply what I learned to my project.

rough estimation of angle and accuracy with certain angle error

I have two issues

How can I roughly estimate angle (for example estimate only round numbers i.e. 10, 20 etc.)? we don't need result with precision of one degree but for example 7-8 degrees will do fine
How can I estimate accuracy when angle error X degree? for example if we have angle error less then X degree result is accurate.

Thanks

Error message when training model

Hi,

I'm getting this error message when I'm training the model:

~\anaconda3\envs\tf10\lib\site-packages\keras_preprocessing\image\iterator.py in _get_batches_of_transformed_samples(self, index_array)
125 A batch of transformed samples.
126 """
--> 127 raise NotImplementedError
128
129

NotImplementedError:

Do you know what is causing it?

About log output

When training the street view, there are logs output like: loss, angle_error, var_loss, var_angle_error, what does this logs mean? How to control this logs output?

terminate called without an active exception

Epoch 1/10
1/78 [..............................] - ETA: 18:04 - loss: 6.8646 - angle_error: 52.20002020-11-05 14:41:31.189663: I tensorflow/core/profiler/lib/profiler_session.cc:184] Profiler session started.
79/78 [==============================] - 75s 944ms/step - loss: 26.7035 - angle_error: 92.1519 - val_loss: 44509464.0000 - val_angle_error: 86.4056
Epoch 2/10
79/78 [==============================] - 61s 771ms/step - loss: 5.9489 - angle_error: 85.8304 - val_loss: 2772.1135 - val_angle_error: 91.6222
Epoch 3/10
79/78 [==============================] - 61s 776ms/step - loss: 5.9423 - angle_error: 86.7544 - val_loss: 100.6272 - val_angle_error: 99.2500
Epoch 4/10
79/78 [==============================] - 62s 781ms/step - loss: 5.9029 - angle_error: 90.5772 - val_loss: 15.7331 - val_angle_error: 91.6167
Epoch 5/10
79/78 [==============================] - 62s 781ms/step - loss: 5.9086 - angle_error: 90.0785 - val_loss: 5.8849 - val_angle_error: 85.2556
Epoch 6/10
79/78 [==============================] - 60s 757ms/step - loss: 5.8797 - angle_error: 86.2304 - val_loss: 5.7751 - val_angle_error: 88.5000
Epoch 7/10
79/78 [==============================] - 60s 765ms/step - loss: 5.8956 - angle_error: 87.9089 - val_loss: 5.8789 - val_angle_error: 84.8389
Epoch 8/10
79/78 [==============================] - 60s 758ms/step - loss: 5.8876 - angle_error: 90.5392 - val_loss: 5.8946 - val_angle_error: 92.6167
Epoch 9/10
79/78 [==============================] - 61s 771ms/step - loss: 5.8850 - angle_error: 88.1291 - val_loss: 5.9170 - val_angle_error: 93.7278
Epoch 10/10
79/78 [==============================] - 61s 768ms/step - loss: 5.8809 - angle_error: 88.1139 - val_loss: 5.8692 - val_angle_error: 84.4833
terminate called without an active exception
terminate called recursively
terminate called recursively
terminate called recursively
Aborted (core dumped)

Package Version

absl-py 0.8.0
astor 0.8.0
certifi 2020.6.20
cycler 0.10.0
gast 0.2.2
google-pasta 0.1.7
grpcio 1.24.0
h5py 2.10.0
Keras 2.3.0
Keras-Applications 1.0.8
Keras-Preprocessing 1.1.0
kiwisolver 1.1.0
Markdown 3.1.1
matplotlib 3.1.1
numpy 1.17.2
opencv-python 4.4.0.46
opt-einsum 3.1.0
pip 20.2.4
protobuf 3.9.2
pyparsing 2.4.2
python-dateutil 2.8.0
PyYAML 5.1.2
scipy 1.5.4
setuptools 50.3.0.post20201103
six 1.12.0
tensorboard 2.0.0
tensorflow 2.0.0
tensorflow-estimator 2.0.0
termcolor 1.1.0
Werkzeug 0.16.0
wget 3.2
wheel 0.35.1
wrapt 1.11.2

Maybe the network didn't learn the horizontal information

I trained a mobilenet v2 with the generated rotated image, which show great performance on generated rotated image but low performance on real rotated image. I think maybe the net learned the way to generate rotated images by interpolating artifacts or other methods

Model Retraining- Transfer Learning

Good Work!! I trained this model for certain application on 40K images and got good accuracy. Now I am trying to utilize the same model for a different set of documents, the accuracy is not good. How Could I partially retrain the model with a few images from the new set?

correct_rotation.py problems

I noticed that in your correct_rotation.py, - in line 16, you wrote '.jpg' twice. Is one of those supposed to be .JPG? I'm testing on some of my own pictures that end with .JPG and if I don't edit the correct_rotation.py code, I get an error message saying that 'numpy.core._internal.AxisError: axis 1 is out of bounds for array of dimension 1'. However, once I edit the code to include '.JPG', it runs with no errors.

Also, I got an error - TypeError: softmax() got an unexpected keyword argument 'axis' - if I didn't first delete 'axis=axis' in...

File "/home//tensorflow/local/lib/python2.7/site-packages/keras/backend/tensorflow_backend.py", line 3149, in softmax

I was doing some research for the 'softmax' error and I found that this only occurs in some combinations of Tensorflow and Keras versions. The ones I am using are Tensorflow 1.4.0 and Keras 2.2.0

Some questions about RotNet

Hello, I have a few questions to ask:

In Snapseed and IPhone, there is a function to automatically detect the angle.
I want to do something similar, but it's a bit different from your algorithm.
In Snapseed and Iphone, the angle of return is generally between -10 degrees and 10 degrees.
It usually returns 0 outside this range, but the accuracy requirement is relatively high.
Pictures with water or horizons need to be corrected to the level.
Pictures with characters and trees need to be corrected to vertical.
How do I adjust your network?
I downloaded your model, rotnet_street_view_resnet50_keras2.hdf5 This file is only 95M, and I trained more than 450M, what is the reason? Is there any way to continue compressing the model to below 20M?
I need to run the program in Android. Is there any way to improve the performance? (chip SDM670, ram 4G, I expect to process a picture less than 500ms)
When training, there are some values in the log (loss, angle_error, var_loss, var_angle_error), what does it mean?
If the training is halfway, interrupt it, how to continue training next time?

The similar features of Snapsed and IPhone are as follows:
Snapseed -> open a image -> tool -> rotate
IPhone -> Photos -> open a image -> Edit -> crop

Implementation of `train_street_view` over PyTorch

See Starry-OvO/rotate-captcha-crack

How to train with GPU

Is U-Net architecture a suitable contender for your model?

So I have this exact problem for Grayscale Images. I want to ask if you used Autoecoder or UNet architecture? I think U-Net can produce good results with the given problem for autorotating. What you you think?

How to train my own data set

How to train my own data set,thanks

research paper required

Do you have research paper of the rotnet , for detailed explanation, in your blog you only mention about the coding part , I want to understand the concept thoroughly about how things are work .

ValueError: Unknown layer: Merge

when I'm trying to load the pre-trained model"rotnet_street_view_resnet50.hdf5" provided on the google drive file I go these error

The model link in the readme doesn't work anymore

https://drive.google.com/file/d/0B9eNEi5uvOI1SmlITDlyQzRIckU/view

Can rotnet trian on vgg instead of resnet 50?

Python has stopped working..

Hey,

Amazing write up on your blog, I'm working on a small challenge and wanted to test out your project against the image below.

I know that none of your giving examples really fits my challenge, but I wanted to try out the rotnet_street_view_resnet50.hdf5 anyway, just to get something out of it.

However, when running the command python .\correct_rotation.py .\rotnet_street_view_resnet50.hdf5 .\test.jpg eventually python will seize to work, it'll pop up an alert saying it stopped and no error is given.

If anyone can check my input on their end, that'd be really appreciated, I'm trying to figure out what is causing this issue.

Here's the output of the command:

C:\Python\lib\site-packages\h5py\__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.
  from ._conv import register_converters as _register_converters
Using TensorFlow backend.
Loading model...
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `InputLayer` call to the Keras 2 API: `InputLayer(batch_input_shape=[None, 224..., sparse=False, name="input_1", dtype="float32")`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="conv1", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(7, 7), filters=64, strides=[2, 2], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn_conv1", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `MaxPooling2D` call to the Keras 2 API: `MaxPooling2D(name="maxpooling2d_1", trainable=True, pool_size=[3, 3], strides=[2, 2], padding="valid", data_format="channels_last")`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res2a_branch2a", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=64, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn2a_branch2a", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res2a_branch2b", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(3, 3), filters=64, strides=[1, 1], padding="same", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn2a_branch2b", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res2a_branch2c", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=256, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res2a_branch1", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=256, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn2a_branch2c", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn2a_branch1", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: The `Merge` layer is deprecated and will be removed after 08/2017. Use instead layers from `keras.layers.merge`, e.g. `add`, `concatenate`, etc.
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res2b_branch2a", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=64, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn2b_branch2a", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res2b_branch2b", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(3, 3), filters=64, strides=[1, 1], padding="same", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn2b_branch2b", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res2b_branch2c", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=256, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn2b_branch2c", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res2c_branch2a", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=64, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn2c_branch2a", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res2c_branch2b", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(3, 3), filters=64, strides=[1, 1], padding="same", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn2c_branch2b", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res2c_branch2c", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=256, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn2c_branch2c", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res3a_branch2a", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=128, strides=[2, 2], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn3a_branch2a", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res3a_branch2b", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(3, 3), filters=128, strides=[1, 1], padding="same", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn3a_branch2b", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res3a_branch2c", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=512, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res3a_branch1", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=512, strides=[2, 2], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn3a_branch2c", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn3a_branch1", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res3b_branch2a", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=128, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn3b_branch2a", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res3b_branch2b", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(3, 3), filters=128, strides=[1, 1], padding="same", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn3b_branch2b", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res3b_branch2c", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=512, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn3b_branch2c", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res3c_branch2a", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=128, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn3c_branch2a", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res3c_branch2b", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(3, 3), filters=128, strides=[1, 1], padding="same", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn3c_branch2b", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res3c_branch2c", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=512, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn3c_branch2c", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res3d_branch2a", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=128, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn3d_branch2a", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res3d_branch2b", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(3, 3), filters=128, strides=[1, 1], padding="same", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn3d_branch2b", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res3d_branch2c", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=512, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn3d_branch2c", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res4a_branch2a", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=256, strides=[2, 2], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn4a_branch2a", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res4a_branch2b", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(3, 3), filters=256, strides=[1, 1], padding="same", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn4a_branch2b", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res4a_branch2c", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=1024, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res4a_branch1", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=1024, strides=[2, 2], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn4a_branch2c", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn4a_branch1", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res4b_branch2a", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=256, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn4b_branch2a", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res4b_branch2b", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(3, 3), filters=256, strides=[1, 1], padding="same", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn4b_branch2b", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res4b_branch2c", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=1024, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn4b_branch2c", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res4c_branch2a", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=256, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn4c_branch2a", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res4c_branch2b", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(3, 3), filters=256, strides=[1, 1], padding="same", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn4c_branch2b", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res4c_branch2c", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=1024, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn4c_branch2c", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res4d_branch2a", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=256, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn4d_branch2a", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res4d_branch2b", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(3, 3), filters=256, strides=[1, 1], padding="same", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn4d_branch2b", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res4d_branch2c", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=1024, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn4d_branch2c", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res4e_branch2a", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=256, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn4e_branch2a", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res4e_branch2b", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(3, 3), filters=256, strides=[1, 1], padding="same", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn4e_branch2b", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res4e_branch2c", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=1024, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn4e_branch2c", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res4f_branch2a", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=256, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn4f_branch2a", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res4f_branch2b", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(3, 3), filters=256, strides=[1, 1], padding="same", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn4f_branch2b", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res4f_branch2c", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=1024, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn4f_branch2c", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res5a_branch2a", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=512, strides=[2, 2], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn5a_branch2a", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res5a_branch2b", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(3, 3), filters=512, strides=[1, 1], padding="same", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn5a_branch2b", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res5a_branch2c", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=2048, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res5a_branch1", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=2048, strides=[2, 2], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn5a_branch2c", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn5a_branch1", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res5b_branch2a", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=512, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn5b_branch2a", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res5b_branch2b", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(3, 3), filters=512, strides=[1, 1], padding="same", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn5b_branch2b", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res5b_branch2c", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=2048, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn5b_branch2c", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res5c_branch2a", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=512, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn5c_branch2a", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res5c_branch2b", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(3, 3), filters=512, strides=[1, 1], padding="same", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn5c_branch2b", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(name="res5c_branch2c", activity_regularizer=None, trainable=True, activation="linear", kernel_size=(1, 1), filters=2048, strides=[1, 1], padding="valid", data_format="channels_last", kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `BatchNormalization` call to the Keras 2 API: `BatchNormalization(gamma_regularizer=None, name="bn5c_branch2c", epsilon=0.001, trainable=True, beta_regularizer=None, momentum=0.99, axis=3)`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `AveragePooling2D` call to the Keras 2 API: `AveragePooling2D(name="avg_pool", trainable=True, pool_size=[7, 7], strides=[7, 7], padding="valid", data_format="channels_last")`
  return cls(**config)
C:\Python\lib\site-packages\keras\engine\topology.py:1271: UserWarning: Update your `Dense` call to the Keras 2 API: `Dense(name="fc360", activity_regularizer=None, trainable=True, input_dim=2048, activation="softmax", units=360, kernel_initializer="glorot_uniform", kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True)`
  return cls(**config)
2018-03-26 12:15:03.017241: I C:\tf_jenkins\workspace\rel-win\M\windows-gpu\PY\36\tensorflow\core\platform\cpu_feature_guard.cc:140] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2
2018-03-26 12:15:03.323715: I C:\tf_jenkins\workspace\rel-win\M\windows-gpu\PY\36\tensorflow\core\common_runtime\gpu\gpu_device.cc:1212] Found device 0 with properties:
name: GeForce GTX 780 Ti major: 3 minor: 5 memoryClockRate(GHz): 0.928
pciBusID: 0000:01:00.0
totalMemory: 3.00GiB freeMemory: 2.46GiB
2018-03-26 12:15:03.330047: I C:\tf_jenkins\workspace\rel-win\M\windows-gpu\PY\36\tensorflow\core\common_runtime\gpu\gpu_device.cc:1312] Adding visible gpu devices: 0
2018-03-26 12:15:03.634879: I C:\tf_jenkins\workspace\rel-win\M\windows-gpu\PY\36\tensorflow\core\common_runtime\gpu\gpu_device.cc:993] Creating TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 2183 MB memory) -> physical GPU (device: 0, name: GeForce GTX 780 Ti, pci bus id: 0000:01:00.0, compute capability: 3.5)
C:\Python\lib\site-packages\keras\models.py:291: UserWarning: Error in loading the saved optimizer state. As a result, your model is starting with a freshly initialized optimizer.
  warnings.warn('Error in loading the saved optimizer '
False
Processsing input image(s)...
.\correct_rotation.py:43: UserWarning: The semantics of the Keras 2 argument `steps_per_epoch` is not the same as the Keras 1 argument `samples_per_epoch`. `steps_per_epoch` is the number of batches to draw from the generator at each epoch. Basically steps_per_epoch = samples_per_epoch/batch_size. Similarly `nb_val_samples`->`validation_steps` and `val_samples`->`steps` arguments have changed. Update your method calls accordingly.
  val_samples=len(image_paths)
.\correct_rotation.py:43: UserWarning: Update your `predict_generator` call to the Keras 2 API: `predict_generator(<utils.Rot..., steps=1)`
  val_samples=len(image_paths)
2018-03-26 12:15:23.679167: E C:\tf_jenkins\workspace\rel-win\M\windows-gpu\PY\36\tensorflow\stream_executor\cuda\cuda_blas.cc:443] failed to create cublas handle: CUBLAS_STATUS_ALLOC_FAILED
2018-03-26 12:15:23.978817: E C:\tf_jenkins\workspace\rel-win\M\windows-gpu\PY\36\tensorflow\stream_executor\cuda\cuda_dnn.cc:385] could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR
2018-03-26 12:15:23.982127: F C:\tf_jenkins\workspace\rel-win\M\windows-gpu\PY\36\tensorflow\core\kernels\conv_ops.cc:717] Check failed: stream->parent()->GetConvolveAlgorithms( conv_parameters.ShouldIncludeWinogradNonfusedAlgo<T>(), &algorithms)

Upgrade model to keras 2.0

Hello!
I believe that maybe the model for the Street View was made using keras 1.x since I get a lot of errors like this one below when trying to load the model.

UserWarning: Update your `AveragePooling2D` call to the Keras 2 API: `AveragePooling2D(name="avg_pool", strides=[7, 7], trainable=True, padding="valid", pool_size=[7, 7], data_format="channels_last")`

And

UserWarning: Error in loading the saved optimizer state. As a result, your model is starting with a freshly initialized optimizer.
  warnings.warn('Error in loading the saved optimizer '

Could you please redo the training with keras 2.x?

Thanks!

input array from shape error

input array from shape I use (640, 480, 3) and it always throw out can't into shape (480, 640, 3)
and when i use (480, 640, 3) and it throw out can't into shape (640,480,3)

How can i fix this problem?

I use Python3.5 and Keras 2.2.4

Traceback (most recent call last):
  File "train/train_pistachio.py", line 104, in <module>
    workers=10
  File "/usr/local/lib/python3.5/dist-packages/keras/legacy/interfaces.py", line 91, in wrapper
    return func(*args, **kwargs)
  File "/usr/local/lib/python3.5/dist-packages/keras/engine/training.py", line 1418, in fit_generator
    initial_epoch=initial_epoch)
  File "/usr/local/lib/python3.5/dist-packages/keras/engine/training_generator.py", line 181, in fit_generator
    generator_output = next(output_generator)
  File "/usr/local/lib/python3.5/dist-packages/keras/utils/data_utils.py", line 601, in get
    six.reraise(*sys.exc_info())
  File "/usr/local/lib/python3.5/dist-packages/six.py", line 693, in reraise
    raise value
  File "/usr/local/lib/python3.5/dist-packages/keras/utils/data_utils.py", line 595, in get
    inputs = self.queue.get(block=True).get()
  File "/usr/lib/python3.5/multiprocessing/pool.py", line 608, in get
    raise self._value
  File "/usr/lib/python3.5/multiprocessing/pool.py", line 119, in worker
    result = (True, func(*args, **kwds))
  File "/usr/local/lib/python3.5/dist-packages/keras/utils/data_utils.py", line 401, in get_index
    return _SHARED_SEQUENCES[uid][i]
  File "/usr/local/lib/python3.5/dist-packages/keras_preprocessing/image.py", line 1441, in __getitem__
    return self._get_batches_of_transformed_samples(index_array)
  File "/js/data/RotNet/utils.py", line 302, in _get_batches_of_transformed_samples
    batch_x[i] = rotated_image
ValueError: could not broadcast input array from shape (480,640,3) into shape (640,480,3)

StopIteration on all training and testing

Perhaps this is a result of library APIs changing?

Steps to reproduce:

Check out repository.
Run python train/train_mnist.py

Output:

Input shape: (28, 28, 1)
60000 train samples
10000 test samples
_________________________________________________________________
Layer (type)                 Output Shape              Param #
=================================================================
input_1 (InputLayer)         (None, 28, 28, 1)         0
_________________________________________________________________
conv2d_1 (Conv2D)            (None, 26, 26, 64)        640
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 24, 24, 64)        36928
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 12, 12, 64)        0
_________________________________________________________________
dropout_1 (Dropout)          (None, 12, 12, 64)        0
_________________________________________________________________
flatten_1 (Flatten)          (None, 9216)              0
_________________________________________________________________
dense_1 (Dense)              (None, 128)               1179776
_________________________________________________________________
dropout_2 (Dropout)          (None, 128)               0
_________________________________________________________________
dense_2 (Dense)              (None, 360)               46440
=================================================================
Total params: 1,263,784
Trainable params: 1,263,784
Non-trainable params: 0
_________________________________________________________________
Epoch 1/50

Traceback (most recent call last):
  File "train/train_mnist.py", line 90, in <module>
    callbacks=[checkpointer, early_stopping, tensorboard]
  File "/usr/local/lib/python2.7/site-packages/keras/legacy/interfaces.py", line 87, in wrapper
    return func(*args, **kwargs)
  File "/usr/local/lib/python2.7/site-packages/keras/engine/training.py", line 2046, in fit_generator
    generator_output = next(output_generator)
  File "/usr/local/lib/python2.7/site-packages/keras/utils/data_utils.py", line 518, in get
    raise StopIteration(e)
StopIteration

My versions:

Name: opencv-python
Version: 3.3.0.10

Name: Keras
Version: 2.0.9

Recommend Projects

React

A declarative, efficient, and flexible JavaScript library for building user interfaces.
Vue.js

🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
Typescript

TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
TensorFlow

An Open Source Machine Learning Framework for Everyone
Django

The Web framework for perfectionists with deadlines.
Laravel

A PHP framework for web artisans
D3

Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

javascript

JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
web

Some thing interesting about web. New door for the world.
server

A server is a program made to process requests and deliver data to clients.
Machine learning

Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Visualization

Some thing interesting about visualization, use data art
Game

Some thing interesting about game, make everyone happy.

Recommend Org

Facebook

We are working to build community through open source technology. NB: members must have two-factor auth.
Microsoft

Open source projects and samples from Microsoft.
Google

Google ❤️ Open Source for everyone.
Alibaba

Alibaba Open Source for everyone
D3

Data-Driven Documents codes.
Tencent

China tencent open source team.