def serve_client(socket, graph): client = socket[0] logging.info("Received Client {}.".format(socket[1])) N = socket[2] data = client.recv(1024) data = data.decode() # print(data) url = '' + (data[:data.find('[END]')]) logging.info("Client submitted URL {}".format(url)) print_local = "image/images000" + str(N + 1) + ".jpg" local = "./" + print_local request.urlretrieve(url, local) logging.info("Image saved to {}".format(print_local)) with graph.as_default(): model = SqueezeNet() img = image.load_img(local, target_size=(227, 227)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) preds = model.predict(x) #type of preds: <class 'numpy.ndarray'> preds = decode_predictions(preds) result = "(\"{}\", {})".format(preds[0][0][1], preds[0][0][2]) logging.info("SqueezeNet result: {}".format(result)) sendit = result.encode() #why cannot use json? # print(sendit) client.sendall(sendit) client.shutdown(2) #different between shutdown and close why?? logging.info("Client connection closed") client.close()
def squeezenet_featurize(imagename, imagedir): ''' This network model has AlexNet accuracy with small footprint (5.1 MB) Pretrained models are converted from original Caffe network. This may be useful for production-purposes if the accuracy is similar to other types of featurizations. See https://github.com/rcmalli/keras-squeezenet ''' model = SqueezeNet() img = image.load_img(imagedir+'/'+imagename, target_size=(227, 227)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) preds = model.predict(x) print('Predicted:', decode_predictions(preds)) features = preds[0] labels=list() for i in range(len(features)): label='squeezenet_feature_%s'%(str(i)) labels.append(label) return features, labels
def set_tags(self): """ Run a convolutional neural network on the server-side per image to associate tags (doesn't take more than a few seconds), and runs in parallel since thread is started per client request """ import numpy as np import keras from keras.preprocessing import image from keras_squeezenet import SqueezeNet from keras.applications.imagenet_utils import preprocess_input, decode_predictions # dtype must be uint8 # Encode image to ascii for Python 3 compatibility server_buffer = np.frombuffer(base64.decodestring( self.image.encode('ascii')), dtype="uint8") server_frame = cv2.imdecode(server_buffer, cv2.IMREAD_UNCHANGED) keras.backend.clear_session() model = SqueezeNet() resized = cv2.resize(server_frame, dsize=(227, 227), interpolation=cv2.INTER_CUBIC) x = image.img_to_array(resized) x = np.expand_dims(x, axis=0) x = preprocess_input(x) preds = decode_predictions(model.predict(x)) # preds is an array containing an array of tags and scores print("Tags: {}".format(preds[0])) for id, pred, score in preds[0]: self.tags.append(pred)
def make_predictions(image_file): model = SqueezeNet() img = image.load_img(image_file, target_size=(227, 227)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) preds = model.predict(x) return decode_predictions(preds)
def model_train(x_train, y_train): model = SqueezeNet(weights='imagenet', include_top=False, input_shape=(IMAGE_SIZE, IMAGE_SIZE, 3)) top_model = Sequential() top_model.add(Flatten(input_shape=model.output_shape[1:])) top_model.add(Dense(256, activation='relu')) top_model.add(Dropout(0.5)) top_model.add(Dense(NUM_LABELS, activation='softmax')) model = Model(inputs=model.input, outputs=top_model(model.output)) for layer in model.layers[:15]: layer.trainable = False model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.summary() callback = EarlyStopping(monitor='val_loss', patience=5, verbose=1, mode='auto') model.fit(x_train, y_train, batch_size=BATCH_SIZE, epochs=EPOCH, validation_split=0.1, callbacks=callback) return model
def testTHPrediction(self): keras.backend.set_image_dim_ordering('th') model = SqueezeNet() img = image.load_img('images/cat.jpeg', target_size=(227, 227)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) preds = model.predict(x) decoded_preds = decode_predictions(preds) #print('Predicted:', decoded_preds) self.assertIn(decoded_preds[0][0][1], 'tabby')
def get_RCNN_face_model(): num_outputs = 2 print "Building SqueezeNet..." model = SqueezeNet() print "Building New Layers..." x = model.get_layer('drop9').output x = Convolution2D(num_outputs, (1, 1), padding='valid', name='conv10')(x) x = Activation('relu', name='relu_conv10')(x) x = GlobalAveragePooling2D()(x) out = Activation('softmax', name='loss')(x) model = Model(inputs=model.input, outputs=out) print "Model has been generated" return model
def __init__(self, n_classes=3): self._fitted = False self.X = [] self.y = [] self.X_conv = [] self._lr = SGDClassifier( loss='log', penalty='l1', #warm_start=True, max_iter=50, tol=1e-3, random_state=2 + 3) self._features = SqueezeNet(weights='imagenet', input_shape=(image_size, image_size, 3))
def server_worker(client_socket, address, tf_graph, pic_num): logger = logging.getLogger('logger' + str(pic_num)) logger.setLevel(logging.DEBUG) ch = logging.StreamHandler() formatter = logging.Formatter( "[%(asctime)s], [%(levelname)s], [%(processName)s], [%(threadName)s] : %(message)s" ) ch.setFormatter(formatter) logger.addHandler(ch) logger.info("Recieve Client ('%s', %s)." % (address[0], address[1])) recieve_string = "" # Read data from a client and send it response back while True: #print(client_socket) data = client_socket.recv(2048) data_decode = data.decode(("utf-8")) recieve_string = recieve_string + data_decode # All the message from client is recieved completely if recieve_string.find("[END]") != -1: break recieve_string = recieve_string[:-5] logger.info("Client submitted URL %s" % recieve_string) request.urlretrieve(recieve_string, "images/%d.jpg" % pic_num) print("get the pic") logger.info("finish download") with tf_graph.as_default(): model = SqueezeNet() img = image.load_img('images/1.jpg', target_size=(227, 227)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) preds = model.predict(x) result = decode_predictions(preds) #print('Predicted:', result) result = result[0][0] logger.info("SqueezeNet result: (\"%s\", %.3f)" % (result[1], result[2])) result = [result[1], str(result[2])] result_string = ';'.join(result) client_socket.sendall(result_string.encode("utf-8")) client_socket.shutdown(socket.SHUT_RDWR) client_socket.close() logger.info("Client connection closed") del logger
def train_model(): model = Sequential([ # image size is 300 x 300 pixels. 3 is for RGB # Include_top lets you select if you want the final dense layers or not # Dense layers are capable of interpreting found patterns in order to classify: e.g. this image contains rock # Set to False as we have labeled what rock data looks like already SqueezeNet(input_shape=(300, 300, 3), include_top=False), # To prevent over-fitting, 20% dropout rate Dropout(0.2), # Add this layer to end of Squeeze NN Convolution2D(LABELS_COUNT, (1, 1), padding='valid'), # Any negative values become 0 and keeps positive values # Why? An Activation function is responsible for taking inputs and assigning weights to output nodes, a model # can't coordinate itself well with negative values, # it becomes un-uniform in the sense of how we expect the model to perform. # ЁЭСУ(ЁЭСе) = max{0, ЁЭСе} => The output of a ReLU unit is non-negative. # Returning x, if less than zero then max returns 0. # Has become the default activation function for many types of neural networks because a model that uses # it is easier to train and often achieves better performance. Activation('relu'), # Perform classification, calculates average output of each feature map in previous layer # i.e data reduction layer, prepares model for Activation('softmax') GlobalAveragePooling2D(), # softmax give probabilities of each hand sign # 4 image class (problem), 'softmax' handles multi-class, anything more than 2 Activation('softmax') ]) return model
class Learner: def __init__(self, n_classes=3): self._fitted = False self.X = [] self.y = [] self.X_conv = [] self._lr = SGDClassifier( loss='log', penalty='l1', #warm_start=True, max_iter=50, tol=1e-3, random_state=2 + 3) self._features = SqueezeNet(weights='imagenet', input_shape=(image_size, image_size, 3)) def add_image(self, img, klass): self.X.append(img) self.y.append(klass) X = np.array(self.X[-1:], dtype=np.float32) X = preprocess_input(X) X_conv = self._features.predict(X) print(decode_predictions(X_conv)) X_conv = X_conv[0] print(X_conv.shape) X_conv = X_conv / np.linalg.norm(X_conv) self.X_conv.append(X_conv) print(Counter(self.y)) def fit(self): X_conv = np.array(self.X_conv) y = np.array(self.y) print(X_conv.shape, y.shape) if len(set(self.y)) > 1: self._lr.fit(X_conv, y) self._fitted = True def predict(self, img): if not self._fitted: return 0 # a batch of one image X = np.array(img, dtype=np.float32) X = X[np.newaxis] X = preprocess_input(X) X_conv = self._features.predict(X)[0] X_conv = X_conv / np.linalg.norm(X_conv) return self._lr.predict([X_conv])[0]
def initial_state(self,state0): #turn the image into gray then resize it to (84,84) then compress the data to 8bits #state0=np.uint8(resize(rgb2gray(state0),(frame_width,frame_height))*255) sq_model = SqueezeNet() start = time.time() #img = state0 img = image.load_img('/home/i16djell/Bureau/state0.jpg', target_size=(227, 227)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) feature = sq_model.predict(x) features=[feature ,feature ,feature ,feature ] features=np.stack(features,axis=0) features=features.reshape(1,4,1000) return features
def child_process(queue, lock): graph = tf.get_default_graph() model = SqueezeNet() with ThreadPoolExecutor(max_workers=4) as executor: while 1: if not queue.empty(): with lock: client_socket, client_address = queue.get() executor.submit(thread_worker, client_socket, client_address, graph, model)
def get_model(): model = Sequential([ SqueezeNet(input_shape=(227, 227, 3), include_top=False), Dropout(0.5), Convolution2D(NUM_CLASSES, (1, 1), padding='valid'), Activation('relu'), GlobalAveragePooling2D(), Activation('softmax') ]) return model
def def_model_param(): gesture_categories = len(CATEGORY_MAP) base_model = Sequential() base_model.add( SqueezeNet(input_shape=(IMAGE_SIZE, IMAGE_SIZE, 3), include_top=False)) base_model.add(Dropout(0.5)) base_model.add(Convolution2D(gesture_categories, (1, 1), padding='valid')) base_model.add(Activation('relu')) base_model.add(GlobalAveragePooling2D()) base_model.add(Activation('softmax')) return base_model
def def_model_param(): GESTURE_CATEGORIES = len(CATEGORY_MAP) base_model = Sequential() base_model.add(SqueezeNet(input_shape=(IMG_SIZE[0], IMG_SIZE[1], 3), include_top=False)) base_model.add(Dropout(0.5)) base_model.add(Convolution2D(GESTURE_CATEGORIES, (1, 1), padding='valid')) base_model.add(Activation('relu')) base_model.add(GlobalAveragePooling2D()) base_model.add(Activation('softmax')) return base_model
def _encoder_model(self, input_shape, hyperparameters): squeezenet = SqueezeNet( input_shape=(self.input_shape[0], self.input_shape[1], 3), include_top=False, ) x = Flatten()(squeezenet.output) embedding = Dense(np.prod(hyperparameters['embedding_dim']), activation='relu')(x) encoder = Model(squeezenet.input, embedding) utils.freeze_layers(squeezenet) return encoder
def f(queue): graph = tf.get_default_graph() model = SqueezeNet() executor = ThreadPoolExecutor(max_workers=4) # 创建线程个数 while True: if not queue.empty(): l.acquire() s = queue.get() l.release() client_socket, client_address = (s[0], s[1]) executor.submit(thread_pool, client_socket, client_address, graph, model)
def handle_request(queue): """ A function that will be executed by a child process. It will keep on getting client connection from a queue. """ g = tf.get_default_graph() model = SqueezeNet() with ThreadPoolExecutor(max_workers=4) as executor: while True: soc, address = queue.get() logging.info("Received {}".format(str(address))) executor.submit(handle_client, g, model, soc, address)
def network(mean_train): shape = 227 label_num = 10 mean_train = np.expand_dims(mean_train, axis=0) mean_train = np.expand_dims(mean_train, axis=0) mean_train = np.expand_dims(mean_train, axis=0) input_tensor = Input((shape, shape, 3)) mean_train_tensor = Input(tensor=tf.constant(mean_train, dtype=tf.float32)) subtracted = Subtract()([input_tensor, mean_train_tensor]) squeezeNet = SqueezeNet(subtracted) output = Dense(label_num, activation=None)(squeezeNet) return Model(inputs=[input_tensor, mean_train_tensor], outputs=output)
def get_model(): model = Sequential([ SqueezeNet(input_shape=(227, 227, 3), include_top=False), #3 channels(rgb) Dropout(0.5), #to prevent overfitting,we have 50% dropout rate Convolution2D(NUM_CLASSES, (1, 1), padding='valid'), Activation('relu'), #rectified linear unit GlobalAveragePooling2D(), #calculates avg of each feature map Activation( 'softmax' ) #The softmax function is an activation function that turns numbers into probabilities which sum to one ]) return model
def get_model(): model = Sequential([ SqueezeNet( input_shape=(227, 227, 3), include_top=False ), #image size is 227x227 and 3 stands for the three channels RGB Dropout(0.5), #in order to prevent overfitting 50% dropout Convolution2D( NUM_CLASSES, (1, 1), padding='valid' ), #appending these few layers to the very end of the squeezenet NN Activation('relu'), GlobalAveragePooling2D( ), #performs the classification itself, calculates the avg op of each feature map in the prev layer i.e. data reduction layer Activation('softmax') #probabilties of each layer ]) return model
def squeezenet_build( input_shape=(224, 224, 3), num_classes=2, weights="imagenet"): print("Building squeezenet", input_shape, "- num_classes", num_classes, "- weights", weights) sys.path.append('keras-squeezenet') from keras_squeezenet import SqueezeNet m1 = SqueezeNet(input_shape=input_shape, weights=weights, include_top=True) features = m1.layers[-2].output x = keras.layers.Dense(num_classes, activation='softmax', use_bias=True, name='Logits')(features) model = keras.Model(m1.input, x) for l in model.layers: l.trainable = True return model, features
def handle_request(queue): """ A function that will be executed by a child process. It will keep on getting client connection from a queue. """ model = SqueezeNet() g = tf.get_default_graph() thread_queue = Queue() for i in range(4): t = ClientThread(g, model, thread_queue) t.start() # Get client from the process queue, # and then put it into the thread queue while True: soc, address = queue.get() logging.info("Received {}".format(str(address))) thread_queue.put((soc, address))
def get_all_nets(network_name, include_top=True): if (network_name == "ResNet50"): model = resnet50.ResNet50(weights='imagenet', include_top=include_top, input_shape=(224, 224, 3)) # if(include_top==False): # model.pop() elif (network_name == "MobileNetV2"): model = mobilenetv2.MobileNetV2(weights='imagenet', include_top=include_top, input_shape=(224, 224, 3)) elif (network_name == "VGG19"): model = vgg19.VGG19(weights='imagenet', include_top=include_top) elif (network_name == "SqueezeNet"): model = SqueezeNet(weights='imagenet', include_top=include_top) # if(include_top==False): # model.pop() # model.pop() # model.pop() # model.pop() return model
def new_state(self,futur_state0,state0,state_1,state_2): sq_model = SqueezeNet() start = time.time() #img = state_2 img = image.load_img('/home/i16djell/Bureau/state_2.jpg', target_size=(227, 227)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) feature1 = sq_model.predict(x) #img = state_1 img = image.load_img('/home/i16djell/Bureau/state_1.jpg', target_size=(227, 227)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) feature2 = sq_model.predict(x) #img = state0 img = image.load_img('/home/i16djell/Bureau/state0.jpg', target_size=(227, 227)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) feature3 = sq_model.predict(x) #img = futur_state0 img = image.load_img('/home/i16djell/Bureau/futur_state0.jpg', target_size=(227, 227)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) feature4 = sq_model.predict(x) features=[feature4,feature3,feature2,feature1] features=np.stack(features,axis=0) features=features.reshape(1,4,1000) return features
import numpy as np from keras_squeezenet import SqueezeNet from keras.applications.imagenet_utils import preprocess_input, decode_predictions from keras.preprocessing import image import time if __name__ == '__main__': model = SqueezeNet() # model.load_weights('../model/squeezenet_weights_tf_dim_ordering_tf_kernels.h5', by_name=True) start = time.time() img = image.load_img('blah/train/cats/cat.3.jpg', target_size=(227, 227)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) preds = model.predict(x) duration = time.time() - start print('Predicted:', decode_predictions(preds))
(3, 3), #kernel_regularizer=regularization, padding='same')(x) x = GlobalAveragePooling2D()(x) output = Activation('softmax', name='predictions')(x) model = Model(img_input, output) elif (MODELS == 'squeezenet'): IMAGE_SIZE = 227 EPOCS = 50 import sys sys.path.append('../keras-squeezenet-master') from keras_squeezenet import SqueezeNet input_tensor = Input(shape=(IMAGE_SIZE, IMAGE_SIZE, 3)) model = SqueezeNet(weights=None, classes=N_CATEGORIES, input_tensor=input_tensor) else: raise Exception('invalid model name') if (MODELS == 'vgg16'): #for fine tuning from keras.optimizers import SGD model.compile(optimizer=SGD(lr=0.0001, momentum=0.9), loss='categorical_crossentropy', metrics=['accuracy']) else: #for full training from keras.optimizers import Adagrad model.compile(optimizer=Adagrad(lr=0.01, epsilon=1e-08, decay=0.0), loss='categorical_crossentropy',
input_tensor=input_tensor) x = base_model.output x = GlobalAveragePooling2D()(x) x = Dense(1024, activation='relu')(x) predictions = Dense(N_CATEGORIES, activation='softmax')(x) model = Model(inputs=base_model.input, outputs=predictions) for layer in base_model.layers[:15]: layer.trainable = False elif (MODELS == 'squeezenet'): IMAGE_SIZE = 227 import sys sys.path.append('../keras-squeezenet-master') from keras_squeezenet import SqueezeNet input_tensor = Input(shape=(IMAGE_SIZE, IMAGE_SIZE, 3)) base_model = SqueezeNet(weights="imagenet", include_top=False, input_tensor=input_tensor) x = base_model.output x = GlobalAveragePooling2D()(x) x = Dense(1024, activation='relu')(x) predictions = Dense(N_CATEGORIES, activation='softmax')(x) model = Model(inputs=base_model.input, outputs=predictions) elif (MODELS == 'squeezenet2'): IMAGE_SIZE = 64 import sys sys.path.append('../keras-squeezenet-master') from keras_squeezenet import SqueezeNet input_tensor = Input(shape=(IMAGE_SIZE, IMAGE_SIZE, 3)) base_model = SqueezeNet(include_top=False, input_tensor=input_tensor) x = base_model.output x = Dropout(0.5, name='drop9')(x)
class_number = 4 train_data_dir = 'data_EE_2F/4class_v2/train' validation_data_dir = 'data_EE_2F/4class_v2/validation' nb_train_samples = 4200 nb_validation_samples = 1450 epochs = 15 batch_size = 50 if K.image_data_format() == 'channels_first': input_shape = (3, img_width, img_height) else: input_shape = (img_width, img_height, 3) model = SqueezeNet(weights=None, input_shape=input_shape, classes=class_number) top2_acc = functools.partial(metrics.top_k_categorical_accuracy, k=2) top2_acc.__name__ = 'top2_acc' model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy', top2_acc]) # this is the augmentation configuration we will use for training train_datagen = ImageDataGenerator(rescale=1. / 255) # this is the augmentation configuration we will use for testing: # only rescaling test_datagen = ImageDataGenerator(rescale=1. / 255)
import numpy as np from keras_squeezenet import SqueezeNet from keras.applications.imagenet_utils import preprocess_input, decode_predictions from keras.preprocessing import image #import matplotlib.pyplot as plt #import matplotlib.image as mpimg model = SqueezeNet() img = image.load_img('pexels-photo-280207.jpeg', target_size=(227, 227)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) preds = model.predict(x) all_results = decode_predictions(preds) for results in all_results: for result in results: print('Probability %0.2f%% => [%s]' % (100*result[2], result[1])) #result_text= 'Probability %0.2f%% => [%s]' % (100*result[2], result[1]) #break #plt.figure(num=1,figsize=(8, 6), dpi=80) #plt.imshow(img) #plt.text(130,90,result_text,horizontalalignment='center', verticalalignment='center',fontsize=16,color='black') #plt.axis('off') #plt.show()