告密者的下场

从前有座山，叫巴里赫德，他一个当一座山，十分的爽。

哎，想不到吧。

这个山里面有树林，有庙，有这个山里灵活的狗。山上有棵树，这棵树不叫高树，因为这个梗太老了。这棵树的形状有些奇特，大概就长这个样子。

import

torch

from

torch

import

nn

import

torch.nn.functional

as

F

import

os

import

tensorboardX

from

torch.utils.data

import

Dataset

from

torch.utils.data

import

DataLoader

device

=

torch.device('cuda'

if

torch.cuda.is_available()

else

'cpu')

class

VGGBaseSimpleS2(nn.Module):

def

__init__(self):

super(VGGBaseSimpleS2,

self).__init__()

self.conv1

=

nn.Sequential(

nn.Conv2d(1,

12,

kernel_size=3,

stride=1,

padding=1),

#nn.BatchNorm2d(16),

nn.ReLU()

)

#

6*6

self.max_pooling1

=

nn.MaxPool2d(kernel_size=2,

stride=1)

#

5*5

self.conv2_1

=

nn.Sequential(

nn.Conv2d(12,

24,

kernel_size=3,

stride=1,

padding=1),

nn.ReLU()

)

self.max_pooling2_1

=

nn.MaxPool2d(kernel_size=2,

stride=1)

#

4*4

self.conv2_2

=

nn.Sequential(

nn.Conv2d(24,

24,

kernel_size=3,

stride=1,

padding=1),

nn.ReLU()

)

self.max_pooling2

=

nn.MaxPool2d(kernel_size=2,

stride=2)

#

2*2

#

2*2

self.fc

=

nn.Linear(24*2*2,

2)

def

forward(self,

x):

batchsize

=

x.size(0)

out

=

self.conv1(x)

out

=

self.max_pooling1(out)

out

=

self.conv2_1(out)

out

=

self.conv2_2(out)

out

=

self.max_pooling2(out)

out

=

out.view(batchsize,

-1)

out

=

self.fc(out)

out

=

F.log_softmax(out,

dim=1)

return

out

class

TrainingDataSet(Dataset):

def

__init__(self):

super(TrainingDataSet,

self).__init__()

self.data_dict_X

=

X_train

self.data_dict_y

=

y_train

def

__getitem__(self,

index):

t

=

self.data_dict_X[index,

0:36]

t

=

torch.tensor(t).view(6,

6)

return

t,

self.data_dict_y[index]

def

__len__(self):

return

len(self.data_dict_y)

class

TestDataSet(Dataset):

def

__init__(self):

super(TestDataSet,

self).__init__()

self.data_dict_X

=

X_validate

self.data_dict_y

=

y_validate

def

__getitem__(self,

index):

t

=

self.data_dict_X[index,

0:36]

t

=

torch.tensor(t).view(6,

6)

return

t,

self.data_dict_y[index]

def

__len__(self):

return

len(self.data_dict_y)

def

cnn_classification():

batch_size

=

256

trainDataLoader

=

DataLoader(TrainingDataSet(),

batch_size=batch_size,

shuffle=False)

testDataLoader

=

DataLoader(TestDataSet(),

batch_size=batch_size,

shuffle=False)

epoch_num

=

200

#lr

=

0.001

lr

=

0.001

net

=

VGGBaseSimpleS2().to(device)

print(net)

#

loss

loss_func

=

nn.CrossEntropyLoss()

#

optimizer

optimizer

=

torch.optim.Adam(net.parameters(),

lr=lr)

#

optimizer

=

torch.optim.SGD(net.parameters(),

lr=lr,

momentum=0.9,

weight_decay=5e-4)

scheduler

=

torch.optim.lr_scheduler.StepLR(optimizer,

step_size=5,

gamma=0.9)

if

not

os.path.exists(“logCNN“):

os.mkdir(“logCNN“)

writer

=

tensorboardX.SummaryWriter(“logCNN“)

for

epoch

in

range(epoch_num):

train_sum_loss

=

0

train_sum_correct

=

0

train_sum_fp

=

0

train_sum_fn

=

0

train_sum_tp

=

0

train_sum_tn

=

0

for

i,

data

in

enumerate(trainDataLoader):

net.train()

inputs,

labels

=

data

inputs

=

inputs.unsqueeze(1).to(torch.float32)

labels

=

labels.type(torch.LongTensor)

inputs,

labels

=

inputs.to(device),

labels.to(device)

outputs

=

net(inputs)

loss

=

loss_func(outputs,

labels)

optimizer.zero_grad()

loss.backward()

optimizer.step()

_,

pred

=

torch.max(outputs.data,

dim=1)

acc

=

pred.eq(labels.data).cpu().sum()

one

=

torch.ones_like(labels)

zero

=

torch.zeros_like(labels)

tn

=

((labels

==

zero)

*

(pred

==

zero)).sum()

tp

=

((labels

==

one)

*

(pred

==

one)).sum()

fp

=

((labels

==

zero)

*

(pred

==

one)).sum()

fn

=

((labels

==

one)

*

(pred

==

zero)).sum()

train_sum_fn

+=

fn.item()

train_sum_fp

+=

fp.item()

train_sum_tn

+=

tn.item()

train_sum_tp

+=

tp.item()

train_sum_loss

+=

loss.item()

train_sum_correct

+=

acc.item()

train_loss

=

train_sum_loss

*

1.0

/

len(trainDataLoader)

train_correct

=

train_sum_correct

*

1.0

/

len(trainDataLoader)

/

batch_size

train_precision

=

train_sum_tp

*

1.0

/

(train_sum_fp

+

train_sum_tp)

train_recall

=

train_sum_tp

*

1.0

/

(train_sum_fn

+

train_sum_tp)

writer.add_scalar(“train

loss“,

train_loss,

global_step=epoch)

writer.add_scalar(“train

correct“,

train_correct,

global_step=epoch)

writer.add_scalar(“train

precision“,

train_precision,

global_step=epoch)

writer.add_scalar(“train

recall“,

train_recall,

global_step=epoch)

if

not

os.path.exists(“models_aug_CNN“):

os.mkdir(“models_aug_CNN“)

torch.save(net.state_dict(),

“models_aug_CNN/{}.pth“.format(epoch

+

1))

scheduler.step()

sum_loss

=

0

sum_correct

=

0

test_sum_fp

=

0

test_sum_fn

=

0

test_sum_tp

=

0

test_sum_tn

=

0

for

i,

data

in

enumerate(testDataLoader):

net.eval()

inputs,

labels

=

data

inputs

=

inputs.unsqueeze(1).to(torch.float32)

labels

=

labels.type(torch.LongTensor)

inputs,

labels

=

inputs.to(device),

labels.to(device)

outputs

=

net(inputs)

loss

=

loss_func(outputs,

labels)

_,

pred

=

torch.max(outputs.data,

dim=1)

acc

=

pred.eq(labels.data).cpu().sum()

one

=

torch.ones_like(labels)

zero

=

torch.zeros_like(labels)

tn

=

((labels

==

zero)

*

(pred

==

zero)).sum()

tp

=

((labels

==

one)

*

(pred

==

one)).sum()

fp

=

((labels

==

zero)

*

(pred

==

one)).sum()

fn

=

((labels

==

one)

*

(pred

==

zero)).sum()

test_sum_fn

+=

fn.item()

test_sum_fp

+=

fp.item()

test_sum_tn

+=

tn.item()

test_sum_tp

+=

tp.item()

sum_loss

+=

loss.item()

sum_correct

+=

acc.item()

test_precision

=

test_sum_tp

*

1.0

/

(test_sum_fp

+

test_sum_tp)

test_recall

=

test_sum_tp

*

1.0

/

(test_sum_fn

+

test_sum_tp)

test_loss

=

sum_loss

*

1.0

/

len(testDataLoader)

test_correct

=

sum_correct

*

1.0

/

len(testDataLoader)

/

batch_size

writer.add_scalar(“test

loss“,

test_loss,

global_step=epoch

+

1)

writer.add_scalar(“test

correct“,

test_correct,

global_step=epoch

+

1)

writer.add_scalar

(“test

precision“,

test_precision,

global_step=epoch

+

1)

writer.add_scala

r(“test

recall“,

test_recall,

global_step=epoch

+

1)

print(“epoch

is“,

epoch,

“train

loss“,

train_loss,

“train

correct“,

train_correct,

“test

loss

is

“,

test_loss,

“test

correct

is:

“,

test_correct,

“train_precision:

“,

train_precision,

“test_precision:

“,

test_precision,

“train_recall:

“,

train_recall,

“test_recall:

“,

test_recall)

writer.close()

可以说非常之高大粗壮，也给山里面人带来了很多不便，为了开发山里面的土地，或者给山里面阳光，村民决定砍伐这棵树。他们砍了整整一天，给树砍了，一股七彩的光芒就飞进了树林。村民就非常爽，晚上就抱着他们女朋友进入了甜蜜的梦乡。

可第二天他们发现树又长回来了，这次不是python这次是特么java。他们又砍树，但第二天又长出来了，这树C，C++，C#,JavaScript,Perl,PHP,Delhi

Pascal,Go，SQL，Matlab，Scratch一样一个。具体是什么我就不写了我怕你们打我。

有一个精通电脑的长老提出来了，很久以前一个叫莱茵的男人犯了病，惹怒了达摩和迦叶波。非常难受，被变成了狮子。

这个sb树肯定是这sb莱茵捣的鬼。

于是长老就π人在晚上守夜。果然他们看见了莱茵偷偷嵌入呸潜入他们树墩下，他们发现这个树没有砍干净还剩了一个

#include〈studio.h〉

int

main()

莱茵用这个舌头一舔，这树就分分钟长成了参天大树。

这sb守夜人也不组织而是禀报给了长老。长老一看十分生气。下令给这个#include〈studio.h〉

int

main()

也连根拔起烧了。

之后狮子发现没有树可以舔了十分难受，有一天他正在路上走着，发现了一根女人叫sb蓄渴衅，他对这个女人说：“sb蓄渴衅，我分分钟就能吃了你，但是我不会吃你，现在我还要给你名贵的药草，让你当药科大学公派留学生，你能不能帮我弄死你们sb长老。”

sb蓄渴衅一听wc，非常爽。就成了莱茵的卧底当了恨国党。天天泄露长老的机密。

长老也发现不对劲，就下令说：“我们之中出来了一个告密者，恨国党，历史虚无主义者，我已经知道它的名字了，我奉劝它能够改邪归正在明天带着莱茵的头颅来见我，要么它只有死路一条。”

蓄渴衅十分慌张，它找到莱茵商量对策，莱茵说：“非常简单，我给你一个别的狮子的头颅。”

蓄渴衅照做了，拿着别的狮子的头颅见了长老，长老一见sb蓄渴衅，酷驰一摆拳，呱嗒一个刺拳，框汤一个鞭腿给它打成了sb，不，本来就是sb。给它皮扒了十八层，骨灰扬到水沟里头。看着蓄渴衅痛苦地死去，长老非常地爽，然后揪出来了在丛林里潜伏的莱茵，夸差，咣当，酷驰一波操作给他也打成了渣渣。

最后，他大吼“看清楚没有，这就是sb告密者的下场。”

先别急着幸福生活，现在这个侯丰文又出来了，跟大家再瞎说几句。

有人说爱国是种美德，是种修养。我觉得是特么屁的美德修养，你特么身为一个人类，你也算是个人了，你国都不爱你算特么什么人类。我都想问不爱国的这些畜牲们一句为什么，到底为什么，有人说物种多样性呀遗传多样性，这特么解释不通啊，妈的物种多样性也特么不是这个地方多样吧，我都不太能把这种东西看成一种生物。

在我看来，爱国已经是最廉价，最基本的品质，一个人可以尖酸刻薄，可以不自律颓废，可以一事无成，可以贪婪吝啬，都不能用你的语言和身体攻击那个给我们稳定幸福生活，养育我们长大的祖国。

对于这类恨国的粪便蛆虫（对不起侮辱粪便蛆虫了）在英雄们冲锋陷阵时，它们肆意嘲讽。在英雄们为国捐躯时，它们恶毒诅咒。它们嘤嘤狗吠自以为不朽，用放屁一般的言语，歪曲事实，虚无历史，辱骂先烈。

我为同这种人生在一片空气里而耻辱而羞愧！

这篇文章不好意思，没有凝华主旨和幸福生活。我要让我的每个读者看到！面对这些蛆虫粪便，我们没必要冷静，我们没必要克制。只有卸掉他们肮脏的头颅，才是对高尚英雄真正地告慰。