# tensorflow 内存不够的情况 适用于tensorflow 2.x
import tensorflow as tf

os.environ["CUDA_VISIBLE_DEVICES"] = "0"  # 指定显卡
config = tf.compat.v1.ConfigProto(allow_soft_placement=True)  # 开启软放置，OP放到CPU上了，为啥源码默认值是7？
config.gpu_options.per_process_gpu_memory_fraction = 0.3  # 进程最多采用30%显存，默认是1，完整使用
tf.compat.v1.keras.backend.set_session(tf.compat.v1.Session(config=config))

---------------------------------------------------------------------------
Error                                     Traceback (most recent call last)
<ipython-input-11-787bc11958b4> in get_proxies(urls)
     14         try:
---> 15             raw = base64.b64decode(response)
     16         except Exception as r:

c:\program files\python3\lib\base64.py in b64decode(s, altchars, validate)
     86         raise binascii.Error('Non-base64 digit found')
---> 87     return binascii.a2b_base64(s)
     88 

Error: Incorrect padding

# 对待解码的字段a进行判断，若为4的倍数则不变，反之缺多少补多少
a = a + '=' * (4 - len(a) % 4) if len(a) % 4 != 0 else a

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
from torchsummary import summary

BATCH_SIZE = 512
EPOCH = 20
DEIVCE = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')

train_loader = torch.utils.data.DataLoader(
    datasets.MNIST(
        'data', 
        train=True, 
        download=False,
        transform=transforms.Compose([
            transforms.ToTensor(),
            transforms.Normalize((0.1307,), (0.3081,))
        ])),
    batch_size=BATCH_SIZE, shuffle=True)


test_loader = torch.utils.data.DataLoader(
    datasets.MNIST(
        'data', 
        train=False, 
        transform=transforms.Compose([
            transforms.ToTensor(),
            transforms.Normalize((0.1307,), (0.3081,))
        ])),
    batch_size=BATCH_SIZE, shuffle=True)

class LeNet(nn.Module):
    def __init__(self):
        super(LeNet, self).__init__()
        # nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0,dilation=1,groups=1, bias=True）
        self.conv1 = nn.Conv2d(1, 6, 5)  
        self.pool1 = nn.MaxPool2d(2)
        self.conv2 = nn.Conv2d(6, 16, 3)
        self.pool2 = nn.MaxPool2d(2)
        # nn.Linear(in_features, out_features, bias=True)
        self.fc1   = nn.Linear(16*5*5, 120)
        self.fc2   = nn.Linear(120, 84)
        self.fc3   = nn.Linear(84, 10)
        
    def forward(self, x):
        out = F.relu(self.conv1(x))  # 24
        # nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1,return_indices=False,ceil_mode=False)
        # max_pool2d(*args, **kwargs)
        out = self.pool1(out)  # 12
        out = F.relu(self.conv2(out))  # 10
        out = self.pool2(out)  # 5
        out = out.view(out.size(0), -1)  # flatten
        out = F.relu(self.fc1(out))
        out = F.relu(self.fc2(out))
        out = self.fc3(out)
        out = F.log_softmax(out,dim=1)
        return out

model = LeNet()
summary(model, (1,28,28))  

model = LeNet().to(device)
optimizer = optim.Adam(model.parameters())

def train(device, model, train_loader, optimizer, epoch):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()  # zero all gradients
        output = model(data)
        loss = F.nll_loss(output, target)  # calculate loss
        loss.backward()
        optimizer.step()  # update all parameters
        if (batch_idx + 1) % 30 == 0:
            print(f"Train Epoch {epoch} [{batch_idx * len(data)}/{len(train_loader.dataset)} Loss: {loss.item():.6f}]")


def test(device, model, test_loader):
    model.eval()
    test_loss = 0
    correct = 0
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)  # predict class probability
            test_loss += F.nll_loss(output, target, reduction='sum').item()  # superposition whole batch loss
            pred = output.max(1, keepdim=True)[1]  # return max probability index
            correct += pred.eq(target.view_as(pred)).sum().item()

    test_loss /= len(test_loader.dataset)
    print(f'\nTest Epoch: Average loss: {test_loss:.4f}, Accuracy: {correct}/{len(test_loader.dataset)} ({100. * correct / len(test_loader.dataset):.2f}%)\n')

def vae_loss(x, x_decoded_mean):
    xent_loss = original_dim * losses.binary_crossentropy(x, x_decoded_mean)
    print(type(xent_loss))
    kl_loss = -0.5 * K.sum(1 + z_log_var - K.square(z_mean) - K.exp(z_log_var), axis=-1)
    print(type(kl_loss))
    return xent_loss + kl_loss

xent_loss --> tensorflow.python.framework.ops.Tensor
kl_loss --> tensorflow.python.keras.engine.keras_tensor.KerasTensor

Tensor+KerasTensor = KerasTensor

# 一般情况下采用该代码能够解决问题，可以发现函数返回结果已经转化成tensorflow.python.framework.ops.Tensor类了
from tensorflow.python.framework.ops import disable_eager_execution
disable_eager_execution()

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

import tensorflow as tf