/
train.py
148 lines (120 loc) · 4.63 KB
/
train.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
import mxnet as mx
import numpy as np
from mxnet import gluon, image, nd
from mxnet.gluon import nn
from mxnet import autograd
import utils
import h5py
import random
import os
''''''
all_data_count = 20580
range_data = list(range(0,20580))
random.shuffle(range_data)
#print(range_data[0])
#exit()
def accuracy(output, labels):
return nd.mean(nd.argmax(output, axis=1) == labels).asscalar()
def evaluate(net, data_iter):
loss, acc, n = 0., 0., 0.
steps = len(data_iter)
for data, label in data_iter:
data, label = data.as_in_context(ctx), label.as_in_context(ctx)
output = net(data)
acc += accuracy(output, label)
loss += nd.mean(softmax_cross_entropy(output, label)).asscalar()
return loss/steps, acc/steps
ctx = mx.gpu()
net = nn.Sequential()
with net.name_scope():
net.add(nn.Dense(256, activation='relu'))
net.add(nn.Dropout(0.5))
net.add(nn.Dense(120))
net.load_params('ttt.params', ctx=ctx)
#net.initialize(ctx=ctx)
#net.initialize(init = init.Xavier(),ctx=ctx)
softmax_cross_entropy = gluon.loss.SoftmaxCrossEntropyLoss()
trainer = gluon.Trainer(net.collect_params(), 'adam', {'learning_rate': 1e-4, 'wd': 1e-5})
################################### predict ###################################
h5f5 = h5py.File('features/test_resnet152_v1.h5', 'r') # train_resnet152_v1 train_inceptionv31
h5f6 = h5py.File('features/test_inceptionv3.h5', 'r') # train_resnet152_v1 train_inceptionv31
features3 = h5f5['features']
features4 = h5f6['features']
train_imgs = gluon.data.vision.ImageFolderDataset( './data/train_valid_test/Images')
ids = sorted(os.listdir('./data/train_valid_test/test/unknown'))
#print(ids)
#exit()
test_count = 10357
outputs = []
for i in range(test_count):
features = np.concatenate([features3[i:i+1], features4[i:i+1]], axis=-1)
predict = net(nd.array(features).as_in_context(ctx))
output = nd.softmax(predict)
#print(output)
#exit()
outputs.extend(output.asnumpy())
with open('submission.csv', 'w') as f:
f.write('id,' + ','.join(train_imgs.synsets) + '\n')
for i, output in zip(ids, outputs):
f.write(i.split('.')[0] + ',' + ','.join([str(num) for num in output]) + '\n')
'''
#################################### train ####################################
#zong shuju 20580
h5f = h5py.File('features/train_resnet152_v1.h5', 'r') # train_resnet152_v1 train_inceptionv31
h5f2 = h5py.File('features/train_inceptionv31.h5', 'r') # train_resnet152_v1 train_inceptionv31
h5f3 = h5py.File('features/labels1.h5', 'r')
features1 = h5f['features']
features2 = h5f2['features']
labels = h5f3['labels']
#features = np.concatenate([features1[0:10], features2[0:10]], axis=-1)
#print(features1[1])
#exit()
#train
epochs = 3
batch_size = 32
train_split = 18522 #18522
val_features = []
val_labels = []
#range_data
for i in range(train_split, all_data_count):
range1 = range_data[i]
val_features.append(np.concatenate([features1[range1], features2[range1]], axis=-1))
val_labels.append(labels[range1])
dataset_val = gluon.data.ArrayDataset(nd.array(val_features), nd.array(val_labels))
data_iter_val = gluon.data.DataLoader(dataset_val, batch_size)
for epoch in range(epochs):
train_loss = 0.
train_acc = 0.
train_loss_batch = 0.
train_acc_batch = 0.
max_batch = (int(train_split/batch_size))
for i in range(max_batch+1):
start_poch = batch_size*i
if(i-1 == max_batch):
end_poch = train_split
else:
end_poch = batch_size*(i+1)
train_features = []
train_labels = []
range1 = range_data[start_poch:end_poch]
for ran in range1:
train_features.append(np.concatenate([features1[ran], features2[ran]], axis=-1))
train_labels.append(labels[ran])
data, label = nd.array(train_features).as_in_context(ctx), nd.array(train_labels).as_in_context(ctx)
with autograd.record():
output = net(data)
loss = softmax_cross_entropy(output, label)
loss.backward()
trainer.step(batch_size)
train_loss_batch = nd.mean(loss).asscalar()
train_loss += train_loss_batch
train_acc_batch = accuracy(output, label)
train_acc += train_acc_batch
if not i % 20:
print("batch %d. loss: %.4f, acc: %.4f%% " % (
i+1, train_loss_batch, train_acc_batch))
val_loss, val_acc = evaluate(net, data_iter_val)
print("Epoch %d. loss: %.4f, acc: %.2f%%, val_loss %.4f, val_acc %.2f%%" % (
epoch+1, train_loss/max_batch, train_acc/max_batch*100, val_loss, val_acc*100))
net.save_params('ttt.params')
'''