Caffe kütüphanesi hakkında bir derleme kılavuz çalışması

1. Caffe KILAVUZU
Birol Kuyumcu
• E-Posta
• Blog
• Linkedin

2. Caffe Kılavuzu
Berkeley Üniversitesi tarafından geliştirilmiş bir sistemdir Caffe . Açık kaynak kodlu, ticari
kullanıma uygun ve GPU destekli bir yapıdır. Temelde C++ olarak yazılmıştır. Hiç program
yazmadan Komut satırından çalıştırılan programlarla ve google 'ın -Protocol Buffers - Google's
data interchange format - ile yazılmış model yapıları ile eğitip kullanabiliyoruz.
NVDIA'nın DIGITS ürünü ilede GUI üzerinden kullanabiliyoruz.
Caffenin bizim açımızdan diğer bir avatajı da OpenCv 3.0 ile birlikte ( DNN modülü ) Caffede
eğitilmiş olan modelleri kullanma imkanına sahib olmamızdır.
Windows kurulumu :
Caffe de resmi windows dağıtımı var.
● Windows Caffe
Caffeyi kullanmak için ilk etapta bu linkle müracaat edin. Önce derlenmiş bir paketlerde
bulunmatadır.
Üç şekilde kullanılabilir Komut staırından Python altından kütüphane olarak yada Matlab dan.
Komut satırından kullanımı :
Kullanımı : caffe <commandt> <args>
commands:
train : Eğitmek yada eğitilmiş model üzerinde ince ayar için kullanılır l
test : Eğitilmiş model i test edip performansını hesaplar
device_query : GPU donanımı hakkında bilgi verir
time : Modelin çalışma zamanını ölçüp raporlar
Flags
-gpu : İşlemlerin gpu üzerinden yapılacağını bildirir - solver dosyasından ayarlanır -
-iterations : iterasyon sayısını ayarlar (The number of iterations to run.) type: int32 default: 50
-model : model dosyasının adını verirsiniz prototxt
-snapshot : yarıda kesilmiş eğitime daha önceden eğitim esnasında kaydedilmiş
“.solverstate” uzantılı dosyayı kullanarak devam etmek için kullanılır
-solver : .protoxt uzantılı eğitim parametrelerini yazdığınız dosyanın adı

3. -weights : Eğitim transferi için daha önceden eğitilmiş olan .caffemodel uzantılı dosya adı
-logdir : eğitim esnasında ekranda yazdıklarını log dosyası olarak kaydetmesini istediğimiz
dizin konumu -yeni versiyonda kalıdırılmış -
Örnek kullanımlar:
● caffe train -solver solver.prototxt -log_dir log -gpu 0
Solver.prototxt dosyasını kullanarak çalışma dizinin içindeki log dizininine log dosyalarını
yazarak ve 0 numaralı gpu kullanarak eğitim işlemini yapar
● caffe train -solver solver.prototxt -weights bvlc_googlenet_iter_1000.caffemodel
Solver.prototxt dosyasını kullanarak ve “bvlc_googlenet_iter_1000.caffemodel” ağırlıklarından
başlayarak eğitim işlemine başlar
● caffe device_query -gpu 0
0 numaralı yani ilk gpu ile ilgili bilgileri verir.
● caffe time -weights bvlc_googlenet_iter_1000.caffemodel -model train_val.prototxt -gpu
0
“Train_val.prototxt” model dosyasını “bvlc_googlenet_iter_1000.caffemodel” ağırlıklarıyla
çalıştırır ve Her katmanda ileri ve geri dönüşlerde ne kadar zaman geçtiğini hesaplayıp yazar
Diğer komut satırı programlar. Gpu 0 ı kullanır. Birden fazla gpu varsa -gpu 0,1 yada -gpu all
diye eğitimde kullanılmasını sağlayabilirsiniz
● caffe caffe train –solver solver.prototxt --snapshot
caffenet_train_iter_10000.solverstate
caffenet_train_iter_10000.solverstate dosyasında kaldığı yerden eğitime devam eder
Convert_imageset
Kullanımı : convert_imageset [seçenekler ] ana dizin / dosya Listesi Veritabanı adı
Ana dizin : dosya listesideki dosya adlarının başına eklenir
Dosya Listesi : Her satırda dosya ismi ve yolu - boşluk - etiket olarak yazılmış liste
Veritabanı Adı : Oluşturulacak veritabanının adı

4. Resimleri etiketleri ile birlikte veritabanına atmaya yarayan bir uygulamadır
Seçenekler :
-backend : veritabanı türü halen iki seçenek var {lmdb, leveldb} ön tanımlı "lmdb"
-encode_type : veritabanına atılacak verilerin kodlanma metodu ('png','jpg',...) gibi
belirtilmezse olduğu gibi aktarılır
-gray : mantıksal değişken bool eğer true ise görüntü siyahbeyaz olarak aktarılır
belirtilmediğinde olduğu gibi
-resize_height : Görüntülerin sabit bir yüksekliğe çevirir default: 0
-resize_width : Görüntülerin sabit bir genişliğe çevirir
-shuffle : Listedeki sıralmayı karıştırır.
Örnek Kullanım
convert_imageset d:/ db-safamerve-train.txt safamerve-train
db-safamerve-train.txt dosyasında
deepProjectssefamerveAlexNet/data/08/67953_01.jpg 5
deepProjectssefamerveAlexNet/data/09/74980_01.jpg 6
….
Şeklidne görüntü dosyası isimleri ve onların etiketleri yazılı
Bu komutla bunlar safamerve-train isimli bir dizin oluşturulup içine lmdb formatında aktarılır.
compute_image_mean
compute_image_mean [seçenekler] Veritabanı Adı [Ortalama Görüntü Dosyası Adı]
Veritabanındaki görüntüler için bir ortalama görüntü - mean image - hesaplar ve kaydeder.
compute_image_mean safamerve-train sefa-merve-mean.binaryproto
compute_image_mean safamerve-train sefa-merve-mean.npy
Gibi veritabanı veritabanı türü halen iki seçenek var {lmdb, leveldb} ön tanımlı "lmdb" diğer
seçenek için -beckend “leveldb” ile beritmeniz gerekiyor.
Görüntü Veritabanı Oluşturma:
Görüntü sınıflandırma işlemi için oluşturulacak veri tabanını hazırlamanın en kolay yolu
Örnek görüntüleri bir ana dizin altında etiket değerlerine göre ayı ayır dizinlerde topla
Sonrasında dizin isimlerinini alıp numaralandır. Etket değeri bu olacak
bu dosyaların isimlerini yolları ile birlikte bir text dosyasına kaydet. Sonuna bir önceki adımdan
elde ettiğimiz etiket numarasınıda koy. Bu işlem için caffetutility adında bir script yazıldı
deepProjectssefamerveAlexNet/data/08/67953_01.jpg 5

5. deepProjectssefamerveAlexNet/data/09/74980_01.jpg 6
Yazılan scriptte eğitim ve test için iki ayrı dosya oluşturuluyor. Ve sırlama karıştırılıyor. Oluşan
text dosyasını convert_imageset ve compute_image_mean programları ile veritabanına
atmanız ve ortama görüntü çıkarmanız mümkün olduğu gibi. Doğrudan eğitim için kulllanıla bilir.
Veritabanına atılmış olmasının hız açısından daha iyi olduğu söyleniyor. Bu aşamada
kullanacağınız modelin isteği görüntü ebatına dönüştürmeniz gerekmektedir. (resize_height ve
width seçenekleri ile )
Solver Dosyası :
Komut satırından kullanımda eğitim ile ilgili bilgilerin ve parameterelerin yazıldığı prototxt
formatında bir dosyadır.
net : Model dosyasının adı prototxt formatında
net: "examples/mnist/lenet_train_test.prototxt"
test_iter : Test için kaç kez çalışması – forward pass- gerektiğini belirler
test_iter: 100
test_interval: Kaç iterasyonda bir test uygulanacağını belirler
test_interval: 500
base_lr : Öğrenme hızı Eğitim başlangıcındaki değeri belirler lr_policy parametresine göre
eğitim esnasında değişebilir
lr_policy: Öğrenme Hızı eğitim esnasında değiştirilebiliyor seçenekler ; "fixed" , "inv", "step",
"multistep", "stepearly", "poly" seçilen tipe göre ilave parametreler gerekebilir.

6. lr_policy [ Learning Rate ] [ Learning Rate Policy]:
• String type
• Defines the learning rate policy
• Types of lr_policy:
• “fixed”
• Sub_Parameters:
• base_lr:
• double type
• Gives the initial system learning rate
• “step”
• function:
• Sub_Parameters:
• base_lr:
• double type
• Gives the initial system learning rate
• gamma:
• double type

7. • Decay rate
• stepsize:
• int type
• Specifies the step uniform intervals
• “exp”
• function:
• Sub_parameters:
• base_lr:
• double type
• Gives the initial system learning rate
• gamma:
• double type
• Decay rate
• “inv”
• function:
• Sub_parameters:
• base_lr:
• double type
• Gives the initial system learning rate
• gamma:
• double type
• Decay rate
• power:
• double type
• “multistep”
• function:
• Sub_Parameters:
• base_lr:
• double type
• Gives the initial system learning rate
• gamma:
• double type
• Decay rate
• stepvalue_size:
• int type
• Specifies the max step size
• Like “step”, but has variable step
• “poly”

8. • function:
• Sub_parameters:
• base_lr:
• double type
• Gives the initial system learning rate
• power:
• double type
Örnek :
lr_policy: "inv"
gamma: 0.0001
power: 0.75
momentum: Eğitim esnasında lokal minimumda takılıp kalmamak için kulanılan bir parametre
momentum: 0.9
weight_decay: Yapay Sinin Ağlarında yapının ezbere kaymasını önleme amaçlı bir ssistemin
bir parametresi. Genellikle çok küçük değerler seçilir.
techniques which can reduce overfitting, even when we have a fixed network and fixed
training data. These are known as regularization techniques. In this section I describe
one of the most commonly used regularization techniques, a technique sometimes
known as weight decay or L2 regularization. The idea of L2 regularization is to add an
extra term to the cost function, a term called the regularization term.
weight_decay: 0.0002
iterations display: Eğitim durum gösterme işlemi kaç iterasyonda bir onu belirler
iterations display: 100
iter_size: Eğitim model dosyasındaki her iterasyon için kullanılacak örnek sayısına batch size
deniyor. Bu işlem için yeterli hafıza yoksa iter_size kadar ufak bir değer seçilebiliyor. Mesela 64
lük bir kümeyi 8 e düşürüp iter_size ile 16 verilebilir.
iter_size: 16
max_iter : Maksimum iterasyon sayısını ayarlar
max_iter: 10000

9. snapshot: maksimum iterasyona ulaşmadan ara kayıt alma işlemini yapar .caffemodel ve
.solverstate uzantılı iki dosya kaydeder. İlkini sonuç hesaplamak için kullanabilirsiniz, ikinci ile
eğitime burdan devam edebilirsiniz.
snapshot: 5000
snapshot_prefix: Kayıt ön başlığı konum ve dosyaismi başlangıcını verir.
snapshot_prefix: "examples/mnist/lenet"
solver mode: Eğitim için işlem modu cpu yada gpu
solver_mode: GPU
solver_type : Eğitim için kullanılacak eğitim metodu çözücü tipi Varsayılan değer SGD
seçenekler;
• Stochastic Gradient Descent (type: "SGD"),
• AdaDelta (type: "AdaDelta"),
• Adaptive Gradient (type: "AdaGrad"),
• Adam (type: "Adam"),
• Nesterov’s Accelerated Gradient (type: "Nesterov") and
• RMSprop (type: "RMSProp"
bakınız
http://caffe.berkeleyvision.org/tutorial/solver.html
http://research.microsoft.com/pubs/192769/tricks-2012.pdf
In order to set these values in a meaningful manner, you need to have a few more bits of
information regarding your data:
1. Training set size the total number of training examples you have, let's call this
quantity T.
2. Trainig batch size the number of training examples processed together in a single
batch, this is usually set by the input data layer in the 'train_val.prototxt'. For
example, in this file the train batch size is set to 256. Let's denote this quantity by tb.
3. Validation set size the total number of examples you set aside for validating your
model, let's denote this by V.
4. Validation batch size value set in batch_size for the TEST phase. In this example
it is set to 50. Let's call this vb.
Now, during training, you would like to get an un-biased estimate of the performance of
your net every once in a while. To do so you run your net on the validation set for
test_iter iterations. To cover the entire validation set you need to have test_iter

10. = V/vb.
How often would you like to get this estimation? It's really up to you. If you have a very
large validation set and a slow net, validating too often will make the training process too
long. On the other hand, not validating often enough may prevent you from noting if and
when your training process failed to converge. test_interval determines how often
you validate: usually for large nets you set test_interval in the order of 5K, for
smaller and faster nets you may choose lower values. Again, all up to you.
In order to cover the entire training set (completing an "epoch") you need to run T/tb
iterations. Usually one trains for several epochs, thus max_iter=#epochs*T/tb.
Regarding iter_size: this allows to average gradi
You can change the iter_size in the solver parameters. Caffe accumulates gradients
over iter_size x batch_size instances in each stochastic gradient descent step. So
increasing iter_size can also get more stable gradient when you cannot use large
batch_size due to the limited memory.
Bakınız http://stackoverflow.com/questions/33780779/caffe-solver-prototxt-values-
setting-strategy
Caffe framework: A real example of batch size,
max_iter, test_iter, epoch
Here is the setup:
test_observations : 6 767;
train_observations: 73 268;
train/test batch_size = 50;
How should I set the batch_size, test_iter, test_interval, max_iter?
From what I understand, if I set the batch_size at 50, it means that I have 73 268 / 50 =
1465,36 batches and in every batch we have 50 training observations. But because we
have a floating number, we get rid of the last 36 observations because they don't make a
full batch.
So from my understanding, I have to set the test_interval every 1465 iterations (because
after 1465 iterations I train all the batches once). So, 1 epoch is 1456 batches.

11. Then, If I set the test batch_size also at 50, i get 6767 / 50 = 135 batches. Which means
that I should set the test_ter to 135 to go thru all the test batches.
For max_iter, i have how many numbers of epochs I want multiplied to the total number
of training batches: Let's say that I want 100 epochs, then my max iter should be: 100 *
1465 = 146 500.
Is something wrong with my above example?
If yes, can one please make a clear example with the above data?
Thank you!
http://quabr.com/39543942/caffe-framework-a-real-example-of-batch-size-max-iter-test-
iter-epoch
Eğitimin Transferi -Finetune- :
Daha Önceden eğitilmiş modelleri ve eğitim ağırlıklarını kullanarak yeni veri seti için daha hızlı
bir öğrenme süreci gerçekleştirilebilir. Yapılması gereken
Model Dosyalarındaki son katmanın adı değiştirilir mesela fc8 katmanın ismi değiştirilir. Bu
katmanın isminin ne olduğu önemli değil kullanacağınız modele göre değişir burda kast edilen
şey softmax öncesi ‘InnerProduct’ katmanının adını ve çıkış sayısını verinize göre
ayarlamanız. Ve bu katmana bağlı katmanlardaki bağlantı ismininde düzeltilmesi lazım.

12. Komut
satırından
eğitim için başlatılırken -weights parametresi ile transferin yapılacağı eğitim ağırlıkları dosyası
belirtilir. (*.caffemodel)
caffe train -solver fsolver.prototxt -weights new-finetune_flickr_style.caffemodel
gibi . Convolution kısmının öğrenme parametrelerini 0 layarak daha önceden öğrenilmiş filtre
kısmını sabitlemek gerekiyor. Kulanılan veri seti ve orjinal veri seti arasınudaki farklılığa göre
öğrenme parametrelerine alternatif değişiklikler yapmak mümkün. Sadece belli katmanlarda
sabit tutup gerisinin öğrenmesine izin vermek . Yada yalnızca bir katmanın öğrenme hızını
diğerlerine göre artırmak gibi
Hazır Ağ Modelleri :
• BVLC Reference CaffeNet in models/bvlc_reference_caffenet: AlexNet trained on
ILSVRC 2012, with a minor variation from the version as described in ImageNet
classification with deep convolutional neural networks by Krizhevsky et al. in NIPS 2012.
(Trained by Jeff Donahue @jeffdonahue) (227x227 ebatında renkli 3 görüntü )
• BVLC AlexNet in models/bvlc_alexnet: AlexNet trained on ILSVRC 2012, almost exactly
as described in ImageNet classification with deep convolutional neural networks by
Krizhevsky et al. in NIPS 2012. (Trained by Evan Shelhamer @shelhamer) (227x227
ebatında renkli 3 görüntü )
• BVLC Reference R-CNN ILSVRC-2013 in models/bvlc_reference_rcnn_ilsvrc13: pure
Caffe implementation of R-CNN as described by Girshick et al. in CVPR 2014. (Trained
by Ross Girshick @rbgirshick) (227x227 ebatında renkli 3 görüntü )
• BVLC GoogLeNet in models/bvlc_googlenet: GoogLeNet trained on ILSVRC 2012,
almost exactly as described in Going Deeper with Convolutions by Szegedy et al. in
ILSVRC 2014. (Trained by Sergio Guadarrama @sguada) (224x224 ebatında renkli 3
görüntü )

13. Caffe ile Kolay Uygulama Geliştirme :
1. Veri seti için görüntüler toplanır ve sınıfına göre ayrı ayrı dizinlere atılır. Görüntüler ya
baştan seçilecek hazır ağ modellerinin ebatlarına göre kaydedilir. Yada 3. adımdaki
programla istenen ebata dönüştürülerek veritabanına aktarılır.
2. “CaffeUtlity.py” programının makeDataFile fonksiyonunu kullanarak doğrudan veriseti
olarak kullanabileceğiniz yada veri tabanına dönüştürebileceğiniz metin dosyalarını
oluşturun Hem eğitim hem test için
3. convert_imageset uygulamasını kullanarak veri tabanlarını oluşturun
4. compute_image_mean ile veritabanından ortalama görüntü çıkarılır
5. Hazır Ağ Modellerinden biri seçilir. Data parametresine oluşturduğumuz veri dosyaları
yazılır ortalama görüntü yazılır.
6. Ağ model sonunda nihai çıkış parametresini uygulamanız için gereken değere çekin
7. solver dosyasını oluşturun
8. Eğitimi başlatın….
Ağ Model Dosyası Ve Katmanları
Caffenin yapısı katmanlar şeklindedir. Blob yada Layer olarak geçer. Dört boyutlu matris
yapısındadır. Genel Yapısı
layer {
name : ”NameOfLayer” # has to be unique
type : ”LayerType1” # has to be one of the types in layer catalogue
bottom : ” bottom blob 1 ”
bottom : ” bottom blob 2 ”
top : ” top blob 1 ”
top : ” top blob 2 ”
top : ” top blob 3 ”
layer_specificparams {
param1 : value1
param2 : ” value2 ”
param3 : value3
}
}
gibidir.
• name: Katmanın adı eşsiz olmalı ki kullanıldığında sade bir katmana işaret etsin

14. • type : Katmanın tipi aşağıda bazılarından bahsedeceğiz.
• top: Kendinden bir önceki katmanın adı
• bottom : Kendinden bir sonraki katmanın adı.
Bütün katmanlar bu şekilde bir birine bağlı olarak çalışır. Katman tipinin özelliklerine göre
kendinden bir önceki katmandan alığı giriş verisini işler kendinden sonraki katmana yollar.
Şimdi gelelim Katman tiplerine
Veri Katmanları :
Database:
Layer type: Data
Eğitim için geken verileri veri tabanından çeker
Parametreleri
Zorunlu olanlar
source: Veri tabanının bulunduğu dizin adı
batch_size: bir seferde işleme girecek kayıt sayısı
İsteğe Bağlı
backend : Veritabanının tip varsayılan değeri LEVELDB diğer alternatif
LMDB
HDF5 Input
Layer type: HDF5Data
Eğitim için geken verileri HDF5 formatındaki dosyadan okur
Parametreleri
Zorunlu olanlar
source: HDF5 tipinde Veri tabanı dosyasının adı
batch_size: bir seferde işleme girecek kayıt sayısı
HDF5 Output
Layer type: HDF5Output
İsmi verilen HDF5 formatındaki dosyaya kayıt yapar.
Parametreleri
Zorunlu olanlar
source: HDF5 tipinde Veri tabanı dosyasının adı
ImageData
Layer type: ImageData

15. Parameters
zorunlu olanlar
source: Eğitim de kullanılacak Görüntü dosya konum ve adlarının
etikletleri ile birlikte kaydedildiği text dosyasının adı
batch_size: bir seferde işleme girecek kayıt sayısı
İsteğe Bağlı
rand_skip: a
shuffle : lişleme giriş sırasının rastgele değiştirilmesi varsayılan değeri false
new_height, new_width: verilmişse veriler işleme girmeden önce bu en ve boya
dönüştürülür.
Veri Katmanları İçin Ortak Seçenekler
veri katmanının içinde yazılır. Data ön işeme parameterelerini tutar.
transform_param {
….
}
transform_param :
mean_file: Ortalama görüntü dosyasının adı compute_image_mean
uygulaması ile oluşturabiliyoruz
mean_value : Ortalama değer rekli görünü için her kanal için ayrı ayrı yazılabilir.
mean_file ile birlikte kullanılmazlar. İşlem esnasında bu değerler
giriş görüntüsünden çıkarılır.
scale : Verinin ölçeklendirilmesini yapar varsayılan değeri 1 yani
değiştirmez. Mesela Görüntü piksel değerleri 0-1 arasına
çekilmesi için 1/255 yani 0.00390625 değeri verilir.
mirror : yatay yada dikey ayna görüntüsünü oluşturur. Varsayılan değer
false uygulanmasını isterseniz true yapın
crop_size : Görüntüden rastgele bir alan seçip verilen ebata getirerek işleme
sokar

16. Örnek Veri katmanları
1) verileri ilsvrc12_train_lmdb dosyasından okuyor rastgele ayna görüntüsü oluşturuluyor.
224x224 ebatında rastgeler alanlar seçiyor. BGR katmanları için (104,117,123) ortalama
değerlerinden çıkarılıyor.
name: "GoogleNet"
layer {
name: "data"
type: "Data"
top: "data"
top: "label"
include {
phase: TRAIN
}
transform_param {

17. mirror: true
crop_size: 224
mean_value: 104
mean_value: 117
mean_value: 123
}
data_param {
source: "examples/imagenet/ilsvrc12_train_lmdb"
batch_size: 32
backend: LMDB
}
}
2) Verileri data/flickr_style/train.txt dosyasında yazılan görüntü dosya isimleri ve etiketlerinden
alıyor. Veriler 256x256 ebatına getiriliyor. rastgele ayna görüntüsü oluşturuluyor. 227x227
ebatında rastgeler alanlar seçiyor. imagenet_mean.binaryproto ortalama dosyası çıkarılıyor.
name: "FlickrStyleCaffeNet"
layer {
name: "data"
type: "ImageData"
top: "data"
top: "label"
include {
phase: TRAIN
}
transform_param {
mirror: true
crop_size: 227
mean_file: "data/ilsvrc12/imagenet_mean.binaryproto"
}
image_data_param {
source: "data/flickr_style/train.txt"
batch_size: 50
new_height: 256
new_width: 256
}
}

18. 3) HDF5 için örnek : bakınız
In addition to image classification datasets, Caffe also have "HDF5Data" layer for
arbitrary inputs. This layer requires all training/validation data to be stored in hdf5 format
files.
This example shows how to use python h5py module to construct such hdf5 file and
how to setup caffe "HDF5Data" layer to read that file.
Build the hdf5 binary file
Assuming you have a text file 'train.txt' with each line with an image file name and
a single floating point number to be used as regression target.
import h5py, os
import caffe
import numpy as np
SIZE = 224 # fixed size to all images
with open( 'train.txt', 'r' ) as T :
lines = T.readlines()
# If you do not have enough memory split data into
# multiple batches and generate multiple separate h5 files
X = np.zeros( (len(lines), 3, SIZE, SIZE), dtype='f4' )
y = np.zeros( (1,len(lines)), dtype='f4' )
for i,l in enumerate(lines):
sp = l.split(' ')
img = caffe.io.load_image( sp[0] )
img = caffe.io.resize( img, (SIZE, SIZE, 3) ) # resize to fixed
size
# you may apply other input transformations here...
X[i] = img
y[i] = float(sp[1])
with h5py.File('train.h5','w') as H:
H.create_dataset( 'X', data=X ) # note the name X given to the
dataset!
H.create_dataset( 'y', data=y ) # note the name y given to the
dataset!
with open('train_h5_list.txt','w') as L:
L.write( 'train.h5' ) # list all h5 files you are going to use
Configuring "HDF5Data" layer
Once you have all h5 files and the corresponding test files listing them you can add an
HDF5 input layer to your train_val.prototxt:
layer {

19. type: "HDF5Data"
top: "X" # same name as given in create_dataset!
top: "y"
hdf5_data_param {
source: "train_h5_list.txt" # do not give the h5 files directly,
but the list.
batch_size: 32
}
include { phase:TRAIN }
}
You can find more information here and here.

20. Görsel Katmanlar :
Convolution
Layer type: Convolution
Bu işlem aslında görüntü üzerinde 2 boyutlu filitre gezdirme işlemidir. Eğitim esnasında
bu filitrelerde eğitilir.
1. Eğitim ile ilgili parametreler bu aşamada öğrenme olmamasını istiyorsak
parametrelere 0 değeri vererek dondurabiliriz. Bakınız finetune
2. 2 boytulu filtre gezdirme ile ilgili parametreler
3. Filtre çekirdek ağırlıklar ve sabit katsayı başlangıç değerleri
Parametreler
Zorunlu olanlar
num_output (c_o): filtre sayısı
kernel_size (or kernel_h and kernel_w): gezidirilecek filrenin ebatı kernel_size
ile belirtildiğinde kare matris. Dik dörtgen olması için en boy
oranı kernel_w ve kernel_h ile beritilir.

21. weight_filler : filitre çekirdek ağırlıklarına ilk değer atama yolu varsayılanı
'constant' sabit bir değerden başlar
bu opsiyon için gereken tipler ve alt parametreleri aşağıdaki gibidir
FillerParameter {
// The filler type.
optional string type = 1 [default = 'constant'];
optional float value = 2 [default = 0]; // the value in constant filler
optional float min = 3 [default = 0]; // the min value in uniform filler
optional float max = 4 [default = 1]; // the max value in uniform filler
optional float mean = 5 [default = 0]; // the mean value in Gaussian filler
optional float std = 6 [default = 1]; // the std value in Gaussian filler
// The expected number of non-zero output weights for a given input in
// Gaussian filler -- the default -1 means don't perform sparsification.
optional int32 sparse = 7 [default = -1];
}
Tipler ; 'constant','uniform','gaussian','xavier'
İsteğe Bağlı olanlar
bias_term : filitre çıkışına ek sabit değer ilavesi varsayılan değer
true
pad (or pad_h and pad_w) : girişin sağına soluna fazladan piksel ekleme
opsiyonu varsayılanı 0
stride (or stride_h and stride_w) [default 1]: filtrenin uygulanma aralığı
group (g) [default 1]: Guruplandırma parametresi .. If g > 1, we restrict the
connectivity of each filter to a subset of the input.
Specifically, the input and output channels are
separated into g groups, and the i’th output group
channels will be only connected to the i’ th input group
channels.
Bu katman girişi : n * c_i * h_i * w_i
ise çıkışı : n * c_o * h_o * w_o
olur
h_o = (h_i + 2 * pad_h - kernel_h) / stride_h + 1 ve

22. w_o = (w_i + 2 * pad_w - kernel_w) / stride_w + 1
Pooling
Layer type: Pooling
Girdi üzerinde 2 boyutlu bir çekirdek ebatında özetleme işlemidir.
Parametreleri (PoolingParameter pooling_param)
Zorunlu olan
kernel_size (or kernel_h and kernel_w): çekirdek en boy yada kare ise bir kenarını verir
İsteğe bağlı olan:
pool: Özetleme metodu girişden çekirdek ebatındaki kısımdan MAX ile maksimumu AVE
ile ortalamayı veya STOCHASTIC ile rastgele birini seçer ve çıkışa aktarır.
pad (or pad_h and pad_w) : girişin sağına soluna fazladan piksel ekleme
opsiyonu varsayılanı 0
stride (or stride_h and stride_w) [default 1]: filtrenin uygulanma aralığı
Giriş
n * c * h_i * w_i
Çıkış
n * c * h_o * w_o, where h_o ve w_o convolution daki hesaplanır.
Örnek

23. layer {
name: "pool1"
type: "Pooling"
bottom: "conv1"
top: "pool1"
pooling_param {
pool: MAX
kernel_size: 3 # pool over a 3x3 region
stride: 2 # step two pixels between pooling regions
}
}
Aktivasyon Katmanları:
giriş değerlerini alır ve aktivasyon fonksiyonuna sokup aynı sonucunu çıkışa iletir
hafıza. İşlem yerinde uygulanabildiğinden katma giriş ve çıkışı katmanı aynı yazılabilir.

24. Sigmoid ,tanh, relu bunlardan başlıcalarıdır.
Tipler ; "ReLU" , "Sigmoid","TanH"
Örnekler
layer {
name: "relu1"
type: "ReLU"
bottom: "conv1"
top: "conv1"
}
layer {
name: "layer"
bottom: "in"
top: "out"
type: "TanH"
}
YSA Katmanı - InnerProduct
Inner Product
Parametereleri
Zorunlu olan
num_output (c_o): Çıkış nöron sayısı
weight_filler : convolution daki ağırlık başlangıç değeri veren sistemlerle aynı
seçenekler
İsteğe bağlı olan:
bias_filler : convolution daki ile aynı
bias_term : Ağ a ek sabit değer ilavesi varsayılan değer true
Giriş
n * c_i * h_i * w_i
Çıkış
n * c_o * 1 * 1
Örnekler
layer {
name: "fc8"
type: "InnerProduct"
# lrate and decay for the weights
param { lr_mult: 1 decay_mult: 1 }
# lrate and decay for the biases
param { lr_mult: 2 decay_mult: 0 }
inner_product_param {
num_output: 1000
weight_filler {
type: "gaussian"
std: 0.01
layer {
name: "fc8"
type: "InnerProduct"
bottom: "fc7"
top: "fc8"
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2

25. }
bias_filler {
type: "constant"
value: 0
}
}
bottom: "fc7"
top: "fc8"
}
decay_mult: 0
}
inner_product_param {
num_output: 1000
weight_filler {
type: "gaussian"
std: 0.01
}
bias_filler {
type: "constant"
value: 0
}
}
}
Loss Katmanları
Ağın çalışması sonunda hedef sonuçlarlarla ( label ) tahmin edilen ( predicted ) sonuçların
kıyaslamasını değişik birimlerde ölçen bir katmandır Ağın ileri doğru çalışıp nihayetinde
hesaplayacağı bir sonuçdur geri yayılımla düzeltmeler bu büyüklük üzerinden yapılır. Genel
itibarıyla sıfıra yakın olması daha iyiidir.
Çeşitli fonksiyonlarla çeşitli katmalar oluşturulmuştur. Çeşitleri ve örnekleri aşağıdadır.
Softmax
Layer type: SoftmaxWithLoss
genelde kullanılan bu metod
layer {
name: "loss"
type: "SoftmaxWithLoss"
bottom: "fc8"
bottom: "label"
top: "loss"
}
Sum-of-Squares / Euclidean
Layer type: EuclideanLoss
regresyon için uygun sınıflandırmada işe yarar
bir sonuç göstermiyor
layer {
name: "loss"
type: "EuclideanLoss"
bottom: "ip4"
bottom: "label"
top: "loss"
}
Hinge / Margin
Layer type: HingeLoss
layer {
name: "loss"
type: "HingeLoss"

26. regresyon için uygun sınıflandırmada işe yarar
bir sonuç göstermiyor
bottom: "pred"
bottom: "label"
top: "loss"
hinge_loss_param {
norm: L2
}
}
Sigmoid Cross-Entropy
Layer type: SigmoidCrossEntropyLoss
Infogain
Layer type: InfogainLoss
dosya "infogainH.binaryproto" için kod
H = np.eye( L, dtype = 'f4' )
import caffe
blob =
caffe.io.array_to_blobproto( H.reshape
( (1,1,L,L) ) )
with open( 'infogainH.binaryproto',
'wb' ) as f :
f.write( blob.SerializeToString() )
layer {
bottom: "topOfPrevLayer"
bottom: "label"
top: "infoGainLoss"
name: "infoGainLoss"
type: "InfogainLoss"
infogain_loss_param {
source: "infogainH.binaryproto"
}
}
"InfogainLoss" hakkında dengesiz veri ile yapılacak sınıflandırma eğitimleri
için aşağıdaki uygulama öneriliyor.
“INFOGAIN_LOSS requires three inputs: class probabilities, labels and the matrix H. The
matrix H can be provided either as a layer parameters infogain_loss_param
{ source: "fiename" }.
Suppose I have a python script that computes H as a numpy.array of shape (L,L)
with dtype='f4' (where L is the number of labels in my model).
Currently, the matrix is configured as follows:
H(i, j) = 0 if i != j
H(i, j) = 1 - f(i) if i == j (with f(i) = the frequency of class i in
the batch
“

27. 1 ) http://stackoverflow.com/questions/30486033/tackling-class-imbalance-scaling-
contribution-to-loss-and-sgd
2) http://stackoverflow.com/questions/27632440/infogainloss-layer
isim yerine sabit de kullanılabiliyor. Mesela ; SOFTMAX_LOSS, EUCLIDEAN_LOSS,
SIGMOID_CROSS_ENTROPY_LOSS gibi
genel bilgi olarak
If you are trying to predict discrete binary labels then "EuclideanLoss" is not a very good
choice. This loss is better suited for regression tasks where you wish to predict
continuous values (e.g., estimating coordinated of bounding boxes etc.).
For predicting discrete labels, "SoftmaxWithLoss" or "InfogainLoss" are better suited.
Usually, "SoftmaxWithLoss" is used. For predicting binary outputs you may also consider
"SigmoidCrossEntropyLoss".
Kaynak ;
Accuracy Katmanı -
Ağın çalışması sonunda hedef sonuçlarlarla ( label ) tahmin edilen ( predicted ) sonuçların
kıyaslamasını değişik birimlerde ölçen bir katmandır. Doğruluk ölçümünü verir. 0-1 arasında
değer verir 1. %100 doğruluğu gösterir.
Örnek
layer {
name: "loss3/top-1"
type: "Accuracy"
bottom: "loss3/classifier"
bottom: "label"
top: "loss3/top-1"
include {
phase: TEST
}
}
layer {
name: "loss3/top-5"
type: "Accuracy"
bottom: "loss3/classifier"
bottom: "label"
top: "loss3/top-5"
include {
phase: TEST
}
accuracy_param {
top_k: 5
}
}

28. include : Hangi safhada çalıştırılacağını gösteriyor phase: TEST çalışma esnasında solver ın
belirlediği sıklıkta test verisyle çalıştırmak için bu şekilde yazılır. Devamlı görmek için bu kısmı
koymayın.
accuracy_param → top_k : n ; bu seçenek ile doğruluk hesabın da ilk n hesaba göre yapılıyor.
Ikinci örnekteki ilk 5 tahminin doğruluğu hesaplanıyor. Bu yazılmadığında ilk tahmin sonucuna
göre doğruluk hesaplanır.
Dropout Katmanı :
Yapay sinir ağlarında nodüller arası bağlantıların kısmen iptal edilmesi ile sistemin eğitilmesinde
ilerlemeler elde ediliyor. Sistemin ezeberlemesinin önüne geçiyor
Genel kullanmı
layer {
name: "drop1"
type: "Dropout"
bottom: "ip11"
top: "ip11"
dropout_param {

29. dropout_ratio: 0.5
}
}
şeklindedir.giriş -bottom- ve çıkış -top- katmanlırının aynı alması işlemin yerinde olmasını
gösterir kendinden bir sonraki katman drop katmanına değil dropdan önceki katmana bağlı
görünür. Tek parametresi dropout_ratio dur bu da bir bağlantının iptal edilme ihtimalini tutar.

30. Python İle Caffe Kullanımı
Caffe derlenirken python destekli derlenmişse. “ pyCaffe” ile python için den kullanmaya hatta
kodlarla ilaveler yapmaya başlayabilirsiniz.
Hazırda yazılımış sınıflar ve imkanlar aşağıdaki şekildedir,
• caffe.Net : Ana sınıfdır modelleri yüklemek ayarlamak ve çalıştırmak için
kullanabilirsiniz. Kullanım açısından kolaylık olsun diye daha özel sınıflarda vardır.
caffe.Classifier ve caffe.Detector sırası ile modeli sınıflandırıcı ve dedektör olarak
çalıştıran yapılardır.
• caffe.SGDSolver : solver yapısını yüklememizi ve kullanmamızı sağlar
• caffe.io : giriş çıkış işlemleri için kullanılıyor.
• caffe.draw : network yapısını grafik olarak göstermek için
• Ağın katmanlarına numpy ndarray olarak ulaşma imkanı sağlıyor.
Eğitilmiş Sınılandırıcı Kullanımı :
caffe.Net kullanarak da yazılabileceği gibi caffe.Classifier sınıfı daha pratik kullanım sahiptir.
Bu konu ile ilgili ‘runModelGen.py’ kodu yazılmış ve değişik eğitilmiş sınıflandırıcının
çalıştırılmasında kullanılmıştır.
Caffe kullanımı için öncelikle import etmemiz gerekiyor. Sonrasında il aşamada caffe nin
çalışacağı cihaz ( cpu veya gpu ) Cihaz grafik işlemci ise numarası verilir
import caffe
caffe.set_mode_gpu()
caffe.set_device(0)
Görüntüleri yüklemek ve göstermek için tavsiyemiz OpenCv kullanmak yönündedir. Ama
caffenin io kısmınıda kullanabilirsiniz.
if withOpenCv :
# image read with OpenCv
cImg = cv2.imread(path+iName)
cv2.imshow("Img :",cImg)
cImg = np.array(cImg, dtype=float)

31. else:
# image read with caffe.io.load_image
cImg = caffe.io.load_image(path+iName)
plt.imshow(cImg)
plt.show()
Sınıflandırıcı sınıfımızı oluşturuyoruz.
Sınıflandırıcı için ;
• çalıştırmak için düzenlenmiş genelde deploy olarak adlandırılan. Prototxt tipinde model
dosyası eğer yoksa eğitim için kullanılan model dosayasın giriş kısmı data ve sondaki
loss kısmı düzeltilerek oluşturulabilir.
• Eğitim sonunda yada esnasında ağırlıkların kaydedilmesiyle oluşturulmuş dosya.
*.caffemodel olarak tutulur. Model dosyasyına göre değişik büyüklükte olabilir.
• Eğer varsa ortalam görüntü dosyası. Değişik formatlarda bulunabilir *.binaryproto , *.nyp
yada her görüntü kanalı için bir değer gibi [128,79,98] gibi
• Görüntü giriş ebatları eğitimde kullanılmış olan büyüklüğünü vereceğiz ki verdiğimiz
görüntü bu ebatlara çevrilip kullanılabilsin
Model ve Ağırlık dosya isimlerini belirliyoruz. Giriş görüntü ebatımızı bildiriyoruz.
mName = 'deploy.prototxt'
wName = 'weights.caffemodel'
imDim = (227, 227)
Mean File devam edelim başlayalım.
eğer *.binaryproto ise ;
mean_filename='hybridCNN_mean.binaryproto'
proto_data = open(mean_filename, "rb").read()
a = caffe.io.caffe_pb2.BlobProto.FromString(proto_data)
meanFile = caffe.io.blobproto_to_array(a)[0].mean(1).mean(1)
eğer *.nyp ise ;
mean_filename='hybridCNN_mean.nyp'
meanFile = np.load(mean_filename).mean(1).mean(1)
eğer sadece her kanal için ortalama değerler varsa ;
R_mean = 123
G_mean = 117
B_mean = 104
meanFile= np.array([B_mean, G_mean, R_mean])

32. eğer hiç biri yoksa;
meanFile = None
Şimdi sınıflandırıcımızı oluşturuyoruz.
classifier = caffe.Classifier(mName,wName,mean=meanFile ,image_dims=imDim)
Eğer görüntümüzü OpenCv ile yüklemediysek yani caffe.io.load_image kullandıysak yapmamız
gereken ilave ayarlar var
if not withOpenCv:
classifier.transformer.set_channel_swap('data', (2,1,0))
classifier.transformer.set_raw_scale('data', 255)
caffe ve Opencv renkli görüntüyü BGR olarak okur caffe.io altında görüntü RGB olarak yüklenir
.transformer.set_channel_swap('data', (2,1,0)) ile bu düzeltme işlemi yapılıyor. Diğeride basit bir
normalizasyon işlemi
Sınıflandırıcımızı çalıştrımak için predict fonksiyonunu çağırıyoruz.
scores = classifier.predict([cImg], oversample=True).flatten()
oversample seçeneği ile vermiş olduğumuz görüntüden 10 görüntü çıkarıp herbiri için
sınıflandırıcıyı çağırır ve sonuçların ortalamasını verir. Bu seçeneği vermediğimizde sadece tek
bir görüntü üzerinden çalışır. Detaylar için bakınız
caffe→ io.py → oversample fonksiyonu
Crop images into the four corners, center, and their mirrored versions.
Parameters
----------
image : iterable of (H x W x K) ndarrays
crop_dims : (height, width) tuple for the crops.
Returns
-------
crops : (10*N x H x W x K) ndarray of crops for number of inputs N.
Flatten fonksiyonu ile sonuç bir vektöre dönüştürülür.
Vektörün ebatı sınıflandırıcının çıkış sayısındadır. Özetle sınıflandırıcı verilen görüntünün her
sınıf için olma ihtimalini dönderir.

33. En yüksek ihtimali bulmak için;
top1 = scores.argmax()
top1_prob = scores[ top1 ]
En yüksek ihtimale sahip k sınıf için
mesela 5 için
k = 5
outlst = (-scores).argsort()[:k]
print 'Top : ',k
sMax = scores[scores.argmax()]
for i in outlst:
print(" Out ", i, scores[i]," - ", int(100*scores[i]/sMax))
burdan sonucu sınıf numarası olarak alıyoruz. Sınıfların ifade ettikleri text değerleri tutan dizi var
ise burdan sınıf isimlerine ulaşabiliriz.