Use python to write the classification network architecture train_test.prototxt and solver.prototxt under the caffe framework and run the program directly

from __future__ import print_function
import caffe
from caffe import layers as L, params as P
from caffe.proto import caffe_pb2

import math
import them
import state
import subprocess


caffe_root = "/home/xn/caffe/"
train_lmdb_file = caffe_root + "../train_lmdb"
test_lmdb_file = caffe_root + "../test_lmdb"
mean_file = caffe_root + "../mean.binaryproto"
path = '/home/xn/caffe/examples/facetestquestions/'
train_path = path + 'train_test.prototxt'
solver_file = 'solver.prototxt'
solver_path = path + solver_file
batch_size = 8
model_name = 'mnin_plant'
log_name = model_name + '.log'
log_dir = path + 'log'
log_file = '{}/{}'.format(log_dir, log_name)
snapshot_dir = path + 'model'
snapshot_prefix = '{}/{}'.format(snapshot_dir, model_name)
num_class = 20
job_file = path + model_name + '.sh'
pretrain_model = path + 'mnin_relu_xavier_iter_30000.caffemodel'

#Write the network architecture, mainly train_test.prototxt
def mnintest(test_lmdb, batch_sizes):

    nettest = caffe.NetSpec()

    nettest.data, nettest.label = caffe.layers.Data(source=test_lmdb, backend=caffe.params.Data.LMDB,
                                                                  batch_size=batch_sizes, ntop=2,
                                                                  transform_param=dict(crop_size=256,
                                                                                       mean_file=mean_file,
                                                                                       mirror=False),
                                                                  include=dict(phase=caffe.TEST))

    kwargs = {
        'param': [dict (lr_mult = 1, decay_mult = 1), dict (lr_mult = 2, decay_mult = 0)],
        'weight_filler': dict(type='xavier'),
        'bias_filler': dict(type='constant', value=0)}

    nettest.conv1 = caffe.layers.Convolution(nettest.data, num_output=192, kernel_size=5, pad=2, **kwargs)
    nettest.relu_conv1 = caffe.layers.ReLU(nettest.conv1, in_place=True)
    nettest.cccp1 = caffe.layers.Convolution(nettest.relu_conv1, num_output=160, kernel_size=1, **kwargs)
    nettest.relu_cccp1 = caffe.layers.ReLU(nettest.cccp1, in_place=True)
    nettest.cccp2 = caffe.layers.Convolution(nettest.relu_cccp1, num_output=96, kernel_size=1, **kwargs)
    nettest.relu_cccp2 = caffe.layers.ReLU(nettest.cccp2, in_place=True)
    nettest.pool1 = caffe.layers.Pooling(nettest.relu_cccp2,kernel_size=3, stride=2, pool=P.Pooling.MAX)
    nettest.dropout1 = caffe.layers.Dropout(nettest.pool1, dropout_ratio=0.5, in_place=True)
    nettest.conv2 = caffe.layers.Convolution(nettest.dropout1, num_output=192, kernel_size=5, pad=2, **kwargs)
    nettest.relu_conv2=caffe.layers.ReLU(nettest.conv2, in_place=True)
    nettest.cccp3 = caffe.layers.Convolution(nettest.relu_conv2, num_output=192, kernel_size=1, **kwargs)
    nettest.relu_cccp3 = caffe.layers.ReLU(nettest.cccp3, in_place=True)
    nettest.cccp4 = caffe.layers.Convolution(nettest.relu_cccp3, num_output=192, kernel_size=1, **kwargs)
    nettest.relu_cccp4 = caffe.layers.ReLU(nettest.cccp4, in_place=True)
    nettest.pool2 = caffe.layers.Pooling(nettest.relu_cccp4, kernel_size=3, stride=2, pool=P.Pooling.MAX)
    nettest.dropout2 = caffe.layers.Dropout(nettest.pool2, dropout_ratio=0.5, in_place=True)
    nettest.conv3 = caffe.layers.Convolution(nettest.dropout2, num_output=192, kernel_size=5, pad=1, **kwargs)
    nettest.relu_conv3 = caffe.layers.ReLU(nettest.conv3, in_place=True)
    nettest.cccp5 = caffe.layers.Convolution(nettest.relu_conv3, num_output=192, kernel_size=1, **kwargs)
    nettest.relu_cccp5 = caffe.layers.ReLU(nettest.cccp5, in_place=True)
    nettest.cccp6 = caffe.layers.Convolution(nettest.relu_cccp5, num_output=192, kernel_size=1, **kwargs)
    nettest.relu_cccp6 = caffe.layers.ReLU(nettest.cccp6, in_place=True)
    nettest.pool3 = caffe.layers.Pooling(nettest.relu_cccp6, kernel_size=3, stride=2, pool=P.Pooling.MAX)
    nettest.dropout3 = caffe.layers.Dropout(nettest.pool3, dropout_ratio=0.5, in_place=True)
    nettest.conv4 = caffe.layers.Convolution(nettest.dropout3, num_output=384, kernel_size=3, pad=1, **kwargs)
    nettest.relu_conv4 = caffe.layers.ReLU(nettest.conv4, in_place=True)
    nettest.cccp7 = caffe.layers.Convolution(nettest.relu_conv4, num_output=384, kernel_size=1, **kwargs)
    nettest.relu_cccp7 = caffe.layers.ReLU(nettest.cccp7, in_place=True)
    nettest.cccp8 = caffe.layers.Convolution(nettest.relu_cccp7, num_output=384, kernel_size=1, **kwargs)
    nettest.relu_cccp8 = caffe.layers.ReLU(nettest.cccp8, in_place=True)
    nettest.pool4 = caffe.layers.Pooling(nettest.relu_cccp8, kernel_size=3, stride=2, pool=P.Pooling.MAX)
    nettest.dropout4 = caffe.layers.Dropout(nettest.pool4, dropout_ratio=0.5, in_place=True)
    nettest.fc1 = caffe.layers.InnerProduct(nettest.dropout4, num_output = num_class, weight_filler=dict(type='gaussian', std=0.01),
                                        bias_filler=dict(type='constant', value=0),
                                        param = [dict (lr_mult = 1, decay_mult = 1), dict (lr_mult = 2, decay_mult = 0)])

    nettest.accuarcy = caffe.layers.Accuarcy (nettest.fc1, nettest.label)
    nettest.loss = caffe.layers.SoftmaxWithLoss(nettest.fc1, nettest.label)

    return nettest.to_proto()
def mnintrain(train_lmdb, batch_sizes):

    nettrain = caffe.NetSpec()

    nettrain.data, nettrain.label = caffe.layers.Data(source=train_lmdb, backend=caffe.params.Data.LMDB,
                                                      batch_size=batch_sizes, ntop=2,
                                                      transform_param=dict(crop_size=256,
                                                                           mean_file=mean_file, mirror=True),
                                                      include=dict(phase=caffe.TRAIN))
    return nettrain.to_proto()

with open(train_path, 'w') as f:
    f.write('name: "mnin"\n')
    f.write(str(mnintrain(train_lmdb_file, batch_size)))
    f.write(str(mnintest(test_lmdb_file, batch_size)))


base_lr = 0.001
num_test_image = 500
iter_size = 1
solver_mode = P.Solver.CPU
test_iter = int(math.ceil(float(num_test_image) / batch_size))
gpus = "0"
gpulist = gpus.split(",")
num_gpus = len(gpulist)

if num_gpus > 0:
  batch_size_per_device = int(math.ceil(float(batch_size) / num_gpus))
  solver_mode = P.Solver.GPU
  device_id = int(gpulist[0])

#The following is solver.prototxt
solver_param = {
    'base_lr': base_lr,
    'weight_decay': 0.0005,
    'lr_policy': "multistep",
    'stepvalue': [10000, 20000],
    'gamma': 0.1,
    'momentum': 0.9,
    'iter_size': iter_size,
    'max_iter': 30000,
    'snapshot': 30000,
    'display': 20,
    'type': "SGD",
    'solver_mode': solver_mode,
    'test_iter': [test_iter],
    'test_interval': 100,
    'ap_version': "11point",
    'test_initialization': False,
    }
solver = caffe_pb2.SolverParameter(
    net = train_path, snapshot_prefix= snapshot_prefix, **solver_param)

with open(solver_path, 'w') as f:
    print(solver, file=f)

#Run the script, the .sh file
train_src_param = '--weights="{}" \\\n'.format(pretrain_model)
with open(job_file, 'w') as f:
  f.write('cd {}\n'.format(caffe_root))
  f.write('./build/tools/caffe train \\\n')
  f.write('--solver="{}" \\\n'.format(solver_path))
  f.write(train_src_param)
  if solver_param['solver_mode'] == P.Solver.GPU:
    f.write('--gpu {} 2>&1 | tee {}\n'.format(gpus, log_file))
  else:
    f.write('2>&1 | tee {}\n'.format(log_file))

#Run the program, run the network
os.chmod(job_file, stat.S_IRWXU)
subprocess.call(job_file, shell=True)