import torch
from torch.autograd import Variable

x = torch.ones(1, requires_grad=True)
y = torch.ones(1)
z = x + y

# z = Variable(z.data, requires_grad=True)
w = torch.ones(1, requires_grad=True)
total = w + z

total.backward()
print(x.requires_grad, x.grad)
print(y.requires_grad, y.grad)
print(z.requires_grad, z.grad)
print(w.requires_grad, w.grad)

b = w1 * a
c = w2 * a 
d = (w3 * b) + (w4 * c)
L = f(d)

class ImportGraph():
    """  Importing and running isolated TF graph """
    def __init__(self, loc):
        # Create local graph and use it in the session
        self.graph = tf.Graph()
        config = tf.ConfigProto(log_device_placement=False)
        config.gpu_options.allow_growth = True
        self.sess = tf.Session(graph=self.graph, config=config)
        with self.graph.as_default():
            # Import saved model from location 'loc' into local graph
            saver = tf.train.import_meta_graph(loc + '.meta',
                                               clear_devices=True)
            saver.restore(self.sess, loc)
            # There are TWO options how to get activation operation:
              # FROM SAVED COLLECTION:
            self.logits = self.graph.get_operation_by_name('proj/Reshape_1').outputs[0]
            # self.activation = tf.get_collection('activation')[0]
              # BY NAME:
            # self.activation = self.graph.get_operation_by_name('activation_opt').outputs[0]

    def run(self, fd):
        """ Running the activation operation previously imported """
        return self.sess.run([self.logits],
                             feed_dict=fd)

import tensorflow as tf
class Model:
    def __init__(self,param):
        self.param = param

        # create & build graph
        self.graph = tf.Graph()
        self.build_graph()

        # create session
        config = tf.ConfigProto()
        config.gpu_options.allow_growth = True
        gpu_num = random.choice(cuda_gpu_count())
        config.gpu_options.visible_device_list= str(gpu_num)
        self.sess = tf.Session(config=config,graph=self.graph)

    def build_graph(self):
        with self.graph.as_default():
            ...
    def __del__(self):
        # explicitly collect resources by closing and deleting session and graph
        self.sess.close()
        del self.sess
        del self.graph
        del self.param

    # train models and return the test accuracy
    def train_test(self,train_data,train_label,test_data,test_label):
        ...

if result is None:
    result = temp
else:
    result = torch.cat([result, temp])

# out[out > 0] = 1
# out[out <= 0] = -1
out = (out >= 0.5).float()
# map 1,0 to 1,-1
out = out * 2 - 1

a = list(self.parameters())[0].clone()
loss.backward()
self.optimizer.step()
b = list(self.parameters())[0].clone()
torch.equal(a.data, b.data)

# -*- coding: utf-8 -*-
from __future__ import absolute_import
from __future__ import print_function

import torch.nn as nn
import torch


class Linear(nn.Module):
    def __init__(self, p_dropout=1):
        super(Linear, self).__init__()
        self.dropout = nn.Dropout(p_dropout)

    def forward(self, x):
        y = self.dropout(x)
        return y


net = Linear()
a = torch.ones(4)

net.train()
print(net(a))

net.eval()
b = torch.ones(4)
print(net(b))

class NetALL:
	__init__(self):
		self.net1 = xx
		self.net2 = xx

torch.save(self.net1.dict()) w1:
torch.save(self.dict()) net1.w1:

print(module.training)

class A():
	xxx

class A(object):
	xxx