def train():
parser = argparse.ArgumentParser()
parser.add_argument('--epoch', '-e', type=int, default=100)
parser.add_argument('--batchsize', '-b', type=int, default=1)
parser.add_argument('--train_dataset', '-tr', default='./data/ori/')
parser.add_argument('--target_dataset', '-ta', default='./data/label/')
parser.add_argument(
'--lr',
'-l',
type=float,
default=1e-5,
)
parser.add_argument('--out_path', '-o')
parser.add_argument('--binary', '-bi', type=int, default=0)
parser.add_argument('--model', '-m', type=int, default=0)
parser.add_argument('--weight', '-w', type=int, default=0)
parser.add_argument('--gpu', '-g', type=int, default=2)
args = parser.parse_args()
path_to_train = args.train_dataset
path_to_target = args.target_dataset
epoch = args.epoch
batchsize = args.batchsize
lr = args.lr
out = args.out_path
binary = [False, True][args.binary]
# set gpu environment
os.environ["CUDA_VISIBLE_DEVICES"] = str(args.gpu)
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
K.set_session(sess)
if not os.path.exists(out):
os.mkdir(out)
f = open(out + '/param.txt', 'w')
f.write('epoch:' + str(args.epoch) + '\n' + 'batch:' + str(batchsize) +
'\n' + 'lr:' + str(lr))
f.close()
np.random.seed(seed=1)
img_size = 512
if binary:
nb_class = 2
else:
# nb_class = 5
nb_class = 3
# 訓練、テスト画像の番号を設定
# 31画像を訓練に、13画像をテストに
num_ar = np.random.permutation([str(i).zfill(3) for i in np.arange(1, 45)])
train_names = num_ar[:31]
test_names = num_ar[31:]
# 訓練の時はこの辺りのコメントを入れる
nb_data = len(train_names)
train_X, train_y = generate_dataset(train_names,
path_to_train,
path_to_target,
img_size,
color=3,
nb_class=nb_class,
aug=20)
test_X, test_y = generate_dataset(test_names,
path_to_train,
path_to_target,
img_size,
color=0,
nb_class=nb_class,
aug=0)
nb_train = train_X.shape[0]
print('train data is ' + str(nb_train))
#--------------------------------------------------------------------------------------------------------------------
# training
#--------------------------------------------------------------------------------------------------------------------
# 訓練時は以下２つのコメントを入れる
class_freq = np.array(
[np.sum(train_y.argmax(axis=3) == i) for i in range(nb_class)])
# class_weights = np.median(class_freq) /class_freq
class_weights = np.mean(class_freq) / class_freq
# FCN = FullyConvolutionalNetwork(img_height=img_size, img_width=img_size,FCN_CLASSES=nb_class)
# unet = Unet(img_height=img_size, img_width=img_size,FCN_CLASSES=nb_class)
# adam = Adam(lr)
# train_model = FCN.create_fcn32s()
# train_model = unet.create_model2()
# train_model.compile(loss=crossentropy, optimizer=adam)
# train_model.compile(loss=weighted_crossentropy, optimizer=adam)
es_cb = EarlyStopping(monitor='val_loss',
patience=5,
verbose=0,
mode='auto')
train_model = make_model(
args.model, args.weight, img_size, nb_class, class_weights,
lr) # (model(1:fcn, 2:unet, 3:unet2) , weight(0:no weight 1:weight))
train_model.fit(train_X, train_y, batch_size=batchsize, epochs=epoch)
train_model.save_weights(out + '/weights.h5')
# train_model.load_weights(out + '/weights.h5')
#--------------------------------------------------------------------------------------------------------------------
# predict
#--------------------------------------------------------------------------------------------------------------------
nb_test = len(test_names)
color_map = make_color_map()
mat = np.zeros([nb_class, nb_class])
pred = train_model.predict(test_X)
pred_score = pred.reshape((-1, nb_class))[:, 1]
pred_label = pred.reshape((-1, nb_class)).argmax(axis=1)
y = test_y.reshape((-1, nb_class)).argmax(axis=1)
for i in range(len(y)):
mat[y[i], pred_label[i]] += 1
file = open(out + '/accuracy.csv', 'w')
pd.DataFrame(mat).to_csv(out + '/confusion.csv')
pixel_wise = np.sum([mat[k, k] for k in range(nb_class)]) / np.sum(mat)
mean_acc_list = [mat[k, k] / np.sum(mat[k, :]) for k in range(nb_class)]
mean_acc = np.sum(mean_acc_list) / nb_class
mean_iou_list = [
mat[k, k] / (np.sum(mat[k, :]) + np.sum(mat[:, k]) - mat[k, k])
for k in range(nb_class)
]
mean_iou = np.sum(mean_iou_list) / nb_class
if binary:
fpr, tpr, threshods = roc_curve(y, pred_score, pos_label=1)
precision, recall, threshold = precision_recall_curve(y, pred_score)
fpr_tpr = np.concatenate(
(np.array(fpr)[:, np.newaxis], np.array(tpr)[:, np.newaxis]),
axis=1)
pr = np.concatenate(
(np.array(precision)[:, np.newaxis], np.array(recall)[:,
np.newaxis]),
axis=1)
np.savetxt(out + '/fpr_tpr.csv', fpr_tpr, delimiter=',')
np.savetxt(out + '/precsion_recall.csv', pr, delimiter=',')
auc_score = auc(fpr, tpr)
recall = mat[1, 1] / np.sum(mat[1, :])
precision = mat[1, 1] / np.sum(mat[:, 1])
if recall == 0 and precision == 0:
f_value = 0
else:
f_value = 2 * recall * precision / (recall + precision)
plt.plot(fpr, tpr)
plt.savefig(out + '/ROC.png')
file.write('pixel wize: ' + str(pixel_wise) + '\n' + 'mean acc: ' +
str(mean_acc) + '\n' + 'mean iou: ' + str(mean_iou) + '\n' +
'auc: ' + str(auc_score) + '\n' + 'f_value: ' +
str(f_value))
else:
file.write('pixel wize: ' + str(pixel_wise) + '\n' + 'mean acc: ' +
str(mean_acc) + '\n' + 'mean iou: ' + str(mean_iou))
file.close()
#--------------------------------------------------------------------------------------------------------------------
# visualize
#--------------------------------------------------------------------------------------------------------------------
ind = np.random.permutation(nb_train)[0:10]
imgs = train_X[ind]
pred_train = train_model.predict(train_X[ind])
train_y = train_y[ind]
for j in range(10):
img = imgs[j] * 255.0
pr = pred_train[j]
y = train_y[j]
pr = pr.argmax(axis=2)
y = y.argmax(axis=2)
y_rgb = np.zeros((img_size, img_size, 3))
pred_rgb = np.zeros((img_size, img_size, 3))
for i in range(nb_class):
y_rgb[y == i] = color_map[i]
pred_rgb[pr == i] = color_map[i]
Image.fromarray(img.astype(np.uint8)).save(out + '/train_input_' +
str(j) + '.png')
Image.fromarray(y_rgb.astype(np.uint8)).save(out + '/train_label_' +
str(j) + '.png')
Image.fromarray(pred_rgb.astype(np.uint8)).save(out + '/train_pred_' +
str(j) + '.png')
for pr, y, name in zip(pred, test_y, test_names):
pr = pr.argmax(axis=2)
y = y.argmax(axis=2)
y_rgb = np.zeros((img_size, img_size, 3))
pred_rgb = np.zeros((img_size, img_size, 3))
for i in range(nb_class):
y_rgb[y == i] = color_map[i]
pred_rgb[pr == i] = color_map[i]
# img.save(out + '/test_input_' + name + '.png')
Image.fromarray(y_rgb.astype(np.uint8)).save(out + '/label_' + name +
'.png')
Image.fromarray(pred_rgb.astype(np.uint8)).save(out + '/pred_' + name +
'.png')
from preprocess import load_data
from color_map import make_color_map
parser = argparse.ArgumentParser(description='Chainer Fully Convolutional Network: predict')
parser.add_argument('--gpu', '-g', default=-1, type=int,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--image_path', '-i', default=None, type=str)
parser.add_argument('--weight', '-w', default="weight/chainer_fcn.weight", type=str)
parser.add_argument('--classes', default=21, type=int)
parser.add_argument('--clop', "-c", default=True, type=bool)
parser.add_argument('--clopsize', "-s", default=224, type=int)
args = parser.parse_args()
img_name = args.image_path.split("/")[-1].split(".")[0]
color_map = make_color_map()
FCN = FullyConvolutionalNetwork()
model = FCN.create_model()
model.load_weights('weights/fcn_params')
o = load_data(args.image_path, size=args.clopsize, mode="original")
x = load_data(args.image_path, size=args.clopsize, mode="data")
start = time()
pred = model.predict(x)
pred = pred[0].argmax(axis=0)
print(pred.max())
row, col = pred.shape
dst = np.ones((row, col, 3))
for i in range(21):
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--image", type=str)
parser.add_argument("--gpu", type=int, default=0)
parser.add_argument("--model", default=None)
parser.add_argument("--n_class", type=int, default=5)
args = parser.parse_args()
print(args)
model = RefineResNet(n_class=args.n_class)
if model is not None:
serializers.load_npz(args.model, model)
if args.gpu >= 0:
cuda.get_device(args.gpu).use()
model.to_gpu()
org = cv2.imread(args.image, cv2.IMREAD_COLOR)
image = cv2.imread(args.image, cv2.IMREAD_COLOR)
org = cv2.resize(org, (160, 160))
image = cv2.resize(image, (160, 160))
image = np.asarray(image, dtype=np.float32)
image = image.transpose((2, 0, 1))
image = np.expand_dims(image, axis=0)
pred = F.softmax(model(image)).data
pred = pred[0].argmax(axis=0)
print(pred)
color_map = make_color_map()
row, col = pred.shape
dst = np.ones((row, col, 3))
for i in range(args.n_class):
dst[pred == i] = color_map[i]
img = Image.fromarray(np.uint8(dst))
trans = Image.new('RGBA', img.size, (0, 0, 0, 0))
w, h = img.size
for x in range(w):
for y in range(h):
pixel = img.getpixel((x, y))
if (pixel[0] == 0 and pixel[1] == 0 and pixel[2] == 0)or \
(pixel[0] == 255 and pixel[1] == 255 and pixel[2] == 255):
continue
trans.putpixel((x, y), pixel)
if not os.path.exists("out"):
os.mkdir("out")
cv2.imwrite("out/original.jpg", org)
trans.save("out/pred.png")
o = cv2.imread("out/original.jpg", 1)
p = cv2.imread("out/pred.png", 1)
pred = cv2.addWeighted(o, 0.6, p, 0.4, 0.0)
cv2.imwrite("out/pred_alpha.png", pred)
os.remove("out/original.jpg")
