def predict(opt):
# net=torch.load('Lenet.pth') # pth格式 只保留参数
# print('net', net)
'''
需要将basic_option中的is_train 修改为false
'''
# opt.is_train = False
acc = 0
total = 0
test_dataloader = create_dataloader(opt)
net = Classification()
net.load_state_dict(
torch.load(
f"./output/train/weights/exp_1/Basic_Epoch_20_Accuracy_0.99.pth"))
net = net.to(device)
with torch.no_grad():
for index, data in enumerate(test_dataloader, start=1):
images, labels = data
images, labels = images.to(device), labels.to(device)
outputs = net(images)
_, predicted = torch.max(outputs.data, dim=1)
print(f'number {index} picture maybe : {classes[predicted[0]]}')
total += labels.size(0)
acc += (predicted == labels).sum().item()
print('Accuracy on test set : {}%'.format(100 * acc / total))
def test_get_season(self):
# create two seasons
classification = Classification(label='test mens')
classification.save()
competition = Competition(
name='div 1',
mode='l',
classification=classification
)
competition.save()
season_1 = Season(label='s1',
start_date=datetime.date.today(),
end_date=datetime.date.today() + datetime.timedelta(365),
competition=competition,
published=True
)
season_2 = Season(label='s2',
start_date=datetime.date.today() + datetime.timedelta(365),
end_date=datetime.date.today() + datetime.timedelta(730),
competition=competition
)
season_1.save()
season_2.save()
self.assertIn(season_1,
Season.get_current_season_by_slugs('test-mens', 'div-1'))
self.assertNotIn(season_2,
Season.get_current_season_by_slugs('test-mens', 'div-1'))
def __init__(self,
adj_matrix,
features=None,
labels=None,
supervised=False,
model='gat',
n_layer=2,
emb_size=128,
random_state=1234,
device='auto',
epochs=5,
batch_size=20,
sample_size=10,
lr=0.7,
unsup_loss_type='margin',
print_progress=True):
super(GNN, self).__init__()
# fix random seeds
random.seed(random_state)
np.random.seed(random_state)
torch.manual_seed(random_state)
torch.cuda.manual_seed_all(random_state)
# set parameters
self.supervised = supervised
self.lr = lr
self.epochs = epochs
self.batch_size = batch_size
self.sample_size = sample_size
self.unsup_loss_type = unsup_loss_type
self.print_progress = print_progress
self.gat = True if model == 'gat' else False
# set device
if device == 'auto':
self.device = torch.device(
"cuda" if torch.cuda.is_available() else "cpu")
else:
self.device = device
# load data
self.dl = DataLoader(adj_matrix, features, labels, supervised,
self.device)
self.gnn = GraphSage(n_layer,
emb_size,
batch_size,
sample_size,
self.dl,
self.device,
gat=self.gat)
self.gnn.to(self.device)
if supervised:
n_classes = len(set(labels))
self.classification = Classification(emb_size, n_classes)
self.classification.to(self.device)
def cl(self):
if self._cl:
return self._cl
if self.clid:
clid = self.clid
else:
clName = self.request.REQUEST.get('cl')
if clName:
self.clid = clid = clName
else:
return False
cl = memcache.get(clid.encode('utf8'))
if cl is None:
if clid.isdigit() and len(clid)<4:
logger.warn("User requested a random classification, not fully implemented")
cl = classification.random(self.ts.numregions,min(int(clid)+2,MAX_n))
self._cl = cl
return cl
else:
cl = Classification.get_by_key_name(clid)
if cl is not None and not memcache.add(clid.encode('utf8'), cl):
logger.error("Memcache set failed [ %s ]"%clid)
if cl is not None:
if cl.public or cl.owner == self.request.user.username:
self._cl = cl
return self._cl
return False
def real_get(self):
values = self.request.REQUEST.get('values')
if not values and self.cl:
C = Classification.get_by_key_name(self.clid)
if C and hasattr(C,'notes'):
values = C.notes
else:
values = ','.join(map(str,range(self.cl.n)))
if self.cs and values:
delim = self.request.REQUEST.get('delim')
if not delim: delim = ','
title = self.request.REQUEST.get('title')
values = values.split(delim)
s = '<div style="width:170px; background-color:#cccccc; padding:5px;">'
if title: s+='<h3 style="margin:0;border:0;padding:0;">%s</h3>'%title
#for i in range(2,self.cs.n):
for i,val in enumerate(values):
r,g,b = map(ord,self.cs.colors[i+2])
s += '<div style="clear:both; float:left; border: 1px black solid; width:20px; height:20px; background-color:#%.2X%.2X%.2X;"> </div>'%(r,g,b)
#s += '<div style="height:22px;">'+values[i-2]+'</div>'
s += '<div style="height:22px;">'+val+'</div>'
s += '</div>'
callback = self.request.REQUEST.get('callback')
if callback:
s = callback+'({"legend":"%s"})'%s.replace('"','\\"')
self.write(s)
def remove_classifications(self):
q = Classification.all(keys_only=True)
q.filter('tileset',self.ts)
if q.count():
db.delete(q.fetch(INDEX_BATCH_SIZE))
self.write("<b>Remove Classifications:</b>Removing, refresh until done.<br />")
else:
self.write("<b>Remove Classifications: DONE.</b><br />")
def cl(self):
""" Search for the Classification Name in the Request and try and load it from Memcache or DataStore, return True or False """
if self._cl:
return self._cl
classificationName = self.request.REQUEST.get('cl','DEFAULT')
if classificationName == 'random':
self.clid = clid = "cl:random"
elif classificationName.isdigit():
self.clid = clid = "cl:__digit:"+self.ts.name+":"+classificationName
elif self.ts:
self.clid = clid = "cl:"+self.ts.name+":"+classificationName
else:
return False
cl = memcache.get(clid)
if cl is not None:
self._cl = cl
else:
cl = None
if self.ts:
N = self.ts.idlen
if clid == 'cl:random':
cl = classification.random(N,min(N,MAX_n))
elif clid.startswith('cl:__digit:'):
cl = classification.random(N,min(int(classificationName)+2,MAX_n))
elif clid.startswith('cl:key_'):
C = Classification.get(classificationName[4:])
if C:
cl = classification.Classification(C.a)
elif clid:
C = Classification.get_by_key_name(clid)
if C:
cl = classification.Classification(C.a)
#if cl and clid != 'cl:random':
#if not memcache.add(clid, cl, 60):
# logging.error("Memcache set failed [ %s ]"%clid)
if not cl:
cl = classification.random(N,3)
self._cl = cl
if cl is not None:
return cl
else:
return False
def post_csv(self,bg=0,br=1):
user = self.request.user
POST = self.request.POST
if 'dat' in POST:
a = array.array(UNSIGNED_ITEM_TYPES[1])
dat = map(int,POST['dat'].split(','))
a.fromlist([bg,br])
a.fromlist(dat)
astring = a.tostring()
cl = Classification("%s:%s"%(user.username,hashlib.md5(astring).hexdigest()))
cl.tileset = self.ts.key_name
cl.dat = zlib.compress(astring)
cl.N = len(a)
assert (cl.N-2) == self.ts.numregions
cl.n = max(a)+1
cl.owner = user.username
cl.public = True
cl.expires = False
cl.date = time.mktime(time.gmtime())
return cl.put()
def train(opt):
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
train_dataloader, val_dataloader = create_dataloader(opt)
net = Classification() # 定义训练的网络模型
net.to(device)
net.train()
loss_function = nn.CrossEntropyLoss() # 定义损失函数为交叉熵损失函数
optimizer = optim.Adam(net.parameters(), lr=0.001) # 定义优化器（训练参数，学习率）
for epoch in range(opt.num_epochs): # 一个epoch即对整个训练集进行一次训练
running_loss = 0.0
correct = 0
total = 0
time_start = time.perf_counter()
for step, data in enumerate(train_dataloader,
start=0): # 遍历训练集，step从0开始计算
inputs, labels = data # 获取训练集的图像和标签
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero_grad() # 清除历史梯度
# forward + backward + optimize
# outputs = net(inputs.permute(0,1,3,2)) # 正向传播
outputs = net(inputs) # 正向传播
print('outputs.shape', outputs.shape, labels.shape)
loss = loss_function(outputs, labels) # 计算损失
loss.backward() # 反向传播
optimizer.step() # 优化器更新参数
predict_y = torch.max(outputs, dim=1)[1]
total += labels.size(0)
correct += (predict_y == labels).sum().item()
running_loss += loss.item()
# print statistics
# print('train_dataloader length: ', len(train_dataloader))
acc = correct / total
print('Train on epoch {}: loss:{}, acc:{}%'.format(epoch + 1, running_loss / total, 100 * correct / total))
# 保存训练得到的参数
if opt.model == 'basic':
save_weight_name = os.path.join(opt.save_path,
'Basic_Epoch_{0}_Accuracy_{1:.2f}.pth'.format(
epoch + 1,
acc))
elif opt.model == 'plus':
save_weight_name = os.path.join(opt.save_path,
'Plus_Epoch_{0}_Accuracy_{1:.2f}.pth'.format(
epoch + 1,
acc))
torch.save(net.state_dict(), save_weight_name)
print('Finished Training')
def real_get(self):
ts = self.ts
if ts:
self.write("Found TileSet: "+ts.name)
self.write("<br />")
img_src = '/o.png?ts='+ts.name
if self.request.get('cl'):
img_src+= '&cl='+self.request.get('cl')
if self.request.get('cs'):
img_src+= '&cs='+self.request.get('cs')
gmap = self.request.url.replace('/m/','/gmap/')
self.write("<a href='%s'><img src='%s' /></a><br />"%(gmap,img_src))
args = {}
args['name'] = ts.name
args['pub'] = "Public" if ts.public else "Private"
args['cLat'] = ts.cLat
args['cLng'] = ts.cLng
args['maxZoom'] = ts.maxZoom
self.write("<b>%(name)s</b> is a <b>%(pub)s</b> TileSet with a centriod of <b>(%(cLng).4f , %(cLat).4f)\
</b> and a maximium zoom level of <b>%(maxZoom)d</b>.<br />"%args)
self.write("Notes: %s<br />"%ts.notes)
self.write("Source: %s<br />"%ts.source)
self.write("ID Spreadsheet: <a href='/ids.csv?ts=%s'>ids.csv </a>"%ts.name)
self.write('<br><br><hr>')
self.write('<a href="classify?ts=%s">Classify this Tile Set.</a>'%ts.name)
q = Classification.all(keys_only=True)
q.filter('tileset',ts)
q.filter('public',True)
if q.count():
self.write("Classifications for this TileSet:<br>")
#q.filter('expires',Flase)
for cl_key in q:
cl = Classification.get(cl_key)
if cl.name:
cl = cl.name
else:
cl = 'key_%s'%cl_key
self.write('<A href="/m/?ts=%s&cl=%s">%s</a><br>'%(ts.name,cl,cl))
def create_models(samples, dictionary):
neumf = NeuMF(len(samples), len(dictionary), 0.5, 8, [64, 32, 16, 8])
attr_nets = dict()
for key, labels in dictionary.items():
if labels is None:
# regression;
attr_nets[key] = Regression(16)
else:
# classification
# NOTE: class num doesnt include blank labels
attr_nets[key] = Classification(16,
len(labels) - 1)
return neumf, attr_nets
def get(self,clid=''):
if clid:
self.clid = clid
cl = self.cl
if cl:
dat = cl.as_dict()
out = {}
for key,val in dat.iteritems():
try:
if issubclass(type(val),basestring):
out[key] = val.encode('utf8')
else:
out[key] = val
except UnicodeDecodeError: pass
return self.write(out)
else:
return self.write({"error":"Classification Not Found"})
else:
return self.write({'classifications':Classification.select('owner',self.request.user.username,keys_only=True)})
def add_classification(self):
text = self.classificationNameInput.text()
same_classifications = self.session.query(Classification).filter_by(
name=text).all()
if len(same_classifications):
self.close()
QMessageBox.warning(self, 'تحذير', 'التصنيف موجود بالفعل!')
return
classification = Classification(name=text)
self.session.add(classification)
self.session.commit()
QMessageBox.information(self, 'عملية ناجحة', 'تمت الاضافة بنجاح')
self.close()
def parse_line(self, line):
columns = line.split(self.HAZARDS_DELIMITER)
# Check columns count
if len(columns) != self.HAZARDS_COL_COUNT:
self.error = 'Number of columns must be %d' % self.HAZARDS_COL_COUNT
return False
# Clean columns
temp = []
for col in columns:
temp.append(col.strip())
columns = temp
# Check signal word
if not HStatement.is_signal_word(columns[self.HAZARDS_COL_SIGNALWORD]):
self.error = "'%s' is not a signal word!" % columns[
self.HAZARDS_COL_SIGNALWORD]
return False
pictogram_names = columns[self.HAZARDS_COL_PICTOGRAM].strip()
for pic_name in pictogram_names.split(','):
pic_name = pic_name.strip()
image_name = pic_name + self.HAZARDS_PICTOGRAM_TYPE
image = None
try:
image = self.zip_file.read(image_name)
except KeyError:
self.error = 'Did not find <b>%s</b> in zip-file.' % image_name
return False
else:
# Parse Pictogram
pic = Pictogram.load(pic_name, image)
# Parse H-Statement
hstatement = HStatement.load(columns[self.HAZARDS_COL_CODE])
hstatement.statement = columns[self.HAZARDS_COL_HSTATEMENT]
hstatement.set_signal_word(
columns[self.HAZARDS_COL_SIGNALWORD])
# Parse Class
cls = Class.laod(columns[self.HAZARDS_COL_CLASS])
cls.pictogram = pic.key
# Parse Category (can be a list)
cats = self.parse_category(columns[self.HAZARDS_COL_CATEGORY])
if cats:
for cat in cats:
c = Classification(parent=CLASSIFICATION_KEY,
clazz=cls.key,
category=cat.key,
hstatement=hstatement.key)
c.put()
cat.put()
else:
self.error = "Category '%s' could not be understood." % columns[
self.HAZARDS_COL_CATEGORY]
return False
# Store all the entities now where everything is fine
pic.put()
hstatement.put()
cls.put()
return True
args.add_argument('--max_epoch', type=int, default=10)
args.add_argument('--batch', type=int, default=2000)
args.add_argument('--strmaxlen', type=int, default=200)
args.add_argument('--embedding', type=int, default=8)
# Select model
args.add_argument('--model', type=str, default='classification', choices=['regression', 'classification'])
config = args.parse_args()
print('HAS_DATASET :', HAS_DATASET)
print('IS_ON_NSML :', IS_ON_NSML)
print('DATASET_PATH :', DATASET_PATH)
model_type = {
'regression' : Regression(config.embedding, config.strmaxlen),
'classification' : Classification(config.embedding, config.strmaxlen),
}
model = model_type[config.model]
if GPU_NUM:
model = model.cuda()
# DONOTCHANGE: Reserved for nsml use
bind_model(model, config)
criterion_type = {
'regression' : nn.MSELoss(),
'classification' : nn.CrossEntropyLoss(),
}
criterion = criterion_type[config.model]
optimizer = optim.Adam(model.parameters(), lr=0.01)
def create_classification(label):
classification = Classification(label=label)
classification.save()
return classification
class GNN(object):
"""Graph Neural Networks that can be easily called and used.
Authors of this code package:
Tong Zhao, [email protected]
Tianwen Jiang, [email protected]
Last updated: 11/25/2019
Parameters
----------
adj_matrix: scipy.sparse.csr_matrix
The adjacency matrix of the graph, where nonzero entries indicates edges.
The number of each nonzero entry indicates the number of edges between these two nodes.
features: numpy.ndarray, optional
The 2-dimension np array that stores given raw feature of each node, where the i-th row
is the raw feature vector of node i.
When raw features are not given, one-hot degree features will be used.
labels: list or 1-D numpy.ndarray, optional
The class label of each node. Used for supervised learning.
supervised: bool, optional, default False
Whether to use supervised learning.
model: {'gat', 'graphsage'}, default 'gat'
The GNN model to be used.
- 'graphsage' is GraphSAGE: https://cs.stanford.edu/people/jure/pubs/graphsage-nips17.pdf
- 'gat' is graph attention network: https://arxiv.org/pdf/1710.10903.pdf
n_layer: int, optional, default 2
Number of layers in the GNN
emb_size: int, optional, default 128
Size of the node embeddings to be learnt
random_state, int, optional, default 1234
Random seed
device: {'cpu', 'cuda', 'auto'}, default 'auto'
The device to use.
epochs: int, optional, default 5
Number of epochs for training
batch_size: int, optional, default 20
Number of node per batch for training
lr: float, optional, default 0.7
Learning rate
unsup_loss_type: {'margin', 'normal'}, default 'margin'
Loss function to be used for unsupervised learning
- 'margin' is a hinge loss with margin of 3
- 'normal' is the unsupervised loss function described in the paper of GraphSAGE
print_progress: bool, optional, default True
Whether to print the training progress
"""
def __init__(self,
adj_matrix,
features=None,
labels=None,
supervised=False,
model='gat',
n_layer=2,
emb_size=128,
random_state=1234,
device='auto',
epochs=5,
batch_size=20,
lr=0.7,
unsup_loss_type='margin',
print_progress=True):
super(GNN, self).__init__()
# fix random seeds
random.seed(random_state)
np.random.seed(random_state)
torch.manual_seed(random_state)
torch.cuda.manual_seed_all(random_state)
# set parameters
self.supervised = supervised
self.lr = lr
self.epochs = epochs
self.batch_size = batch_size
self.unsup_loss_type = unsup_loss_type
self.print_progress = print_progress
self.gat = True if model == 'gat' else False
# set device
if device == 'auto':
self.device = torch.device(
"cuda" if torch.cuda.is_available() else "cpu")
else:
self.device = device
# load data
self.dl = DataLoader(adj_matrix, features, labels, supervised,
self.device)
self.gnn = GraphSage(n_layer,
emb_size,
self.dl,
self.device,
gat=self.gat)
self.gnn.to(self.device)
if supervised:
n_classes = len(set(labels))
self.classification = Classification(emb_size, n_classes)
self.classification.to(self.device)
def fit(self):
train_nodes = copy.deepcopy(self.dl.nodes_train)
if self.supervised:
labels = self.dl.labels
models = [self.gnn, self.classification]
else:
unsup_loss = Unsup_Loss(self.dl, self.device)
models = [self.gnn]
if self.unsup_loss_type == 'margin':
num_neg = 6
elif self.unsup_loss_type == 'normal':
num_neg = 100
for epoch in range(self.epochs):
np.random.shuffle(train_nodes)
params = []
for model in models:
for param in model.parameters():
if param.requires_grad:
params.append(param)
optimizer = torch.optim.SGD(params, lr=self.lr)
optimizer.zero_grad()
for model in models:
model.zero_grad()
batches = math.ceil(len(train_nodes) / self.batch_size)
visited_nodes = set()
for index in range(batches):
if not self.supervised and len(visited_nodes) == len(
train_nodes):
# finish this epoch if all nodes are visited
break
nodes_batch = train_nodes[index * self.batch_size:(index + 1) *
self.batch_size]
# extend nodes batch for unspervised learning
if not self.supervised:
nodes_batch = np.asarray(
list(
unsup_loss.extend_nodes(nodes_batch,
num_neg=num_neg)))
visited_nodes |= set(nodes_batch)
# feed nodes batch to the GNN and returning the nodes embeddings
embs_batch = self.gnn(nodes_batch)
# calculate loss
if self.supervised:
# superivsed learning
logists = self.classification(embs_batch)
labels_batch = labels[nodes_batch]
loss_sup = -torch.sum(
logists[range(logists.size(0)), labels_batch], 0)
loss_sup /= len(nodes_batch)
loss = loss_sup
else:
# unsupervised learning
if self.unsup_loss_type == 'margin':
loss_net = unsup_loss.get_loss_margin(
embs_batch, nodes_batch)
elif self.unsup_loss_type == 'normal':
loss_net = unsup_loss.get_loss_sage(
embs_batch, nodes_batch)
loss = loss_net
if self.print_progress:
logging.info(
'Epoch: [{}/{}],Step [{}/{}], Loss: {:.4f}, Dealed Nodes [{}/{}] '
.format(epoch + 1, self.epochs, index + 1, batches,
loss.item(), len(visited_nodes),
len(train_nodes)))
loss.backward()
for model in models:
nn.utils.clip_grad_norm_(model.parameters(), 5)
optimizer.step()
optimizer.zero_grad()
for model in models:
model.zero_grad()
def generate_embeddings(self):
nodes = self.dl.nodes_train
b_sz = 500
batches = math.ceil(len(nodes) / b_sz)
embs = []
for index in range(batches):
nodes_batch = nodes[index * b_sz:(index + 1) * b_sz]
with torch.no_grad():
embs_batch = self.gnn(nodes_batch)
assert len(embs_batch) == len(nodes_batch)
embs.append(embs_batch)
assert len(embs) == batches
embs = torch.cat(embs, 0)
assert len(embs) == len(nodes)
return embs.cpu().numpy()
def predict(self):
if not self.supervised:
print('GNN.predict() is only supported for supervised learning.')
sys.exit(0)
nodes = self.dl.nodes_train
b_sz = 500
batches = math.ceil(len(nodes) / b_sz)
preds = []
for index in range(batches):
nodes_batch = nodes[index * b_sz:(index + 1) * b_sz]
with torch.no_grad():
embs_batch = self.gnn(nodes_batch)
logists = self.classification(embs_batch)
_, predicts = torch.max(logists, 1)
preds.append(predicts)
assert len(preds) == batches
preds = torch.cat(preds, 0)
assert len(preds) == len(nodes)
return preds.cpu().numpy()
batch_size = 16
train_data = gdata.DataLoader(cifar_train.transform_first(transform_train),
batch_size=batch_size,
shuffle=True)
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010])
])
val_data = gluon.data.DataLoader(cifar_test.transform_first(transform_test),
batch_size=batch_size,
shuffle=False)
if __name__ == '__main__':
ctx = mx.gpu()
net = get_model('cifar_resnet20_v1', classes=10, pretrained=True)
net.collect_params().reset_ctx(ctx)
net.initialize(ctx=ctx)
model = Classification(net=net, ctx=ctx)
model.summary()
history = model.fit(train_data, 1, val_data)
history.plot()
plt.legend()
plt.show()
# image size 3, 32, 32
# batch size must be an even number
# shuffle must be True
cifar_10_train_dt = MyCustomDataset('data',
download=True,
transform=ToTensor())
cifar_10_train_l = DataLoader(cifar_10_train_dt,
batch_size=batch_size,
shuffle=True,
drop_last=True,
pin_memory=torch.cuda.is_available())
encoder = Encoder().to(device)
loss_fn = DeepInfoMaxLoss(1, 0, 1).to(device)
classification = Classification().to(device)
encoder_optim = Adam(encoder.parameters(), lr=1e-4)
loss_optim = Adam(loss_fn.parameters(), lr=1e-4)
classification_optim = Adam(classification.parameters(), lr=1e-4)
epoch_restart = 0
root = Path(r'models')
if epoch_restart > 0 and root is not None:
enc_file = root / Path('encoder' + str(epoch_restart) + '.wgt')
loss_file = root / Path('loss' + str(epoch_restart) + '.wgt')
classification_loss_file = root / Path('classification_loss' +
str(epoch_restart) + '.wgt')
encoder.load_state_dict(torch.load(str(enc_file)))
loss_fn.load_state_dict(torch.load(str(loss_file)))
classification.load_state_dict(
def real_post(self):
""" Handles /classify POST requests/
The POST data must contain "classifcation" and "ts"
'classification': a string of integers in the range >=2 and <=255.
0 and 1 are reserved for background and borders
each integer represents the classID of a region,
the order of the class ids MUST match the order
of the IDS provided by the GET ?noform=1 handler.
"""
if self.ts:
cl = self.request.REQUEST.get('classification')
b64 = self.request.REQUEST.get('b64encode')
if not cl:
self.write("Bad Request")
return self.die(400)
try:
if b64 == 'True':
a = array.array('B')
a.fromstring(b64decode(cl))
cl = a.tolist()
else:
cl = cl.strip().split(',')
cl = map(int,cl)
assert len(cl) == self.ts.idlen
cl = [0,1]+cl
a = array.array(UNSIGNED_ITEM_TYPES[1])
a.fromlist(cl)
a = zlib.compress(a.tostring())
name = self.request.REQUEST.get('name')
exp = False
if not name:
name = 'user_%s'%str(time()).replace('.','')
exp = True
if name:
clid = 'cl:%s:%s'%(self.ts.name,name)
memcache.delete(clid)
C = Classification(key_name=clid)
C.name = name
C.expires = exp
#else:
# key_name = 'cs:%s:%s'%(self.ts.name,str(time()).replace('.',''))
# C = Classification(key_name)
C.tileset = self.ts.key()
C.a = a
C.N = len(cl)-2
C.n = max(cl)+1
title = self.request.REQUEST.get('title')
if title:
C.title = title
notes = self.request.REQUEST.get('notes')
if notes:
C.notes = notes
public = self.request.REQUEST.get('public')
if public and public == 'False':
C.public = False
elif public:
C.public = True
try:
key = C.put()
except CapabilityDisabledError:
logging.error("Capability has been disabled")
self.dir(500)
callback = self.request.REQUEST.get("callback")
if name:
if callback:
self.write('%s({"key":"%s"})'%(callback,name))
else:
self.write("Put: %s"%name)
else:
if callback:
self.write('%s({"key":"%s"})'%(callback,key))
else:
self.write("Put: key_%s"%key)
except:
raise
else:
self.die(400)
x = self.features(x)
x = self.output(x)
return x
mnist_train = gdata.vision.FashionMNIST(train=True,
root=r'../resource/fashion')
mnist_test = gdata.vision.FashionMNIST(train=False,
root=r'../resource/fashion')
transform = gdata.vision.transforms.ToTensor()
train_iter = gdata.DataLoader(dataset=mnist_train.transform_first(transform),
shuffle=True,
batch_size=128)
test_iter = gdata.DataLoader(mnist_test.transform(transform), batch_size=128)
if __name__ == '__main__':
ctx = mx.gpu()
net = Net(classes=10)
net.initialize(ctx=ctx)
print(net)
trainer = Trainer(net.collect_params(), 'adam', {'learning_rate': 0.01})
fun = gloss.SoftmaxCrossEntropyLoss()
model = Classification(neural=net, fun=fun, opt=trainer)
model.train(mnist_train.transform_first(transform),
batch_size=256,
epochs=32)
args.add_argument('--strmaxlen', type=int, default=200)
args.add_argument('--embedding', type=int, default=300)
args.add_argument('--model_name', type=str, default='RCNN')
config = args.parse_args()
config2 = Config()
dataset = SentenceClassificationDataset('../data/processing_data',
config.strmaxlen)
print('unique labels = {}'.format(dataset.get_unique_labels_num()))
print('vocab size = {}'.format(dataset.get_vocab_size()))
if config.model_name == 'CNN':
model = Classification(config.embedding, config.strmaxlen,
dataset.get_unique_labels_num(),
dataset.get_vocab_size())
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)
elif config.model_name == 'RCNN':
model = RCNN(config.embedding, config.strmaxlen,
dataset.get_unique_labels_num(), dataset.get_vocab_size())
if config.mode == 'train':
model = model.cuda()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)
elif config.model_name == "DUALRCNN":
model = DualRCNN(config.embedding, config.strmaxlen,
