net = net.cuda()
net.train()
optimizer = SGD(net.parameters(),
lr=warm_lr,
momentum=YOLOv3Config["MOMENTUM"],
weight_decay=YOLOv3Config["WEIGHT_DECAY"])
data_loader = DataLoader(ListDataset(
"/input",
target_transform=AnnotationTransform(classes=YOLOv3Config["CLASSES"])),
batch_size=YOLOv3Config["BATCH_SIZE"],
shuffle=False)
bar = ProgressBar(YOLOv3Config["EPOCHS"], len(data_loader), "Loss:%.3f")
for epoch in range(1, YOLOv3Config["EPOCHS"]):
for i, (imgs, targets) in enumerate(data_loader):
imgs = Variable(imgs.cuda() if YOLOv3Config["GPU_NUMS"] > 0 else imgs)
# targets = [anno.cuda() for anno in targets] if CFG["GPU_NUMS"] > 0 else [anno for anno in targets]
optimizer.zero_grad()
loss = net(imgs, targets)
loss.backward()
optimizer.step()
bar.show(epoch, loss.item())
torch.save(net.state_dict(), "YOLOv3_%3d.pth" % epoch)
Predict_Noise_var = Variable(
torch.randn(100, CONFIG["NOISE_DIM"]).cuda(
) if CONFIG["GPU_NUMS"] > 0 else torch.randn(100, CONFIG["NOISE_DIM"]))
temp_z_ = torch.randn(10, 100)
fixed_z_ = temp_z_
Predict_y = torch.zeros(10, 1)
for i in range(1, 10):
fixed_z_ = torch.cat([fixed_z_, temp_z_], 0)
temp = torch.zeros(10, 1) + (i % 2)
Predict_y = torch.cat([Predict_y, temp], 0)
Predict_y = one_hot(Predict_y.long())
Predict_y = Variable(Predict_y.cuda() if CONFIG["GPU_NUMS"] > 0 else Predict_y)
bar = ProgressBar(CONFIG["EPOCHS"], len(train_loader),
"D Loss:%.3f, G Loss:%.3f")
for epoch in range(1, CONFIG["EPOCHS"] + 1):
if epoch % 20 == 0:
G_optimizer.param_groups[0]['lr'] /= 10
D_optimizer.param_groups[0]['lr'] /= 10
for img_real, label_real in train_loader:
mini_batch = label_real.shape[0]
label_true = torch.ones(mini_batch)
label_false = torch.zeros(mini_batch)
label_true_var = Variable(
label_true.cuda() if CONFIG["GPU_NUMS"] > 0 else label_true)
label_false_var = Variable(
label_false.cuda() if CONFIG["GPU_NUMS"] > 0 else label_false)
criterion = BCELoss()
true_labels = Variable(t.ones(CONFIG["BATCH_SIZE"]))
fake_labels = Variable(t.zeros(CONFIG["BATCH_SIZE"]))
fix_noises = Variable(t.randn(CONFIG["BATCH_SIZE"], CONFIG["NOISE_DIM"], 1, 1))
noises = Variable(t.randn(CONFIG["BATCH_SIZE"], CONFIG["NOISE_DIM"], 1, 1))
if CONFIG["GPU_NUMS"] > 0:
netD.cuda()
netG.cuda()
criterion.cuda()
true_labels, fake_labels = true_labels.cuda(), fake_labels.cuda()
fix_noises, noises = fix_noises.cuda(), noises.cuda()
proBar = ProgressBar(CONFIG["EPOCHS"], len(dataLoader),
"D Loss:%.3f;G Loss:%.3f")
for epoch in range(1, CONFIG["EPOCHS"] + 1):
if epoch % 30 == 0:
optimizer_discriminator.param_groups[0]['lr'] /= 10
optimizer_generator.param_groups[0]['lr'] /= 10
for ii, (img, _) in enumerate(dataLoader):
real_img = Variable(img.cuda() if CONFIG["GPU_NUMS"] > 1 else img)
if ii % 1 == 0:
# 训练判别器
netD.zero_grad()
## 尽可能的把真图片判别为正确
output = netD(real_img)
error_d_real = criterion(output, true_labels)
error_d_real.backward()
self.hidden = torch.nn.Linear(n_feature, n_hidden) # hidden layer
self.out = torch.nn.Linear(n_hidden, n_output) # output layer
def forward(self, x):
x = F.relu(self.hidden(x)) # activation function for hidden layer
x = self.out(x)
return x
net = Net(n_feature=2, n_hidden=10, n_output=2) # define the network
optimizer = torch.optim.RMSprop(net.parameters(), lr=0.01)
loss_func = torch.nn.CrossEntropyLoss(
) # the target label is NOT an one-hotted
bar = ProgressBar(1, STEPS, "Loss:%.9f, Accuracy:%.3f")
predict = []
myloss = []
N, M = 50, 50 # 横纵各采样多少个值
x1_min, x2_min = x_data.min()
x1_max, x2_max = x_data.max()
t1 = np.linspace(x1_min, x1_max, N)
t2 = np.linspace(x2_min, x2_max, M)
x1, x2 = np.meshgrid(t1, t2) # 生成网格采样点
x_show = np.stack((x1.flat, x2.flat), axis=1) # 测试点
for step in range(STEPS):
out = net(x) # input x and predict based on x
loss = loss_func(
out, y
) # must be (1. nn output, 2. target), the target label is NOT one-hotted
x = x.clamp(0, 1)
x = x.view(x.size(0), 1, 28, 28)
return x
EPOCH = 100
BATCH_SIZE = 128
learning_rate = 1e-3
img_transform = transforms.Compose([
transforms.ToTensor()
# transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
train_data = MNISTDataSetForPytorch(train=True, transform=torchvision.transforms.ToTensor())
train_loader = DataLoader(train_data, batch_size=BATCH_SIZE, shuffle=True)
proBar = ProgressBar(EPOCH, len(train_loader), "loss:%.3f")
class VAE(nn.Module):
def __init__(self):
super(VAE, self).__init__()
self.fc1 = nn.Linear(784, 400)
self.fc21 = nn.Linear(400, 20)
self.fc22 = nn.Linear(400, 20)
self.fc3 = nn.Linear(20, 400)
self.fc4 = nn.Linear(400, 784)
def encode(self, x):
h1 = F.relu(self.fc1(x))
return self.fc21(h1), self.fc22(h1)
self.map3 = Linear(hidden_size, output_size)
def forward(self, x):
x = leaky_relu(self.map1(x), 0.1)
x = leaky_relu(self.map2(x), 0.1)
return sigmoid(self.map3(x))
generator = SimpleMLP(input_size=z_dim, hidden_size=50, output_size=DIMENSION)
discriminator = SimpleMLP(input_size=DIMENSION, hidden_size=100, output_size=1)
if GPU_NUMS > 0:
generator.cuda()
discriminator.cuda()
criterion = BCELoss()
d_optimizer = Adadelta(discriminator.parameters(), lr=1)
g_optimizer = Adadelta(generator.parameters(), lr=1)
progBar = ProgressBar(1, iterations, "D Loss:(real/fake) %.3f/%.3f,G Loss:%.3f")
for train_iter in range(1, iterations + 1):
for d_index in range(3):
# 1. Train D on real+fake
discriminator.zero_grad()
# 1A: Train D on real
real_samples = sample_2d(lut_2d, bs)
d_real_data = Variable(torch.Tensor(real_samples))
if GPU_NUMS > 0:
d_real_data = d_real_data.cuda()
d_real_decision = discriminator(d_real_data)
labels = Variable(torch.ones(bs))
if GPU_NUMS > 0:
labels = labels.cuda()
d_real_loss = criterion(d_real_decision, labels) # ones = true
d_optimizer = torch.optim.Adam(NetD.parameters(), lr=0.001, betas=(0.5, 0.999))
fixed_noise = torch.Tensor(np.zeros((CONFIG["NOISE_DIM"], CONFIG["Z_DIM"])))
fixed_noise_var = torch.autograd.Variable(fixed_noise.cuda() if CONFIG["GPU_NUMS"] > 0 else fixed_noise)
tmp = np.zeros((CONFIG["NOISE_DIM"], CONFIG["CC_DIM"]))
for k in range(10):
tmp[k * 10:(k + 1) * 10, 0] = np.linspace(-2, 2, 10)
fixed_cc = torch.Tensor(tmp)
fixed_cc_var =torch.autograd.Variable(fixed_cc.cuda() if CONFIG["GPU_NUMS"] > 0 else fixed_cc)
tmp = np.zeros((CONFIG["NOISE_DIM"], CONFIG["DC_DIM"]))
for k in range(10):
tmp[k * 10 : (k + 1) * 10, k] = 1
fixed_dc = torch.Tensor(tmp)
fixed_dc_var = torch.autograd.Variable(fixed_dc.cuda() if CONFIG["GPU_NUMS"] > 0 else fixed_dc)
bar = ProgressBar(CONFIG["EPOCH"], len(data_loader), "D Loss:%.3f;G Loss:%.3f")
for epoch in range(1, CONFIG["EPOCH"] + 1):
for i, (images, labels) in enumerate(data_loader):
images = torch.autograd.Variable(images.cuda() if CONFIG["GPU_NUMS"] > 0 else images)
mini_batch = images.size(0)
cc = torch.Tensor(np.random.randn(mini_batch, CONFIG["CC_DIM"]) * 0.5 + 0.0)
cc_var = torch.autograd.Variable(cc.cuda() if CONFIG["GPU_NUMS"] > 0 else cc)
codes=[]
code = np.zeros((mini_batch, CONFIG["DC_DIM"]))
random_cate = np.random.randint(0, CONFIG["DC_DIM"], mini_batch)
code[range(mini_batch), random_cate] = 1
codes.append(code)
codes = np.concatenate(codes,1)
z = z.cuda()
z_test = z_test.cuda()
optimizerD = t.optim.Adam(NetD.parameters(),lr=CONFIG["LEARNING_RATE_D"],betas=(CONFIG["BETA1"],0.999), weight_decay=0)
optimizerG = t.optim.Adam(NetG.parameters(),lr=CONFIG["LEARNING_RATE_G"],betas=(CONFIG["BETA1"],0.999), weight_decay=0)
transform=tv.transforms.Compose([
tv.transforms.Resize((CONFIG["IMAGE_SIZE"], CONFIG["IMAGE_SIZE"])) ,
tv.transforms.ToTensor(),
tv.transforms.Normalize([0.5]*3,[0.5]*3)
])
dataset = dset.ImageFolder(root=CONFIG["DATA_PATH"], transform=transform)
dataloader = t.utils.data.DataLoader(dataset, batch_size=CONFIG["BATCH_SIZE"], shuffle=True)
bar = ProgressBar(CONFIG["EPOCHS"], len(dataloader), "D Loss:%.3f;G Loss:%.3f")
for epoch in range(1, CONFIG["EPOCHS"] + 1):
for i, data_batch in enumerate(dataloader, 0):
for p in NetD.parameters():
p.requires_grad = True
NetD.zero_grad()
images, labels = data_batch
current_batch_size = images.size(0)
images = images.cuda() if CONFIG["GPU_NUMS"] > 0 else images
x.data.resize_as_(images).copy_(images)
y.data.resize_(current_batch_size).fill_(1)
y_pred = NetD(x)
errD_real = criterion(y_pred, y)
errD_real.backward()
D_real = y_pred.data.mean()
labelMat.append(int(lineArr[2])) #添加标签
fr.close() #关闭文件
return dataMat, labelMat
X, Y = loadDataSet()
# data = load_iris()
# X = data.data[data.target != 0]
# y = data.target[data.target != 0]
# y[y == 1] = 0
# y[y == 2] = 1
# Y = y.reshape(-1,1)
X = np.asarray(X)
Y = np.asarray(Y)
Y = Y.reshape(-1, 1)
bar = ProgressBar(1, 1000, "loss:%.3f")
class LogisticRegression(object):
def __init__(self):
self.sigmoid = lambda x: 1. / (1 + np.exp(-x))
def fit(self, X, y):
self.w = np.random.randn(X.shape[1], 1)
for _ in range(10000):
y_pred = self.sigmoid(X @ self.w)
#self.w += 0.01 * X.T @ (y - y_pred) #梯度上升
self.w -= 0.0001 * X.T @ (y_pred - y) # 梯度下降
#bar.show(np.mean(0.5*(y_pred- y)**2))
def predict(self, X):
y_pred = np.round(self.sigmoid(X.dot(self.w)))
x_train = torch.FloatTensor(x_train)
y_train = torch.FloatTensor(y_train)
Net = Sequential(
# BatchNorm1d(num_features=2),
Linear(in_features=2, out_features=10),
ReLU(inplace=True),
Linear(in_features=10, out_features=1),
)
optimizer = RMSprop(Net.parameters(), lr=0.001)
loss_func = MSELoss()
x_data, y_data = Variable(x_train), Variable(y_train)
bar = ProgressBar(1, STEPS, "train_loss:%.9f")
predict = []
myloss = []
for step in range(STEPS):
prediction = Net(x_data)
loss = loss_func(prediction, y_data)
optimizer.zero_grad()
loss.backward()
optimizer.step()
bar.show(1, loss.item())
if (step + 1) % DECAY_STEP == 0:
predict.append(prediction.data.numpy())
myloss.append(loss.item())
train_data = Cifar10DataSetForPytorch(train=True, transform=json["transform"])
train_loader = DataLoader(dataset=train_data,
batch_size=BATCH_SIZE,
shuffle=True)
# 准备网络
model = json["model"](json["pretrained"])
model = torch.nn.DataParallel(
model).cuda() if GPU_NUMS > 1 else torch.nn.DataParallel(model)
optimizer = Adam(model.parameters(), lr=LR)
loss_func = CrossEntropyLoss().cuda() if GPU_NUMS > 0 else CrossEntropyLoss()
# 训练数据
proBar = ProgressBar(EPOCH, len(train_loader), "loss:%.3f,acc:%.3f")
for epoch in range(EPOCH):
for step, (x, y) in enumerate(train_loader):
data = Variable(x.cuda() if GPU_NUMS > 0 else x)
label = Variable(
torch.squeeze(y, dim=1).type(torch.LongTensor).cuda() if
GPU_NUMS > 0 else torch.squeeze(y, dim=1).type(torch.LongTensor))
optimizer.zero_grad()
output = model(data)
loss = loss_func(output, label)
loss.backward()
optimizer.step()
prediction = torch.max(softmax(output), 1)[1]
pred_label = prediction.data.cpu().numpy().squeeze()
"VOC2012", "JPEGImages"),
list_file='utils/voc2012train.txt',
train=True,
transform=[ToTensor()])
train_loader = DataLoader(train_dataset,
batch_size=YOLOv1Config["BATCH_SIZE"],
shuffle=True)
criterion = YOLOv1Loss()
# 优化器
optimizer = SGD(Net.parameters(),
lr=YOLOv1Config["LEARNING_RATE"],
momentum=0.95,
weight_decay=5e-4)
bar = ProgressBar(YOLOv1Config["EPOCHS"],
len(train_loader),
"Loss:%.3f",
current_epoch=FROM_TRAIN_ITER)
if FROM_TRAIN_ITER > 1:
Net.load_state_dict(
torch.load("output/YoloV1_%d.pth" % (FROM_TRAIN_ITER - 1)))
for epoch in range(FROM_TRAIN_ITER, YOLOv1Config["EPOCHS"]):
if epoch == 1:
LEARNING_RATE = 0.0005
if epoch == 2:
LEARNING_RATE = 0.00075
if epoch >= 3 and epoch < 80:
LEARNING_RATE = 0.001
if epoch >= 80 and epoch < 100:
LEARNING_RATE = 0.0001
self.out = nn.Linear(in_features=32 * 7 * 7, out_features=10, bias=False)
def forward(self, x):
x = self.conv1(x)
x = self.conv2(x)
x = x.view(x.size(0), -1)
return self.out(x)
train_data = MNISTDataSetForPytorch(train=True, transform=torchvision.transforms.ToTensor())
train_loader = data.DataLoader(dataset=train_data, batch_size=128,
shuffle=True)
cnn = CNN().cuda() if GPU_NUMS > 0 else CNN()
optimizer = Adam(cnn.parameters(), lr=LR)
loss_func = nn.CrossEntropyLoss().cuda() if GPU_NUMS > 0 else nn.CrossEntropyLoss()
proBar = ProgressBar(EPOCH, len(train_loader), "Loss: %.3f;Accuracy: %.3f")
for epoch in range(EPOCH):
for step, (x,y) in enumerate(train_loader):
b_x = Variable(x.cuda() if GPU_NUMS > 0 else x)
b_y = Variable(y.type(torch.LongTensor).cuda() if GPU_NUMS > 0 else y.type(torch.LongTensor)).squeeze_()
output = cnn(b_x)
loss = loss_func(output, b_y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
prediction = torch.max(F.softmax(output, dim=1), 1)[1]
pred_y = prediction.cpu().data.numpy().squeeze()
target_y = b_y.cpu().data.numpy()
accuracy = sum(pred_y == target_y) / len(target_y)
nn.ReLU(True),
nn.ConvTranspose2d(8, 1, 2, stride=2, padding=1), # b, 1, 28, 28
nn.Tanh()
)
def forward(self, x):
x = self.encoder(x)
x = self.decoder(x)
return x
model = autoencoder().cuda() if torch.cuda.is_available() else autoencoder()
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate,
weight_decay=1e-5)
proBar = ProgressBar(num_epochs, len(dataloader), "loss:%.3f")
for epoch in range(num_epochs):
for data in dataloader:
img, _ = data
img = Variable(img).cuda() if torch.cuda.is_available() else Variable(img)
# ===================forward=====================
output = model(img)
loss = criterion(output, img)
# ===================backward====================
optimizer.zero_grad()
loss.backward()
optimizer.step()
proBar.show(loss.data[0])
if epoch % 10 == 0:
pic = to_img(output.cpu().data)
ReLU(True), Linear(12, 3))
self.decoder = Sequential(Linear(3, 12), ReLU(True), Linear(12, 64),
ReLU(True), Linear(64, 128), ReLU(True),
Linear(128, 28 * 28), Tanh())
def forward(self, x):
x = self.encoder(x)
x = self.decoder(x)
return x
model = autoencoder().cuda() if GPU_NUMS > 0 else autoencoder()
criterion = MSELoss()
optimizer = Adam(model.parameters(), lr=learning_rate, weight_decay=1e-5)
proBar = ProgressBar(EPOCH, len(train_loader), "Loss:%.3f")
for epoch in range(1, EPOCH):
for data in train_loader:
img, _ = data
img = img.view(img.size(0), -1)
img = Variable(img).cuda() if GPU_NUMS > 0 else Variable(img)
# ===================forward=====================
output = model(img)
loss = criterion(output, img)
# ===================backward====================
optimizer.zero_grad()
loss.backward()
optimizer.step()
proBar.show(epoch, loss.item())
# ===================log========================
loss_fn = cross_entropy2d
'''
Data
'''
data_loader = VOCSegDataSet(is_transform=True, img_size=(FCNConfig["IMAGE_SIZE"], FCNConfig["IMAGE_SIZE"]),
augmentations=Compose([RandomRotate(10),
RandomHorizontallyFlip()]), img_norm=True)
train_loader = DataLoader(data_loader, batch_size=FCNConfig["BATCH_SIZE"], shuffle=True)
'''
Train
'''
bar = ProgressBar(FCNConfig["EPOCHS"], len(train_loader), "Loss:%.3f")
for epoch in range(1, FCNConfig["EPOCHS"]):
model.train()
for i, (images, labels) in enumerate(train_loader):
images = Variable(images.cuda() if FCNConfig["GPU_NUMS"] > 0 else images)
labels = Variable(labels.cuda() if FCNConfig["GPU_NUMS"] > 0 else labels)
optimizer.zero_grad()
outputs = model(images)
loss = loss_fn(input=outputs, target=labels)
loss.backward()
optimizer.step()
bar.show(epoch, loss.item())
return BCE + KLD
model = VAE()
if GPU_NUMS > 0:
model.cuda()
reconstruction_function = BCELoss()
reconstruction_function.size_average = False
optimizer = Adam(model.parameters(), lr=1e-4)
dataset = ImageFolder(root='/input/face/64_crop',
transform=Compose([ToTensor()]))
train_loader = DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=True)
bar = ProgressBar(EPOCH, len(train_loader), "Loss:%.3f")
model.train()
train_loss = 0
for epoch in range(EPOCH):
for ii, (image, label) in enumerate(train_loader):
mini_batch = image.shape[0]
data = Variable(image.cuda() if GPU_NUMS > 0 else image)
optimizer.zero_grad()
recon_batch, mu, logvar = model(data)
loss = loss_function(recon_batch, data, mu, logvar)
loss.backward()
train_loss += loss.data[0]
optimizer.step()
bar.show(loss.data[0] / mini_batch)
Weights_L1 = tf.Variable(tf.random_normal([2, 10]))
biases_L1 = tf.Variable(tf.zeros([1, 10]))
Wx_plus_b_L1 = tf.matmul(x, Weights_L1) + biases_L1
L1 = tf.nn.relu(Wx_plus_b_L1)
Weights_L2 = tf.Variable(tf.random_normal([10, 1]))
biases_L2 = tf.Variable(tf.zeros([1, 1]))
prediction = tf.matmul(L1, Weights_L2) + biases_L2
# prediction = tf.nn.tanh(Wx_plus_b_L2)
loss = tf.reduce_mean(tf.square(y - prediction))
train_step = tf.train.AdamOptimizer(0.001).minimize(loss)
predict = []
myloss = []
bar = ProgressBar(1, STEPS, "train_loss:%.9f")
sess = tf.Session()
sess.run(tf.global_variables_initializer())
for step in range(STEPS):
_, train_loss, prediction_value = sess.run([train_step, loss, prediction],
feed_dict={
x: x_train,
y: y_train
})
bar.show(1, train_loss)
if (step + 1) % DECAY_STEP == 0:
predict.append(prediction_value)
myloss.append(train_loss)
fig, ax = plt.subplots()
optimizer = SGD(Net.parameters(), lr=1e-3, momentum=0.9, weight_decay=5e-4)
criterion = MultiBoxLoss().cuda() if GPU_NUMS > 0 else MultiBoxLoss()
Net.train()
loc_loss, conf_loss = 0, 0
dataset = SSDDataSetForPytorch(
transform=Augmentation(),
target_transform=AnnotationTransform(classes=VOC_CLASSES))
data_loader = DataLoader(dataset,
BATCH_SIZE,
shuffle=True,
collate_fn=detection_collate,
pin_memory=True)
epoch_size = len(dataset) // BATCH_SIZE
bar = ProgressBar(EPOCH, len(data_loader), "Loss:%.3f")
for epoch in range(1, EPOCH):
for i, (imgs, targets) in enumerate(data_loader):
imgs = Variable(imgs.cuda() if GPU_NUMS > 0 else imgs)
targets = [anno.cuda() for anno in targets
] if GPU_NUMS > 0 else [anno for anno in targets]
optimizer.zero_grad()
out = Net(imgs)
loss_l, loss_c = criterion(out, targets)
loss = loss_c + loss_l
loss.backward()
optimizer.step()
