Scribd Logo
Upload

Welcome to Scribd!

  • 34 views

    Animal Monitoring Screen Code

    Uploaded by

    The Mind
    1. The document describes the training and testing phases of a deep learning model for image segmentation and object detection. 2. In the training phase, it preprocesses images, performs feature extraction using a convolutional neural network (CNN), and trains the CNN classifier. 3. In the testing phase, it preprocesses new images, runs the CNN to extract features and classify objects, and uses a separate Caffe model for mobile object detection.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd

    Animal Monitoring Screen Code

    Uploaded by

    The Mind
    34 views17 pages
    1. The document describes the training and testing phases of a deep learning model for image segmentation and object detection. 2. In the training phase, it preprocesses images, performs feature extraction using a convolutional neural network (CNN), and trains the CNN classifier. 3. In the testing phase, it preprocesses new images, runs the CNN to extract features and classify objects, and uses a separate Caffe model for mobile object detection.

    Original Title

    animal-monitoring-screen-code

    Copyright

    © © All Rights Reserved

    Available Formats

    DOCX, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    1. The document describes the training and testing phases of a deep learning model for image segmentation and object detection. 2. In the training phase, it preprocesses images, performs feature extraction using a convolutional neural network (CNN), and trains the CNN classifier. 3. In the testing phase, it preprocesses new images, runs the CNN to extract features and classify objects, and uses a separate Caffe model for mobile object detection.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd
    Download as docx, pdf, or txt
    34 views17 pages

    Animal Monitoring Screen Code

    Uploaded by

    The Mind
    1. The document describes the training and testing phases of a deep learning model for image segmentation and object detection. 2. In the training phase, it preprocesses images, performs feature extraction using a convolutional neural network (CNN), and trains the CNN classifier. 3. In the testing phase, it preprocesses new images, runs the CNN to extract features and classify objects, and uses a separate Caffe model for mobile object detection.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd
    Download as docx, pdf, or txt
    of 17

    Training Phase

    Preprocessing
    import cv2
    if n==0:
    tit="Preprocessing"
    image = PIL.Image.open("static/dataset/"+fn)
    #new_image = PIL.image.resize((300, 300))
    image.save('static/trained/'+fn)

    path='static/trained/'+fn
    im = Image.open(path)
    pfn="p"+fn
    path3="static/trained/"+pfn
    for idx, box in enumerate(split(im)):
    im.crop(box).save(path3.format(idx))

    fnn=fn
    elif n==1:
    tit="Grayscale"
    pfn="p"+fn
    path3="static/trained/"+pfn
    image = Image.open(path3).convert('L')
    image.save(path3)
    fnn=pfn

    elif n==2:
    pfn="p"+fn
    img = cv2.imread('static/trained/'+pfn)
    gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
    ret, thresh =
    cv2.threshold(gray,0,255,cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)
    # noise removal
    kernel = np.ones((3,3),np.uint8)
    opening = cv2.morphologyEx(thresh,cv2.MORPH_OPEN,kernel, iterations = 2)
    # sure background area
    sure_bg = cv2.dilate(opening,kernel,iterations=3)
    # Finding sure foreground area
    dist_transform = cv2.distanceTransform(opening,cv2.DIST_L2,5)
    ret, sure_fg = cv2.threshold(dist_transform,0.7*dist_transform.max(),255,0)
    # Finding unknown region
    sure_fg = np.uint8(sure_fg)
    segment = cv2.subtract(sure_bg,sure_fg)
    fname="s"+fn
    cv2.imwrite("static/trained/"+fname, segment)
    fnn=fname
    ###Segmentation using RNN
    def crfrnn_segmenter(model_def_file, model_file, gpu_device, inputs):

    assert os.path.isfile(model_def_file), "File {} is missing".format(model_def_file)


    assert os.path.isfile(model_file), ("File {} is missing. Please download it using "
    "./download_trained_model.sh").format(model_file)

    if gpu_device >= 0:
    caffe.set_device(gpu_device)
    caffe.set_mode_gpu()
    else:
    caffe.set_mode_cpu()

    net = caffe.Net(model_def_file, model_file, caffe.TEST)

    num_images = len(inputs)
    num_channels = inputs[0].shape[2]
    assert num_channels == 3, "Unexpected channel count. A 3-channel RGB image is
    exptected."

    caffe_in = np.zeros((num_images, num_channels, _MAX_DIM, _MAX_DIM),


    dtype=np.float32)
    for ix, in_ in enumerate(inputs):
    caffe_in[ix] = in_.transpose((2, 0, 1))

    start_time = time.time()
    out = net.forward_all(**{net.inputs[0]: caffe_in})
    end_time = time.time()

    print("Time taken to run the network: {:.4f} seconds".format(end_time - start_time))


    predictions = out[net.outputs[0]]

    return predictions[0].argmax(axis=0).astype(np.uint8)

    def run_crfrnn(input_file, output_file, gpu_device):


    """ Runs the CRF-RNN segmentation on the given RGB image and saves the segmentation
    mask.
    Args:
    input_file: Input RGB image file (e.g. in JPEG format)
    output_file: Path to save the resulting segmentation in PNG format
    gpu_device: ID of the GPU device. If using the CPU, set this to -1
    """

    input_image = 255 * caffe.io.load_image(input_file)


    input_image = resize_image(input_image)

    image = PILImage.fromarray(np.uint8(input_image))
    image = np.array(image)

    palette = get_palette(256)
    #PIL reads image in the form of RGB, while cv2 reads image in the form of BGR, mean_vec
    = [R,G,B]
    mean_vec = np.array([123.68, 116.779, 103.939], dtype=np.float32)
    mean_vec = mean_vec.reshape(1, 1, 3)

    # Rearrange channels to form BGR


    im = image[:, :, ::-1]
    # Subtract mean
    im = im - mean_vec

    # Pad as necessary
    cur_h, cur_w, cur_c = im.shape
    pad_h = _MAX_DIM - cur_h
    pad_w = _MAX_DIM - cur_w
    im = np.pad(im, pad_width=((0, pad_h), (0, pad_w), (0, 0)), mode='constant',
    constant_values=0)

    # Get predictions
    segmentation = crfrnn_segmenter(_MODEL_DEF_FILE, _MODEL_FILE, gpu_device, [im])
    segmentation = segmentation[0:cur_h, 0:cur_w]

    output_im = PILImage.fromarray(segmentation)
    output_im.putpalette(palette)
    output_im.save(output_file)
    ###Feature extraction & Classification
    def DCNN_process(self):

    train_data_preprocess = ImageDataGenerator(
    rescale = 1./255,
    shear_range = 0.2,
    zoom_range = 0.2,
    horizontal_flip = True)

    test_data_preprocess = (1./255)

    train = train_data_preprocess.flow_from_directory(
    'dataset/training',
    target_size = (128,128),
    batch_size = 32,
    class_mode = 'binary')

    test = train_data_preprocess.flow_from_directory(
    'dataset/test',
    target_size = (128,128),
    batch_size = 32,
    class_mode = 'binary')
    ## Initialize the Convolutional Neural Net

    # Initialising the CNN


    cnn = Sequential()

    # Step 1 - Convolution
    # Step 2 - Pooling
    cnn.add(Conv2D(32, (3, 3), input_shape = (128, 128, 3), activation = 'relu'))
    cnn.add(MaxPooling2D(pool_size = (2, 2)))

    # Adding a second convolutional layer


    cnn.add(Conv2D(32, (3, 3), activation = 'relu'))
    cnn.add(MaxPooling2D(pool_size = (2, 2)))

    # Step 3 - Flattening
    cnn.add(Flatten())

    # Step 4 - Full connection


    cnn.add(Dense(units = 128, activation = 'relu'))
    cnn.add(Dense(units = 1, activation = 'sigmoid'))

    # Compiling the CNN


    cnn.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])

    history = cnn.fit_generator(train,
    steps_per_epoch = 250,
    epochs = 25,
    validation_data = test,
    validation_steps = 2000)

    plt.plot(history.history['acc'])
    plt.plot(history.history['val_acc'])
    plt.title('Model Accuracy')
    plt.ylabel('accuracy')
    plt.xlabel('epoch')
    plt.legend(['train', 'test'], loc='upper left')
    plt.show()

    plt.plot(history.history['loss'])
    plt.plot(history.history['val_loss'])
    plt.title('Model Loss')
    plt.ylabel('loss')
    plt.xlabel('epoch')
    plt.legend(['train', 'test'], loc='upper left')
    plt.show()
    test_image = image.load_img('\\dataset\\', target_size=(128,128))
    test_image = image.img_to_array(test_image)
    test_image = np.expand_dims(test_image, axis=0)
    result = cnn.predict(test_image)
    print(result)

    if result[0][0] == 1:
    print('feature extracted and classified')

    Testing Phase
    if n==0:
    tit="Preprocessing"
    image = PIL.Image.open("static/trained/"+fn)
    #new_image = PIL.image.resize((300, 300))
    image.save('static/trained/'+fn)

    path='static/trained/'+fn
    im = Image.open(path)

    pfn="q"+fn
    path3="static/trained/"+pfn
    for idx, box in enumerate(split(im)):
    im.crop(box).save(path3.format(idx))

    fnn=fn
    elif n==1:
    tit="Grayscale"
    pfn="q"+fn
    path3="static/trained/"+pfn
    image = Image.open(path3).convert('L')
    image.save(path3)
    fnn=pfn

    elif n==2:
    pfn="q"+fn
    img = cv2.imread('static/trained/'+pfn)
    gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
    ret, thresh =
    cv2.threshold(gray,0,255,cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)

    # noise removal
    kernel = np.ones((3,3),np.uint8)
    opening = cv2.morphologyEx(thresh,cv2.MORPH_OPEN,kernel, iterations = 2)
    # sure background area
    sure_bg = cv2.dilate(opening,kernel,iterations=3)

    # Finding sure foreground area


    dist_transform = cv2.distanceTransform(opening,cv2.DIST_L2,5)
    ret, sure_fg = cv2.threshold(dist_transform,0.7*dist_transform.max(),255,0)

    # Finding unknown region


    sure_fg = np.uint8(sure_fg)
    segment = cv2.subtract(sure_bg,sure_fg)
    fname="s"+fn
    cv2.imwrite("static/trained/"+fname, segment)
    fnn=fname

    # construct the argument parse


    parser = argparse.ArgumentParser(
    description='Script to run MobileNet-SSD object detection network ')
    parser.add_argument("--video", help="path to video file. If empty, camera's stream will be
    used")
    parser.add_argument("--prototxt", default="MobileNetSSD_deploy.prototxt",
    help='Path to text network file: '
    'MobileNetSSD_deploy.prototxt for Caffe model or '
    )
    parser.add_argument("--weights", default="MobileNetSSD_deploy.caffemodel",
    help='Path to weights: '
    'MobileNetSSD_deploy.caffemodel for Caffe model or '
    )
    parser.add_argument("--thr", default=0.2, type=float, help="confidence threshold to filter out
    weak detections")
    args = parser.parse_args()

    # Labels of Network.

    # Open video file or capture device.


    '''if args.video:
    cap = cv2.VideoCapture(args.video)
    else:
    cap = cv2.VideoCapture(0)'''

    #Load the Caffe model


    net = cv2.dnn.readNetFromCaffe(args.prototxt, args.weights)

    frame = cv2.imread("static/dataset/"+fnn)
    frame_resized = cv2.resize(frame,(300,300)) # resize frame for prediction

    blob = cv2.dnn.blobFromImage(frame_resized, 0.007843, (300, 300), (127.5, 127.5, 127.5),


    False)
    #Set to network the input blob
    net.setInput(blob)
    #Prediction of network
    detections = net.forward()

    #Size of frame resize (300x300)


    cols = frame_resized.shape[1]
    rows = frame_resized.shape[0]

    for i in range(detections.shape[2]):
    confidence = detections[0, 0, i, 2] #Confidence of prediction
    if confidence > args.thr: # Filter prediction
    class_id = int(detections[0, 0, i, 1]) # Class label

    # Object location
    xLeftBottom = int(detections[0, 0, i, 3] * cols)
    yLeftBottom = int(detections[0, 0, i, 4] * rows)
    xRightTop = int(detections[0, 0, i, 5] * cols)
    yRightTop = int(detections[0, 0, i, 6] * rows)

    # Factor for scale to original size of frame


    heightFactor = frame.shape[0]/300.0
    widthFactor = frame.shape[1]/300.0
    # Scale object detection to frame
    xLeftBottom = int(widthFactor * xLeftBottom)
    yLeftBottom = int(heightFactor * yLeftBottom)
    xRightTop = int(widthFactor * xRightTop)
    yRightTop = int(heightFactor * yRightTop)
    # Draw location of object
    cv2.rectangle(frame, (xLeftBottom, yLeftBottom), (xRightTop, yRightTop),
    (0, 255, 0))
    try:
    y=yLeftBottom
    h=yRightTop-y
    x=xLeftBottom
    w=xRightTop-x
    image = cv2.imread("static/dataset/"+fnn)
    mm=cv2.rectangle(image, (x, y), (x+w, y+h), (0, 255, 0), 2)
    cv2.imwrite("static/result/"+fnn, mm)
    cropped = image[yLeftBottom:yRightTop, xLeftBottom:xRightTop]
    gg="segment.jpg"
    cv2.imwrite("static/result/"+gg, cropped)
    #mm2 = PIL.Image.open('static/trained/'+gg)
    #rz = mm2.resize((300,300), PIL.Image.ANTIALIAS)
    #rz.save('static/trained/'+gg)
    except:
    print("none")
    #shutil.copy('getimg.jpg', 'static/trained/test.jpg')
    # Draw label and confidence of prediction in frame resized
    if class_id in classNames:
    label = classNames[class_id] + ": " + str(confidence)
    labelSize, baseLine = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.5,
    1)

    yLeftBottom = max(yLeftBottom, labelSize[1])


    cv2.rectangle(frame, (xLeftBottom, yLeftBottom - labelSize[1]),
    (xLeftBottom + labelSize[0], yLeftBottom + baseLine),
    (255, 255, 255), cv2.FILLED)
    cv2.putText(frame, label, (xLeftBottom, yLeftBottom),
    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0))

    You might also like