Operating System – Water's Home

Style Transfer : Caffe Example

Posted on January 17, 2019January 17, 2019 by admin

Default

Start

python nstyle.py

Example 1

Start with style-weight 2

python nstyle.py --content-image ~/Machine_Learning/Style_Transfer/src.png --style-image ~/Machine_Learning/Style_Transfer/style.jpg --output_dir ~/Machine_Learning/Style_Transfer/output_style-weight-2/ --save-epochs 200 --style-weight 2

Metric Learning : Caffe Example

Posted on January 17, 2019January 17, 2019 by admin

Prepare (MNIST Data)

```
python gen_pairwise_imglist.py
```

/home/water/caffe/build/tools/convert_imageset ./ train.txt train_lmdb --gray

/home/water/caffe/build/tools/convert_imageset ./ train_p.txt train_p_lmdb --gray

/home/water/caffe/build/tools/convert_imageset ./ val.txt val_lmdb --gray

/home/water/caffe/build/tools/convert_imageset ./ val_p.txt val_p_lmdb --gray

Based on Caffe siamese

Train loss vs iters

Visualize Result (Normal)

Visualize Result (τ- SNE)

Object Detection : MXNet SSD Example

Posted on January 17, 2019January 17, 2019 by admin

Prepare

```
cd /home/water/mxnet/example/ssd
```

wget https://github.com/zhreshold/mxnet-ssd/releases/download/v0.6/resnet50_ssd_512_voc0712_trainval.zi

unzip resnet50_ssd_512_voc0712_trainval.zip

python data/demo/download_demo_images.py

Test

```
python demo.py --gpu 0
```

python demo.py --epoch 0 --images ./data/demo/dog.jpg --thresh 0.5

python demo.py --cpu --network resnet50 --data-shape 512

```
. . . . . .
```

python demo.py --images ./data/demo/person.jpg --thresh 0.3

python demo.py --images ./data/demo/person.jpg --network inceptionv3

Result

Transfer learning & Fine tuning

Posted on January 15, 2019January 16, 2019 by admin

Based on CVGJ model

ResNet10_cvgj

Train Curve

Confusion Matrix

Precision-Recall, PR

Receiver operating characteristic curve, ROC

Visualize Activation

Collecting Data & Remove

Posted on January 15, 2019 by admin

Collecting Data from the Web with Python If you like

Remove duplicate image

1. Remove invalid images

```
import os
```
```
import sys
```
```
import cv2
```
```
 
```

from collect_data import SUPPORTED_FORMATS

```
 
```
```
input_path = sys.argv[1]
```
```
 
```

for root, dirs, files in os.walk(input_path):

```
    for filename in files:
```

        ext = filename[filename.rfind('.')+1:].lower()

        if ext not in SUPPORTED_FORMATS:

```
            continue
```

        filepath = os.sep.join([root, filename])

        if cv2.imread(filepath) is None:

            os.system('rm {}'.format(filepath))

            print('{} is not a valid image file. Deleted!'.format(filepath))

2. Remove duplicate files

FDUPES is a program for identifying duplicate files residing
within specified directories.

```
sudo apt-get install fdupes
```
```
fdupes -rdN ./
```

3. Remove visually similar or duplicate images

3.1 Down scale

```
import os
```
```
import cv2
```
```
import sys
```
```
 
```
```
input_path = sys.argv[1].rstrip(os.sep)
```
```
 
```
```
target_short_edge = int(sys.argv[2])
```
```
 
```

for root, dirs, files in os.walk(input_path):

    print('scanning {} ...'.format(root))

```
    for filename in files:
```

        filepath = os.sep.join([root, filename])

```
        img = cv2.imread(filepath)
```
```
        h, w = img.shape[:2]
```
```
        short_edge = min(w, h)
```
```
 
```

        if short_edge > target_short_edge:

            scale = float(target_short_edge) / float(short_edge)

            new_w = int(round(w * scale))

            new_h = int(round(h * scale))

            print('Down sampling {} from {} x {} to {} x {} ...'.format(

                filepath, w, w, new_w, new_h

```
            ))
```

            img = cv2.resize(img, (new_w, new_h))

```
            cv2.imwrite(filepath, img)
```
```
print('Done!')
```

3.2 Find image dupes

```
sudo apt-get install findimagedupes
```
```
findimagedupes -R train > dup_list
```

3.3 Remove duplicates

```
import os
```
```
import sys
```
```
dup_list = sys.argv[1]
```
```
with open(dup_list, 'r') as f:
```
```
    lines = f.readlines()
```
```
    for line in lines:
```
```
        dups = line.split()
```

        print('Removing duplicates of {}'.format(dups[0]))

```
        for dup in dups[1:]:
```
```
            cmd = 'rm {}'.format(dup)
```
```
            os.system(cmd)
```

Regression : Caffe

Posted on January 15, 2019 by admin

Based on LeNet-5

Deploy with GPU

```
name: "RegressionExample"
```
```
layer {
```
```
  name: "data"
```
```
  type: "Input"
```
```
  top: "data"
```
```
  input_param    {
```
```
    shape:  {
```
```
        dim:    100
```
```
        dim:    1
```
```
        dim:    100
```
```
        dim:    100
```
```
    }
```
```
  }
```
```
}
```
```
……
```

Convolution Visualization

MNIST : MXNet

Posted on January 15, 2019 by admin

MNIST Data (refer to MNIST : Caffe)

Prepare imglist for MXNet

```
import os
```
```
import sys
```
```
 
```
```
input_path = sys.argv[1].rstrip(os.sep)
```
```
 
```
```
out_path = sys.argv[2]
```
```
 
```
```
filenames = os.listdir(input_path)
```
```
with open(out_path, 'w') as f:
```

    for i, filename in enumerate(filenames):

        filepath = os.sep.join([input_path, filename])

        label = filename[: filename.rfind('.')].split('_')[1]

```
 
```

        line = '{}\t{}\t{}\n'.format(i, label, filepath)

```
        f.write(line)
```

Convert to rec

python gen_mxnet_imglist.py mnist/train train.lst

python gen_mxnet_imglist.py mnist/val val.lst

python gen_mxnet_imglist.py mnist/test test.lst

```
 
```

/home/d/mxnet/bin/im2rec train.lst ./ train.rec color=0

/home/d/mxnet/bin/im2rec val.lst ./ val.rec color=0

/home/d/mxnet/bin/im2rec test.lst ./ test.rec color=0

Train (LeNet-5)

```
import mxnet as mx
```
```
 
```
```
data = mx.symbol.Variable('data')
```
```
 
```

conv1 = mx.symbol.Convolution(data=data, kernel=(5, 5), num_filter=20)

pool1 = mx.symbol.Pooling(data=conv1, pool_type="max", kernel=(2, 2), stride=(2, 2))

```
 
```

conv2 = mx.symbol.Convolution(data=pool1, kernel=(5, 5), num_filter=50)

pool2 = mx.symbol.Pooling(data=conv2, pool_type="max", kernel=(2, 2), stride=(2, 2))

```
 
```
```
flatten = mx.symbol.Flatten(data=pool2)
```

fc1 = mx.symbol.FullyConnected(data=flatten, num_hidden=500)

relu1 = mx.symbol.Activation(data=fc1, act_type="relu")

```
 
```

fc2 = mx.symbol.FullyConnected(data=relu1, num_hidden=10)

```
 
```

lenet5 = mx.symbol.SoftmaxOutput(data=fc2, name='softmax')

```
 
```

mod = mx.mod.Module(lenet5, context=mx.gpu(0))

```
 
```
```
#
```
```
 
```
```
train_dataiter = mx.io.ImageRecordIter(
```
```
    path_imgrec="train.rec",
```
```
    data_shape=(1, 28, 28),
```
```
    batch_size=50,
```
```
    mean_r=128,
```
```
    scale=0.00390625,
```
```
    rand_crop=True,
```
```
    min_crop_size=24,
```
```
    max_crop_size=28,
```
```
    max_rotate_angle=15,
```
```
    fill_value=0
```
```
)
```
```
val_dataiter = mx.io.ImageRecordIter(
```
```
    path_imgrec="val.rec",
```
```
    data_shape=(1, 28, 28),
```
```
    batch_size=100,
```
```
    mean_r=128,
```
```
    scale=0.00390625,
```
```
)
```
```
 
```
```
#
```
```
 
```
```
import logging
```
```
 
```

logging.getLogger().setLevel(logging.DEBUG)

fh = logging.FileHandler('train_mnist_lenet.log')

```
logging.getLogger().addHandler(fh)
```
```
 
```

lr_scheduler = mx.lr_scheduler.FactorScheduler(1000, factor=0.95)

```
optimizer_params = {
```
```
    'learning_rate': 0.01,
```
```
    'momentum': 0.9,
```
```
    'wd': 0.0005,
```
```
    'lr_scheduler': lr_scheduler
```
```
}
```
```
 
```

checkpoint = mx.callback.do_checkpoint('mnist_lenet', period=5)

```
 
```
```
mod.fit(train_dataiter,
```
```
        eval_data=val_dataiter,
```

        optimizer_params=optimizer_params,

```
        num_epoch=36,
```
```
        epoch_end_callback=checkpoint)
```

Log Visualization

Test Model Accuracy

```
import mxnet as mx
```
```
 
```
```
test_dataiter = mx.io.ImageRecordIter(
```
```
    path_imgrec="test.rec",
```
```
    data_shape=(1, 28, 28),
```
```
    batch_size=100,
```
```
    mean_r=128,
```
```
    scale=0.00390625,
```
```
)
```
```
 
```

mod = mx.mod.Module.load('mnist_lenet', 35, context=mx.gpu(0))

```
 
```
```
mod.bind(
```

    data_shapes=test_dataiter.provide_data,

    label_shapes=test_dataiter.provide_label,

```
    for_training=False)
```
```
 
```
```
metric = mx.metric.create('acc')
```
```
 
```
```
mod.score(test_dataiter, metric)
```
```
 
```

for name, val in metric.get_name_value():

    print('{} = {:.2f}%'.format(name, val * 100))

Test Model Time

```
import time
```
```
import mxnet as mx
```
```
 
```

benchmark_dataiter = mx.io.ImageRecordIter(

```
    path_imgrec="test.rec",
```
```
    data_shape=(1, 28, 28),
```
```
    batch_size=64,
```
```
    mean_r=128,
```
```
    scale=0.00390625,
```
```
)
```
```
 
```

mod = mx.mod.Module.load('mnist_lenet', 35, context=mx.gpu(0))

```
mod.bind(
```

    data_shapes=benchmark_dataiter.provide_data,

    label_shapes=benchmark_dataiter.provide_label,

```
    for_training=False)
```
```
 
```
```
start = time.time()
```
```
 
```

for i, batch in enumerate(benchmark_dataiter):

```
    mod.forward(batch)
```
```
 
```
```
time_elapsed = time.time() - start
```

msg = '{} batches iterated!\nAverage forward time per batch: {:.6f} ms'

print(msg.format(i + 1, 1000 * time_elapsed / float(i)))

MNIST : Caffe

Posted on January 15, 2019 by admin

Prepare

wget http://deeplearning.net/data/mnist/mnist.pkl.gz

Loading data from pkl

```
import os
```
```
import pickle, gzip
```
```
from matplotlib import pyplot
```
```
 
```

print('Loading data from mnist.pkl.gz ...')

with gzip.open('mnist.pkl.gz', 'rb') as f:

    train_set, valid_set, test_set = pickle.load(f)

```
 
```
```
imgs_dir = 'mnist'
```

os.system('mkdir -p {}'.format(imgs_dir))

datasets = {'train': train_set, 'val': valid_set, 'test': test_set}

```
 
```

for dataname, dataset in datasets.items():

    print('Converting {} dataset ...'.format(dataname))

    data_dir = os.sep.join([imgs_dir, dataname])

```
 
```

    os.system('mkdir -p {}'.format(data_dir))

```
 
```

    for i, (img, label) in enumerate(zip(*dataset)):

```
 
```

        filename = '{:0>6d}_{}.jpg'.format(i, label)

```
 
```

        filepath = os.sep.join([data_dir, filename])

```
 
```
```
        img = img.reshape((28, 28))
```
```
 
```

        pyplot.imsave(filepath, img, cmap='gray')

```
        if (i + 1) % 10000 == 0:
```

            print('{} images converted!'.format(i + 1))

Prepare imglist for Caffe

```
import os
```
```
import sys
```
```
 
```
```
input_path = sys.argv[1].rstrip(os.sep)
```
```
 
```
```
output_path = sys.argv[2]
```
```
 
```
```
filenames = os.listdir(input_path)
```
```
with open(output_path, 'w') as f:
```
```
    for filename in filenames:
```
```
 
```

        filepath = os.sep.join([input_path, filename])

```
 
```

        label = filename[: filename.rfind('.')].split('_')[1]

```
 
```

        line = '{} {}\n'.format(filepath, label)

```
        f.write(line)
```

Convert to LMDB

python gen_caffe_imglist.py mnist/train train.txt

python gen_caffe_imglist.py mnist/val val.txt

python gen_caffe_imglist.py mnist/test test.txt

```
 
```

/home/d/Documents/caffe/build/tools/convert_imageset ./ train.txt train_lmdb --gray --shuffle

/home/d/Documents/caffe/build/tools/convert_imageset ./ val.txt val_lmdb --gray --shuffle

/home/d/Documents/caffe/build/tools/convert_imageset ./ test.txt test_lmdb --gray --shuffle

Train (LeNet-5)

/home/d/Documents/caffe/build/tools/caffe train -solver lenet_solver.prototxt -log_dir ./

Log Visualization

loss_iters

python /home/d/Documents/caffe/tools/extra/plot_training_log.py.example 2 loss_iters.png caffe.ubuntu.d.log

accuracy_iters

python /home/d/Documents/caffe/tools/extra/plot_training_log.py.example 0 accuracy_iters.png caffe.ubuntu.d.log

Test Model Accuracy

/home/d/Documents/caffe/build/tools/caffe test -model lenet_test.prototxt -weights mnist_lenet_iter_36000.caffemodel -iterations 100

Test Model Time

/home/d/Documents/caffe/build/tools/caffe time -model lenet.prototxt

Augmented, Train

loss_iters

python /home/d/Documents/caffe/tools/extra/plot_training_log.py.example 2 loss_iters_aug.png mnist_train.log mnist_train_with_augmentation.log

accuracy_iters

python /home/d/Documents/caffe/tools/extra/plot_training_log.py.example 0 accuracy_iters_aug.png mnist_train.log mnist_train_with_augmentation.log

Update solver max_iter, Train

/home/d/Documents/caffe/build/tools/caffe train -solver lenet_solver_aug.prototxt -snapshot mnist_aug_lenet_iter_36000.solverstate -log_dir ./

Install NVIDIA Driver & CUDA : Ubuntu 16.04

Posted on January 12, 2019 by admin

Remove Default Driver

sudo apt --purge remove xserver-xorg-video-nouveau

Add NVIDIA Respository

sudo add-apt-repository ppa:graphics-drivers/ppa

Install NVIDIA Driver

sudo apt install nvidia-361 nvidia-settings nvidia-prime

Install NVIDIA CUDA

```
sudo apt install nvidia-cuda-toolkit
```

Reboot

Caffe Installation : Ubuntu 16.04

Posted on January 7, 2019 by admin

Prepare

```
sudo apt update
```

sudo apt install build-essential git libatlas-base-dev

```
sudo apt-get install python-pip
```
```
pip install --upgrade pip
```
```
sudo apt-get install graphviz
```
```
sudo pip install graphviz
```

sudo apt install libprotobuf-dev libleveldb-dev libsnappy-dev libboost-all-dev libhdf5-serial-dev protobuf-compiler gfortran libjpeg62 libfreeimage-dev libgoogle-glog-dev libbz2-dev libxml2-dev libxslt-dev libffi-dev libssl-dev libgflags-dev liblmdb-dev python-yaml

sudo apt-get install libopencv-dev python-opencv

Config

# git clone https://github.com/BVLC/caffe. git

```
# Or
```
```
unzip caffe-master.zip 
```
```
cd caffe-master/
```

cp Makefile.config.example Makefile.config

```
 
```

d@ubuntu:~/Documents/caffe$ diff Makefile.config.example Makefile.config

```
8c8
```
```
< # CPU_ONLY := 1
```
```
---
```
```
> CPU_ONLY := 1
```
```
94c94
```
```
< # WITH_PYTHON_LAYER := 1
```
```
---
```
```
> WITH_PYTHON_LAYER := 1
```
```
97,98c97,98
```

< INCLUDE_DIRS := $(PYTHON_INCLUDE) /usr/local/include

< LIBRARY_DIRS := $(PYTHON_LIB) /usr/local/lib /usr/lib

```
---
```

> INCLUDE_DIRS := $(PYTHON_INCLUDE) /usr/local/include /usr/include/hdf5/serial/

> LIBRARY_DIRS := $(PYTHON_LIB) /usr/local/lib /usr/lib /usr/lib/x86_64-linux-gnu/hdf5/serial/

```
d@ubuntu:~/Documents/caffe$
```

Compile & Test

export LD_LIBRARY=$LD_LIBRARY:/usr/include/hdf5

export PYTHONPATH=$PYTHONPATH:/home/d/Documents/caffe/python

```
make pycaffe -j
```
```
make all -j
```
```
make test -j
```
```
make runtest
```

virtual memory exhausted

```
sudo mkdir /opt/images/
```
```
sudo rm -rf /opt/images/swap
```

sudo dd if=/dev/zero of=/opt/images/swap bs=1024 count=10240000

```
sudo mkswap /opt/images/swap
```
```
sudo swapon /opt/images/swap
```