import coremltools
coreml_model = coremltools.converters.caffe.convert(('pose_iter_440000.caffemodel', 'pose_deploy_linevec.prototxt'))
coremltools.utils.save_spec(coreml_model, 'my_model.mlmodel')

coremltools.utils.save_spec(coreml_model, 'my_model.mlmodel')
  File "/Users/***/xCode/NeuralNetworks/openpose-1.2.0/models/pose/coco/mlvirtualenv/pythonenv/lib/python2.7/site-packages/coremltools/models/utils.py", line 54, in save_spec
    s = spec.SerializeToString()
AttributeError: 'MLModel' object has no attribute 'SerializeToString'

import coremltools
coreml_model = coremltools.converters.keras.convert(model)
coreml_model.save('my_model.mlmodel')

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-7-ba230c07a72c> in <module>()
      1 import coremltools
----> 2 coreml_model = coremltools.converters.keras.convert(model)
      3 # Saving the Core ML model to a file.
      4 coreml_model.save('my_model.mlmodel')

/home/jonas/projects/keras/keras-env/local/lib/python2.7/site-packages/coremltools/converters/keras/_keras_converter.pyc in convert(model, input_names, output_names, image_input_names, is_bgr, red_bias, green_bias, blue_bias, gray_bias, image_scale, class_labels, predicted_feature_name, model_precision, predicted_probabilities_output, add_custom_layers, custom_conversion_functions)
    743                       predicted_probabilities_output,
    744                       add_custom_layers,
--> 745                       custom_conversion_functions=custom_conversion_functions)
    746 
    747     return _MLModel(spec)

/home/jonas/projects/keras/keras-env/local/lib/python2.7/site-packages/coremltools/converters/keras/_keras_converter.pyc in convertToSpec(model, input_names, output_names, image_input_names, is_bgr, red_bias, green_bias, blue_bias, gray_bias, image_scale, class_labels, predicted_feature_name, model_precision, predicted_probabilities_output, add_custom_layers, custom_conversion_functions, custom_objects)
    541                                            add_custom_layers=add_custom_layers,
    542                                            custom_conversion_functions=custom_conversion_functions,
--> 543                                            custom_objects=custom_objects)
    544     else:
    545         raise RuntimeError(

/home/jonas/projects/keras/keras-env/local/lib/python2.7/site-packages/coremltools/converters/keras/_keras2_converter.pyc in _convert(model, input_names, output_names, image_input_names, is_bgr, red_bias, green_bias, blue_bias, gray_bias, image_scale, class_labels, predicted_feature_name, predicted_probabilities_output, add_custom_layers, custom_conversion_functions, custom_objects)
    185 
    186     # Check valid versions
--> 187     _check_unsupported_layers(model, add_custom_layers)
    188 
    189     # Build network graph to represent Keras model

/home/jonas/projects/keras/keras-env/local/lib/python2.7/site-packages/coremltools/converters/keras/_keras2_converter.pyc in _check_unsupported_layers(model, add_custom_layers)
     98         else:
     99             if type(layer) not in _KERAS_LAYER_REGISTRY:
--> 100                 raise ValueError("Keras layer '%s' not supported. " % str(type(layer)))
    101             if isinstance(layer, _keras.layers.wrappers.TimeDistributed):
    102                 if type(layer.layer) not in _KERAS_LAYER_REGISTRY:

ValueError: Keras layer '<class 'keras_resnet.layers._batch_normalization.BatchNormalization'>' not supported. 

inputlayer = Input(shape=(126,12))

model = BatchNormalization()(inputlayer)
model = Conv1D(16, 25, activation='relu')(model)
model = Flatten()(model)
model = Dense(output_size, activation='sigmoid')(model)

model = Model(inputs=inputlayer, outputs=model)

coreml_model = coremltools.converters.keras.convert(model,
                                                    class_labels=classes)
coreml_model.save('speech_model.mlmodel')

from keras.models import Sequential
from keras.layers import Conv2D
from keras.layers import MaxPooling2D
from keras.layers import Flatten
from keras.layers import Dense
import coremltools
print("Installed")
# Initialising the CNN
classifier = Sequential()
# Step 1 - Convolution
classifier.add(Conv2D(32, (3, 3), input_shape = (64, 64, 3), activation = 'relu'))
# Step 2 - Pooling
classifier.add(MaxPooling2D(pool_size = (2, 2)))
# Adding a second convolutional layer
classifier.add(Conv2D(32, (3, 3), activation = 'relu'))
classifier.add(MaxPooling2D(pool_size = (2, 2)))
# Step 3 - Flattening
classifier.add(Flatten())
# Step 4 - Full connection
classifier.add(Dense(units = 128, activation = 'relu'))
classifier.add(Dense(units = 1, activation = 'sigmoid'))
# Compiling the CNN
classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
# Part 2 - Fitting the CNN to the images
from keras.preprocessing.image import ImageDataGenerator
train_datagen = ImageDataGenerator(rescale = 1./255,
                                   shear_range = 0.2,
                                   zoom_range = 0.2,
                                   horizontal_flip = True)
test_datagen = ImageDataGenerator(rescale = 1./255)
training_set = train_datagen.flow_from_directory('dataset/training_set',
                                                 target_size = (64, 64),
                                                 batch_size = 2,
                                                 class_mode = 'binary')
test_set = test_datagen.flow_from_directory('dataset/test_set',
                                            target_size = (64, 64),
                                            batch_size = 2,
                                            class_mode = 'binary')
classifier.fit_generator(training_set,
                         steps_per_epoch = 42,
                         epochs = 5,
                         validation_data = test_set,
                         validation_steps = 8)
# Part 3 - Making new predictions
import numpy as np
from keras.preprocessing import image
test_image = image.load_img('dataset/single_prediction/1.jpeg', target_size = (64, 64))
test_image = image.img_to_array(test_image)
test_image = np.expand_dims(test_image, axis = 0)
result = classifier.predict(test_image)
training_set.class_indices
print(result[0][0])
if result[0][0] == 1:
    prediction = 'plastic'
else:
    prediction = 'metal'
print(prediction)
coreml_model = coremltools.converters.keras.convert(classifier, input_names=['image'], output_names=['chairConfidence'], class_labels=['metal','plastic'], image_input_names=['image'])
coreml_model.save('my_model.mlmodel')

0 : lstm_1_input, <keras.engine.topology.InputLayer object at 0x122c77f50>
1 : lstm_1, <keras.layers.recurrent.LSTM object at 0x122d14f10>
2 : bidirectional_1, <keras.layers.wrappers.Bidirectional object at 0x122ecfb10>
3 : lstm_3, <keras.layers.recurrent.LSTM object at 0x123699a90>
4 : bidirectional_2, <keras.layers.wrappers.Bidirectional object at 0x123a44d90>
5 : lstm_5, <keras.layers.recurrent.LSTM object at 0x1241a4990>
6 : time_distributed_1, <keras.layers.wrappers.TimeDistributed object at 0x12450b8d0>
7 : time_distributed_1__activation__, <keras.layers.core.Activation object at 0x1255e6590>
Fatal Python error: PyThreadState_Get: no current thread

model.add(Activation('linear'))
model.add(Reshape((GRID_H, GRID_W, BOX, 4 + 1 + CLASS)))

...
31 : conv2d_8, <keras.layers.convolutional.Conv2D object at 0x1149f8a50>
32 : activation_1, <keras.layers.core.Activation object at 0x114b87b90>
33 : reshape_1, <keras.layers.core.Reshape object at 0x114be7f10>
Traceback (most recent call last):
  File "./tinyyolo.py", line 160, in <module>
    coreml_model = coremltools.converters.keras.convert(model, image_input_names='yolo_in', output_names='reshape_1')
  File "/Users/era/git/coremltools/coremltools/converters/keras/_keras_converter.py", line 505, in convert
    predicted_probabilities_output = predicted_probabilities_output)
  File "/Users/era/git/coremltools/coremltools/converters/keras/_keras2_converter.py", line 278, in _convert
    converter_func(builder, layer, input_names, output_names, keras_layer)
  File "/Users/era/git/coremltools/coremltools/converters/keras/_layers2.py", line 858, in convert_reshape
    _utils.raise_error_unsupported_categorical_option('input_shape', str(input_shape), 'reshape', layer)
  File "/Users/era/git/coremltools/coremltools/converters/keras/_utils.py", line 12, in raise_error_unsupported_categorical_option
    layer_type, layer_name))
RuntimeError: Unsupported option input_shape=(None, 13, 13, 160) in layer reshape(reshape_1)

Keras (2.1.1)
coremltools (0.6.3)

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
yolo_in (Conv2D)             (None, 416, 416, 16)      432       
_________________________________________________________________
batch_normalization_1 (Batch (None, 416, 416, 16)      64        
_________________________________________________________________
leaky_re_lu_1 (LeakyReLU)    (None, 416, 416, 16)      0         
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 208, 208, 16)      0         
_________________________________________________________________
conv2d_1 (Conv2D)            (None, 208, 208, 32)      4608      
_________________________________________________________________
batch_normalization_2 (Batch (None, 208, 208, 32)      128       
_________________________________________________________________
leaky_re_lu_2 (LeakyReLU)    (None, 208, 208, 32)      0         
_________________________________________________________________
max_pooling2d_2 (MaxPooling2 (None, 104, 104, 32)      0         
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 104, 104, 64)      18432     
_________________________________________________________________
batch_normalization_3 (Batch (None, 104, 104, 64)      256       
_________________________________________________________________
leaky_re_lu_3 (LeakyReLU)    (None, 104, 104, 64)      0         
_________________________________________________________________
max_pooling2d_3 (MaxPooling2 (None, 52, 52, 64)        0         
_________________________________________________________________
conv2d_3 (Conv2D)            (None, 52, 52, 128)       73728     
_________________________________________________________________
batch_normalization_4 (Batch (None, 52, 52, 128)       512       
_________________________________________________________________
leaky_re_lu_4 (LeakyReLU)    (None, 52, 52, 128)       0         
_________________________________________________________________
max_pooling2d_4 (MaxPooling2 (None, 26, 26, 128)       0         
_________________________________________________________________
conv2d_4 (Conv2D)            (None, 26, 26, 256)       294912    
_________________________________________________________________
batch_normalization_5 (Batch (None, 26, 26, 256)       1024      
_________________________________________________________________
leaky_re_lu_5 (LeakyReLU)    (None, 26, 26, 256)       0         
_________________________________________________________________
max_pooling2d_5 (MaxPooling2 (None, 13, 13, 256)       0         
_________________________________________________________________
conv2d_5 (Conv2D)            (None, 13, 13, 512)       1179648   
_________________________________________________________________
batch_normalization_6 (Batch (None, 13, 13, 512)       2048      
_________________________________________________________________
leaky_re_lu_6 (LeakyReLU)    (None, 13, 13, 512)       0         
_________________________________________________________________
max_pooling2d_6 (MaxPooling2 (None, 13, 13, 512)       0         
_________________________________________________________________
conv2d_6 (Conv2D)            (None, 13, 13, 1024)      4718592   
_________________________________________________________________
batch_normalization_7 (Batch (None, 13, 13, 1024)      4096      
_________________________________________________________________
leaky_re_lu_7 (LeakyReLU)    (None, 13, 13, 1024)      0         
_________________________________________________________________
conv2d_7 (Conv2D)            (None, 13, 13, 1024)      9437184   
_________________________________________________________________
batch_normalization_8 (Batch (None, 13, 13, 1024)      4096      
_________________________________________________________________
leaky_re_lu_8 (LeakyReLU)    (None, 13, 13, 1024)      0         
_________________________________________________________________
conv2d_8 (Conv2D)            (None, 13, 13, 160)       164000    
_________________________________________________________________
activation_1 (Activation)    (None, 13, 13, 160)       0         
_________________________________________________________________
reshape_1 (Reshape)          (None, 13, 13, 5, 32)     0         
=================================================================
Total params: 15,903,760
Trainable params: 15,897,648
Non-trainable params: 6,112

    keras_model = Sequential()
    keras_model.add(Permute((3, 2, 1), input_shape=(10, 64,3)))

    input_names = ['input']
    output_names = ['output']
    coreml_model = keras.convert(model, input_names, output_names)

   print coreml_model.get_spec()

SEQUENCE_LENGTH = 8000
NUM_CATS = 1025

inputs = Input(shape=(SEQUENCE_LENGTH,))
L0 = Reshape((SEQUENCE_LENGTH,1))(inputs)
L1 = Conv1D(filters=4,
             kernel_size=4,
             strides=4, 
             padding='same', 
             activation='relu')(L0)
L2  = Dense(32, activation='relu')(L1)
L3 = Dense(NUM_CATS, activation='softmax')(L2)

model = Model(inputs=inputs, outputs=L3)

inputx = np.array(X[0])
print(inputx.shape)
t0 = time.time()
print("CoreML model output shape: ", coreml_model.predict({'input1': inputx})['output1'].shape)
print("Time taken: ", time.time()-t0)

(8000,)
CoreML model output shape:  (2000, 1025)
Time taken:  0.049160003662109375

inputx = np.array([X[0:20]])
print(inputx.shape)
t0 = time.time()
print("CoreML model output shape: ", coreml_model.predict({'input1': inputx})['output1'].shape)
print("Time taken: ", time.time()-t0)

(1, 20, 8000)
CoreML model output shape:  (2000, 1025)
Time taken:  0.5843930244445801

# Instantiate model
model = Sequential()

model.add(Conv2D(64, (3, 3), activation='relu', data_format = 'channels_last', input_shape = (224, 224, 3)))
model.add(MaxPooling2D((2, 2), strides=(1, 1)))

model.add(Conv2D(128, (4,4), activation='relu'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))

model.add(Conv2D(256, (4,4), activation='relu'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))

model.add(Flatten())
model.add(Dropout(0.5))
model.add(Reshape((1, 719104)))

model.add(LSTM(256, return_sequences=True, return_state=False, dropout=0.5))

model.add(Dense(num_classes, activation='sigmoid'))

from sklearn.ensemble import GradientBoostingClassifier
from sklearn.datasets import load_boston
import numpy as np
import pandas as pd

from coremltools.converters import sklearn as skl_converter

args = {'max_leaf_nodes': None, 'min_samples_leaf': 1, 'min_samples_split': 2,
        'min_weight_fraction_leaf': 0.5, 'max_features': 1, 'max_depth': 1}

scikit_model = GradientBoostingClassifier(random_state = 1, **args)

scikit_data = load_boston()
X = scikit_data.data.astype('f').astype('d')

num_classes = 3
t = scikit_data.target
target = np.digitize(t, np.histogram(t, bins = num_classes - 1)[1]) - 1
scikit_model.fit(X, target)

coreml_model = skl_converter.convert(scikit_model, scikit_data.feature_names)

df = pd.DataFrame(X, columns=scikit_data.feature_names)

indexs_for_wrong_predictions = []
for i, row in df.iterrows():
    predicted = coreml_model.predict(dict(row))
    print(predicted['classProbability'], scikit_model.predict_proba([X[i]]))

from keras.layers.core import Flatten
initial_model = keras.applications.ResNet50(include_top=True, weights='imagenet')
initial_model.save("original.h5")
convert = coremltools.converters.keras.convert(
    "original.h5", 
    input_names=['img'], 
    image_input_names=['img'], 
    class_labels=list(map(str, range(1000)))
)
convert.save("orig.mlmodel")

import UIKit
import AVKit
import Vision

class XYZ: UIViewController, AVCaptureVideoDataOutputSampleBufferDelegate{
  override func viewDidLoad() {
    super.viewDidLoad()
    
    let captureSession = AVCaptureSession()
    
    guard let captureDevice = AVCaptureDevice.default(for: .video) else { return }
    guard let input = try? AVCaptureDeviceInput(device: captureDevice) else { return }
    captureSession.addInput(input)
    captureSession.startRunning()
    
    let previewLayer = AVCaptureVideoPreviewLayer(session: captureSession)
    view.layer.addSublayer(previewLayer)
    previewLayer.frame = view.frame
    
    let dataOutput = AVCaptureVideoDataOutput()
    dataOutput.setSampleBufferDelegate(self, queue: DispatchQueue(label: "videoQueue"))
    captureSession.addOutput(dataOutput)
    
  }
  
  func captureOutput(_ output: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer, from connection: AVCaptureConnection) {
    guard let pixelBuffer: CVPixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else { return }
    
    guard let model = try? VNCoreMLModel(for: orig().model) else { return }
    let request = VNCoreMLRequest(model: model) { (finishedReq, err) in
      guard let results = finishedReq.results as? [VNClassificationObservation] else {
        return
      }
      guard let firstObservation = results.first else { return }
      print(firstObservation.identifier, firstObservation.confidence)      
    }
    
    try? VNImageRequestHandler(cvPixelBuffer: pixelBuffer, options: [:]).perform([request])
  }
  
}

def MobileNetEncoder(input_shape,
                     alpha=1.0,
                     depth_multiplier=1): 
    img_input = Input(shape=input_shape)
    b00 = _conv_block(img_input, 32, alpha, strides=(2, 2), block_id=0)
    ...
    b13 = _depthwise_conv_block(b12, 1024, alpha, depth_multiplier, block_id=13)
    model = Model(img_input,[b00, b13])
    return model

    img_input = Input(shape=input_shape)

    height, width, channels = input_shape

    encoder =  MobileNetEncoder(input_shape)
    encoder =  MobileNetEncoder(input_shape)
    encoder_output =encoder(img_input)
    output = Conv2D(30,
                    (1, 1), strides=(1, 1),
                    padding='same',
                    name='conv_23',
                    kernel_initializer='lecun_normal')(encoder_output[-1])
    model = Model(img_input, yolo_model)

layers {
  name: "conv_23"
  input: "model_1_conv_0_relu_output"
  output: "conv_23"
  convolution {
    outputChannels: 30
    kernelChannels: 1024
    nGroups: 1
    kernelSize: 1
    kernelSize: 1
    stride: 1
    stride: 1
    dilationFactor: 1
    dilationFactor: 1
    same {
    }
    hasBias: true
    weights {
    }
    bias {
    }
  }
}

import coremltools
model = coremltools.converters.caffe.convert('snapshot_iter_1890.caffemodel')

Traceback (most recent call last):
  File "convert_to_coreml.py", line 20, in <module>
    image_scale=1/255.)
  File "/Users/WeiJay/anaconda/envs/py2/lib/python2.7/site-packages/coremltools/converters/keras/_keras_converter.py", line 747, in convert
    return _MLModel(spec)
  File "/Users/WeiJay/anaconda/envs/py2/lib/python2.7/site-packages/coremltools/models/model.py", line 153, in __init__
    self.__proxy__ = _get_proxy_from_spec(filename)
  File "/Users/WeiJay/anaconda/envs/py2/lib/python2.7/site-packages/coremltools/models/model.py", line 77, in _get_proxy_from_spec
    return _MLModelProxy(filename)
RuntimeError: Error compiling model: "compiler error:  Error saving network to file.".

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
input_1 (InputLayer)         (None, 416, 416, 3)       0         
_________________________________________________________________
conv2d_1 (Conv2D)            (None, 416, 416, 16)      432       
_________________________________________________________________
batch_normalization_1 (Batch (None, 416, 416, 16)      64        
_________________________________________________________________
leaky_re_lu_1 (LeakyReLU)    (None, 416, 416, 16)      0         
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 208, 208, 16)      0         
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 208, 208, 32)      4608      
_________________________________________________________________
batch_normalization_2 (Batch (None, 208, 208, 32)      128       
_________________________________________________________________
leaky_re_lu_2 (LeakyReLU)    (None, 208, 208, 32)      0         
_________________________________________________________________
max_pooling2d_2 (MaxPooling2 (None, 104, 104, 32)      0         
_________________________________________________________________
conv2d_3 (Conv2D)            (None, 104, 104, 64)      18432     
_________________________________________________________________
batch_normalization_3 (Batch (None, 104, 104, 64)      256       
_________________________________________________________________
leaky_re_lu_3 (LeakyReLU)    (None, 104, 104, 64)      0         
_________________________________________________________________
max_pooling2d_3 (MaxPooling2 (None, 52, 52, 64)        0         
_________________________________________________________________
conv2d_4 (Conv2D)            (None, 52, 52, 128)       73728     
_________________________________________________________________
batch_normalization_4 (Batch (None, 52, 52, 128)       512       
_________________________________________________________________
leaky_re_lu_4 (LeakyReLU)    (None, 52, 52, 128)       0         
_________________________________________________________________
max_pooling2d_4 (MaxPooling2 (None, 26, 26, 128)       0         
_________________________________________________________________
conv2d_5 (Conv2D)            (None, 26, 26, 256)       294912    
_________________________________________________________________
batch_normalization_5 (Batch (None, 26, 26, 256)       1024      
_________________________________________________________________
leaky_re_lu_5 (LeakyReLU)    (None, 26, 26, 256)       0         
_________________________________________________________________
max_pooling2d_5 (MaxPooling2 (None, 13, 13, 256)       0         
_________________________________________________________________
conv2d_6 (Conv2D)            (None, 13, 13, 512)       1179648   
_________________________________________________________________
batch_normalization_6 (Batch (None, 13, 13, 512)       2048      
_________________________________________________________________
leaky_re_lu_6 (LeakyReLU)    (None, 13, 13, 512)       0         
_________________________________________________________________
max_pooling2d_6 (MaxPooling2 (None, 13, 13, 512)       0         
_________________________________________________________________
conv2d_7 (Conv2D)            (None, 13, 13, 1024)      4718592   
_________________________________________________________________
batch_normalization_7 (Batch (None, 13, 13, 1024)      4096      
_________________________________________________________________
leaky_re_lu_7 (LeakyReLU)    (None, 13, 13, 1024)      0         
_________________________________________________________________
conv2d_8 (Conv2D)            (None, 13, 13, 512)       4718592   
_________________________________________________________________
batch_normalization_8 (Batch (None, 13, 13, 512)       2048      
_________________________________________________________________
leaky_re_lu_8 (LeakyReLU)    (None, 13, 13, 512)       0         
_________________________________________________________________
conv2d_9 (Conv2D)            (None, 13, 13, 425)       218025    
=================================================================
Total params: 11,237,145
Trainable params: 11,232,057
Non-trainable params: 5,088
_________________________________________________________________

0 : input_1, <keras.engine.topology.InputLayer object at 0x11d8fd590>
1 : conv2d_1, <keras.layers.convolutional.Conv2D object at 0x11d8fd910>
2 : batch_normalization_1, <keras.layers.normalization.BatchNormalization object at 0x11d8fd9d0>
/Users/WeiJay/anaconda/envs/py2/lib/python2.7/site-packages/coremltools/converters/keras/_layers2.py:499: RuntimeWarning: invalid value encountered in sqrt
  f = 1.0 / _np.sqrt(std + keras_layer.epsilon)
3 : leaky_re_lu_1, <keras.layers.advanced_activations.LeakyReLU object at 0x11d8fdb90>
4 : max_pooling2d_1, <keras.layers.pooling.MaxPooling2D object at 0x11d8fd810>
5 : conv2d_2, <keras.layers.convolutional.Conv2D object at 0x11d8fd850>
6 : batch_normalization_2, <keras.layers.normalization.BatchNormalization object at 0x11d8fda50>
7 : leaky_re_lu_2, <keras.layers.advanced_activations.LeakyReLU object at 0x11d8fdc10>
8 : max_pooling2d_2, <keras.layers.pooling.MaxPooling2D object at 0x11d8fddd0>
9 : conv2d_3, <keras.layers.convolutional.Conv2D object at 0x11d9383d0>
10 : batch_normalization_3, <keras.layers.normalization.BatchNormalization object at 0x11d9385d0>
11 : leaky_re_lu_3, <keras.layers.advanced_activations.LeakyReLU object at 0x11d938750>
12 : max_pooling2d_3, <keras.layers.pooling.MaxPooling2D object at 0x11d938650>
13 : conv2d_4, <keras.layers.convolutional.Conv2D object at 0x11d9387d0>
14 : batch_normalization_4, <keras.layers.normalization.BatchNormalization object at 0x11d938810>
15 : leaky_re_lu_4, <keras.layers.advanced_activations.LeakyReLU object at 0x11d938950>
16 : max_pooling2d_4, <keras.layers.pooling.MaxPooling2D object at 0x11d938a90>
17 : conv2d_5, <keras.layers.convolutional.Conv2D object at 0x11d938b10>
18 : batch_normalization_5, <keras.layers.normalization.BatchNormalization object at 0x11d938b50>
19 : leaky_re_lu_5, <keras.layers.advanced_activations.LeakyReLU object at 0x11d938c90>
20 : max_pooling2d_5, <keras.layers.pooling.MaxPooling2D object at 0x11d938dd0>
21 : conv2d_6, <keras.layers.convolutional.Conv2D object at 0x11d938e50>
22 : batch_normalization_6, <keras.layers.normalization.BatchNormalization object at 0x11d938e90>
23 : leaky_re_lu_6, <keras.layers.advanced_activations.LeakyReLU object at 0x11d938fd0>
24 : max_pooling2d_6, <keras.layers.pooling.MaxPooling2D object at 0x11d94d150>
25 : conv2d_7, <keras.layers.convolutional.Conv2D object at 0x11d94d1d0>
26 : batch_normalization_7, <keras.layers.normalization.BatchNormalization object at 0x11d94d210>
27 : leaky_re_lu_7, <keras.layers.advanced_activations.LeakyReLU object at 0x11d94d350>
28 : conv2d_8, <keras.layers.convolutional.Conv2D object at 0x11d94d490>
29 : batch_normalization_8, <keras.layers.normalization.BatchNormalization object at 0x11d94d4d0>
30 : leaky_re_lu_8, <keras.layers.advanced_activations.LeakyReLU object at 0x11d94d610>
31 : conv2d_9, <keras.layers.convolutional.Conv2D object at 0x11d94d750>
Input name(s) and shape(s): 
image : (C,H,W) = (3, 416, 416) 
Neural Network compiler 0: 100 , name = conv2d_1, output shape : (C,H,W) = (16, 416, 416) 
Neural Network compiler 1: 160 , name = batch_normalization_1, output shape : (C,H,W) = (16, 416, 416) 
Neural Network compiler 2: 130 , name = leaky_re_lu_1, output shape : (C,H,W) = (16, 416, 416) 
Neural Network compiler 3: 120 , name = max_pooling2d_1, output shape : (C,H,W) = (16, 208, 208) 
Neural Network compiler 4: 100 , name = conv2d_2, output shape : (C,H,W) = (32, 208, 208) 
Neural Network compiler 5: 160 , name = batch_normalization_2, output shape : (C,H,W) = (32, 208, 208) 
Neural Network compiler 6: 130 , name = leaky_re_lu_2, output shape : (C,H,W) = (32, 208, 208) 
Neural Network compiler 7: 120 , name = max_pooling2d_2, output shape : (C,H,W) = (32, 104, 104) 
Neural Network compiler 8: 100 , name = conv2d_3, output shape : (C,H,W) = (64, 104, 104) 
Neural Network compiler 9: 160 , name = batch_normalization_3, output shape : (C,H,W) = (64, 104, 104) 
Neural Network compiler 10: 130 , name = leaky_re_lu_3, output shape : (C,H,W) = (64, 104, 104) 
Neural Network compiler 11: 120 , name = max_pooling2d_3, output shape : (C,H,W) = (64, 52, 52) 
Neural Network compiler 12: 100 , name = conv2d_4, output shape : (C,H,W) = (128, 52, 52) 
Neural Network compiler 13: 160 , name = batch_normalization_4, output shape : (C,H,W) = (128, 52, 52) 
Neural Network compiler 14: 130 , name = leaky_re_lu_4, output shape : (C,H,W) = (128, 52, 52) 
Neural Network compiler 15: 120 , name = max_pooling2d_4, output shape : (C,H,W) = (128, 26, 26) 
Neural Network compiler 16: 100 , name = conv2d_5, output shape : (C,H,W) = (256, 26, 26) 
Neural Network compiler 17: 160 , name = batch_normalization_5, output shape : (C,H,W) = (256, 26, 26) 
Neural Network compiler 18: 130 , name = leaky_re_lu_5, output shape : (C,H,W) = (256, 26, 26) 
Neural Network compiler 19: 120 , name = max_pooling2d_5, output shape : (C,H,W) = (256, 13, 13) 
Neural Network compiler 20: 100 , name = conv2d_6, output shape : (C,H,W) = (512, 13, 13) 
Neural Network compiler 21: 160 , name = batch_normalization_6, output shape : (C,H,W) = (512, 13, 13) 
Neural Network compiler 22: 130 , name = leaky_re_lu_6, output shape : (C,H,W) = (512, 13, 13) 
Neural Network compiler 23: 120 , name = max_pooling2d_6, output shape : (C,H,W) = (512, 13, 13) 
Neural Network compiler 24: 100 , name = conv2d_7, output shape : (C,H,W) = (1024, 13, 13) 
Neural Network compiler 25: 160 , name = batch_normalization_7, output shape : (C,H,W) = (1024, 13, 13) 
Neural Network compiler 26: 130 , name = leaky_re_lu_7, output shape : (C,H,W) = (1024, 13, 13) 
Neural Network compiler 27: 100 , name = conv2d_8, output shape : (C,H,W) = (512, 13, 13) 
Neural Network compiler 28: 160 , name = batch_normalization_8, output shape : (C,H,W) = (512, 13, 13) 
Neural Network compiler 29: 130 , name = leaky_re_lu_8, output shape : (C,H,W) = (512, 13, 13) 
Neural Network compiler 30: 100 , name = conv2d_9, output shape : (C,H,W) = (425, 13, 13) 

import sys
sys.path.insert(0, r'/Users/corneel/GitHub/KerasTests2')
import coremltools
from keras.models import load_model
model = load_model('final_model.h5')
print("Loaded")

coreml_model = coremltools.converters.keras.convert(model,
    input_names="input_1",
    image_input_names="input_1",
    output_names="sequential_1",
    add_custom_layers=True)

coreml_model.save('final3.mlmodel')

File "Convert.py", line 15, in <module> add_custom_layers=True)
File "/Users/corneel/GitHub/KerasTests2/coremltools/converters/keras/_keras_converter.py" line 745, in convert custom_conversion_functions=custom_conversion_functions)
File "/Users/corneel/GitHub/KerasTests2/coremltools/converters/keras/_keras_converter.py", line 543, in convertToSpec custom_objects=custom_objects)
File "/Users/corneel/GitHub/KerasTests2/coremltools/converters/keras/_keras2_converter.py", line 191, in _convert graph.build()
File "/Users/corneel/GitHub/KerasTests2/coremltools/converters/keras/_topology2.py", line 704, in build self.make_output_layers()
File "/Users/corneel/GitHub/KerasTests2/coremltools/converters/keras/_topology2.py", line 185, in make_output_layers raise ValueError("No outputs can be identified")
ValueError: No outputs can be identified

from keras import applications
from keras.preprocessing.image import ImageDataGenerator
from keras import optimizers
from keras.models import Sequential
from keras.models import Model
from keras.layers import Dropout, Flatten, Dense

# path to the model weights files.
weights_path = '../keras/examples/vgg16_weights.h5'
top_model_weights_path = 'bottleneck_fc_model.h5'
# dimensions of our images.
img_width, img_height = 150, 150

train_data_dir = 'data/train'
validation_data_dir = 'data/validation'
nb_train_samples = 2000
nb_validation_samples = 800
epochs = 50
batch_size = 16

# build the VGG16 network
base_model = applications.VGG16(weights='imagenet', include_top=False, input_shape=(150,150,3))
print('Model loaded.')

# build a classifier model to put on top of the convolutional model
top_model = Sequential()
top_model.add(Flatten(input_shape=base_model.output_shape[1:]))
top_model.add(Dense(256, activation='relu'))
top_model.add(Dropout(0.5))
top_model.add(Dense(1, activation='sigmoid'))

# note that it is necessary to start with a fully-trained
# classifier, including the top classifier,
# in order to successfully do fine-tuning
top_model.load_weights(top_model_weights_path)

# add the model on top of the convolutional base
# model.add(top_model)
model = Model(inputs=base_model.input, outputs=top_model(base_model.output))

# set the first 25 layers (up to the last conv block)
# to non-trainable (weights will not be updated)
for layer in model.layers[:15]:
    layer.trainable = False

# compile the model with a SGD/momentum optimizer
# and a very slow learning rate.
model.compile(loss='binary_crossentropy',
              optimizer=optimizers.SGD(lr=1e-4, momentum=0.9),
              metrics=['accuracy'])

# prepare data augmentation configuration
train_datagen = ImageDataGenerator(
    rescale=1. / 255,
    shear_range=0.2,
    zoom_range=0.2,
    horizontal_flip=True)

test_datagen = ImageDataGenerator(rescale=1. / 255)

train_generator = train_datagen.flow_from_directory(
    train_data_dir,
    target_size=(img_height, img_width),
    batch_size=batch_size,
    class_mode='binary')

validation_generator = test_datagen.flow_from_directory(
    validation_data_dir,
    target_size=(img_height, img_width),
    batch_size=batch_size,
    class_mode='binary')

model.summary()

# fine-tune the model
model.fit_generator(
    train_generator,
    steps_per_epoch=nb_train_samples // batch_size,
    epochs=epochs,
    validation_data=validation_generator,
    validation_steps=nb_validation_samples // batch_size,
    verbose=2)

model.predict_function

model.save

from coremltools.models.utils import evaluate_regressor
from coremltools.converters import xgboost as xgb_converter

from sklearn.datasets import load_boston
import xgboost
import pandas as pd

arg = {'colsample_bytree': 1, 'colsample_bylevel': 1, 'scale_pos_weight': 1,
       'learning_rate': 0.1, 'max_delta_step': 0.1, 'min_child_weight': 1,
       'n_estimators': 1, 'objective': 'reg:linear', 'max_depth': 1}

scikit_data = load_boston()
X = scikit_data.data.astype('f').astype('d')
feature_names, output_name = scikit_data.feature_names, 'target'

dtrain = xgboost.DMatrix(scikit_data.data, label = scikit_data.target,
                            feature_names = feature_names)
xgb_model = xgboost.train(arg, dtrain)

spec = xgb_converter.convert(xgb_model,feature_names, output_name, force_32bit_float = False)

df = pd.DataFrame(X, columns=feature_names)
df['prediction'] = xgb_model.predict(dtrain)

metrics = evaluate_regressor(spec, df, target = 'target', verbose = True)

Fatal Python error: PyThreadState_Get: no current thread
Abort trap: 6

import keras
from keras.layers.core import Flatten
initial_model = keras.applications.mobilenet.MobileNet(input_shape=(size, size, 3), include_top=False, weights='imagenet', classes=2)
last = initial_model.output
x = Flatten()(last)
preds = Dense(2, activation='softmax')(x)

model = Model(initial_model.input, preds)

from keras.utils.generic_utils import CustomObjectScope
with CustomObjectScope({'relu6': keras.applications.mobilenet.relu6,'DepthwiseConv2D': keras.applications.mobilenet.DepthwiseConv2D}):
      convert = coremltools.converters.keras.convert("model.h5", input_names=['img'], image_input_names=['img'], class_labels=['class1', 'class2'])

---------------------------------------------------------------------------
ImportError                               Traceback (most recent call last)
<ipython-input-2-0841eccd1027> in <module>()
----> 1 caffe_converter.convert('/Users/tobyroseman/Downloads/oxford102.caffemodel')

/Users/tobyroseman/anaconda3/lib/python3.6/site-packages/coremltools/converters/caffe/_caffe_converter.py in convert(model, image_input_names, is_bgr, red_bias, blue_bias, green_bias, gray_bias, image_scale, class_labels, predicted_feature_name, model_precision)
    181             blue_bias,
    182             green_bias, gray_bias, image_scale, class_labels,
--> 183             predicted_feature_name)
    184     model = MLModel(model_path)
    185 

/Users/tobyroseman/anaconda3/lib/python3.6/site-packages/coremltools/converters/caffe/_caffe_converter.py in _export(filename, model, image_input_names, is_bgr, red_bias, blue_bias, green_bias, gray_bias, image_scale, class_labels, predicted_feature_name)
    194            image_scale=1.0,
    195            class_labels=None, predicted_feature_name=None):
--> 196     from ... import libcaffeconverter
    197 
    198     if isinstance(model, basestring):

ImportError: dynamic module does not define module export function (PyInit_libcaffeconverter)

import xgboost
import coremltools

xgb_model = xgboost.XGBRegressor()
xgb_model.fit([[0,0],[1,1]], [0,2])

coremltools.converters.xgboost.convert(xgb_model)

lib/python2.7/site-packages/coremltools/graph_visualization/

inputs = [Input(shape=(2,3,4)) for _ in range(3)]
convLayer = Conv2D(12, kernel_size=(2,2), padding='valid')
conved = [convLayer(_i) for _i in inputs]
flat_layer = [Flatten()(c) for c in conved]
model = Model(inputs=inputs, outputs=flat_layer)

KeyError: u'flatten_1'

RuntimeError: Error compiling model: "compiler error:  Invalid dst shape1 x 1 x 1344 x 1->1->1 x 1 x 84 x 0 x 4 x ".

inputs = [Input(shape=(2,3,4)) for _ in range(3)]
conved = [ Conv2D(12, kernel_size=(2,2), padding='valid')(_i) for _i in inputs]
flat_layer = [Flatten()(c) for c in conved]
model = Model(inputs=discriminator_in, outputs=flat_layer)