Multiple Programming Languages

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)
```

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 ./

Caffe Sample

Posted on January 9, 2019January 9, 2019 by admin

Gen HDF5 Data

```
import pickle
```
```
import numpy as np
```
```
import h5py
```
```
 
```
```
with open('data.pkl', 'rb') as f:
```
```
    samples, labels = pickle.load(f)
```
```
sample_size = len(labels)
```
```
 
```

samples = np.array(samples).reshape((sample_size, 2))

labels = np.array(labels).reshape((sample_size, 1))

```
 
```
```
h5_filename = 'data.h5'
```
```
with h5py.File(h5_filename, 'w') as h:
```

    h.create_dataset('data', data=samples)

    h.create_dataset('label', data=labels)

```
 
```
```
with open('data_h5.txt', 'w') as f:
```
```
    f.write(h5_filename)
```

Gen Network Picture

python /home/d/Documents/caffe/python/draw_net.py train.prototxt mlp_train.png --rankdir BT

Start Train

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

Start Test

```
import sys
```
```
import pickle
```
```
import numpy as np
```
```
import matplotlib.pyplot as plt
```
```
from mpl_toolkits.mplot3d import Axes3D
```

sys.path.append('/home/d/Documents/caffe/python')

```
import caffe
```
```
 
```

net = caffe.Net('test.prototxt', 'simple_mlp_iter_2000.caffemodel', caffe.TEST)

```
 
```
```
with open('data.pkl', 'rb') as f:
```
```
    samples, labels = pickle.load(f)
```
```
samples = np.array(samples)
```
```
labels = np.array(labels)
```
```
 
```
```
X = np.arange(0, 1.05, 0.05)
```
```
Y = np.arange(0, 1.05, 0.05)
```
```
X, Y = np.meshgrid(X, Y)
```
```
 
```

grids = np.array([[X[i][j], Y[i][j]] for i in range(X.shape[0]) for j in range(X.shape[1])])

```
 
```
```
grid_probs = []
```
```
for grid in grids:
```

    net.blobs['data'].data[...] = grid.reshape((1, 2))[...]

```
    output = net.forward()
```

    grid_probs.append(output['prob'][0][1])

grid_probs = np.array(grid_probs).reshape(X.shape)

```
fig = plt.figure('Sample Surface')
```
```
ax = fig.gca(projection='3d')
```

ax.plot_surface(X, Y, grid_probs, alpha=0.15, color='k', rstride=2, cstride=2, lw=0.5)

```
 
```
```
samples0 = samples[labels==0]
```
```
samples0_probs = []
```
```
for sample in samples0:
```

    net.blobs['data'].data[...] = sample.reshape((1, 2))[...]

```
    output = net.forward()
```

    samples0_probs.append(output['prob'][0][1])

```
samples1 = samples[labels==1]
```
```
samples1_probs = []
```
```
for sample in samples1:
```

    net.blobs['data'].data[...] = sample.reshape((1, 2))[...]

```
    output = net.forward()
```

    samples1_probs.append(output['prob'][0][1])

```
 
```

ax.scatter(samples0[:, 0], samples0[:, 1], samples0_probs, c='r', marker='o', s=50)

ax.scatter(samples1[:, 0], samples1[:, 1], samples1_probs, c='b', marker='^', s=50)

```
 
```
```
plt.show()
```

MXNet Sample

Posted on January 9, 2019 by admin

MXNet Sample

```
import pickle
```
```
import numpy as np
```
```
 
```
```
def cos_curve(x):
```

    return 0.25 * np.sin(2 * x * np.pi + 0.5 * np.pi) + 0.5

```
 
```
```
np.random.seed(123)
```
```
samples = []
```
```
labels = []
```
```
 
```
```
sample_density = 50
```
```
for i in range(sample_density):
```
```
    x1, x2 = np.random.random(2)
```
```
 
```
```
    bound = cos_curve(x1)
```
```
 
```
```
    if bound - 0.1 < x2 <= bound + 0.1:
```
```
        continue
```
```
    else:
```
```
        samples.append((x1, x2))
```
```
 
```
```
        if x2 > bound:
```
```
            labels.append(1)
```
```
        else:
```
```
            labels.append(0)
```
```
 
```
```
with open('data.pkl', 'wb') as f:
```
```
    pickle.dump((samples, labels), f)
```
```
 
```
```
import matplotlib.pyplot as plt
```
```
 
```
```
for i, sample in enumerate(samples):
```

    plt.plot(sample[0], sample[1], 'o' if labels[i] else '^',

             mec='r' if labels[i] else 'b',

```
             mfc='none',
```
```
             markersize=10)
```
```
x1 = np.linspace(0, 1)
```
```
plt.plot(x1, cos_curve(x1), 'k--')
```
```
plt.show()
```
```
 
```
```
#
```
```
 
```
```
import numpy as np
```
```
import mxnet as mx
```
```
 
```
```
data = mx.sym.Variable('data')
```
```
 
```

fc1 = mx.sym.FullyConnected(data=data, name='fc1', num_hidden=2)

```
 
```

sigmoid1 = mx.sym.Activation(data=fc1, name='sigmoid1', act_type='sigmoid')

```
 
```

fc2 = mx.sym.FullyConnected(data=sigmoid1, name='fc2', num_hidden=2)

```
 
```

mlp = mx.sym.SoftmaxOutput(data=fc2, name='softmax')

```
 
```
```
shape = {'data': (2,)}
```

mlp_dot = mx.viz.plot_network(symbol=mlp, shape=shape)

mlp_dot.render('simple_mlp.gv', view=True)

```
 
```
```
#
```
```
 
```
```
import pickle
```
```
import logging
```
```
 
```
```
with open('data.pkl', 'rb') as f:
```
```
    samples, labels = pickle.load(f)
```
```
 
```

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

```
 
```
```
batch_size = len(labels)
```
```
samples = np.array(samples)
```
```
labels = np.array(labels)
```
```
 
```

train_iter = mx.io.NDArrayIter(samples, labels, batch_size)

```
 
```
```
model = mx.model.FeedForward.create(
```
```
    symbol=mlp,
```
```
    X=train_iter,
```
```
    num_epoch=1000,
```
```
    learning_rate=0.1,
```
```
    momentum=0.99
```
```
)
```
```
'''
```
```
model = mx.model.FeedForward(
```
```
    symbol=mlp,
```
```
    num_epoch=1000,
```
```
    learning_rate=0.1
```
```
    momentum=0.99
```
```
)
```
```
model.fit(X=train_iter)
```
```
'''
```

print(model.predict(mx.nd.array([[0.5, 0.5]])))

```
 
```
```
#
```
```
 
```
```
import matplotlib.pyplot as plt
```
```
from mpl_toolkits.mplot3d import Axes3D
```
```
 
```
```
X = np.arange(0, 1.05, 0.05)
```
```
Y = np.arange(0, 1.05, 0.05)
```
```
X, Y = np.meshgrid(X, Y)
```
```
 
```

grids = mx.nd.array([[X[i][j], Y[i][j]] for i in range(X.shape[0]) for j in range(X.shape[1])])

```
 
```

grid_probs = model.predict(grids)[:, 1].reshape(X.shape)

```
 
```
```
fig = plt.figure('Sample Surface')
```
```
ax = fig.gca(projection='3d')
```
```
 
```

ax.plot_surface(X, Y, grid_probs, alpha=0.15, color='k', rstride=2, cstride=2, lw=0.5)

```
 
```
```
samples0 = samples[labels==0]
```

samples0_probs = model.predict(samples0)[:, 1]

```
samples1 = samples[labels==1]
```

samples1_probs = model.predict(samples1)[:, 1]

```
 
```

ax.scatter(samples0[:, 0], samples0[:, 1], samples0_probs, c='r', marker='o', s=50)

ax.scatter(samples1[:, 0], samples1[:, 1], samples1_probs, c='b', marker='^', s=50)

```
 
```
```
plt.show()
```

Matplotlib RGB & OpenCV BGR

Posted on January 9, 2019 by admin

Matplotlib RGB & OpenCV BGR

```
import matplotlib.pyplot as plt
```
```
import numpy as np
```
```
import cv2
```
```
 
```
```
img = np.array([
```

    [[255, 0, 0], [0, 255, 0], [0, 0, 255]],

    [[255, 255, 0], [255, 0, 255], [0, 255, 255]],

    [[255, 255, 255], [128, 128, 128], [0, 0, 0]],

```
], dtype=np.uint8)
```
```
 
```
```
plt.imsave('img_pyplot.png', img)
```
```
cv2.imwrite('img_cv2.jpg', img)
```

Default

Start

Example 1

Start with style-weight 2

Prepare (MNIST Data)

Based on Caffe siamese

Train loss vs iters

Visualize Result (Normal)

Visualize Result (τ- SNE)

Prepare

Test

Result

Based on CVGJ model

Train Curve

Confusion Matrix

Precision-Recall, PR

Receiver operating characteristic curve, ROC

Visualize Activation

Remove duplicate image

1. Remove invalid images

2. Remove duplicate files

3. Remove visually similar or duplicate images

3.1 Down scale

3.2 Find image dupes

3.3 Remove duplicates

MNIST Data (refer to MNIST : Caffe)

Prepare imglist for MXNet

Convert to rec

Train (LeNet-5)

Log Visualization

Test Model Accuracy

Test Model Time

Prepare

Loading data from pkl

Prepare imglist for Caffe

Convert to LMDB

Train (LeNet-5)

Log Visualization

loss_iters

accuracy_iters

Test Model Accuracy

Test Model Time

Augmented, Train

loss_iters

accuracy_iters

Update solver max_iter, Train

Gen HDF5 Data

Network Train

Gen Network Picture

Network Solver

Start Train

Network Test

Start Test

MXNet Sample

Matplotlib RGB & OpenCV BGR