diff --git a/Note 7.0 pv documentation/DL/neural network/pytorch/nn.py b/7.0/models/DL/pytorch/non_parallel/nn.py similarity index 95% rename from Note 7.0 pv documentation/DL/neural network/pytorch/nn.py rename to 7.0/models/DL/pytorch/non_parallel/nn.py index d04986b4..1faec0fc 100644 --- a/Note 7.0 pv documentation/DL/neural network/pytorch/nn.py +++ b/7.0/models/DL/pytorch/non_parallel/nn.py @@ -50,4 +50,4 @@ def backward(self,loss): #backward function,kernel uses it for backpropagation. def opt(self): #opt function,kernel uses it to optimize. self.optim.step() - return + return \ No newline at end of file diff --git a/7.0/models/DL/pytorch/parallel/nn.py b/7.0/models/DL/pytorch/parallel/nn.py new file mode 100644 index 00000000..d9b05567 --- /dev/null +++ b/7.0/models/DL/pytorch/parallel/nn.py @@ -0,0 +1,41 @@ +import torch # import the PyTorch library +from torch import nn # import the neural network module from PyTorch + +class NeuralNetwork(nn.Module): # define a class for the neural network model + def __init__(self): # define the constructor method + super().__init__() # call the parent class constructor + self.flatten = nn.Flatten() # define a layer to flatten the input + self.linear_relu_stack=nn.Sequential( # define a stack of linear and relu layers + nn.Linear(28*28,512), # a linear layer with 28*28 input features and 512 output features + nn.ReLU(), # a relu activation function + nn.Linear(512,512), # another linear layer with 512 input and output features + nn.ReLU(), # another relu activation function + nn.Linear(512,10) # a final linear layer with 512 input features and 10 output features + ) + + + def forward(self,x): # define the forward method + x = self.flatten(x) # flatten the input x + logits=self.linear_relu_stack(x) # pass x through the linear relu stack and get the logits + return logits # return the logits + + +class neuralnetwork: # define another class for the neural network object + def __init__(self): # define the constructor method + if torch.cuda.is_available(): # check if cuda is available + self.device=torch.device('cuda') # set the device to cuda + else: + self.device=torch.device('cpu') # otherwise set the device to cpu + self.model=NeuralNetwork().to(self.device) # create an instance of the NeuralNetwork class and move it to the device + self.loss_fn=nn.CrossEntropyLoss() # define the loss function as cross entropy loss + self.opt=[torch.optim.SGD(self.model.parameters(),lr=1e-3) for _ in range(7)] # define a list of three stochastic gradient descent optimizers with learning rate 1e-3 + + + def fp(self,x): # define a method for forward propagation + pred=self.model(x.to(self.device)) # get the predictions from the model by passing x to the device + return pred # return the predictions + + + def loss(self,output,labels): # define a method for calculating the loss + loss=self.loss_fn(output,labels.to(self.device)) # compute the loss by passing output and labels to the device + return loss # return the loss \ No newline at end of file diff --git a/7.0/models/DL/pytorch/parallel/nn_device.py b/7.0/models/DL/pytorch/parallel/nn_device.py new file mode 100644 index 00000000..ad4b8069 --- /dev/null +++ b/7.0/models/DL/pytorch/parallel/nn_device.py @@ -0,0 +1,45 @@ +import torch # import the PyTorch library +from torch import nn # import the neural network module from PyTorch +from Note.nn.parallel.assign_device_pytorch import assign_device # import a custom function to assign device for PyTorch tensors + + +class NeuralNetwork(nn.Module): # define a class for the neural network model + def __init__(self): # define the constructor method + super().__init__() # call the parent class constructor + self.flatten = nn.Flatten() # define a layer to flatten the input tensor + self.linear_relu_stack=nn.Sequential( # define a stack of linear and relu layers + nn.Linear(28*28,512), # define a linear layer with input size 28*28 and output size 512 + nn.ReLU(), # define a relu activation function + nn.Linear(512,512), # define another linear layer with input and output size 512 + nn.ReLU(), # define another relu activation function + nn.Linear(512,10) # define the final linear layer with output size 10 + ) + + + def forward(self,x): # define the forward method for the model + x = self.flatten(x) # flatten the input tensor + logits=self.linear_relu_stack(x) # pass the flattened tensor through the linear relu stack + return logits # return the logits as the output + + +class neuralnetwork: # define another class for the neural network object + def __init__(self): # define the constructor method + if torch.cuda.is_available(): # check if cuda device is available + self.device=torch.device('cuda') # set the device to cuda + else: # otherwise + self.device=torch.device('cpu') # set the device to cpu + self.model=NeuralNetwork().to(self.device) # create an instance of the neural network model and move it to the device + self.loss_fn=nn.CrossEntropyLoss() # define the loss function as cross entropy loss + self.opt=[torch.optim.SGD(self.model.parameters(),lr=1e-3) for _ in range(7)] # define a list of optimizers as stochastic gradient descent with learning rate 1e-3 + + + def fp(self,x,p): # define a method for forward propagation + pred=self.model(x.to(assign_device(p,'GPU'))) # assign the device according to the process index p + # get the predictions from the model by passing the input tensor to the device and then to the model + return pred # return the predictions + + + def loss(self,output,labels,p): # define a method for calculating loss + loss=self.loss_fn(output,labels.to(assign_device(p,'GPU'))) # assign the device according to the process index p + # calculate the loss by passing the output and labels tensors to the device and then to the loss function + return loss # return the loss \ No newline at end of file diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/cnn.py b/7.0/models/DL/tensorflow/non_parallel/cnn.py similarity index 93% rename from Note 7.0 pv documentation/DL/neural network/tensorflow/cnn.py rename to 7.0/models/DL/tensorflow/non_parallel/cnn.py index 93a2aef1..bd7ad1bf 100644 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/cnn.py +++ b/7.0/models/DL/tensorflow/non_parallel/cnn.py @@ -24,4 +24,4 @@ def fp(self,data): def loss(self,output,labels): loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) - return loss(labels,output) + return loss(labels,output) \ No newline at end of file diff --git a/7.0/models/DL/tensorflow/non_parallel/layer/cnn.py b/7.0/models/DL/tensorflow/non_parallel/layer/cnn.py new file mode 100644 index 00000000..cf396557 --- /dev/null +++ b/7.0/models/DL/tensorflow/non_parallel/layer/cnn.py @@ -0,0 +1,48 @@ +import tensorflow as tf +from Note.nn.layer.conv2d import conv2d +from Note.nn.layer.dense import dense +from Note.nn.layer.flatten import flatten +from Note.nn.Model import Model + +""" +This is an example of using the Note layer module. +""" + +# Define a convolutional neural network class +class cnn: + def __init__(self): + # Initialize the loss function and the optimizer + self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) + self.opt=tf.keras.optimizers.Adam() + + + def build(self): + # Create three convolutional layers with relu activations + self.conv1=conv2d(32,[3,3],strides=(1,1),padding='SAME',activation='relu') + self.conv2=conv2d(64,[3,3],strides=(2,2),padding='SAME',activation='relu') + self.conv3=conv2d(64,[3,3],strides=(1,1),padding='SAME',activation='relu') + self.flatten=flatten() + # Create two dense layers with relu and linear activations + self.dense1=dense(64,activation='relu') + self.dense2=dense(10) + # Store the parameters of the layers in a list + self.param=Model.param + return + + + def fp(self,data): + # Perform forward propagation on the input data + x=self.conv1(data) # First convolutional layer + x=tf.nn.max_pool2d(x,ksize=(2,2),strides=(2,2),padding='VALID') # First max pooling layer + x=self.conv2(x) # Second convolutional layer + x=tf.nn.max_pool2d(x,ksize=(2,2),strides=(2,2),padding='VALID') # Second max pooling layer + x=self.conv3(x) # Third convolutional layer + x=self.flatten(x) # Flatten the output to a vector + x=self.dense1(x) # First dense layer with relu activation + output=self.dense2.output(x) # Output layer with linear activation + return output + + + def loss(self,output,labels): + # Compute the loss between the output and the labels + return self.loss_object(labels,output) \ No newline at end of file diff --git a/7.0/models/DL/tensorflow/non_parallel/layer/nn.py b/7.0/models/DL/tensorflow/non_parallel/layer/nn.py new file mode 100644 index 00000000..7dc63176 --- /dev/null +++ b/7.0/models/DL/tensorflow/non_parallel/layer/nn.py @@ -0,0 +1,38 @@ +import tensorflow as tf +from Note.nn.layer.dense import dense +from Note.nn.layer.flatten import flatten +from Note.nn.Model import Model + +""" +This is an example of using the Note layer module. +""" + +# Define a neural network class +class nn: + def __init__(self): + # Initialize the loss function and the optimizer + self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) + self.opt=tf.keras.optimizers.Adam() #optimizer,kernel uses it to optimize. + + + def build(self): + # Create two dense layers with relu and linear activations + self.layer1=dense(128,activation='relu') + self.layer2=dense(10) + self.flatten=flatten() + # Store the parameters of the layers in a list + self.param=Model.param + return + + + def fp(self,data): + # Perform forward propagation on the input data + data=self.flatten(data) + output1=self.layer1(data) + output2=self.layer2(output1) + return output2 + + + def loss(self,output,labels): + # Compute the loss between the output and the labels + return self.loss_object(labels,output) \ No newline at end of file diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/nn.py b/7.0/models/DL/tensorflow/non_parallel/nn.py similarity index 92% rename from Note 7.0 pv documentation/DL/neural network/tensorflow/nn.py rename to 7.0/models/DL/tensorflow/non_parallel/nn.py index 031b75c0..b4f03a92 100644 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/nn.py +++ b/7.0/models/DL/tensorflow/non_parallel/nn.py @@ -20,4 +20,4 @@ def fp(self,data): #forward propagation function,kernel uses it for forward pro def loss(self,output,labels): #loss functino,kernel uses it to calculate loss. - return self.loss_object(labels,output) + return self.loss_object(labels,output) \ No newline at end of file diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/nn_acc.py b/7.0/models/DL/tensorflow/non_parallel/nn_acc.py similarity index 93% rename from Note 7.0 pv documentation/DL/neural network/tensorflow/nn_acc.py rename to 7.0/models/DL/tensorflow/non_parallel/nn_acc.py index 5574e102..0a726603 100644 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/nn_acc.py +++ b/7.0/models/DL/tensorflow/non_parallel/nn_acc.py @@ -25,4 +25,4 @@ def loss(self,output,labels): #loss functino,kernel uses it to calculate loss. def accuracy(self,output,labels): #accuracy function,kernel uses it to calculate accuracy. - return self.train_accuracy(labels,output) + return self.train_accuracy(labels,output) \ No newline at end of file diff --git a/7.0/models/DL/tensorflow/non_parallel/nn_ol.py b/7.0/models/DL/tensorflow/non_parallel/nn_ol.py new file mode 100644 index 00000000..9dfa608d --- /dev/null +++ b/7.0/models/DL/tensorflow/non_parallel/nn_ol.py @@ -0,0 +1,37 @@ +import tensorflow as tf # import TensorFlow library +import numpy as np # import NumPy library + +# This is an example of online training. +class nn: # define a class for the neural network + def __init__(self,data,labels): # initialize the network with data and labels + self.train_data=data # store the training data + self.train_labels=labels # store the training labels + self.model=tf.keras.models.Sequential([ # create a sequential model with four layers + tf.keras.layers.Flatten(input_shape=(28, 28)), # flatten the input to a vector of 28*28 elements + tf.keras.layers.Dense(128,activation='relu'), # add a dense layer with 128 units and ReLU activation + tf.keras.layers.Dropout(0.2), # add a dropout layer with 0.2 dropout rate to prevent overfitting + tf.keras.layers.Dense(10) # add a dense layer with 10 units for the output logits + ]) + self.param=self.model.weights # parameter list, kernel uses it list for backpropagation + self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) # loss object, kernel uses it to calculate loss. Here we use sparse categorical crossentropy with logits as output + self.opt=tf.keras.optimizers.Adam() # optimizer, kernel uses it to optimize. Here we use Adam optimizer + self.train_loss_list=[] # a list to store the training loss values + self.counter=0 # counter to keep track of the number of online updates + self.max_length=1000 # maximum length of train_loss_list + + + def online(self): # This is simulative online function, kernel uses it to get online data and labels + index=np.random.choice(60000,size=[32]) # randomly sample 32 indices from 0 to 59999 + if self.counter==10000: # if the counter reaches 10000, stop the online training + return 'stop' + else: # otherwise, return the data and labels corresponding to the sampled indices + return [self.train_data[index],self.train_labels[index]] + + + def fp(self,data): # forward propagation function, kernel uses it for forward propagation + output=self.model(data) # pass the data through the model and get the output logits + return output + + + def loss(self,output,labels): # loss function, kernel uses it to calculate loss + return self.loss_object(labels,output) # return the sparse categorical crossentropy loss between labels and output \ No newline at end of file diff --git a/7.0/models/DL/tensorflow/parallel/cnn.py b/7.0/models/DL/tensorflow/parallel/cnn.py new file mode 100644 index 00000000..6e084ee8 --- /dev/null +++ b/7.0/models/DL/tensorflow/parallel/cnn.py @@ -0,0 +1,51 @@ +import tensorflow as tf +from Note.nn.layer.conv2d import conv2d +from Note.nn.layer.dense import dense +from Note.nn.layer.flatten import flatten +from Note.nn.parallel.optimizer import Adam +from Note.nn.Model import Model + +# Define a convolutional neural network class +class cnn: + def __init__(self): + # Initialize the loss function and the optimizer + self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) + + + def build(self): + # Create three convolutional layers with relu activations + self.conv1=conv2d(32,[3,3],3,strides=(1,1),padding='SAME',activation='relu') + self.conv2=conv2d(64,[3,3],32,strides=(2,2),padding='SAME',activation='relu') + self.conv3=conv2d(64,[3,3],64,strides=(1,1),padding='SAME',activation='relu') + self.flatten=flatten() + # Create two dense layers with relu and linear activations + self.dense1=dense(64,64,activation='relu') + self.dense2=dense(10,64) + self.optimizer=Adam() + # Store the parameters of the layers in a list + self.param=Model.param + return + + + def fp(self,data): + # Perform forward propagation on the input data + x=self.conv1(data) # First convolutional layer + x=tf.nn.max_pool2d(x,ksize=(2,2),strides=(2,2),padding='VALID') # First max pooling layer + x=self.conv2(x) # Second convolutional layer + x=tf.nn.max_pool2d(x,ksize=(2,2),strides=(2,2),padding='VALID') # Second max pooling layer + x=self.conv3(x) # Third convolutional layer + x=self.flatten(x) # Flatten the output to a vector + x=self.dense1(x) # First dense layer with relu activation + output=self.dense2.output(x) # Output layer with linear activation + return output + + + def loss(self,output,labels): + # Compute the loss between the output and the labels + return self.loss_object(labels,output) + + + def opt(self,gradient): + # Perform optimization on the parameters using the gradient and the batch count + param=self.optimizer(gradient,self.param,self.bc[0]) + return param \ No newline at end of file diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/process/nn.py b/7.0/models/DL/tensorflow/parallel/nn.py similarity index 61% rename from Note 7.0 pv documentation/DL/neural network/tensorflow/process/nn.py rename to 7.0/models/DL/tensorflow/parallel/nn.py index 24c65772..db171189 100644 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/process/nn.py +++ b/7.0/models/DL/tensorflow/parallel/nn.py @@ -1,30 +1,32 @@ import tensorflow as tf -import Note.nn.layer.dense as d -import Note.nn.process.optimizer as o +from Note.nn.layer.dense import dense +from Note.nn.parallel.optimizer import SGD from Note.nn.layer.flatten import flatten +from Note.nn.Model import Model # Define a neural network class class nn: def __init__(self): # Initialize the loss function and the optimizer self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) - self.optimizer=o.Momentum(0.07,0.7) def build(self): # Create two dense layers with relu and linear activations - self.layer1=d.dense([784,128],activation='relu') - self.layer2=d.dense([128,10]) + self.layer1=dense(128,784,activation='relu') + self.layer2=dense(10,128) + self.flatten=flatten() + self.optimizer=SGD() # Store the parameters of the layers in a list - self.param=[self.layer1.param,self.layer2.param] + self.param=Model.param return def fp(self,data): # Perform forward propagation on the input data - data=flatten(data) - output1=self.layer1.output(data) - output2=self.layer2.output(output1) + data=self.flatten(data) + output1=self.layer1(data) + output2=self.layer2(output1) return output2 @@ -35,5 +37,5 @@ def loss(self,output,labels): def opt(self,gradient): # Perform optimization on the parameters using the gradient - param=self.optimizer.opt(gradient,self.param) - return param + param=self.optimizer(gradient,self.param) + return param \ No newline at end of file diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/process/nn_acc.py b/7.0/models/DL/tensorflow/parallel/nn_acc.py similarity index 60% rename from Note 7.0 pv documentation/DL/neural network/tensorflow/process/nn_acc.py rename to 7.0/models/DL/tensorflow/parallel/nn_acc.py index c33b7795..cd3c8026 100644 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/process/nn_acc.py +++ b/7.0/models/DL/tensorflow/parallel/nn_acc.py @@ -1,31 +1,33 @@ import tensorflow as tf -import Note.nn.layer.dense as d -import Note.nn.process.optimizer as o +from Note.nn.layer.dense import dense +from Note.nn.parallel.optimizer import SGD from Note.nn.layer.flatten import flatten +from Note.nn.accuracy import sparse_categorical_accuracy +from Note.nn.Model import Model # Define a neural network class class nn: def __init__(self): # Initialize the loss function and the optimizer self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) - self.train_accuracy=tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy') - self.optimizer=o.Momentum(0.07,0.7) def build(self): # Create two dense layers with relu and linear activations - self.layer1=d.dense([784,128],activation='relu') - self.layer2=d.dense([128,10]) + self.layer1=dense(128,784,activation='relu') + self.layer2=dense(10,128) + self.flatten=flatten() + self.optimizer=SGD() # Store the parameters of the layers in a list - self.param=[self.layer1.param,self.layer2.param] + self.param=Model.param return def fp(self,data): # Perform forward propagation on the input data - data=flatten(data) - output1=self.layer1.output(data) - output2=self.layer2.output(output1) + data=self.flatten(data) + output1=self.layer1(data) + output2=self.layer2(output1) return output2 @@ -35,10 +37,10 @@ def loss(self,output,labels): def accuracy(self,output,labels): #accuracy function,kernel uses it to calculate accuracy. - return self.train_accuracy(labels,output) + return sparse_categorical_accuracy(labels,output) def opt(self,gradient): # Perform optimization on the parameters using the gradient - param=self.optimizer.opt(gradient,self.param) + param=self.optimizer(gradient,self.param) return param \ No newline at end of file diff --git a/7.0/models/DL/tensorflow/parallel/nn_attenuate.py b/7.0/models/DL/tensorflow/parallel/nn_attenuate.py new file mode 100644 index 00000000..41f77f62 --- /dev/null +++ b/7.0/models/DL/tensorflow/parallel/nn_attenuate.py @@ -0,0 +1,56 @@ +import tensorflow as tf +from tensorflow.python.util import nest +from Note.nn.layer.dense import dense +from Note.nn.parallel.optimizer import SGD +from Note.nn.layer.flatten import flatten +from Note.nn.accuracy import sparse_categorical_accuracy +from Note.nn.Model import Model + +# Define a neural network class with gradient attenuation +class nn: + def __init__(self): + # Initialize the loss function and the optimizer + self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) + + + def build(self): + # Create two dense layers with relu and linear activations + self.layer1=dense(128,784,activation='relu') + self.layer2=dense(10,128) + self.flatten=flatten() + self.optimizer=SGD() + # Store the parameters of the layers in a list + self.param=Model.param + return + + + def fp(self,data): + # Perform forward propagation on the input data + data=self.flatten(data) # Flatten the data to a one-dimensional vector + output1=self.layer1(data) # Apply the first layer to the data and get the output + output2=self.layer2(output1) # Apply the second layer to the output of the first layer and get the final output + return output2 + + + def loss(self,output,labels): + # Compute the loss between the output and the labels + return self.loss_object(labels,output) # Use the loss function to calculate the loss + + + def accuracy(self,output,labels): #accuracy function,kernel uses it to calculate accuracy. + return sparse_categorical_accuracy(labels,output) + + + def attenuate(self,gradient,p): #gradient attenuation function,kernel uses it to calculate attenuation coefficient. + # Apply an exponential decay to the gradient based on the optimization counter + ac=0.9**self.opt_counter[0][p] #ac:attenuation coefficient + gradient_flat=nest.flatten(gradient) # Flatten the gradient to a one-dimensional vector + for i in range(len(gradient_flat)): #self.opt_counter:optimization counter + gradient_flat[i]=tf.cast(ac,gradient_flat[i].dtype)*gradient_flat[i] #p:process number + return gradient + + + def opt(self,gradient): + # Perform optimization on the parameters using the gradient + param=self.optimizer(gradient,self.param) # Use the optimizer to update the parameters + return param \ No newline at end of file diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/process/nn_clipping.py b/7.0/models/DL/tensorflow/parallel/nn_clipping.py similarity index 69% rename from Note 7.0 pv documentation/DL/neural network/tensorflow/process/nn_clipping.py rename to 7.0/models/DL/tensorflow/parallel/nn_clipping.py index eb4d374b..4929a49b 100644 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/process/nn_clipping.py +++ b/7.0/models/DL/tensorflow/parallel/nn_clipping.py @@ -1,31 +1,33 @@ import tensorflow as tf -import Note.nn.layer.dense as d -import Note.nn.process.optimizer as o +from Note.nn.layer.dense import dense +from Note.nn.parallel.optimizer import SGD from Note.nn.layer.flatten import flatten from Note.nn.gradient_clipping import gradient_clipping +from Note.nn.Model import Model # Define a neural network class class nn: def __init__(self): # Initialize the loss function and the optimizer self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) - self.optimizer=o.Momentum(0.07,0.7) def build(self): # Create two dense layers with relu and linear activations - self.layer1=d.dense([784,128],activation='relu') - self.layer2=d.dense([128,10]) + self.layer1=dense(128,784,activation='relu') + self.layer2=dense(10,128) + self.flatten=flatten() + self.optimizer=SGD() # Store the parameters of the layers in a list - self.param=[self.layer1.param,self.layer2.param] + self.param=Model.param return def fp(self,data): # Perform forward propagation on the input data - data=flatten(data) - output1=self.layer1.output(data) - output2=self.layer2.output(output1) + data=self.flatten(data) + output1=self.layer1(data) + output2=self.layer2(output1) return output2 @@ -43,5 +45,5 @@ def gradient(self,tape,loss): def opt(self,gradient): # Perform optimization on the parameters using the gradient - param=self.optimizer.opt(gradient,self.param) - return param + param=self.optimizer(gradient,self.param) + return param \ No newline at end of file diff --git a/7.0/models/DL/tensorflow/parallel/nn_device.py b/7.0/models/DL/tensorflow/parallel/nn_device.py new file mode 100644 index 00000000..7935af2e --- /dev/null +++ b/7.0/models/DL/tensorflow/parallel/nn_device.py @@ -0,0 +1,50 @@ +import tensorflow as tf # import TensorFlow library +from Note.nn.layer.dense import dense # import dense layer class +from Note.nn.layer.flatten import flatten # import Note's flatten layer function +from Note.nn.parallel.optimizer import SGD # import Note's momentum optimizer module +from Note.nn.parallel.assign_device import assign_device # import the function to assign device according to the process index and the device type +from Note.nn.Model import Model + + +class nn: # A neural network class example, allocate device for multiple threads + def __init__(self): # initialize the network + self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) # loss object, kernel uses it to calculate loss. Here we use sparse categorical crossentropy with logits as output + + + def build(self): # build function, kernel uses it to create the network layers + # Create two dense layers with relu and linear activations + self.layer1=dense(128,784,activation='relu') # the first layer with 784 input units and 128 output units and ReLU activation + self.layer2=dense(10,128) # the second layer with 128 input units and 10 output units and linear activation + self.flatten=flatten() + self.optimizer=SGD() + # Store the parameters of the layers in a list + self.param=Model.param # parameter list of both layers, kernel uses it list for backpropagation + return + + + def fp(self,data,p): # forward propagation function, kernel uses it for forward propagation + with tf.device(assign_device(p,'GPU')): # assign the device according to the process index p + data=self.flatten(data) # flatten the data to a vector of 784 elements + output1=self.layer1(data) # pass the data through the first layer and get the output + output2=self.layer2(output1) # pass the output of the first layer through the second layer and get the final output logits + return output2 + + + def loss(self,output,labels,p): # loss function, kernel uses it to calculate loss + with tf.device(assign_device(p,'GPU')): # assign the device according to the process index p + return self.loss_object(labels,output) # return the mean softmax cross entropy loss between labels and output + + + def GradientTape(self,data,labels,p): + with tf.device(assign_device(p,'GPU')): + with tf.GradientTape(persistent=True) as tape: + output=self.fp(data,p) + loss=self.loss(output,labels,p) + return tape,output,loss + + + def opt(self,gradient,p): # optimization function, kernel uses it to optimize parameter + # Perform optimization on the parameters using the gradient + with tf.device(assign_device(p,'GPU')): # assign the device according to the process index p + param=self.optimizer(gradient,self.param) # apply the Note's momentum optimizer to update the parameters using the gradient + return param \ No newline at end of file diff --git a/Note 7.0 pv documentation/RL/neural network/pytorch/DDPG.py b/7.0/models/RL/pytorch/non_parallel/DDPG.py similarity index 91% rename from Note 7.0 pv documentation/RL/neural network/pytorch/DDPG.py rename to 7.0/models/RL/pytorch/non_parallel/DDPG.py index 04953dd7..238a27d2 100644 --- a/Note 7.0 pv documentation/RL/neural network/pytorch/DDPG.py +++ b/7.0/models/RL/pytorch/non_parallel/DDPG.py @@ -1,6 +1,5 @@ import torch import torch.nn.functional as F -import numpy as np import gym @@ -36,7 +35,7 @@ def __init__(self,hidden_dim,sigma,gamma,tau,actor_lr,critic_lr): self.device=torch.device('cuda') else: self.device=torch.device('cpu') - self.genv=gym.make('Pendulum-v0') + self.genv=gym.make('Pendulum-v1') state_dim=self.genv.observation_space.shape[0] action_dim=self.genv.action_space.shape[0] action_bound=self.genv.action_space.high[0] @@ -53,10 +52,6 @@ def __init__(self,hidden_dim,sigma,gamma,tau,actor_lr,critic_lr): self.critic_opt=torch.optim.Adam(self.critic.parameters(),lr=critic_lr) - def noise(self): - return np.random.normal(scale=self.sigma) - - def env(self,a=None,initial=None): if initial==True: state=self.genv.reset(seed=0) @@ -76,14 +71,13 @@ def loss(self,s,a,next_s,r,d): q_target=r+self.gamma*next_q_value*(1-d) actor_loss=-torch.mean(self.critic(s,self.actor(s))) critic_loss=F.mse_loss(self.critic(s,a),q_target) - return [actor_loss,critic_loss] + return actor_loss+critic_loss def backward(self,loss): self.actor_opt.zero_grad() - loss[0].backward() self.critic_opt.zero_grad() - loss[1].backward() + loss.backward() return diff --git a/Note 7.0 pv documentation/RL/neural network/pytorch/DQN.py b/7.0/models/RL/pytorch/non_parallel/DQN.py similarity index 96% rename from Note 7.0 pv documentation/RL/neural network/pytorch/DQN.py rename to 7.0/models/RL/pytorch/non_parallel/DQN.py index b0bfc089..a0e58689 100644 --- a/Note 7.0 pv documentation/RL/neural network/pytorch/DQN.py +++ b/7.0/models/RL/pytorch/non_parallel/DQN.py @@ -61,4 +61,4 @@ def opt(self): #opt function,kernel uses it to optimize. def update_param(self): #update function,kernel uses it to update parameter. self.target_q_net.load_state_dict(self.nn.state_dict()) - return + return \ No newline at end of file diff --git a/Note 7.0 pv documentation/RL/neural network/pytorch/DQN_pr.py b/7.0/models/RL/pytorch/non_parallel/DQN_pr.py similarity index 95% rename from Note 7.0 pv documentation/RL/neural network/pytorch/DQN_pr.py rename to 7.0/models/RL/pytorch/non_parallel/DQN_pr.py index f680cd24..763a47fd 100644 --- a/Note 7.0 pv documentation/RL/neural network/pytorch/DQN_pr.py +++ b/7.0/models/RL/pytorch/non_parallel/DQN_pr.py @@ -25,7 +25,7 @@ def __init__(self,state_dim,hidden_dim,action_dim): self.nn=Qnet(state_dim,hidden_dim,action_dim).to(self.device) self.target_q_net=Qnet(state_dim,hidden_dim,action_dim).to(self.device) self.pr=pr.pr() - self.initial_TD=7 + self.initial_TD=7. self._epsilon=0.0007 self.alpha=0.7 self.optimizer=torch.optim.Adam(self.nn.parameters(),lr=2e-3) diff --git a/Note 7.0 pv documentation/RL/neural network/pytorch/DoubleDQN.py b/7.0/models/RL/pytorch/non_parallel/DoubleDQN.py similarity index 96% rename from Note 7.0 pv documentation/RL/neural network/pytorch/DoubleDQN.py rename to 7.0/models/RL/pytorch/non_parallel/DoubleDQN.py index 48942acd..31e606e8 100644 --- a/Note 7.0 pv documentation/RL/neural network/pytorch/DoubleDQN.py +++ b/7.0/models/RL/pytorch/non_parallel/DoubleDQN.py @@ -62,4 +62,4 @@ def opt(self): def update_param(self): self.target_q_net.load_state_dict(self.nn.state_dict()) - return + return \ No newline at end of file diff --git a/Note 7.0 pv documentation/RL/neural network/pytorch/DuelingDQN.py b/7.0/models/RL/pytorch/non_parallel/DuelingDQN.py similarity index 96% rename from Note 7.0 pv documentation/RL/neural network/pytorch/DuelingDQN.py rename to 7.0/models/RL/pytorch/non_parallel/DuelingDQN.py index 5e51792a..b81eeb37 100644 --- a/Note 7.0 pv documentation/RL/neural network/pytorch/DuelingDQN.py +++ b/7.0/models/RL/pytorch/non_parallel/DuelingDQN.py @@ -64,4 +64,4 @@ def opt(self): def update_param(self): self.target_q_net.load_state_dict(self.nn.state_dict()) - return + return \ No newline at end of file diff --git a/7.0/models/RL/pytorch/parallel/DQN.py b/7.0/models/RL/pytorch/parallel/DQN.py new file mode 100644 index 00000000..f4d8417d --- /dev/null +++ b/7.0/models/RL/pytorch/parallel/DQN.py @@ -0,0 +1,65 @@ +import torch +import gym +import torch.nn.functional as F +from Note.nn.parallel.assign_device_pytorch import assign_device + + +class Qnet(torch.nn.Module): + def __init__(self,state_dim,hidden_dim,action_dim): + super(Qnet,self).__init__() + self.fc1=torch.nn.Linear(state_dim,hidden_dim) + self.fc2=torch.nn.Linear(hidden_dim,action_dim) + + + def forward(self,x): + x=F.relu(self.fc1(x)) + return self.fc2(x) + + +class DQN: + def __init__(self,state_dim,hidden_dim,action_dim): + if torch.cuda.is_available(): + self.device=torch.device('cuda') + else: + self.device=torch.device('cpu') + self.nn=Qnet(state_dim,hidden_dim,action_dim).to(self.device) + self.target_q_net=Qnet(state_dim,hidden_dim,action_dim).to(self.device) + self.optimizer=[torch.optim.Adam(self.nn.parameters(),lr=2e-3) for _ in range(5)] #optimizer,kernel uses it to optimize. + self.genv=[gym.make('CartPole-v0') for _ in range(5)] #create environment + + + def env(self,a=None,p=None,initial=None): #environment function,kernel uses it to interact with the environment. + if initial==True: + state=self.genv[p].reset() + return state + else: + next_state,reward,done,_=self.genv[p].step(a) + return next_state,reward,done + + + def loss(self,s,a,next_s,r,d,p): #loss function,kernel uses it to calculate loss. + s=torch.tensor(s,dtype=torch.float).to(assign_device(p,'GPU')) + a=torch.tensor(a,dtype=torch.int64).view(-1,1).to(assign_device(p,'GPU')) + next_s=torch.tensor(next_s,dtype=torch.float).to(assign_device(p,'GPU')) + r=torch.tensor(r,dtype=torch.float).view(-1,1).to(assign_device(p,'GPU')) + d=torch.tensor(d,dtype=torch.float).view(-1,1).to(assign_device(p,'GPU')) + q_value=self.nn(s).gather(1,a) + next_q_value=self.target_q_net(next_s).max(1)[0].view(-1,1) + target=r+0.98*next_q_value*(1-d) + return F.mse_loss(q_value,target) + + + def backward(self,loss,p): #backward function,kernel uses it for backpropagation. + self.optimizer[p].zero_grad(set_to_none=True) + loss.backward() + return + + + def opt(self,p): #opt function,kernel uses it to optimize. + self.optimizer[p].step() + return + + + def update_param(self): #update function,kernel uses it to update parameter. + self.target_q_net.load_state_dict(self.nn.state_dict()) + return \ No newline at end of file diff --git a/7.0/models/RL/pytorch/parallel/DQN_pr.py b/7.0/models/RL/pytorch/parallel/DQN_pr.py new file mode 100644 index 00000000..53718dd9 --- /dev/null +++ b/7.0/models/RL/pytorch/parallel/DQN_pr.py @@ -0,0 +1,77 @@ +import torch +import Note.RL.rl.prioritized_replay as pr +import gym +import torch.nn.functional as F +from Note.nn.parallel.assign_device_pytorch import assign_device + + +class Qnet(torch.nn.Module): + def __init__(self,state_dim,hidden_dim,action_dim): + super(Qnet,self).__init__() + self.fc1=torch.nn.Linear(state_dim,hidden_dim) + self.fc2=torch.nn.Linear(hidden_dim,action_dim) + + + def forward(self,x): + x=F.relu(self.fc1(x)) + return self.fc2(x) + + +class DQN: + def __init__(self,state_dim,hidden_dim,action_dim): + if torch.cuda.is_available(): + self.device=torch.device('cuda') + else: + self.device=torch.device('cpu') + self.nn=Qnet(state_dim,hidden_dim,action_dim).to(self.device) + self.target_q_net=Qnet(state_dim,hidden_dim,action_dim).to(self.device) + self.pr=pr.pr_mp_() + self.initial_TD=7. + self.epsilon=0.0007 + self.alpha=0.7 + self.optimizer=[torch.optim.Adam(self.nn.parameters(),lr=2e-3) for _ in range(5)] #optimizer,kernel uses it to optimize. + self.genv=[gym.make('CartPole-v0') for _ in range(5)] #create environment + + + def env(self,a=None,p=None,initial=None): #environment function,kernel uses it to interact with the environment. + if initial==True: + state=self.genv[p].reset() + return state + else: + next_state,reward,done,_=self.genv[p].step(a) + return next_state,reward,done + + + def data_func(self,state_pool,action_pool,next_state_pool,reward_pool,done_pool,batch,p): + s,a,next_s,r,d=self.pr.sample(state_pool,action_pool,next_state_pool,reward_pool,done_pool,self.epsilon,self.alpha,batch,p) + return s,a,next_s,r,d + + + def loss(self,s,a,next_s,r,d,p): #loss function,kernel uses it to calculate loss. + s=torch.tensor(s,dtype=torch.float).to(assign_device(p,'GPU')) + a=torch.tensor(a,dtype=torch.int64).view(-1,1).to(assign_device(p,'GPU')) + next_s=torch.tensor(next_s,dtype=torch.float).to(assign_device(p,'GPU')) + r=torch.tensor(r,dtype=torch.float).view(-1,1).to(assign_device(p,'GPU')) + d=torch.tensor(d,dtype=torch.float).view(-1,1).to(assign_device(p,'GPU')) + q_value=self.nn(s).gather(1,a) + next_q_value=self.target_q_net(next_s).max(1)[0].view(-1,1) + target=r+0.98*next_q_value*(1-d) + TD=target-q_value + self.pr.update_TD(TD) + return torch.mean(TD**2) + + + def backward(self,loss,p): #backward function,kernel uses it for backpropagation. + self.optimizer[p].zero_grad(set_to_none=True) + loss.backward() + return + + + def opt(self,p): #opt function,kernel uses it to optimize. + self.optimizer[p].step() + return + + + def update_param(self): #update function,kernel uses it to update parameter. + self.target_q_net.load_state_dict(self.nn.state_dict()) + return diff --git a/7.0/models/RL/tensorflow/non_parallel/DDPG.py b/7.0/models/RL/tensorflow/non_parallel/DDPG.py new file mode 100644 index 00000000..41cb8fd3 --- /dev/null +++ b/7.0/models/RL/tensorflow/non_parallel/DDPG.py @@ -0,0 +1,76 @@ +import tensorflow as tf # import TensorFlow library +from Note import nn +import gym # import OpenAI Gym library + + +class actor: # define a class for the actor network + def __init__(self,state_dim,hidden_dim,action_dim,action_bound): # initialize the network with state dimension, hidden dimension, action dimension and action bound + self.dense1 = nn.dense(hidden_dim, state_dim, activation='relu') + self.dense2 = nn.dense(action_dim, hidden_dim, activation='tanh') + self.action_bound=action_bound + self.param=[self.dense1.param,self.dense2.param] # store the network parameters in a list + + + def __call__(self,x): # forward propagation function, kernel uses it for forward propagation + x = self.dense1(x) + return self.dense2(x)*self.action_bound + + +class critic: # define a class for the critic network + def __init__(self,state_dim,hidden_dim,action_dim): # initialize the network with state dimension, hidden dimension and action dimension + self.dense1 = nn.dense(hidden_dim, state_dim+action_dim, activation='relu') + self.dense2 = nn.dense(action_dim, hidden_dim) + self.param=[self.dense1.param,self.dense2.param] # store the network parameters in a list + + + def __call__(self,x,a): # forward propagation function, kernel uses it for forward propagation + cat=tf.concat([x,a],axis=1) + x=self.dense1(cat) + return self.dense2(x) + + +class DDPG: # define a class for the DDPG agent + def __init__(self,hidden_dim,sigma,gamma,tau,actor_lr,critic_lr): # initialize the agent with hidden dimension, noise scale, discount factor, soft update factor, actor learning rate and critic learning rate + self.genv=gym.make('Pendulum-v1') # create environment + state_dim=self.genv.observation_space.shape[0] # get the state dimension from the environment observation space + action_dim=self.genv.action_space.shape[0] # get the action dimension from the environment action space + action_bound=self.genv.action_space.high[0] # get the action bound from the environment action space high value (assume symmetric) + self.actor=actor(state_dim,hidden_dim,action_dim,action_bound) # create an actor network for the agent + self.critic=critic(state_dim,hidden_dim,action_dim) # create a critic network for the agent + self.target_actor=actor(state_dim,hidden_dim,action_dim,action_bound) # create a target actor network for the agent + self.target_critic=critic(state_dim,hidden_dim,action_dim) # create a target critic network for the agent + self.actor_param=self.actor.param # parameter list of actor network, kernel uses it list for backpropagation + self.critic_param=self.critic.param # parameter list of critic network, kernel uses it list for backpropagation + nn.assign_param(self.target_actor.param,self.actor.param) # copy the parameters from actor network to target actor network + nn.assign_param(self.target_critic.param,self.critic.param) # copy the parameters from critic network to target critic network + self.param=[self.actor_param,self.critic_param] # parameter list of both networks, kernel uses it list for backpropagation + self.sigma=sigma # noise scale + self.gamma=gamma # discount factor + self.tau=tau # soft update factor + self.opt=tf.keras.optimizers.Adam() # optimizer, kernel uses it to optimize. Here we use Adam optimizer + + + def env(self,a=None,initial=None): # environment function, kernel uses it to interact with the environment + if initial==True: # if initial is True, reset the environment and return the initial state + state=self.genv.reset(seed=0) + return state + else: # otherwise, take an action and return the next state, reward and done flag + next_state,reward,done,_=self.genv.step(a) + return next_state,reward,done + + + def loss(self,s,a,next_s,r,d): # loss function, kernel uses it to calculate loss + a=tf.expand_dims(a,axis=1) # expand the action vector to match the Q-value matrix shape + next_q_value=self.target_critic(next_s,self.target_actor(next_s)) # get the Q-value for the next state and action from the target critic network + q_target=tf.cast(r,'float32')+self.gamma*next_q_value*(1-tf.cast(d,'float32')) # calculate the target value using Bellman equation with discount factor gamma + actor_loss=-tf.reduce_mean(self.critic(s,self.actor(s))) # calculate the actor loss as the negative mean of the Q-value for the current state and action from the critic network + critic_loss=tf.reduce_mean((self.critic(s,a)-q_target)**2) # calculate the critic loss as the mean squared error between Q-value and target value + return actor_loss+critic_loss # return a sum of actor loss and critic loss + + + def update_param(self): # update function, kernel uses it to update parameter + for target_param,param in zip(self.target_actor.param,self.actor.param): # for each pair of parameters in target actor network and actor network + target_param.assign(target_param*(1.0-self.tau)+param*self.tau) # update the target parameter using soft update with factor tau + for target_param,param in zip(self.target_critic.param,self.critic.param): # for each pair of parameters in target critic network and critic network + target_param.assign(target_param*(1.0-self.tau)+param*self.tau) # update the target parameter using soft update with factor tau + return \ No newline at end of file diff --git a/7.0/models/RL/tensorflow/non_parallel/DQN.py b/7.0/models/RL/tensorflow/non_parallel/DQN.py new file mode 100644 index 00000000..aa897704 --- /dev/null +++ b/7.0/models/RL/tensorflow/non_parallel/DQN.py @@ -0,0 +1,45 @@ +import tensorflow as tf # import TensorFlow library +from Note import nn +import gym # import OpenAI Gym library + + +class Qnet: # define a class for the Q-network + def __init__(self,state_dim,hidden_dim,action_dim): # initialize the network with state dimension, hidden dimension and action dimension + self.dense1 = nn.dense(hidden_dim, state_dim, activation='relu') + self.dense2 = nn.dense(action_dim, hidden_dim) + self.param=[self.dense1.param,self.dense2.param] # store the network parameters in a list + + def __call__(self,x): # forward propagation function, kernel uses it for forward propagation + x = self.dense2(self.dense1(x)) + return x + + +class DQN: # define a class for the DQN agent + def __init__(self,state_dim,hidden_dim,action_dim): # initialize the agent with state dimension, hidden dimension and action dimension + self.nn=Qnet(state_dim,hidden_dim,action_dim) # create a Q-network for the agent + self.target_q_net=Qnet(state_dim,hidden_dim,action_dim) # create a target Q-network for the agent + self.param=self.nn.param # parameter list, kernel uses it list for backpropagation + self.opt=tf.keras.optimizers.Adam() # optimizer, kernel uses it to optimize + self.genv=gym.make('CartPole-v0') # create environment + + + def env(self,a=None,initial=None): # environment function, kernel uses it to interact with the environment + if initial==True: # if initial is True, reset the environment and return the initial state + state=self.genv.reset(seed=0) + return state + else: # otherwise, take an action and return the next state, reward and done flag + next_state,reward,done,_=self.genv.step(a) + return next_state,reward,done + + + def loss(self,s,a,next_s,r,d): # loss function, kernel uses it to calculate loss + a=tf.expand_dims(a,axis=1) # expand the action vector to match the Q-value matrix shape + q_value=tf.gather(self.nn(s),a,axis=1,batch_dims=1) # get the Q-value for the selected action + next_q_value=tf.reduce_max(self.target_q_net(next_s),axis=1) # get the maximum Q-value for the next state from the target network + target=tf.cast(r,'float32')+0.98*next_q_value*(1-tf.cast(d,'float32')) # calculate the target value using Bellman equation with discount factor 0.98 + return tf.reduce_mean((q_value-target)**2) # return the mean squared error between Q-value and target value + + + def update_param(self): # update function, kernel uses it to update parameter + nn.assign_param(self.target_q_net.param, self.param) # copy the parameters from the Q-network to the target network + return \ No newline at end of file diff --git a/Note 7.0 pv documentation/RL/neural network/tensorflow/DQN_pr.py b/7.0/models/RL/tensorflow/non_parallel/DQN_pr.py similarity index 58% rename from Note 7.0 pv documentation/RL/neural network/tensorflow/DQN_pr.py rename to 7.0/models/RL/tensorflow/non_parallel/DQN_pr.py index 0ab299df..5d105c3c 100644 --- a/Note 7.0 pv documentation/RL/neural network/tensorflow/DQN_pr.py +++ b/7.0/models/RL/tensorflow/non_parallel/DQN_pr.py @@ -1,19 +1,18 @@ import tensorflow as tf +from Note import nn import gym -import Note.create.RL.rl.prioritized_replay as pr +import Note.RL.rl.prioritized_replay as pr class Qnet: def __init__(self,state_dim,hidden_dim,action_dim): - self.weight1=tf.Variable(tf.random.normal([state_dim,hidden_dim])) - self.bias1=tf.Variable(tf.random.normal([hidden_dim])) - self.weight2=tf.Variable(tf.random.normal([hidden_dim,action_dim])) - self.bias2=tf.Variable(tf.random.normal([action_dim])) - self.param=[self.weight1,self.bias1,self.weight2,self.bias2] + self.dense1 = nn.dense(hidden_dim, state_dim, activation='relu') + self.dense2 = nn.dense(action_dim, hidden_dim) + self.param=[self.dense1.param,self.dense2.param] # store the network parameters in a list - def fp(self,x): - x=tf.nn.relu(tf.matmul(x,self.weight1)+self.bias1) - return tf.matmul(x,self.weight2)+self.bias2 + def __call__(self,x): + x = self.dense2(self.dense1(x)) + return x class DQN: @@ -22,8 +21,8 @@ def __init__(self,state_dim,hidden_dim,action_dim): self.target_q_net=Qnet(state_dim,hidden_dim,action_dim) self.param=self.nn.param self.pr=pr.pr() - self.initial_TD=7 - self._epsilon=0.0007 + self.initial_TD=tf.Variable(7.) + self.epsilon=0.0007 self.alpha=0.7 self.opt=tf.keras.optimizers.Adam() self.genv=gym.make('CartPole-v0') @@ -45,9 +44,9 @@ def data_func(self,state_pool,action_pool,next_state_pool,reward_pool,done_pool, def loss(self,s,a,next_s,r,d): a=tf.expand_dims(a,axis=1) - q_value=tf.gather(self.nn.fp(s),a,axis=1,batch_dims=1) - next_q_value=tf.reduce_max(self.target_q_net.fp(next_s),axis=1) - target=r+0.98*next_q_value*(1-d) + q_value=tf.gather(self.nn(s),a,axis=1,batch_dims=1) + next_q_value=tf.reduce_max(self.target_q_net(next_s),axis=1) + target=tf.cast(r,'float32')+0.98*next_q_value*(1-tf.cast(d,'float32')) target=tf.expand_dims(target,axis=1) TD=target-q_value self.pr.update_TD(TD) @@ -55,5 +54,5 @@ def loss(self,s,a,next_s,r,d): def update_param(self): - self.target_q_net.param=self.param.copy() - return + nn.assign_param(self.target_q_net.param, self.param) + return \ No newline at end of file diff --git a/7.0/models/RL/tensorflow/non_parallel/PPO.py b/7.0/models/RL/tensorflow/non_parallel/PPO.py new file mode 100644 index 00000000..cb1cbd55 --- /dev/null +++ b/7.0/models/RL/tensorflow/non_parallel/PPO.py @@ -0,0 +1,68 @@ +import tensorflow as tf +from Note import nn +import gym + + +class actor: + def __init__(self,state_dim,hidden_dim,action_dim): + self.dense1 = nn.dense(hidden_dim, state_dim, activation='relu') + self.dense2 = nn.dense(action_dim, hidden_dim) + self.param=[self.dense1.param,self.dense2.param] # store the network parameters in a list + + def __call__(self,x): + x=self.dense1(x) + return tf.nn.softmax(self.dense2(x)) + + +class critic: + def __init__(self,state_dim,hidden_dim): + self.dense1 = nn.dense(hidden_dim, state_dim, activation='relu') + self.dense2 = nn.dense(1, hidden_dim) + self.param=[self.dense1.param,self.dense2.param] # store the network parameters in a list + + def __call__(self,x): + x=self.dense1(x) + return self.dense2(x) + + +class PPO: + def __init__(self,state_dim,hidden_dim,action_dim,clip_eps,alpha): + self.actor_=actor(state_dim,hidden_dim,action_dim) + self.actor=actor(state_dim,hidden_dim,action_dim) + nn.assign_param(self.actor.param,self.actor_.param) + self.critic=critic(state_dim,hidden_dim) + self.clip_eps=clip_eps + self.alpha=alpha + self.param=[self.actor_.param,self.critic.param] + self.opt=[tf.keras.optimizers.Adam(),tf.keras.optimizers.Adam()] + self.genv=gym.make('CartPole-v0') + + + def env(self,a=None,initial=None): + if initial==True: + state=self.genv.reset(seed=0) + return state + else: + next_state,reward,done,_=self.genv.step(a) + return next_state,reward,done + + + def loss(self,s,a,next_s,r,d): + a=tf.expand_dims(a,axis=1) + action_prob=tf.gather(self.actor_(s),a,axis=1,batch_dims=1) + action_prob_old=tf.gather(self.actor(s),a,axis=1,batch_dims=1) + raito=action_prob/action_prob_old + value=self.critic(s) + value_tar=tf.cast(r,'float32')+0.98*self.critic(next_s)*(1-tf.cast(d,'float32')) + TD=value_tar-value + sur1=raito*TD + sur2=tf.clip_by_value(raito,clip_value_min=1-self.clip_eps,clip_value_max=1+self.clip_eps)*TD + clip_loss=-tf.math.minimum(sur1,sur2) + entropy=action_prob*tf.math.log(action_prob+1e-8) + clip_loss=clip_loss-self.alpha*entropy + return tf.reduce_mean(clip_loss)+tf.reduce_mean((TD)**2) + + + def update_param(self): + nn.assign_param(self.nn.param, self.actor.param) + return \ No newline at end of file diff --git a/7.0/models/RL/tensorflow/non_parallel/PPO_eps.py b/7.0/models/RL/tensorflow/non_parallel/PPO_eps.py new file mode 100644 index 00000000..6b2eeb98 --- /dev/null +++ b/7.0/models/RL/tensorflow/non_parallel/PPO_eps.py @@ -0,0 +1,63 @@ +import tensorflow as tf +from Note import nn +import gym + + +class actor: + def __init__(self,state_dim,hidden_dim,action_dim): + self.dense1 = nn.dense(hidden_dim, state_dim, activation='relu') + self.dense2 = nn.dense(action_dim, hidden_dim) + self.param=[self.dense1.param,self.dense2.param] # store the network parameters in a list + + def __call__(self,x): + x=self.dense1(x) + return tf.nn.softmax(self.dense2(x)) + + +class critic: + def __init__(self,state_dim,hidden_dim): + self.dense1 = nn.dense(hidden_dim, state_dim, activation='relu') + self.dense2 = nn.dense(1, hidden_dim) + self.param=[self.dense1.param,self.dense2.param] # store the network parameters in a list + + def __call__(self,x): + x=self.dense1(x) + return self.dense2(x) + + +class PPO: + def __init__(self,state_dim,hidden_dim,action_dim,clip_eps): + self.actor_=actor(state_dim,hidden_dim,action_dim) + self.actor=actor(state_dim,hidden_dim,action_dim) + nn.assign_param(self.actor.param,self.actor_.param) + self.critic=critic(state_dim,hidden_dim) + self.clip_eps=clip_eps + self.param=[self.actor_.param,self.critic.param] + self.opt=[tf.keras.optimizers.Adam(),tf.keras.optimizers.Adam()] + self.genv=gym.make('CartPole-v0') + + + def env(self,a=None,initial=None): + if initial==True: + state=self.genv.reset(seed=0) + return state + else: + next_state,reward,done,_=self.genv.step(a) + return next_state,reward,done + + + def loss(self,s,a,next_s,r,d): + a=tf.expand_dims(a,axis=1) + raito=tf.gather(self.actor_(s),a,axis=1,batch_dims=1)/tf.gather(self.actor(s),a,axis=1,batch_dims=1) + value=self.critic(s) + value_tar=tf.cast(r,'float32')+0.98*self.critic(next_s)*(1-tf.cast(d,'float32')) + TD=value_tar-value + sur1=raito*TD + sur2=tf.clip_by_value(raito,clip_value_min=1-self.clip_eps,clip_value_max=1+self.clip_eps)*TD + clip_loss=-tf.math.minimum(sur1,sur2) + return tf.reduce_mean(clip_loss)+tf.reduce_mean((TD)**2) + + + def update_param(self): + nn.assign_param(self.actor.param, self.actor_.param) + return \ No newline at end of file diff --git a/7.0/models/RL/tensorflow/parallel/DDPG.py b/7.0/models/RL/tensorflow/parallel/DDPG.py new file mode 100644 index 00000000..095ae670 --- /dev/null +++ b/7.0/models/RL/tensorflow/parallel/DDPG.py @@ -0,0 +1,83 @@ +import tensorflow as tf # import TensorFlow library +from Note import nn +import gym # import OpenAI Gym library +import Note.nn.parallel.optimizer as o # import Note's optimizer module + + +class actor: # define a class for the actor network + def __init__(self,state_dim,hidden_dim,action_dim,action_bound): # initialize the network with state dimension, hidden dimension, action dimension and action bound + self.dense1 = nn.dense(hidden_dim, state_dim, activation='relu') + self.dense2 = nn.dense(action_dim, hidden_dim, activation='tanh') + self.action_bound=action_bound + self.param=[self.dense1.param,self.dense2.param] # store the network parameters in a list + + + def __call__(self,x): # forward propagation function, kernel uses it for forward propagation + x = self.dense1(x) + return self.dense2(x)*self.action_bound + + +class critic: # define a class for the critic network + def __init__(self,state_dim,hidden_dim,action_dim): # initialize the network with state dimension, hidden dimension and action dimension + self.dense1 = nn.dense(hidden_dim, state_dim+action_dim, activation='relu') + self.dense2 = nn.dense(action_dim, hidden_dim) + self.param=[self.dense1.param,self.dense2.param] # store the network parameters in a list + + + def __call__(self,x,a): # forward propagation function, kernel uses it for forward propagation + cat=tf.concat([x,a],axis=1) + x=self.dense1(cat) + return self.dense2(x) + + +class DDPG: # define a class for the DDPG agent + def __init__(self,hidden_dim,sigma,gamma,tau,actor_lr,critic_lr): # initialize the agent with hidden dimension, noise scale, discount factor, soft update factor, actor learning rate and critic learning rate + self.genv=[gym.make('Pendulum-v1') for _ in range(5)] # create a list of 5 environments + state_dim=self.genv.observation_space.shape[0] # get the state dimension from the environment observation space + action_dim=self.genv.action_space.shape[0] # get the action dimension from the environment action space + action_bound=self.genv.action_space.high[0] # get the action bound from the environment action space high value (assume symmetric) + self.actor=actor(state_dim,hidden_dim,action_dim,action_bound) # create an actor network for the agent + self.critic=critic(state_dim,hidden_dim,action_dim) # create a critic network for the agent + self.target_actor=actor(state_dim,hidden_dim,action_dim,action_bound) # create a target actor network for the agent + self.target_critic=critic(state_dim,hidden_dim,action_dim) # create a target critic network for the agent + self.actor_param=self.actor.param # parameter list of actor network, kernel uses it list for backpropagation + self.critic_param=self.critic.param # parameter list of critic network, kernel uses it list for backpropagation + nn.assign_param(self.target_actor.param,self.actor.param) # copy the parameters from actor network to target actor network + nn.assign_param(self.target_critic.param,self.critic.param) # copy the parameters from critic network to target critic network + self.param=[self.actor_param,self.critic_param] # parameter list of both networks, kernel uses it list for backpropagation + self.sigma=sigma # noise scale + self.gamma=gamma # discount factor + self.tau=tau # soft update factor + self.optimizer=[o.SGD(param=self.param[0]),o.SGD(param=self.param[1])] # optimizer, kernel uses it to optimize. Here we use a custom SGD optimizer + + + def env(self,a=None,p=None,initial=None): # environment function, kernel uses it to interact with the environment + if initial==True: # if initial is True, reset the environment with index p and return the initial state + state=self.genv[p].reset(seed=0) + return state + else: # otherwise, take an action and return the next state, reward and done flag from the environment with index p + next_state,reward,done,_=self.genv[p].step(a) + return next_state,reward,done + + + def loss(self,s,a,next_s,r,d): # loss function, kernel uses it to calculate loss + a=tf.expand_dims(a,axis=1) # expand the action vector to match the Q-value matrix shape + next_q_value=self.target_critic(next_s,self.target_actor(next_s)) # get the Q-value for the next state and action from the target critic network + q_target=tf.cast(r,'float32')+self.gamma*next_q_value*(1-tf.cast(d,'float32')) # calculate the target value using Bellman equation with discount factor gamma + actor_loss=-tf.reduce_mean(self.critic(s,self.actor(s))) # calculate the actor loss as the negative mean of the Q-value for the current state and action from the critic network + critic_loss=tf.reduce_mean((self.critic(s,a)-q_target)**2) # calculate the critic loss as the mean squared error between Q-value and target value + return actor_loss+critic_loss # return a sum of actor loss and critic loss + + + def update_param(self): # update function, kernel uses it to update parameter + for target_param,param in zip(self.target_actor.param,self.actor.param): # for each pair of parameters in target actor network and actor network + target_param.assign(target_param*(1.0-self.tau)+param*self.tau) # update the target parameter using soft update with factor tau + for target_param,param in zip(self.target_critic.param,self.critic.param): # for each pair of parameters in target critic network and critic network + target_param.assign(target_param*(1.0-self.tau)+param*self.tau) # update the target parameter using soft update with factor tau + return + + + def opt(self,gradient): # optimization function, kernel uses it to optimize parameter + param1=self.optimizer[0](gradient[0],self.param[0]) # apply the custom momentum optimizer to update the parameters using the gradient + param2=self.optimizer[1](gradient[1],self.param[1]) + return [param1,param2] \ No newline at end of file diff --git a/7.0/models/RL/tensorflow/parallel/DQN.py b/7.0/models/RL/tensorflow/parallel/DQN.py new file mode 100644 index 00000000..dcd18861 --- /dev/null +++ b/7.0/models/RL/tensorflow/parallel/DQN.py @@ -0,0 +1,51 @@ +import tensorflow as tf # import TensorFlow library +from Note import nn +import gym # import OpenAI Gym library +import Note.nn.parallel.optimizer as o # import Note's optimizer module + + +class Qnet: # define a class for the Q-network + def __init__(self,state_dim,hidden_dim,action_dim): # initialize the network with state dimension, hidden dimension and action dimension + self.dense1 = nn.dense(hidden_dim, state_dim, activation='relu') + self.dense2 = nn.dense(action_dim, hidden_dim) + self.param=[self.dense1.param,self.dense2.param] # store the network parameters in a list + + def __call__(self,x): # forward propagation function, kernel uses it for forward propagation + x = self.dense2(self.dense1(x)) + return x + + +class DQN: # define a class for the DQN agent + def __init__(self,state_dim,hidden_dim,action_dim): # initialize the agent with state dimension, hidden dimension and action dimension + self.nn=Qnet(state_dim,hidden_dim,action_dim) # create a Q-network for the agent + self.target_q_net=Qnet(state_dim,hidden_dim,action_dim) # create a target Q-network for the agent + self.param=self.nn.param # parameter list, kernel uses it list for backpropagation + self.optimizer=o.SGD(param=self.param) # optimizer, kernel uses it to optimize. Here we use a custom SGD optimizer + self.genv=[gym.make('CartPole-v0') for _ in range(5)] # create a list of 5 environments + + + def env(self,a=None,p=None,initial=None): # environment function, kernel uses it to interact with the environment + if initial==True: # if initial is True, reset the environment with index p and return the initial state + state=self.genv[p].reset(seed=0) + return state + else: # otherwise, take an action and return the next state, reward and done flag from the environment with index p + next_state,reward,done,_=self.genv[p].step(a) + return next_state,reward,done + + + def loss(self,s,a,next_s,r,d): # loss function, kernel uses it to calculate loss + a=tf.expand_dims(a,axis=1) # expand the action vector to match the Q-value matrix shape + q_value=tf.gather(self.nn(s),a,axis=1,batch_dims=1) # get the Q-value for the selected action + next_q_value=tf.reduce_max(self.target_q_net(next_s),axis=1) # get the maximum Q-value for the next state from the target network + target=tf.cast(r,'float32')+0.98*next_q_value*(1-tf.cast(d,'float32')) # calculate the target value using Bellman equation with discount factor 0.98 + return tf.reduce_mean((q_value-target)**2) # return the mean squared error between Q-value and target value + + + def update_param(self): # update function, kernel uses it to update parameter + nn.assign(self.target_q_net.param,self.param) # copy the parameters from the Q-network to the target network + return + + + def opt(self,gradient): # optimization function, kernel uses it to optimize parameter + param=self.optimizer(gradient,self.param) # apply the custom momentum optimizer to update the parameters using the gradient + return param \ No newline at end of file diff --git a/7.0/models/RL/tensorflow/parallel/DQN_pr.py b/7.0/models/RL/tensorflow/parallel/DQN_pr.py new file mode 100644 index 00000000..bea2059b --- /dev/null +++ b/7.0/models/RL/tensorflow/parallel/DQN_pr.py @@ -0,0 +1,63 @@ +import tensorflow as tf # import TensorFlow library +from Note import nn +import Note.RL.rl.prioritized_replay as pr +import gym # import OpenAI Gym library +import Note.nn.parallel.optimizer as o # import Note's optimizer module + + +class Qnet: # define a class for the Q-network + def __init__(self,state_dim,hidden_dim,action_dim): # initialize the network with state dimension, hidden dimension and action dimension + self.dense1 = nn.dense(hidden_dim, state_dim, activation='relu') + self.dense2 = nn.dense(action_dim, hidden_dim) + self.param=[self.dense1.param,self.dense2.param] # store the network parameters in a list + + def __call__(self,x): # forward propagation function, kernel uses it for forward propagation + x = self.dense2(self.dense1(x)) + return x + + +class DQN: # define a class for the DQN agent + def __init__(self,state_dim,hidden_dim,action_dim): # initialize the agent with state dimension, hidden dimension and action dimension + self.nn=Qnet(state_dim,hidden_dim,action_dim) # create a Q-network for the agent + self.target_q_net=Qnet(state_dim,hidden_dim,action_dim) # create a target Q-network for the agent + self.param=self.nn.param # parameter list, kernel uses it list for backpropagation + self.pr=pr.pr_mp() + self.initial_TD=tf.Variable(7.) + self.epsilon=0.0007 + self.alpha=0.7 + self.optimizer=o.SGD(param=self.param) # optimizer, kernel uses it to optimize. Here we use a custom SGD optimizer + self.genv=[gym.make('CartPole-v0') for _ in range(5)] # create a list of 5 environments + + + def env(self,a=None,p=None,initial=None): # environment function, kernel uses it to interact with the environment + if initial==True: # if initial is True, reset the environment with index p and return the initial state + state=self.genv[p].reset(seed=0) + return state + else: # otherwise, take an action and return the next state, reward and done flag from the environment with index p + next_state,reward,done,_=self.genv[p].step(a) + return next_state,reward,done + + + def data_func(self,state_pool,action_pool,next_state_pool,reward_pool,done_pool,batch,p): + s,a,next_s,r,d=self.pr.sample(state_pool,action_pool,next_state_pool,reward_pool,done_pool,self.epsilon,self.alpha,batch,p) + return s,a,next_s,r,d + + + def loss(self,s,a,next_s,r,d): # loss function, kernel uses it to calculate loss + a=tf.expand_dims(a,axis=1) # expand the action vector to match the Q-value matrix shape + q_value=tf.gather(self.nn(s),a,axis=1,batch_dims=1) # get the Q-value for the selected action + next_q_value=tf.reduce_max(self.target_q_net(next_s),axis=1) # get the maximum Q-value for the next state from the target network + target=tf.cast(r,'float32')+0.98*next_q_value*(1-tf.cast(d,'float32')) # calculate the target value using Bellman equation with discount factor 0.98 + TD=q_value-target + self.pr.update_TD(TD) + return tf.reduce_mean(TD**2) # return the mean squared error between Q-value and target value + + + def update_param(self): # update function, kernel uses it to update parameter + nn.assign(self.target_q_net.param,self.param) # copy the parameters from the Q-network to the target network + return + + + def opt(self,gradient): # optimization function, kernel uses it to optimize parameter + param=self.optimizer(gradient,self.param) # apply the custom momentum optimizer to update the parameters using the gradient + return param \ No newline at end of file diff --git a/7.0/models/RL/tensorflow/parallel/PPO.py b/7.0/models/RL/tensorflow/parallel/PPO.py new file mode 100644 index 00000000..8227abe8 --- /dev/null +++ b/7.0/models/RL/tensorflow/parallel/PPO.py @@ -0,0 +1,74 @@ +import tensorflow as tf +from Note import nn +import gym +import Note.nn.parallel.optimizer as o + + +class actor: + def __init__(self,state_dim,hidden_dim,action_dim): + self.dense1 = nn.dense(hidden_dim, state_dim, activation='relu') + self.dense2 = nn.dense(action_dim, hidden_dim) + self.param=[self.dense1.param,self.dense2.param] # store the network parameters in a list + + def __call__(self,x): + x=self.dense1(x) + return tf.nn.softmax(self.dense2(x)) + + +class critic: + def __init__(self,state_dim,hidden_dim): + self.dense1 = nn.dense(hidden_dim, state_dim, activation='relu') + self.dense2 = nn.dense(1, hidden_dim) + self.param=[self.dense1.param,self.dense2.param] # store the network parameters in a list + + def __call__(self,x): + x=self.dense1(x) + return self.dense2(x) + + +class PPO: + def __init__(self,state_dim,hidden_dim,action_dim,clip_eps,alpha): + self.actor_=actor(state_dim,hidden_dim,action_dim) + self.actor=actor(state_dim,hidden_dim,action_dim) + nn.assign(self.actor.param,self.actor_.param) + self.critic=critic(state_dim,hidden_dim) + self.clip_eps=clip_eps + self.param=[self.actor_.param,self.critic.param] + self.opt=[o.SGD(param=self.param[0]),o.SGD(param=self.param[1])] + self.genv=[gym.make('CartPole-v0') for _ in range(5)] + + + def env(self,a=None,p=None,initial=None): + if initial==True: + state=self.genv[p].reset(seed=0) + return state + else: + next_state,reward,done,_=self.genv[p].step(a) + return next_state,reward,done + + + def loss(self,s,a,next_s,r,d): + a=tf.expand_dims(a,axis=1) + action_prob=tf.gather(self.actor_(s),a,axis=1,batch_dims=1) + action_prob_old=tf.gather(self.actor(s),a,axis=1,batch_dims=1) + raito=action_prob/action_prob_old + value=self.critic(s) + value_tar=tf.cast(r,'float32')+0.98*self.critic(next_s)*(1-tf.cast(d,'float32')) + TD=value_tar-value + sur1=raito*TD + sur2=tf.clip_by_value(raito,clip_value_min=1-self.clip_eps,clip_value_max=1+self.clip_eps)*TD + clip_loss=-tf.math.minimum(sur1,sur2) + entropy=action_prob*tf.math.log(action_prob+1e-8) + clip_loss=clip_loss-self.alpha*entropy + return tf.reduce_mean(clip_loss)+tf.reduce_mean((TD)**2) + + + def update_param(self): + nn.assign(self.actor.param,self.actor_.param) + return + + + def opt(self,gradient): + param1=self.optimizer[0](gradient[0],self.param[0]) + param2=self.optimizer[1](gradient[1],self.param[1]) + return [param1,param2] \ No newline at end of file diff --git a/7.0/models/RL/tensorflow/parallel/PPO_eps.py b/7.0/models/RL/tensorflow/parallel/PPO_eps.py new file mode 100644 index 00000000..68975a38 --- /dev/null +++ b/7.0/models/RL/tensorflow/parallel/PPO_eps.py @@ -0,0 +1,70 @@ +import tensorflow as tf +from Note import nn +import gym +import Note.nn.parallel.optimizer as o + + +class actor: + def __init__(self,state_dim,hidden_dim,action_dim): + self.dense1 = nn.dense(hidden_dim, state_dim, activation='relu') + self.dense2 = nn.dense(action_dim, hidden_dim) + self.param=[self.dense1.param,self.dense2.param] # store the network parameters in a list + + def __call__(self,x): + x=self.dense1(x) + return tf.nn.softmax(self.dense2(x)) + + +class critic: + def __init__(self,state_dim,hidden_dim): + self.dense1 = nn.dense(hidden_dim, state_dim, activation='relu') + self.dense2 = nn.dense(1, hidden_dim) + self.param=[self.dense1.param,self.dense2.param] # store the network parameters in a list + + def __call__(self,x): + x=self.dense1(x) + return self.dense2(x) + + +class PPO: + def __init__(self,state_dim,hidden_dim,action_dim,clip_eps): + self.actor_=actor(state_dim,hidden_dim,action_dim) + self.actor=actor(state_dim,hidden_dim,action_dim) + nn.assign(self.actor.param,self.actor_.param) + self.critic=critic(state_dim,hidden_dim) + self.clip_eps=clip_eps + self.param=[self.actor_.param,self.critic.param] + self.opt=[o.SGD(param=self.param[0]),o.SGD(param=self.param[1])] + self.genv=[gym.make('CartPole-v0') for _ in range(5)] + + + def env(self,a=None,p=None,initial=None): + if initial==True: + state=self.genv[p].reset(seed=0) + return state + else: + next_state,reward,done,_=self.genv[p].step(a) + return next_state,reward,done + + + def loss(self,s,a,next_s,r,d): + a=tf.expand_dims(a,axis=1) + raito=tf.gather(self.actor_(s),a,axis=1,batch_dims=1)/tf.gather(self.actor(s),a,axis=1,batch_dims=1) + value=self.critic(s) + value_tar=tf.cast(r,'float32')+0.98*self.critic(next_s)*(1-tf.cast(d,'float32')) + TD=value_tar-value + sur1=raito*TD + sur2=tf.clip_by_value(raito,clip_value_min=1-self.clip_eps,clip_value_max=1+self.clip_eps)*TD + clip_loss=-tf.math.minimum(sur1,sur2) + return tf.reduce_mean(clip_loss)+tf.reduce_mean((TD)**2) + + + def update_param(self): + nn.assign(self.actor.param,self.actor_.param) + return + + + def opt(self,gradient): + param1=self.optimizer[0](gradient[0],self.param[0]) + param2=self.optimizer[1](gradient[1],self.param[1]) + return [param1,param2] \ No newline at end of file diff --git a/Note 7.0 pv documentation/DL/kernel.txt b/Note 7.0 pv documentation/DL/kernel.txt deleted file mode 100644 index 2437fb64..00000000 --- a/Note 7.0 pv documentation/DL/kernel.txt +++ /dev/null @@ -1,114 +0,0 @@ -Use kernel to train neural network. First, you should write a neural network class that include method object and Instance object. -Method object: -Method object need to use Tensorflow 2.0 version and above to write. -1. fp(data) forward propagation function,it receive data,return output. -2. loss(output,labels) loss function,it receive output and labels output loss. -You can also do. -1. fp(data,labels) forward propagation function,it receive data and labels,return output and loss. -2. opt(gradient). - -Instance object: -1.If you don't want to write optimizer by yourself,assign opt as optimizer of tensorflow. -2.Instance include parameter and hyper-parameter,where parameter must be named param, instance can include anything you need. - - ----------------------------------------------------------------------------------------- -If you accomplish your neural network,you can use kernel to train. -example: -import Note.create.DL.kernel as k #import kernel -import tensorflow as tf #import platform -import cnn as c #import neural network -mnist=tf.keras.datasets.mnist -(x_train,y_train),(x_test,y_test)=mnist.load_data() -x_train,x_test =x_train/255.0,x_test/255.0 -y_train=tf.one_hot(y_train,10) -cnn=c.cnn() #create neural network object -kernel=k.kernel(cnn) #start kernel -kernel.platform=tf #use platform -kernel.data(x_train,y_train) #input you data,if you have test data can transfer to kernel API data() - #data can be a list,[data1,data2,...,datan] -kernel.train(32,5) #train neural network - #batch: batch size - #epoch:epoch - - ------------------------------------------------------------------------------------------ -Parallel optimization: -You can use parallel optimization to speed up your training,parallel optimization speed up training by multiprocessing. -Note have two types of parallel optimization: -1. parallel forward propagation and optimizing. -2. parallel forward propagation and calculate a gradient and optimizing. -3. parallel forward propagation and calculate multiple gradients and optimizing. - - ----------------------------------------------------------------------------------------- -Save: -This kernel API can save you neural network and param as a file. -kernel.save(path) - - ----------------------------------------------------------------------------------------- -Restore: -If you want to train your neural network again. -import Note.create.DL.kernel as k -kernel=k.kernel() #don't need neural network object. -kernel.restore(s_path,p_path) #use this API to restore your neural network and param file. - - ------------------------------------------------------------------------------------------ -This kernel API can visualize your taining. -visualize_train(self) -kernel.visualize_train() #use train_visual() by kernel - - ------------------------------------------------------------------------------------------ -Kernel's instance object: -self.nn: neural network object -self.nn.km: kernel mode -self.PO: parallel optimization -self.thread_lock: thread lock -self.thread: thread sum -self.ol: online training function be used for kernel to oniline train -self.suspend: if you want to suspend training,you can assign self.suspend to True -self.stop: if you want to stop training,you can assign self.stop to True -self.save_epoch: if you want to save your neural network,you can assign self.save_epoch to an epoch -self.batch: batch size -self.epoch: epoch -self.train_loss: train loss -self.train_loss_list: self.train_visual() use this instance to visualize train loss's curve -self.test_flag: test flag if you want test,make self.test_flag=True -self.total_epoch: total epoch -self.time: train time -self.total_time:total train time -self.train_data: train data -self.train_labels: train labels -self.nn.param: neural network object's param list -self.gradient: this instance be used for the second kind of parallel optimization,for reduce memory consumption -self.nn.ec: epoch counter -self.nn.bc: batch counter -self.train_counter: count the number of times the train function has been used - - ------------------------------------------------------------------------------------------ -Kernel's methon object: -data(self,train_data,train_labels,test_data=None,test_labels=None): assign data for self.train_data,self.train_labels,self.test_data,self.test_labels -init(self,param=None): initialize some kernel's instance -apply_gradient(self,tape,opt,loss,parameter): optimize neural network -loss_acc(self,output=None,labels_batch=None,loss=None,test_batch=None,total_loss=None,total_acc=None,t=None): compute loss and acc -train(self,batch=None,epoch=None,test_batch=None,file_path=None,one=True,p=None,s=None): train neural network -test(self,test_data,test_labels,batch=None,t=None): output test loss and test acc -suspend_func(self): be used to suspend training -train_visual(self): visualize train loss and train acc by matplotlib -save_p(self,path): save neural network's parameter -save(self,path,i=None,one=True): save neural network and neural network's parameter -restore(self,s_path,p_path): restore neural network and neural network's parameter - - ------------------------------------------------------------------------------------------ -Support suspending training. -Support stop and save in training. -Support stop and save in multithreading training. -Support stop mechanism. -Support gradient attenuation. -Support memory protection mechanism. -Support training priority and memory priority. diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/bert.py b/Note 7.0 pv documentation/DL/neural network/tensorflow/bert.py deleted file mode 100644 index c3dc6588..00000000 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/bert.py +++ /dev/null @@ -1,167 +0,0 @@ -import tensorflow as tf -import tensorflow_hub as hub - - -class bert: - def __init__(self): - text_input=tf.keras.layers.Input(shape=(),dtype=tf.string,name='text') - preprocessing_layer=hub.KerasLayer(tfhub_handle_preprocess,name='preprocessing') - encoder_inputs=preprocessing_layer(text_input) - encoder=hub.KerasLayer(tfhub_handle_encoder,trainable=True,name='BERT_encoder') - outputs=encoder(encoder_inputs) - net=outputs['pooled_output'] - net=tf.keras.layers.Dropout(0.1)(net) - net=tf.keras.layers.Dense(1,activation=None,name='classifier')(net) - self.model=tf.keras.Model(text_input,net) - self.param=self.model.weights - self.opt=tf.keras.optimizers.Adam() - - - def fp(self,data): - return self.model(data) - - - def loss(self,output,labels): - bce=tf.keras.losses.BinaryCrossentropy(from_logits=True) - return bce(output,labels) - - -bert_model_name = 'small_bert/bert_en_uncased_L-4_H-512_A-8' -map_name_to_handle = { - 'bert_en_uncased_L-12_H-768_A-12': - 'https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/3', - 'bert_en_cased_L-12_H-768_A-12': - 'https://tfhub.dev/tensorflow/bert_en_cased_L-12_H-768_A-12/3', - 'bert_multi_cased_L-12_H-768_A-12': - 'https://tfhub.dev/tensorflow/bert_multi_cased_L-12_H-768_A-12/3', - 'small_bert/bert_en_uncased_L-2_H-128_A-2': - 'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-128_A-2/1', - 'small_bert/bert_en_uncased_L-2_H-256_A-4': - 'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-256_A-4/1', - 'small_bert/bert_en_uncased_L-2_H-512_A-8': - 'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-512_A-8/1', - 'small_bert/bert_en_uncased_L-2_H-768_A-12': - 'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-768_A-12/1', - 'small_bert/bert_en_uncased_L-4_H-128_A-2': - 'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-128_A-2/1', - 'small_bert/bert_en_uncased_L-4_H-256_A-4': - 'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-256_A-4/1', - 'small_bert/bert_en_uncased_L-4_H-512_A-8': - 'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-512_A-8/1', - 'small_bert/bert_en_uncased_L-4_H-768_A-12': - 'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-768_A-12/1', - 'small_bert/bert_en_uncased_L-6_H-128_A-2': - 'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-128_A-2/1', - 'small_bert/bert_en_uncased_L-6_H-256_A-4': - 'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-256_A-4/1', - 'small_bert/bert_en_uncased_L-6_H-512_A-8': - 'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-512_A-8/1', - 'small_bert/bert_en_uncased_L-6_H-768_A-12': - 'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-768_A-12/1', - 'small_bert/bert_en_uncased_L-8_H-128_A-2': - 'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-128_A-2/1', - 'small_bert/bert_en_uncased_L-8_H-256_A-4': - 'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-256_A-4/1', - 'small_bert/bert_en_uncased_L-8_H-512_A-8': - 'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-512_A-8/1', - 'small_bert/bert_en_uncased_L-8_H-768_A-12': - 'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-768_A-12/1', - 'small_bert/bert_en_uncased_L-10_H-128_A-2': - 'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-128_A-2/1', - 'small_bert/bert_en_uncased_L-10_H-256_A-4': - 'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-256_A-4/1', - 'small_bert/bert_en_uncased_L-10_H-512_A-8': - 'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-512_A-8/1', - 'small_bert/bert_en_uncased_L-10_H-768_A-12': - 'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-768_A-12/1', - 'small_bert/bert_en_uncased_L-12_H-128_A-2': - 'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-128_A-2/1', - 'small_bert/bert_en_uncased_L-12_H-256_A-4': - 'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-256_A-4/1', - 'small_bert/bert_en_uncased_L-12_H-512_A-8': - 'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-512_A-8/1', - 'small_bert/bert_en_uncased_L-12_H-768_A-12': - 'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-768_A-12/1', - 'albert_en_base': - 'https://tfhub.dev/tensorflow/albert_en_base/2', - 'electra_small': - 'https://tfhub.dev/google/electra_small/2', - 'electra_base': - 'https://tfhub.dev/google/electra_base/2', - 'experts_pubmed': - 'https://tfhub.dev/google/experts/bert/pubmed/2', - 'experts_wiki_books': - 'https://tfhub.dev/google/experts/bert/wiki_books/2', - 'talking-heads_base': - 'https://tfhub.dev/tensorflow/talkheads_ggelu_bert_en_base/1', -} -map_model_to_preprocess = { - 'bert_en_uncased_L-12_H-768_A-12': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'bert_en_cased_L-12_H-768_A-12': - 'https://tfhub.dev/tensorflow/bert_en_cased_preprocess/3', - 'small_bert/bert_en_uncased_L-2_H-128_A-2': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'small_bert/bert_en_uncased_L-2_H-256_A-4': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'small_bert/bert_en_uncased_L-2_H-512_A-8': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'small_bert/bert_en_uncased_L-2_H-768_A-12': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'small_bert/bert_en_uncased_L-4_H-128_A-2': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'small_bert/bert_en_uncased_L-4_H-256_A-4': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'small_bert/bert_en_uncased_L-4_H-512_A-8': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'small_bert/bert_en_uncased_L-4_H-768_A-12': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'small_bert/bert_en_uncased_L-6_H-128_A-2': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'small_bert/bert_en_uncased_L-6_H-256_A-4': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'small_bert/bert_en_uncased_L-6_H-512_A-8': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'small_bert/bert_en_uncased_L-6_H-768_A-12': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'small_bert/bert_en_uncased_L-8_H-128_A-2': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'small_bert/bert_en_uncased_L-8_H-256_A-4': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'small_bert/bert_en_uncased_L-8_H-512_A-8': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'small_bert/bert_en_uncased_L-8_H-768_A-12': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'small_bert/bert_en_uncased_L-10_H-128_A-2': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'small_bert/bert_en_uncased_L-10_H-256_A-4': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'small_bert/bert_en_uncased_L-10_H-512_A-8': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'small_bert/bert_en_uncased_L-10_H-768_A-12': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'small_bert/bert_en_uncased_L-12_H-128_A-2': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'small_bert/bert_en_uncased_L-12_H-256_A-4': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'small_bert/bert_en_uncased_L-12_H-512_A-8': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'small_bert/bert_en_uncased_L-12_H-768_A-12': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'bert_multi_cased_L-12_H-768_A-12': - 'https://tfhub.dev/tensorflow/bert_multi_cased_preprocess/3', - 'albert_en_base': - 'https://tfhub.dev/tensorflow/albert_en_preprocess/3', - 'electra_small': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'electra_base': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'experts_pubmed': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'experts_wiki_books': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', - 'talking-heads_base': - 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3', -} -tfhub_handle_encoder=map_name_to_handle[bert_model_name] -tfhub_handle_preprocess=map_model_to_preprocess[bert_model_name] diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/layer/LSTM.py b/Note 7.0 pv documentation/DL/neural network/tensorflow/layer/LSTM.py deleted file mode 100644 index 1e52f834..00000000 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/layer/LSTM.py +++ /dev/null @@ -1,37 +0,0 @@ -import tensorflow as tf -from Note.nn.layer.LSTM import LSTM -from Note.nn.layer.dense import dense - -# Define a recurrent neural network class with LSTM layers -class lstm: - def __init__(self): - # Initialize the loss function and the optimizer - self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) - self.opt=tf.keras.optimizers.Adam() - - - def build(self): - # Create two LSTM layers with 50 hidden units each - self.lstm1=LSTM(weight_shape=(3,50),return_sequence=True) # First LSTM layer that returns the full sequence - self.lstm2=LSTM(weight_shape=(50,50),) # Second LSTM layer that returns the last output only - # Create a dense layer with 10 output units - self.dense=dense([50, 10]) - # Store the parameters of the layers in a list - self.param=[self.lstm1.param, - self.lstm2.param, - self.dense.param, - ] - return - - - def fp(self,data): - # Perform forward propagation on the input data - x=self.lstm1.output(data) # First LSTM layer output - x=self.lstm2.output(x) # Second LSTM layer output - output=self.dense.output(x) # Dense layer output - return output - - - def loss(self, output, labels): - # Compute the loss between the output and the labels - return self.loss_object(labels, output) diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/layer/Transformer.py b/Note 7.0 pv documentation/DL/neural network/tensorflow/layer/Transformer.py deleted file mode 100644 index 5d00ffb7..00000000 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/layer/Transformer.py +++ /dev/null @@ -1,46 +0,0 @@ -import tensorflow as tf -from Note.nn.layer.Transformer import Transformer -from Note.nn.layer.dense import dense -from Note.nn.layer.emdedding import embedding -from Note.nn.positional_encoding import positional_encoding - -# Define a positional encoding transformer neural network class -class Transformer: - def __init__(self,vocab_size,embed_size,num_heads,num_layers,max_len): - self.vocab_size=vocab_size - self.embed_size=embed_size - self.num_heads=num_heads - self.num_layers=num_layers - self.max_len=max_len - # Initialize the loss function and the optimizer - self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) - self.opt=tf.keras.optimizers.Adam() - - - def build(self): - # Create an embedding layer to map input tokens to vectors - self.embedding_layer = embedding(self.vocab_size,self.embed_size) - # Create a list of transformer layers - self.transformer_layers = [transformer(weight_shape=[self.embed_size, self.embed_size], num_heads=self.num_heads) for _ in range(self.num_layers)] - # Create a linear layer to map the transformer output to logits - self.logits_layer = dense([self.embed_size,self.vocab_size]) - # Store the parameters of the layers in a list - self.param = [self.embedding_layer.embeddings] - for transformer_layer in self.transformer_layers: - self.param.extend(transformer_layer.param) - self.param.extend(self.logits_layer.param) - - - def fp(self,data): - # Perform forward propagation on the input data - x = self.embedding_layer.output(data) # shape: (batch_size, seq_len, embed_size) - x += positional_encoding(self.max_len,self.embed_size) # shape: (batch_size, seq_len, embed_size) - for transformer_layer in self.transformer_layers: - x = transformer_layer.output(x) # shape: (batch_size, seq_len, embed_size) - output = self.logits_layer.output(x) # shape: (batch_size, seq_len, vocab_size) - return output - - - def loss(self,output,labels): - # Compute the loss between the output and the labels - return self.loss_object(labels,output) diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/layer/attn_LSTM.py b/Note 7.0 pv documentation/DL/neural network/tensorflow/layer/attn_LSTM.py deleted file mode 100644 index 5d4fa942..00000000 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/layer/attn_LSTM.py +++ /dev/null @@ -1,44 +0,0 @@ -import tensorflow as tf -from Note.nn.layer.LSTM import LSTM -from Note.nn.layer.dense import dense -from Note.nn.layer.attention import attention - -# Define a recurrent neural network class with LSTM layers and attention -class attn_lstm: - def __init__(self): - # Initialize the loss function and the optimizer - self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) - self.opt=tf.keras.optimizers.Adam() - - - def build(self): - # Create two LSTM layers with 50 hidden units each - self.lstm1=LSTM(weight_shape=(3,50),return_sequence=True) # First LSTM layer that returns the full sequence - self.lstm2=LSTM(weight_shape=(50,50),) # Second LSTM layer that returns the last output only - # Create a dense layer with 10 output units and softmax activation - self.dense=dense([100, 10],activation='softmax') - # Create an attention object with weight shape (50, 50) - self.attn=attention((50,50)) - # Store the parameters of the layers and the attention in a list - self.param=[self.lstm1.param, - self.lstm2.param, - self.dense.param, - self.attn.param] # Add the attention parameters to the list - return - - - def fp(self,data): - # Perform forward propagation on the input data - x=self.lstm1.output(data) # First LSTM layer output, shape (B, N, 50) - y=self.lstm2.output(x) # Second LSTM layer output, shape (B, 50) - # Use the attention object to compute the context vector from x and y, shape (B, 50) - context_vector,_,_=self.attn.output(x,y) - # Concatenate the context vector and the second LSTM output, shape (B, 100) - z=tf.concat([context_vector,y],axis=-1) - output=self.dense.output(z) # Dense layer output with softmax activation, shape (B, 10) - return output - - - def loss(self,output,labels): - # Compute the loss between the output and the labels - return self.loss_object(labels,output) diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/layer/cnn.py b/Note 7.0 pv documentation/DL/neural network/tensorflow/layer/cnn.py deleted file mode 100644 index aa2667f8..00000000 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/layer/cnn.py +++ /dev/null @@ -1,50 +0,0 @@ -import tensorflow as tf -from Note.nn.layer.conv2d import conv2d -from Note.nn.layer.dense import dense -from Note.nn.layer.flatten import flatten - -# Define a convolutional neural network class -class cnn: - def __init__(self): - # Initialize the loss function and the optimizer - self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) - self.opt=tf.keras.optimizers.Adam() - - - def build(self): - # Create three convolutional layers with relu activations - self.conv1=conv2d(weight_shape=(3,3,3,32),activation='relu') - self.conv2=conv2d(weight_shape=(3,3,32,64),activation='relu') - self.conv3=conv2d(weight_shape=(3,3,64,64),activation='relu') - # Create two dense layers with relu and linear activations - self.dense1=dense([64*4*4,64],activation='relu') - self.dense2=dense([64,10]) - # Store the parameters of the layers in a list - self.param = [self.conv1.weight, - self.conv2.weight, - self.conv3.weight, - self.dense1.weight, - self.dense1.bias, - self.dense2.weight, - self.dense2.bias] - return - - - def fp(self,data): - # Perform forward propagation on the input data - x=tf.nn.conv2d(data,self.conv1.weight,strides=(1,1),padding='SAME') # First convolutional layer - x=tf.nn.max_pool2d(x,ksize=(2,2),strides=(2,2),padding='VALID') # First max pooling layer - x=tf.nn.conv2d(x,self.conv2.weight,strides=(1,1),padding='SAME') # Second convolutional layer - x=tf.nn.max_pool2d(x,ksize=(2,2),strides=(2,2),padding='VALID') # Second max pooling layer - x=tf.nn.conv2d(x,self.conv3.weight,strides=(1,1),padding='SAME') # Third convolutional layer - x=flatten(x) # Flatten the output to a vector - x=tf.nn.relu(tf.matmul(x,self.dense1.weight)+self.dense1.bias) # First dense layer with relu activation - x=tf.nn.dropout(x,rate=0.5) # Apply dropout to prevent overfitting - output=tf.matmul(x,self.dense2.weight)+self.dense2.bias # Output layer with linear activation - output=tf.nn.dropout(output,rate=0.5) # Apply dropout to prevent overfitting - return output - - - def loss(self,output,labels): - # Compute the loss between the output and the labels - return self.loss_object(labels,output) \ No newline at end of file diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/layer/cnn_lmix.py b/Note 7.0 pv documentation/DL/neural network/tensorflow/layer/cnn_lmix.py deleted file mode 100644 index 2c01b135..00000000 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/layer/cnn_lmix.py +++ /dev/null @@ -1,58 +0,0 @@ -import tensorflow as tf -from Note.nn.layer.conv2d import conv2d -from Note.nn.layer.dense import dense -from Note.nn.layer.flatten import flatten -from Note.nn.layer.LMix import lmix - -# Define a convolutional neural network class with mixup augmentation -class cnn: - def __init__(self): - # Initialize the loss function and the optimizer - self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) - self.opt=tf.keras.optimizers.Adam() - # Initialize the alpha parameter for mixup - self.alpha=1.0 - - - def build(self): - # Create three convolutional layers with relu activations - self.conv1=conv2d(weight_shape=(3,3,3,32),activation='relu') - self.conv2=conv2d(weight_shape=(3,3,32,64),activation='relu') - self.conv3=conv2d(weight_shape=(3,3,64,64),activation='relu') - # Create two dense layers with relu and linear activations - self.dense1=dense([64*4*4,64],activation='relu') - self.dense2=dense([64,10]) - # Store the parameters of the layers in a list - self.param = [self.conv1.weight, - self.conv2.weight, - self.conv3.weight, - self.dense1.weight, - self.dense1.bias, - self.dense2.weight, - self.dense2.bias] - return - - - def data_func(self,data_batch,labels_batch): - # Apply mixup augmentation on the input data and labels - return lmix(data_batch,labels_batch,self.alpha) - - - def fp(self,data): - # Perform forward propagation on the input data - x=tf.nn.conv2d(data,self.conv1.weight,strides=(1,1),padding='SAME') # First convolutional layer - x=tf.nn.max_pool2d(x,ksize=(2,2),strides=(2,2),padding='VALID') # First max pooling layer - x=tf.nn.conv2d(x,self.conv2.weight,strides=(1,1),padding='SAME') # Second convolutional layer - x=tf.nn.max_pool2d(x,ksize=(2,2),strides=(2,2),padding='VALID') # Second max pooling layer - x=tf.nn.conv2d(x,self.conv3.weight,strides=(1,1),padding='SAME') # Third convolutional layer - x=flatten(x) # Flatten the output to a vector - x=tf.nn.relu(tf.matmul(x,self.dense1.weight)+self.dense1.bias) # First dense layer with relu activation - x=tf.nn.dropout(x,rate=0.5) # Apply dropout to prevent overfitting - output=tf.matmul(x,self.dense2.weight)+self.dense2.bias # Output layer with linear activation - output=tf.nn.dropout(output,rate=0.5) # Apply dropout to prevent overfitting - return output - - - def loss(self,output,labels): - # Compute the loss between the output and the labels - return self.loss_object(labels,output) diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/layer/nn.py b/Note 7.0 pv documentation/DL/neural network/tensorflow/layer/nn.py deleted file mode 100644 index 561a9bd5..00000000 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/layer/nn.py +++ /dev/null @@ -1,27 +0,0 @@ -import tensorflow as tf -import Note.nn.layer.dense as d -from Note.nn.layer.flatten import flatten - - -class nn: - def __init__(self): - self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) - self.opt=tf.keras.optimizers.Adam() - - - def build(self): - self.layer1=d.dense([784,128],activation='relu') - self.layer2=d.dense([128,10]) - self.param=[self.layer1.param,self.layer2.param] - return - - - def fp(self,data): - data=flatten(data) - output1=self.layer1.output(data) - output2=self.layer2.output(output1) - return output2 - - - def loss(self,output,labels): - return self.loss_object(labels,output) diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/layer/nn_acc.py b/Note 7.0 pv documentation/DL/neural network/tensorflow/layer/nn_acc.py deleted file mode 100644 index cad20961..00000000 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/layer/nn_acc.py +++ /dev/null @@ -1,32 +0,0 @@ -import tensorflow as tf -import Note.nn.layer.dense as d -from Note.nn.layer.flatten import flatten - - -class nn: - def __init__(self): - self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) - self.train_accuracy=tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy') - self.opt=tf.keras.optimizers.Adam() - - - def build(self): - self.layer1=d.dense([784,128],activation='relu') - self.layer2=d.dense([128,10]) - self.param=[self.layer1.param,self.layer2.param] - return - - - def fp(self,data): - data=flatten(data) - output1=self.layer1.output(data) - output2=self.layer2.output(output1) - return output2 - - - def loss(self,output,labels): - return self.loss_object(labels,output) - - - def accuracy(self,output,labels): - return self.train_accuracy(labels,output) \ No newline at end of file diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/layer/nn_clipping.py b/Note 7.0 pv documentation/DL/neural network/tensorflow/layer/nn_clipping.py deleted file mode 100644 index db0bc108..00000000 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/layer/nn_clipping.py +++ /dev/null @@ -1,40 +0,0 @@ -import tensorflow as tf -import Note.nn.layer.dense as d -from Note.nn.layer.flatten import flatten -from Note.nn.gradient_clipping import gradient_clipping - -# Define a neural network class -class nn: - def __init__(self): - # Initialize the loss function and the optimizer - self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) - self.opt=tf.keras.optimizers.Adam() - - - def build(self): - # Create two dense layers with relu and linear activations - self.layer1=d.dense([784,128],activation='relu') - self.layer2=d.dense([128,10]) - # Store the parameters of the layers in a list - self.param=[self.layer1.param,self.layer2.param] - return - - - def fp(self,data): - # Perform forward propagation on the input data - data=flatten(data) - output1=self.layer1.output(data) - output2=self.layer2.output(output1) - return output2 - - - def loss(self,output,labels): - # Compute the loss between the output and the labels - return self.loss_object(labels,output) - - - def gradient(self,tape,loss): - # Compute the gradients of the loss with respect to the parameters - grads=tape.gradient(loss,self.param) - # Clip the gradients by value to avoid exploding gradients - return gradient_clipping(grads,'value',1.0) diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/layer/self_LSTM.py b/Note 7.0 pv documentation/DL/neural network/tensorflow/layer/self_LSTM.py deleted file mode 100644 index 1b93a9e6..00000000 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/layer/self_LSTM.py +++ /dev/null @@ -1,45 +0,0 @@ -import tensorflow as tf -from Note.nn.layer.LSTM import LSTM -from Note.nn.layer.self_attention import self_attention -from Note.nn.layer.dense import dense -from Note.nn.layer.emdedding import embedding - -# Define a LSTM self attention neural network class -class self_LSTM: - def __init__(self,vocab_size,embed_size,num_heads,num_layers): - self.vocab_size=vocab_size - self.embed_size=embed_size - self.num_heads=num_heads - # Initialize the loss function and the optimizer - self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) - self.opt=tf.keras.optimizers.Adam() - - - def build(self): - # Create an embedding layer to map input tokens to vectors - self.embedding_layer = embedding(self.vocab_size,self.embed_size) - # Create a LSTM layer to process the input sequence - self.lstm_layer = LSTM(weight_shape=[self.embed_size,self.embed_size],return_sequence=True) - # Create a self attention layer to attend to the LSTM output - self.self_attention_layer = self_attention(weight_shape=[self.embed_size,self.embed_size],num_heads=self.num_heads) - # Create a linear layer to map the attention output to logits - self.logits_layer = dense([self.embed_size,self.vocab_size]) - # Store the parameters of the layers in a list - self.param = [self.embedding_layer.embeddings] - self.param.extend(self.lstm_layer.param) - self.param.extend(self.self_attention_layer.param) - self.param.extend(self.logits_layer.param) - - - def fp(self,data): - # Perform forward propagation on the input data - x = self.embedding_layer.output(data) # shape: (batch_size, seq_len, embed_size) - x = self.lstm_layer.output(x) # shape: (batch_size, seq_len, embed_size) - x, attention_weights = self.self_attention_layer.output(x,self.num_heads) # shape: (batch_size, seq_len, embed_size) - output = self.logits_layer.output(x) # shape: (batch_size, seq_len, vocab_size) - return output - - - def loss(self,output,labels): - # Compute the loss between the output and the labels - return self.loss_object(labels,output) diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/lstm.py b/Note 7.0 pv documentation/DL/neural network/tensorflow/lstm.py deleted file mode 100644 index 1fb05875..00000000 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/lstm.py +++ /dev/null @@ -1,26 +0,0 @@ -import tensorflow as tf - - -class lstm: - def __init__(self,encoder): - self.model=tf.keras.Sequential([ - encoder, - tf.keras.layers.Embedding(len(encoder.get_vocabulary()), 64, mask_zero=True), - tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(64, return_sequences=True)), - tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(32)), - tf.keras.layers.Dense(64, activation='relu'), - tf.keras.layers.Dropout(0.5), - tf.keras.layers.Dense(1) - ]) - self.param=self.model.weights[1:] - self.opt=tf.keras.optimizers.Adam() - - - def fp(self,data): - output=self.model(data) - return output - - - def loss(self,output,labels): - bce=tf.keras.losses.BinaryCrossentropy(from_logits=True) - return bce(labels,output) diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/nn_attenuate.py b/Note 7.0 pv documentation/DL/neural network/tensorflow/nn_attenuate.py deleted file mode 100644 index 98cc31e9..00000000 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/nn_attenuate.py +++ /dev/null @@ -1,32 +0,0 @@ -import tensorflow as tf - - -#gradient attenuation example -class nn: - def __init__(self): - self.model=tf.keras.models.Sequential([ - tf.keras.layers.Flatten(input_shape=(28, 28)), - tf.keras.layers.Dense(128,activation='relu'), - tf.keras.layers.Dropout(0.2), - tf.keras.layers.Dense(10) - ]) - self.param=self.model.weights - self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) - self.opt=tf.keras.optimizers.Adam(learning_rate=0.001) - self.opt_counter=tf.Variable(tf.zeros(3,dtype=tf.float64)) - - - def fp(self,data): - output=self.model(data) - return output - - - def loss(self,output,labels): - return self.loss_object(labels,output) - - - def attenuate(self,gradient,oc,t): #gradient attenuation function,kernel uses it to calculate attenuation coefficient. - ac=0.9**oc[t] #ac:attenuation coefficient - for i in range(len(gradient)): #oc:optimizing counter - gradient[i]=ac*gradient[i] #t:thread number - return gradient diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/nn_device.py b/Note 7.0 pv documentation/DL/neural network/tensorflow/nn_device.py deleted file mode 100644 index 6b7b1135..00000000 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/nn_device.py +++ /dev/null @@ -1,27 +0,0 @@ -import tensorflow as tf - - -class nn: #A neural network class example,allocate device for multiple threads. - def __init__(self): - self.weight1=tf.Variable(tf.random.normal([784,64])) - self.bias1=tf.Variable(tf.random.normal([64])) - self.weight2=tf.Variable(tf.random.normal([64,64])) - self.bias2=tf.Variable(tf.random.normal([64])) - self.weight3=tf.Variable(tf.random.normal([64,10])) - self.bias3=tf.Variable(tf.random.normal([10])) - self.param=[self.weight1,self.weight2,self.weight3,self.bias1,self.bias2,self.bias3] - self.optimizer=tf.keras.optimizers.Adam() - self.device_table={0:'GPU:0',1:'GPU:0',2:'GPU:0',3:'GPU:1',4:'GPU:1',5:'GPU:1',6:'GPU:2'} - self.info='example' - - - def fp(self,data,t): - with tf.device(self.device_table[t]): - layer1=tf.nn.relu(tf.matmul(data,self.param[0])+self.param[3]) - layer2=tf.nn.relu(tf.matmul(layer1,self.param[1])+self.param[4]) - output=tf.matmul(layer2,self.param[2])+self.param[5] - return output - - - def loss(self,output,labels): - return tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=output,labels=labels)) diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/nn_ol.py b/Note 7.0 pv documentation/DL/neural network/tensorflow/nn_ol.py deleted file mode 100644 index 5a0beb8a..00000000 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/nn_ol.py +++ /dev/null @@ -1,37 +0,0 @@ -import tensorflow as tf -import numpy as np - -#This is an example of online training. -class nn: - def __init__(self,data,labels): - self.train_data=data - self.train_labels=labels - self.model=tf.keras.models.Sequential([ - tf.keras.layers.Flatten(input_shape=(28, 28)), - tf.keras.layers.Dense(128,activation='relu'), - tf.keras.layers.Dropout(0.2), - tf.keras.layers.Dense(10) - ]) - self.param=self.model.weights #parameter list,kernel uses it list for backpropagation. - self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) - self.opt=tf.keras.optimizers.Adam() #optimizer,kernel uses it to optimize. - self.train_loss_list=[] - self.c=0 #counter - self.max_length=1000 - - - def ol(self): #This is simulative online function. - index=np.random.choice(60000,size=[32]) - if self.c==10000: - return 'stop' - else: - return [self.train_data[index],self.train_labels[index]] - - - def fp(self,data): #forward propagation function,kernel uses it for forward propagation. - output=self.model(data) - return output - - - def loss(self,output,labels): #loss functino,kernel uses it to calculate loss. - return self.loss_object(labels,output) diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/nn_ol_p.py b/Note 7.0 pv documentation/DL/neural network/tensorflow/nn_ol_p.py deleted file mode 100644 index e7d0eb90..00000000 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/nn_ol_p.py +++ /dev/null @@ -1,37 +0,0 @@ -import tensorflow as tf -import numpy as np - -#This is an example of online training. -class nn: - def __init__(self,data,labels): - self.train_data=data - self.train_labels=labels - self.model=tf.keras.models.Sequential([ - tf.keras.layers.Flatten(input_shape=(28, 28)), - tf.keras.layers.Dense(128,activation='relu'), - tf.keras.layers.Dropout(0.2), - tf.keras.layers.Dense(10) - ]) - self.param=self.model.weights #parameter list,kernel uses it list for backpropagation. - self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) - self.opt=tf.keras.optimizers.Adam() #optimizer,kernel uses it to optimize. - self.train_loss_list=[] - self.c=0 #counter - self.max_length=1000 - - - def ol(self,t): #This is simulative online function. - index=np.random.choice(60000,size=[32]) - if self.c>=10000: - return 'stop' - else: - return [self.train_data[index],self.train_labels[index]] - - - def fp(self,data): #forward propagation function,kernel uses it for forward propagation. - output=self.model(data) - return output - - - def loss(self,output,labels): #loss functino,kernel uses it to calculate loss. - return self.loss_object(labels,output) diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/process/LSTM.py b/Note 7.0 pv documentation/DL/neural network/tensorflow/process/LSTM.py deleted file mode 100644 index 03527ea7..00000000 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/process/LSTM.py +++ /dev/null @@ -1,46 +0,0 @@ -import tensorflow as tf -from Note.nn.layer.LSTM import LSTM -from Note.nn.layer.dense import dense -import Note.nn.process.optimizer as o - -# Define a recurrent neural network class with LSTM layers -class lstm: - def __init__(self): - # Initialize the loss function and the optimizer - self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) - self.optimizer=o.Adam() - # Initialize a variable to keep track of the batch count - self.bc=tf.Variable(0, dtype=tf.float32) - - - def build(self): - # Create two LSTM layers with 50 hidden units each - self.lstm1=LSTM(weight_shape=(3,50),return_sequence=True) # First LSTM layer that returns the full sequence - self.lstm2=LSTM(weight_shape=(50,50),) # Second LSTM layer that returns the last output only - # Create a dense layer with 10 output units - self.dense=dense([50, 10]) - # Store the parameters of the layers in a list - self.param=[self.lstm1.param, - self.lstm2.param, - self.dense.param, - ] - return - - - def fp(self,data): - # Perform forward propagation on the input data - x=self.lstm1.output(data) # First LSTM layer output - x=self.lstm2.output(x) # Second LSTM layer output - output=self.dense.output(x) # Dense layer output - return output - - - def loss(self, output, labels): - # Compute the loss between the output and the labels - return self.loss_object(labels, output) - - - def opt(self,gradient): - # Perform optimization on the parameters using the gradient and the batch count - param=self.optimizer.opt(gradient,self.param,self.bc) - return param diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/process/Transformer.py b/Note 7.0 pv documentation/DL/neural network/tensorflow/process/Transformer.py deleted file mode 100644 index de39b10f..00000000 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/process/Transformer.py +++ /dev/null @@ -1,55 +0,0 @@ -import tensorflow as tf -import Note.nn.process.optimizer as o -from Note.nn.layer.Transformer import Transformer -from Note.nn.layer.dense import dense -from Note.nn.layer.emdedding import embedding -from Note.nn.positional_encoding import positional_encoding - -# Define a positional encoding transformer neural network class -class Transformer: - def __init__(self,vocab_size,embed_size,num_heads,num_layers,max_len): - self.vocab_size=vocab_size - self.embed_size=embed_size - self.num_heads=num_heads - self.num_layers=num_layers - self.max_len=max_len - # Initialize the loss function and the optimizer - self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) - self.optimizer=o.Adam() - # Initialize a variable to keep track of the batch count - self.bc=tf.Variable(0,dtype=tf.float32) - - - def build(self): - # Create an embedding layer to map input tokens to vectors - self.embedding_layer = embedding(self.vocab_size,self.embed_size) - # Create a list of transformer layers - self.transformer_layers = [transformer(weight_shape=[self.embed_size, self.embed_size], num_heads=self.num_heads) for _ in range(self.num_layers)] - # Create a linear layer to map the transformer output to logits - self.logits_layer = dense([self.embed_size,self.vocab_size]) - # Store the parameters of the layers in a list - self.param = [self.embedding_layer.embeddings] - for transformer_layer in self.transformer_layers: - self.param.extend(transformer_layer.param) - self.param.extend(self.logits_layer.param) - - - def fp(self,data): - # Perform forward propagation on the input data - x = self.embedding_layer.output(data) # shape: (batch_size, seq_len, embed_size) - x += positional_encoding(self.max_len,self.embed_size) # shape: (batch_size, seq_len, embed_size) - for transformer_layer in self.transformer_layers: - x = transformer_layer.output(x) # shape: (batch_size, seq_len, embed_size) - output = self.logits_layer.output(x) # shape: (batch_size, seq_len, vocab_size) - return output - - - def loss(self,output,labels): - # Compute the loss between the output and the labels - return self.loss_object(labels,output) - - - def opt(self,gradient): - # Perform optimization on the parameters using the gradient and the batch count - param=self.optimizer.opt(gradient,self.param,self.bc) - return param diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/process/attn_LSTM.py b/Note 7.0 pv documentation/DL/neural network/tensorflow/process/attn_LSTM.py deleted file mode 100644 index 728afb96..00000000 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/process/attn_LSTM.py +++ /dev/null @@ -1,53 +0,0 @@ -import tensorflow as tf -from Note.nn.layer.LSTM import LSTM -from Note.nn.layer.dense import dense -from Note.nn.layer.attention import attention -import Note.nn.process.optimizer as o - -# Define a recurrent neural network class with LSTM layers and attention -class attn_lstm: - def __init__(self): - # Initialize the loss function and the optimizer - self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) - self.optimizer=o.Adam() - # Initialize a variable to keep track of the batch count - self.bc=tf.Variable(0, dtype=tf.float32) - - - def build(self): - # Create two LSTM layers with 50 hidden units each - self.lstm1=LSTM(weight_shape=(3,50),return_sequence=True) # First LSTM layer that returns the full sequence - self.lstm2=LSTM(weight_shape=(50,50),) # Second LSTM layer that returns the last output only - # Create a dense layer with 10 output units and softmax activation - self.dense=dense([100, 10],activation='softmax') - # Create an attention object with weight shape (50, 50) - self.attn=attention((50,50)) - # Store the parameters of the layers and the attention in a list - self.param=[self.lstm1.param, - self.lstm2.param, - self.dense.param, - self.attn.param] # Add the attention parameters to the list - return - - - def fp(self,data): - # Perform forward propagation on the input data - x=self.lstm1.output(data) # First LSTM layer output, shape (B, N, 50) - y=self.lstm2.output(x) # Second LSTM layer output, shape (B, 50) - # Use the attention object to compute the context vector from x and y, shape (B, 50) - context_vector,_,_=self.attn.output(x,y) - # Concatenate the context vector and the second LSTM output, shape (B, 100) - z=tf.concat([context_vector,y],axis=-1) - output=self.dense.output(z) # Dense layer output with softmax activation, shape (B, 10) - return output - - - def loss(self,output,labels): - # Compute the loss between the output and the labels - return self.loss_object(labels,output) - - - def opt(self,gradient): - # Perform optimization on the parameters using the gradient and the batch count - param=self.optimizer.opt(gradient,self.param,self.bc) - return param \ No newline at end of file diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/process/cnn.py b/Note 7.0 pv documentation/DL/neural network/tensorflow/process/cnn.py deleted file mode 100644 index d5432232..00000000 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/process/cnn.py +++ /dev/null @@ -1,59 +0,0 @@ -import tensorflow as tf -from Note.nn.layer.conv2d import conv2d -from Note.nn.layer.dense import dense -from Note.nn.layer.flatten import flatten -import Note.nn.process.optimizer as o - -# Define a convolutional neural network class -class cnn: - def __init__(self): - # Initialize the loss function and the optimizer - self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) - self.optimizer=o.Adam() - # Initialize a variable to keep track of the batch count - self.bc=tf.Variable(0,dtype=tf.float32) - - - def build(self): - # Create three convolutional layers with relu activations - self.conv1=conv2d(weight_shape=(3,3,3,32),activation='relu') - self.conv2=conv2d(weight_shape=(3,3,32,64),activation='relu') - self.conv3=conv2d(weight_shape=(3,3,64,64),activation='relu') - # Create two dense layers with relu and linear activations - self.dense1=dense([64*4*4,64],activation='relu') - self.dense2=dense([64,10]) - # Store the parameters of the layers in a list - self.param = [self.conv1.weight, - self.conv2.weight, - self.conv3.weight, - self.dense1.weight, - self.dense1.bias, - self.dense2.weight, - self.dense2.bias] - return - - - def fp(self,data): - # Perform forward propagation on the input data - x=tf.nn.conv2d(data,self.conv1.weight,strides=(1,1),padding='SAME') # First convolutional layer - x=tf.nn.max_pool2d(x,ksize=(2,2),strides=(2,2),padding='VALID') # First max pooling layer - x=tf.nn.conv2d(x,self.conv2.weight,strides=(1,1),padding='SAME') # Second convolutional layer - x=tf.nn.max_pool2d(x,ksize=(2,2),strides=(2,2),padding='VALID') # Second max pooling layer - x=tf.nn.conv2d(x,self.conv3.weight,strides=(1,1),padding='SAME') # Third convolutional layer - x=flatten(x) # Flatten the output to a vector - x=tf.nn.relu(tf.matmul(x,self.dense1.weight)+self.dense1.bias) # First dense layer with relu activation - x=tf.nn.dropout(x,rate=0.5) # Apply dropout to prevent overfitting - output=tf.matmul(x,self.dense2.weight)+self.dense2.bias # Output layer with linear activation - output=tf.nn.dropout(output,rate=0.5) # Apply dropout to prevent overfitting - return output - - - def loss(self,output,labels): - # Compute the loss between the output and the labels - return self.loss_object(labels,output) - - - def opt(self,gradient): - # Perform optimization on the parameters using the gradient and the batch count - param=self.optimizer.opt(gradient,self.param,self.bc) - return param diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/process/cnn_lmix.py b/Note 7.0 pv documentation/DL/neural network/tensorflow/process/cnn_lmix.py deleted file mode 100644 index 1883f175..00000000 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/process/cnn_lmix.py +++ /dev/null @@ -1,67 +0,0 @@ -import tensorflow as tf -from Note.nn.layer.conv2d import conv2d -from Note.nn.layer.dense import dense -from Note.nn.layer.flatten import flatten -import Note.nn.process.optimizer as o -from Note.nn.layer.LMix import lmix - -# Define a convolutional neural network class with mixup augmentation -class cnn: - def __init__(self): - # Initialize the loss function and the optimizer - self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) - self.optimizer=o.Adam() - # Initialize the alpha parameter for mixup - self.alpha=1.0 - # Initialize a variable to keep track of the batch count - self.bc=tf.Variable(0,dtype=tf.float32) - - - def build(self): - # Create three convolutional layers with relu activations - self.conv1=conv2d(weight_shape=(3,3,3,32),activation='relu') - self.conv2=conv2d(weight_shape=(3,3,32,64),activation='relu') - self.conv3=conv2d(weight_shape=(3,3,64,64),activation='relu') - # Create two dense layers with relu and linear activations - self.dense1=dense([64*4*4,64],activation='relu') - self.dense2=dense([64,10]) - # Store the parameters of the layers in a list - self.param = [self.conv1.weight, - self.conv2.weight, - self.conv3.weight, - self.dense1.weight, - self.dense1.bias, - self.dense2.weight, - self.dense2.bias] - return - - - def data_func(self,data_batch,labels_batch): - # Apply mixup augmentation on the input data and labels - return lmix(data_batch,labels_batch,self.alpha) - - - def fp(self,data): - # Perform forward propagation on the input data - x=tf.nn.conv2d(data,self.conv1.weight,strides=(1,1),padding='SAME') # First convolutional layer - x=tf.nn.max_pool2d(x,ksize=(2,2),strides=(2,2),padding='VALID') # First max pooling layer - x=tf.nn.conv2d(x,self.conv2.weight,strides=(1,1),padding='SAME') # Second convolutional layer - x=tf.nn.max_pool2d(x,ksize=(2,2),strides=(2,2),padding='VALID') # Second max pooling layer - x=tf.nn.conv2d(x,self.conv3.weight,strides=(1,1),padding='SAME') # Third convolutional layer - x=flatten(x) # Flatten the output to a vector - x=tf.nn.relu(tf.matmul(x,self.dense1.weight)+self.dense1.bias) # First dense layer with relu activation - x=tf.nn.dropout(x,rate=0.5) # Apply dropout to prevent overfitting - output=tf.matmul(x,self.dense2.weight)+self.dense2.bias # Output layer with linear activation - output=tf.nn.dropout(output,rate=0.5) # Apply dropout to prevent overfitting - return output - - - def loss(self,output,labels): - # Compute the loss between the output and the labels - return self.loss_object(labels,output) - - - def opt(self,gradient): - # Perform optimization on the parameters using the gradient and the batch count - param=self.optimizer.opt(gradient,self.param,self.bc) - return param diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/process/nn_.py b/Note 7.0 pv documentation/DL/neural network/tensorflow/process/nn_.py deleted file mode 100644 index b1e11193..00000000 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/process/nn_.py +++ /dev/null @@ -1,39 +0,0 @@ -import tensorflow as tf -import Note.nn.process.optimizer as o -from Note.nn.layer.flatten import flatten - -# Define a neural network class -class nn: - def __init__(self): - # Initialize the weights and biases of three layers with random values - self.weight1=tf.Variable(tf.random.normal([784,64],dtype='float64')) - self.bias1=tf.Variable(tf.random.normal([64],dtype='float64')) - self.weight2=tf.Variable(tf.random.normal([64,64],dtype='float64')) - self.bias2=tf.Variable(tf.random.normal([64],dtype='float64')) - self.weight3=tf.Variable(tf.random.normal([64,10],dtype='float64')) - self.bias3=tf.Variable(tf.random.normal([10],dtype='float64')) - # Store the parameters of the layers in a list - self.param=[self.weight1,self.weight2,self.weight3,self.bias1,self.bias2,self.bias3] - # Initialize the loss function and the optimizer - self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) - self.optimizer=o.Momentum(0.07,0.7) - - - def fp(self,data): - # Perform forward propagation on the input data - data=flatten(data) - layer1=tf.nn.relu(tf.matmul(data,self.weight1)+self.bias1) # First layer with relu activation - layer2=tf.nn.relu(tf.matmul(layer1,self.weight2)+self.bias2) # Second layer with relu activation - output=tf.matmul(layer2,self.weight3)+self.bias3 # Output layer with linear activation - return output - - - def loss(self,output,labels): - # Compute the loss between the output and the labels - return self.loss_object(labels,output) - - - def opt(self,gradient): - # Perform optimization on the parameters using the gradient - param=self.optimizer.opt(gradient,self.param) - return param diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/process/nn_attenuate.py b/Note 7.0 pv documentation/DL/neural network/tensorflow/process/nn_attenuate.py deleted file mode 100644 index 17e827fa..00000000 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/process/nn_attenuate.py +++ /dev/null @@ -1,49 +0,0 @@ -import tensorflow as tf -import Note.nn.layer.dense as d -import Note.nn.process.optimizer as o -from Note.nn.layer.flatten import flatten - -# Define a neural network class with gradient attenuation -class nn: - def __init__(self): - # Initialize the loss function and the optimizer - self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) - self.optimizer=o.Momentum(0.07,0.7) - # Initialize a variable to keep track of the number of optimization steps - self.opt_counter=tf.Variable(tf.zeros(7,dtype=tf.float32)) - - - def build(self): - # Create two dense layers with relu and linear activations - self.layer1=d.dense([784,128],activation='relu') - self.layer2=d.dense([128,10]) - # Store the parameters of the layers in a list - self.param=[self.layer1.param,self.layer2.param] - return - - - def fp(self,data): - # Perform forward propagation on the input data - data=flatten(data) - output1=self.layer1.output(data) - output2=self.layer2.output(output1) - return output2 - - - def loss(self,output,labels): - # Compute the loss between the output and the labels - return self.loss_object(labels,output) - - - def attenuate(self,gradient,oc,p): #gradient attenuation function,kernel uses it to calculate attenuation coefficient. - # Apply an exponential decay to the gradient based on the optimization counter - ac=0.9**oc[p] #ac:attenuation coefficient - for i in range(len(gradient)): #oc:optimization counter - gradient[i]=ac*gradient[i] #p:process number - return gradient - - - def opt(self,gradient): - # Perform optimization on the parameters using the gradient - param=self.optimizer.opt(gradient,self.param) - return param diff --git a/Note 7.0 pv documentation/DL/neural network/tensorflow/process/self_LSTM.py b/Note 7.0 pv documentation/DL/neural network/tensorflow/process/self_LSTM.py deleted file mode 100644 index ea87f392..00000000 --- a/Note 7.0 pv documentation/DL/neural network/tensorflow/process/self_LSTM.py +++ /dev/null @@ -1,54 +0,0 @@ -import tensorflow as tf -import Note.nn.process.optimizer as o -from Note.nn.layer.LSTM import LSTM -from Note.nn.layer.self_attention import self_attention -from Note.nn.layer.dense import dense -from Note.nn.layer.emdedding import embedding - -# Define a LSTM self attention neural network class -class self_LSTM: - def __init__(self,vocab_size,embed_size,num_heads,num_layers): - self.vocab_size=vocab_size - self.embed_size=embed_size - self.num_heads=num_heads - # Initialize the loss function and the optimizer - self.loss_object=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) - self.optimizer=o.Adam() - # Initialize a variable to keep track of the batch count - self.bc=tf.Variable(0,dtype=tf.float32) - - - def build(self): - # Create an embedding layer to map input tokens to vectors - self.embedding_layer = embedding(self.vocab_size,self.embed_size) - # Create a LSTM layer to process the input sequence - self.lstm_layer = LSTM(weight_shape=[self.embed_size,self.embed_size],return_sequence=True) - # Create a self attention layer to attend to the LSTM output - self.self_attention_layer = self_attention(weight_shape=[self.embed_size,self.embed_size],num_heads=self.num_heads) - # Create a linear layer to map the attention output to logits - self.logits_layer = dense([self.embed_size,self.vocab_size]) - # Store the parameters of the layers in a list - self.param = [self.embedding_layer.embeddings] - self.param.extend(self.lstm_layer.param) - self.param.extend(self.self_attention_layer.param) - self.param.extend(self.logits_layer.param) - - - def fp(self,data): - # Perform forward propagation on the input data - x = self.embedding_layer.output(data) # shape: (batch_size, seq_len, embed_size) - x = self.lstm_layer.output(x) # shape: (batch_size, seq_len, embed_size) - x, attention_weights = self.self_attention_layer.output(x,self.num_heads) # shape: (batch_size, seq_len, embed_size) - output = self.logits_layer.output(x) # shape: (batch_size, seq_len, vocab_size) - return output - - - def loss(self,output,labels): - # Compute the loss between the output and the labels - return self.loss_object(labels,output) - - - def opt(self,gradient): - # Perform optimization on the parameters using the gradient and the batch count - param=self.optimizer.opt(gradient,self.param,self.bc) - return param diff --git a/Note 7.0 pv documentation/RL/kernel.txt b/Note 7.0 pv documentation/RL/kernel.txt deleted file mode 100644 index 1d6bbb21..00000000 --- a/Note 7.0 pv documentation/RL/kernel.txt +++ /dev/null @@ -1,19 +0,0 @@ -Pool network: -Pool network use multithreading parallel and random add episode in pool,which would make data being uncorrelated in pool, -then pools would be used parallel training agent. -Each thread have a pool. -Note have two types of pool network. - -First type: -Each thread number would save in list that is abstract. - -Second type: -Each thread number would save in matrix that is abstract. - -It also can be realized by higher dimension,but i haven't realized. - -Support stop mechanism. -Support prioritized replay. -Support gradient attenuation. -Support memory protection mechanism. -Support training priority and memory priority. diff --git a/Note 7.0 pv documentation/RL/neural network/tensorflow/DDPG.py b/Note 7.0 pv documentation/RL/neural network/tensorflow/DDPG.py deleted file mode 100644 index 3fc0cd49..00000000 --- a/Note 7.0 pv documentation/RL/neural network/tensorflow/DDPG.py +++ /dev/null @@ -1,84 +0,0 @@ -import tensorflow as tf -import numpy as np -import gym - - -class actor: - def __init__(self,state_dim,hidden_dim,action_dim,action_bound): - self.weight1=tf.Variable(tf.random.normal([state_dim,hidden_dim])) - self.bias1=tf.Variable(tf.random.normal([hidden_dim])) - self.weight2=tf.Variable(tf.random.normal([hidden_dim,action_dim])) - self.bias2=tf.Variable(tf.random.normal([action_dim])) - self.action_bound=action_bound - self.param=[self.weight1,self.bias1,self.weight2,self.bias2] - - - def fp(self,x): - x=tf.nn.relu(tf.matmul(x,self.weight1)+self.bias1) - return tf.nn.tanh(tf.matmul(x,self.weight2)+self.bias2)*self.action_bound - - -class critic: - def __init__(self,state_dim,hidden_dim,action_dim): - self.weight1=tf.Variable(tf.random.normal([state_dim+action_dim,hidden_dim])) - self.bias1=tf.Variable(tf.random.normal([hidden_dim])) - self.weight2=tf.Variable(tf.random.normal([hidden_dim,action_dim])) - self.bias2=tf.Variable(tf.random.normal([action_dim])) - self.param=[self.weight1,self.bias1,self.weight2,self.bias2] - - - def fp(self,x,a): - cat=tf.concat([x,a],axis=1) - x=tf.nn.relu(tf.matmul(cat,self.weight1)+self.bias1) - return tf.matmul(x,self.weight2)+self.bias2 - - -class DDPG: - def __init__(self,hidden_dim,sigma,gamma,tau,actor_lr,critic_lr): - self.genv=gym.make('Pendulum-v0') - state_dim=self.genv.observation_space.shape[0] - action_dim=self.genv.action_space.shape[0] - action_bound=self.genv.action_space.high[0] - self.actor=actor(state_dim,hidden_dim,action_dim,action_bound) - self.critic=critic(state_dim,hidden_dim,action_dim) - self.target_actor=actor(state_dim,hidden_dim,action_dim,action_bound) - self.target_critic=critic(state_dim,hidden_dim,action_dim) - self.actor_param=self.actor.param - self.critic_param=self.critic.param - self.target_actor.param=self.actor_param.copy() - self.target_critic.param=self.critic_param.copy() - self.param=[self.actor_param,self.critic_param] - self.sigma=sigma - self.gamma=gamma - self.tau=tau - self.opt=tf.keras.optimizers.Adam() - - - def noise(self): - return np.random.normal(scale=self.sigma) - - - def env(self,a=None,initial=None): - if initial==True: - state=self.genv.reset(seed=0) - return state - else: - next_state,reward,done,_=self.genv.step(a) - return next_state,reward,done - - - def loss(self,s,a,next_s,r,d): - a=tf.expand_dims(a,axis=1) - next_q_value=self.target_critic.fp(next_s,self.target_actor.fp(next_s)) - q_target=r+self.gamma*next_q_value*(1-d) - actor_loss=-tf.reduce_mean(self.critic.fp(s,self.actor.fp(s))) - critic_loss=tf.reduce_mean((self.critic.fp(s,a)-q_target)**2) - return [actor_loss,critic_loss] - - - def update_param(self): - for target_param,param in zip(self.target_actor.param,self.actor.param): - target_param=target_param*(1.0-self.tau)+param*self.tau - for target_param,param in zip(self.target_critic.param,self.critic.param): - target_param=target_param*(1.0-self.tau)+param*self.tau - return diff --git a/Note 7.0 pv documentation/RL/neural network/tensorflow/DQN.py b/Note 7.0 pv documentation/RL/neural network/tensorflow/DQN.py deleted file mode 100644 index 79650bf4..00000000 --- a/Note 7.0 pv documentation/RL/neural network/tensorflow/DQN.py +++ /dev/null @@ -1,46 +0,0 @@ -import tensorflow as tf -import gym - - -class Qnet: - def __init__(self,state_dim,hidden_dim,action_dim): - self.weight1=tf.Variable(tf.random.normal([state_dim,hidden_dim])) - self.bias1=tf.Variable(tf.random.normal([hidden_dim])) - self.weight2=tf.Variable(tf.random.normal([hidden_dim,action_dim])) - self.bias2=tf.Variable(tf.random.normal([action_dim])) - self.param=[self.weight1,self.bias1,self.weight2,self.bias2] - - def fp(self,x): #forward propagation function,kernel uses it for forward propagation. - x=tf.nn.relu(tf.matmul(x,self.weight1)+self.bias1) - return tf.matmul(x,self.weight2)+self.bias2 - - -class DQN: - def __init__(self,state_dim,hidden_dim,action_dim): - self.nn=Qnet(state_dim,hidden_dim,action_dim) - self.target_q_net=Qnet(state_dim,hidden_dim,action_dim) - self.param=self.nn.param #parameter list,kernel uses it list for backpropagation. - self.opt=tf.keras.optimizers.Adam() #optimizer,kernel uses it to optimize. - self.genv=gym.make('CartPole-v0') #create environment. - - - def env(self,a=None,initial=None): #environment function,kernel uses it to interact with the environment. - if initial==True: - state=self.genv.reset(seed=0) - return state - else: - next_state,reward,done,_=self.genv.step(a) - return next_state,reward,done - - - def loss(self,s,a,next_s,r,d): #loss functino,kernel uses it to calculate loss. - a=tf.expand_dims(a,axis=1) - q_value=tf.gather(self.nn.fp(s),a,axis=1,batch_dims=1) - next_q_value=tf.reduce_max(self.target_q_net.fp(next_s),axis=1) - target=r+0.98*next_q_value*(1-d) - return tf.reduce_mean((q_value-target)**2) - - - def update_param(self): #update function,kernel uses it to update parameter. - self.target_q_net.param=self.param.copy() - return diff --git a/Note 7.0 pv documentation/RL/neural network/tensorflow/pool net/DQN.py b/Note 7.0 pv documentation/RL/neural network/tensorflow/pool net/DQN.py deleted file mode 100644 index 2b23c816..00000000 --- a/Note 7.0 pv documentation/RL/neural network/tensorflow/pool net/DQN.py +++ /dev/null @@ -1,52 +0,0 @@ -import tensorflow as tf -import gym -import Note.nn.process.optimizer as o - - -class Qnet: - def __init__(self,state_dim,hidden_dim,action_dim): - self.weight1=tf.Variable(tf.random.normal([state_dim,hidden_dim])) - self.bias1=tf.Variable(tf.random.normal([hidden_dim])) - self.weight2=tf.Variable(tf.random.normal([hidden_dim,action_dim])) - self.bias2=tf.Variable(tf.random.normal([action_dim])) - self.param=[self.weight1,self.bias1,self.weight2,self.bias2] - - def fp(self,x): - x=tf.nn.relu(tf.matmul(x,self.weight1)+self.bias1) - return tf.matmul(x,self.weight2)+self.bias2 - - -class DQN: - def __init__(self,state_dim,hidden_dim,action_dim): - self.nn=Qnet(state_dim,hidden_dim,action_dim) - self.target_q_net=Qnet(state_dim,hidden_dim,action_dim) - self.param=self.nn.param - self.optimizer=o.Momentum(0.07,0.7) - self.genv=[gym.make('CartPole-v0') for _ in range(5)] - - - def env(self,a=None,p=None,initial=None): - if initial==True: - state=self.genv[p].reset(seed=0) - return state - else: - next_state,reward,done,_=self.genv[p].step(a) - return next_state,reward,done - - - def loss(self,s,a,next_s,r,d): - a=tf.expand_dims(a,axis=1) - q_value=tf.gather(self.nn.fp(s),a,axis=1,batch_dims=1) - next_q_value=tf.reduce_max(self.target_q_net.fp(next_s),axis=1) - target=r+0.98*next_q_value*(1-d) - return tf.reduce_mean((q_value-target)**2) - - - def update_param(self): - self.target_q_net.param=self.param.copy() - return - - - def opt(self,gradient): - param=self.optimizer.opt(gradient,self.param) - return param diff --git a/Note 7.0 pv documentation/RL/neural network/tensorflow/pool net/thread/DDPG.py b/Note 7.0 pv documentation/RL/neural network/tensorflow/pool net/thread/DDPG.py deleted file mode 100644 index 4f6479f9..00000000 --- a/Note 7.0 pv documentation/RL/neural network/tensorflow/pool net/thread/DDPG.py +++ /dev/null @@ -1,84 +0,0 @@ -import tensorflow as tf -import numpy as np -import gym - - -class actor: - def __init__(self,state_dim,hidden_dim,action_dim,action_bound): - self.weight1=tf.Variable(tf.random.normal([state_dim,hidden_dim])) - self.bias1=tf.Variable(tf.random.normal([hidden_dim])) - self.weight2=tf.Variable(tf.random.normal([hidden_dim,action_dim])) - self.bias2=tf.Variable(tf.random.normal([action_dim])) - self.action_bound=action_bound - self.param=[self.weight1,self.bias1,self.weight2,self.bias2] - - - def fp(self,x): - x=tf.nn.relu(tf.matmul(x,self.weight1)+self.bias1) - return tf.nn.tanh(tf.matmul(x,self.weight2)+self.bias2)*self.action_bound - - -class critic: - def __init__(self,state_dim,hidden_dim,action_dim): - self.weight1=tf.Variable(tf.random.normal([state_dim+action_dim,hidden_dim])) - self.bias1=tf.Variable(tf.random.normal([hidden_dim])) - self.weight2=tf.Variable(tf.random.normal([hidden_dim,action_dim])) - self.bias2=tf.Variable(tf.random.normal([action_dim])) - self.param=[self.weight1,self.bias1,self.weight2,self.bias2] - - - def fp(self,x,a): - cat=tf.concat([x,a],axis=1) - x=tf.nn.relu(tf.matmul(cat,self.weight1)+self.bias1) - return tf.matmul(x,self.weight2)+self.bias2 - - -class DDPG: - def __init__(self,hidden_dim,sigma,gamma,tau,actor_lr,critic_lr): - self.genv=[gym.make('Pendulum-v0') for _ in range(5)] - state_dim=self.genv[0].observation_space.shape[0] - action_dim=self.genv[0].action_space.shape[0] - action_bound=self.genv[0].action_space.high[0] - self.actor=actor(state_dim,hidden_dim,action_dim,action_bound) - self.critic=critic(state_dim,hidden_dim,action_dim) - self.target_actor=actor(state_dim,hidden_dim,action_dim,action_bound) - self.target_critic=critic(state_dim,hidden_dim,action_dim) - self.actor_param=self.actor.param - self.critic_param=self.critic.param - self.target_actor.param=self.actor_param.copy() - self.target_critic.param=self.critic_param.copy() - self.param=[self.actor_param,self.critic_param] - self.sigma=sigma - self.gamma=gamma - self.tau=tau - self.opt=tf.keras.optimizers.Adam() - - - def noise(self): - return np.random.normal(scale=self.sigma) - - - def env(self,a=None,t=None,initial=None): - if initial==True: - state=self.genv[t].reset(seed=0) - return state - else: - next_state,reward,done,_=self.genv[t].step(a) - return next_state,reward,done - - - def loss(self,s,a,next_s,r,d): - a=tf.expand_dims(a,axis=1) - next_q_value=self.target_critic.fp(next_s,self.target_actor.fp(next_s)) - q_target=r+self.gamma*next_q_value*(1-d) - actor_loss=-tf.reduce_mean(self.critic.fp(s,self.actor.fp(s))) - critic_loss=tf.reduce_mean((self.critic.fp(s,a)-q_target)**2) - return [actor_loss,critic_loss] - - - def update_param(self): - for target_param,param in zip(self.target_actor.param,self.actor.param): - target_param=target_param*(1.0-self.tau)+param*self.tau - for target_param,param in zip(self.target_critic.param,self.critic.param): - target_param=target_param*(1.0-self.tau)+param*self.tau - return diff --git a/Note 7.0 pv documentation/RL/neural network/tensorflow/pool net/thread/DQN.py b/Note 7.0 pv documentation/RL/neural network/tensorflow/pool net/thread/DQN.py deleted file mode 100644 index b3117956..00000000 --- a/Note 7.0 pv documentation/RL/neural network/tensorflow/pool net/thread/DQN.py +++ /dev/null @@ -1,46 +0,0 @@ -import tensorflow as tf -import gym - - -class Qnet: - def __init__(self,state_dim,hidden_dim,action_dim): - self.weight1=tf.Variable(tf.random.normal([state_dim,hidden_dim])) - self.bias1=tf.Variable(tf.random.normal([hidden_dim])) - self.weight2=tf.Variable(tf.random.normal([hidden_dim,action_dim])) - self.bias2=tf.Variable(tf.random.normal([action_dim])) - self.param=[self.weight1,self.bias1,self.weight2,self.bias2] - - def fp(self,x): #forward propagation function,kernel uses it for forward propagation. - x=tf.nn.relu(tf.matmul(x,self.weight1)+self.bias1) - return tf.matmul(x,self.weight2)+self.bias2 - - -class DQN: - def __init__(self,state_dim,hidden_dim,action_dim): - self.nn=Qnet(state_dim,hidden_dim,action_dim) - self.target_q_net=Qnet(state_dim,hidden_dim,action_dim) - self.param=self.nn.param #parameter list,kernel uses it list for backpropagation. - self.opt=tf.keras.optimizers.Adam() #optimizer,kernel uses it to optimize. - self.genv=[gym.make('CartPole-v0') for _ in range(5)] #create environment. - - - def env(self,a=None,t=None,initial=None): #environment function,kernel uses it to interact with the environment. - if initial==True: - state=self.genv[t].reset(seed=0) - return state - else: - next_state,reward,done,_=self.genv[t].step(a) - return next_state,reward,done - - - def loss(self,s,a,next_s,r,d): #loss functino,kernel uses it to calculate loss. - a=tf.expand_dims(a,axis=1) - q_value=tf.gather(self.nn.fp(s),a,axis=1,batch_dims=1) - next_q_value=tf.reduce_max(self.target_q_net.fp(next_s),axis=1) - target=r+0.98*next_q_value*(1-d) - return tf.reduce_mean((q_value-target)**2) - - - def update_param(self): #update function,kernel uses it to update parameter. - self.target_q_net.param=self.param.copy() - return diff --git a/Note 7.0 pv documentation/RL/neural network/tensorflow/pool net/thread/DQN_m.py b/Note 7.0 pv documentation/RL/neural network/tensorflow/pool net/thread/DQN_m.py deleted file mode 100644 index a9a2cd85..00000000 --- a/Note 7.0 pv documentation/RL/neural network/tensorflow/pool net/thread/DQN_m.py +++ /dev/null @@ -1,48 +0,0 @@ -import tensorflow as tf -import gym - - -class Qnet: - def __init__(self,state_dim,hidden_dim,action_dim): - self.weight1=tf.Variable(tf.random.normal([state_dim,hidden_dim])) - self.bias1=tf.Variable(tf.random.normal([hidden_dim])) - self.weight2=tf.Variable(tf.random.normal([hidden_dim,action_dim])) - self.bias2=tf.Variable(tf.random.normal([action_dim])) - self.param=[self.weight1,self.bias1,self.weight2,self.bias2] - - def fp(self,x): - x=tf.nn.relu(tf.matmul(x,self.weight1)+self.bias1) - return tf.matmul(x,self.weight2)+self.bias2 - - -class DQN: - def __init__(self,state_dim,hidden_dim,action_dim): - self.nn=Qnet(state_dim,hidden_dim,action_dim) - self.target_q_net=Qnet(state_dim,hidden_dim,action_dim) - self.param=self.nn.param - self.opt=tf.keras.optimizers.Adam() - self.genv=[gym.make('CartPole-v0') for _ in range(5)] - self.row=2 - self.rank=2 - - - def env(self,a=None,t=None,initial=None): - if initial==True: - state=self.genv[t].reset(seed=0) - return state - else: - next_state,reward,done,_=self.genv[t].step(a) - return next_state,reward,done - - - def loss(self,s,a,next_s,r,d): - a=tf.expand_dims(a,axis=1) - q_value=tf.gather(self.nn.fp(s),a,axis=1,batch_dims=1) - next_q_value=tf.reduce_max(self.target_q_net.fp(next_s),axis=1) - target=r+0.98*next_q_value*(1-d) - return tf.reduce_mean((q_value-target)**2) - - - def update_param(self): - self.target_q_net.param=self.param.copy() - return diff --git a/Note 7.0 pv documentation/RL/neural network/tensorflow/pool net/thread/DQN_mtpr.py b/Note 7.0 pv documentation/RL/neural network/tensorflow/pool net/thread/DQN_mtpr.py deleted file mode 100644 index 114f594b..00000000 --- a/Note 7.0 pv documentation/RL/neural network/tensorflow/pool net/thread/DQN_mtpr.py +++ /dev/null @@ -1,59 +0,0 @@ -import tensorflow as tf -import gym -import Note.create.RL.rl.prioritized_replay as pr - - -class Qnet: - def __init__(self,state_dim,hidden_dim,action_dim): - self.weight1=tf.Variable(tf.random.normal([state_dim,hidden_dim])) - self.bias1=tf.Variable(tf.random.normal([hidden_dim])) - self.weight2=tf.Variable(tf.random.normal([hidden_dim,action_dim])) - self.bias2=tf.Variable(tf.random.normal([action_dim])) - self.param=[self.weight1,self.bias1,self.weight2,self.bias2] - - def fp(self,x): - x=tf.nn.relu(tf.matmul(x,self.weight1)+self.bias1) - return tf.matmul(x,self.weight2)+self.bias2 - - -class DQN: - def __init__(self,state_dim,hidden_dim,action_dim): - self.nn=Qnet(state_dim,hidden_dim,action_dim) - self.target_q_net=Qnet(state_dim,hidden_dim,action_dim) - self.param=self.nn.param - self.pr=pr.pr_mt() - self.initial_TD=7 - self._epsilon=0.0007 - self.alpha=0.7 - self.opt=tf.keras.optimizers.Adam() - self.genv=[gym.make('CartPole-v0') for _ in range(5)] - - - def env(self,a=None,t=None,initial=None): - if initial==True: - state=self.genv[t].reset(seed=0) - return state - else: - next_state,reward,done,_=self.genv[t].step(a) - return next_state,reward,done - - - def data_func(self,state_pool,action_pool,next_state_pool,reward_pool,done_pool,batch,t): - s,a,next_s,r,d=self.pr.sample(state_pool,action_pool,next_state_pool,reward_pool,done_pool,self.epsilon,self.alpha,batch,t) - return s,a,next_s,r,d - - - def loss(self,s,a,next_s,r,d,t): - a=tf.expand_dims(a,axis=1) - q_value=tf.gather(self.nn.fp(s),a,axis=1,batch_dims=1) - next_q_value=tf.reduce_max(self.target_q_net.fp(next_s),axis=1) - target=r+0.98*next_q_value*(1-d) - target=tf.expand_dims(target,axis=1) - TD=target-q_value - self.pr.update_TD(TD,t) - return tf.reduce_mean(TD**2) - - - def update_param(self): - self.target_q_net.param=self.param.copy() - return diff --git a/Note 7.0 pv documentation/compiler/nc.txt b/Note 7.0 pv documentation/compiler/nc.txt deleted file mode 100644 index 14ea9e06..00000000 --- a/Note 7.0 pv documentation/compiler/nc.txt +++ /dev/null @@ -1,33 +0,0 @@ -Note Compiler - -Note Compiler can compile filename.n into filename.py. -Using Note compiler can use different grammar to write your neural network in filename.n. - -Grammar transition by Note Compiler: -Operator: -(object.*object)->tf.matmul(object1,object2) -(object.^)->tf.reverse(object) -(object1.|object2)->tf.concat([object1,object2],0) -(object1.||object2)->tf.concat([object1,object2],1) -(object./)->tf.math.sqrt(object) -(object1.=object2)->state_ops.assign(object1,object2) - -Init: -example: -param=zint32. [3,4]->param=tf.zeros([3,4],dtype=tf.int32) -return zint32. [3,4]->return tf.zeros([3,4],dtype=tf.int32) -param=uint32. (0,1)[3,4]->param=tf.random.uniform([3,4],0,1,dtype=tf.int32) -return uint32. (0,1)[3,4]->return tf.random.uniform([3,4],0,1,dtype=tf.int32) -param=nint32. (0,1)[3,4]->param=tf.random.normal([3,4],0,1,dtype=tf.int32) -return nint32. (0,1)[3,4]->return tf.random.normal([3,4],0,1,dtype=tf.int32) -param=oint32. [3,4]->param=tf.ones([3,4],dtype=tf.int32) -return oint32. [3,4]->return tf.ones([3,4],dtype=tf.int32) - -Using example: -import Note.create.nc as nc -c=nc.compiler('nn.n') -c.Compile() -#then you will get filename.py. - -Macro: -define. macro name string \ No newline at end of file diff --git a/Note 7.0 pv documentation/compiler/nn.n b/Note 7.0 pv documentation/compiler/nn.n deleted file mode 100644 index fdf619f1..00000000 --- a/Note 7.0 pv documentation/compiler/nn.n +++ /dev/null @@ -1,26 +0,0 @@ -import tensorflow as tf -define. Pi 3.14 - -class nn: #a simple example,a neural network class - def __init__(self): - self.weight1=tf.Variable(nfloat32. [784,64]) - self.bias1=tf.Variable(nfloat32. [64]) - self.weight2=tf.Variable(nfloat32. [64,64]) - self.bias2=tf.Variable(nfloat32. [64]) - self.weight3=tf.Variable(nfloat32. [64,10]) - self.bias3=tf.Variable(nfloat32. [10]) - self.param=[self.weight1,self.weight2,self.weight3,self.bias1,self.bias2,self.bias3] - self.opt=tf.keras.optimizers.Adam() - self.info='example' - - - def fp(self,data): - with tf.device('GPU:0'): - layer1=tf.nn.relu((data.*self.weight1)+self.bias1) - layer2=tf.nn.relu((layer1.*self.weight2)+self.bias2) - output=(layer2.*self.weight3)+self.bias3+Pi - return output - - - def loss(self,output,labels): - return tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=output,labels=labels)) \ No newline at end of file diff --git a/Note 7.0 pv documentation/compiler/nn.py b/Note 7.0 pv documentation/compiler/nn.py deleted file mode 100644 index 7d02bda4..00000000 --- a/Note 7.0 pv documentation/compiler/nn.py +++ /dev/null @@ -1,25 +0,0 @@ -import tensorflow as tf - -class nn: #a simple example,a neural network class - def __init__(self): - self.weight1=tf.Variable(tf.random.normal([784,64],dtype=tf.float32)) - self.bias1=tf.Variable(tf.random.normal([64],dtype=tf.float32)) - self.weight2=tf.Variable(tf.random.normal([64,64],dtype=tf.float32)) - self.bias2=tf.Variable(tf.random.normal([64],dtype=tf.float32)) - self.weight3=tf.Variable(tf.random.normal([64,10],dtype=tf.float32)) - self.bias3=tf.Variable(tf.random.normal([10],dtype=tf.float32)) - self.param=[self.weight1,self.weight2,self.weight3,self.bias1,self.bias2,self.bias3] - self.opt=tf.keras.optimizers.Adam() - self.info='example' - - - def fp(self,data): - with tf.device('GPU:0'): - layer1=tf.nn.relu(tf.matmul(data,self.weight1)+self.bias1) - layer2=tf.nn.relu(tf.matmul(layer1,self.weight2)+self.bias2) - output=tf.matmul(layer2,self.weight3)+self.bias3+3.14 - return output - - - def loss(self,output,labels): - return tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=output,labels=labels)) \ No newline at end of file diff --git a/README.md b/README.md deleted file mode 100644 index 00233a70..00000000 --- a/README.md +++ /dev/null @@ -1,484 +0,0 @@ -# Stop training and saving when condition is met: -## DL: -**example(Stop training and saving when condition is met.):** -```python -import Note.DL.kernel as k #import kernel -import tensorflow as tf #import platform -import nn as n #import neural network -mnist=tf.keras.datasets.mnist -(x_train,y_train),(x_test,y_test)=mnist.load_data() -x_train,x_test =x_train/255.0,x_test/255.0 -nn=n.nn() #create neural network object -kernel=k.kernel(nn) #start kernel -kernel.platform=tf #use platform -kernel.stop=True -kernel.end_loss=0.7 -kernel.data(x_train,y_train) #input you data -kernel.train(32,5) #train neural network - #batch size:32 - #epoch:5 -``` - -## RL: -**example(Stop training and saving when condition is met.):** -```python -import Note.RL.kernel as k #import kernel -import DQN as d -dqn=d.DQN(4,128,2) #create neural network object -kernel=k.kernel(dqn,5) #start kernel -kernel.stop=True -kernel.action_count=2 -kernel.set_up(epsilon=0.01,pool_size=10000,batch=64,update_step=10,trial_count=10,criterion=200) -kernel.train(500) -kernel.loss_list or kernel.loss #view training loss -kernel.visualize_train() -kernel.reward #view reward -kernel.visualize_reward() -``` - - -# Parallel test: -**You can download neural network example in this link,and then you can import neural network and train with kernel,link and example code are below.** - -https://github.com/NoteDancing/Note-documentation/blob/Note-7.0-pv/Note%207.0%20pv%20documentation/DL/neural%20network/tensorflow/nn_acc.py - -**example(parallel test):** -```python -import Note.DL.kernel as k #import kernel -import tensorflow as tf #import platform -import nn_acc as n #import neural network -import threading -mnist=tf.keras.datasets.mnist -(x_train,y_train),(x_test,y_test)=mnist.load_data() -x_train,x_test =x_train/255.0,x_test/255.0 -nn=n.nn() #create neural network object -kernel=k.kernel(nn) #start kernel -kernel.threading=threading -kernel.thread_t=6 #test thread count -kernel.platform=tf #use platform -kernel.data(x_train,y_train,x_test,y_test) #input you data -kernel.train(32,5,32) #train neural network - #batch size:32 - #test batch size:32 - #epoch:5 -kernel.save() #save neural network -``` - -**example(test module):** -```python -import nn_acc as n -import Note.DL.dl.test as t -import threading -mnist=tf.keras.datasets.mnist -(x_train,y_train),(x_test,y_test)=mnist.load_data() -x_train,x_test =x_train/255.0,x_test/255.0 -nn=n.nn() -test=t.parallel_test(nn,x_test,y_test,6,32) -test.segment_data() -class thread(threading.Thread): - def run(self): - test.test() -for _ in range(6): - _thread=thread() - _thread.start() -for _ in range(6): - _thread.join() -loss,acc=test.loss_acc() -``` - - -# Multiprocessing: -## PO3: -**multiprocessing example(PO3):** -```python -import Note.DL.process.kernel as k #import kernel -import tensorflow as tf -import nn as n #import neural network -from multiprocessing import Process,Lock,Manager -mnist=tf.keras.datasets.mnist -(x_train,y_train),(x_test,y_test)=mnist.load_data() -x_train,x_test =x_train/255.0,x_test/255.0 -x_train=x_train.reshape([60000,784]) -nn=n.nn() #create neural network object -nn.build() -kernel=k.kernel(nn) #start kernel -kernel.process=7 #7 processes to train -kernel.data_segment_flag=True -kernel.epoch=6 #epoch:6 -kernel.batch=32 #batch:32 -kernel.PO=3 #use PO3 -kernel.data(x_train,y_train) #input you data -manager=Manager() #create manager object -kernel.init(manager) #initialize shared data -lock=[Lock(),Lock()] -g_lock=[Lock(),Lock(),Lock()] -for p in range(7): - Process(target=kernel.train,args=(p,lock,g_lock)).start() -kernel.update_nn_param() -kernel.test(x_train,y_train,32) -``` -## Stop training and saving when condition is met: -**multiprocessing example(Stop training and saving when condition is met.):** -```python -import Note.DL.process.kernel as k #import kernel -import tensorflow as tf -import nn as n #import neural network -from multiprocessing import Process,Lock,Manager -mnist=tf.keras.datasets.mnist -(x_train,y_train),(x_test,y_test)=mnist.load_data() -x_train,x_test =x_train/255.0,x_test/255.0 -x_train=x_train.reshape([60000,784]) -nn=n.nn() #create neural network object -nn.build() -kernel=k.kernel(nn) #start kernel -kernel.stop=True -kernel.end_loss=0.7 #stop condition -kernel.process=7 #7 processes to train -kernel.data_segment_flag=True -kernel.epoch=6 #epoch:6 -kernel.batch=32 #batch:32 -kernel.PO=3 #use PO3 -kernel.data(x_train,y_train) #input you data -manager=Manager() #create manager object -kernel.init(manager) #initialize shared data -lock=[Lock(),Lock()] -g_lock=[Lock(),Lock(),Lock()] -for p in range(7): - Process(target=kernel.train,args=(p,lock,g_lock)).start() -``` - - -# Multithreading: -## DL： -**You can download neural network example in this link,and then you can import neural network and train with kernel,link and example code are below.** - -https://github.com/NoteDancing/Note-documentation/blob/Note-7.0-pv/Note%207.0%20pv%20documentation/DL/neural%20network/tensorflow/nn.py - -**multithreading example:** -```python -import Note.DL.kernel as k #import kernel -import tensorflow as tf #import platform -import nn as n #import neural network -import threading -mnist=tf.keras.datasets.mnist -(x_train,y_train),(x_test,y_test)=mnist.load_data() -x_train,x_test =x_train/255.0,x_test/255.0 -nn=n.nn() #create neural network object -kernel=k.kernel(nn) #start kernel -kernel.platform=tf #use platform -kernel.thread=7 #thread count,use 7 threads to train -kernel.epoch_=6 #epoch:6 -kernel.PO=2 #use PO2 -kernel.data(x_train,y_train) #input you data -kernel.lock=[threading.Lock(),threading.Lock(),threading.Lock()] -class thread(threading.Thread): - def run(self): - kernel.train(32) #batch size:32 -for _ in range(7): - _thread=thread() - _thread.start() -for _ in range(7): - _thread.join() -kernel.visualize_train() -``` - -**multithreading example(segment data):** -```python -import Note.DL.kernel as k #import kernel -import tensorflow as tf #import platform -import nn as n #import neural network -import threading -mnist=tf.keras.datasets.mnist -(x_train,y_train),(x_test,y_test)=mnist.load_data() -x_train,x_test =x_train/255.0,x_test/255.0 -nn=n.nn() #create neural network object -kernel=k.kernel(nn) #start kernel -kernel.platform=tf #use platform -kernel.thread=7 #thread count,use 7 threads to train -kernel.data_segment_flag=True -kernel.batches=1875 #batches:1875 -kernel.epoch_=6 #epoch:6 -kernel.PO=2 -kernel.data(x_train,y_train) #input you data -kernel.lock=[threading.Lock(),threading.Lock(),threading.Lock()] -class thread(threading.Thread): - def run(self): - kernel.train(32) #batch size:32 -for _ in range(7): - _thread=thread() - _thread.start() -for _ in range(7): - _thread.join() -kernel.visualize_train() -``` - -**multithreading example:** -```python -import Note.DL.kernel as k #import kernel -import tensorflow as tf #import platform -import nn as n #import neural network -import threading -mnist=tf.keras.datasets.mnist -(x_train,y_train),(x_test,y_test)=mnist.load_data() -x_train,x_test =x_train/255.0,x_test/255.0 -nn=n.nn() #create neural network object -kernel=k.kernel(nn) #start kernel -kernel.platform=tf #use platform -kernel.thread=2 #thread count,use 2 threads to train -kernel.PO=2 #use PO2 -kernel.data(x_train,y_train) #input you data -kernel.lock=[threading.Lock(),threading.Lock(),threading.Lock()] -class thread(threading.Thread): - def run(self): - kernel.train(32,3) #batch size:32 epoch:3 -for _ in range(2): - _thread=thread() - _thread.start() -for _ in range(2): - _thread.join() -kernel.visualize_train() -``` - -### Stop training and saving when condition is met: -**multithreading example(Stop training and saving when condition is met.):** -```python -import Note.DL.kernel as k #import kernel -import tensorflow as tf #import platform -import nn as n #import neural network -import threading -mnist=tf.keras.datasets.mnist -(x_train,y_train),(x_test,y_test)=mnist.load_data() -x_train,x_test =x_train/255.0,x_test/255.0 -nn=n.nn() #create neural network object -kernel=k.kernel(nn) #start kernel -kernel.platform=tf #use platform -kernel.stop=True -kernel.end_loss=0.7 #stop condition -kernel.thread=2 #thread count,use 2 threads to train -kernel.PO=2 -kernel.data(x_train,y_train) #input you data -kernel.lock=[threading.Lock(),threading.Lock(),threading.Lock()] -class thread(threading.Thread): - def run(self): - kernel.train(32,3) #batch size:32 epoch:3 -for _ in range(2): - _thread=thread() - _thread.start() -for _ in range(2): - _thread.join() -kernel.train_loss_list or kernel.train_loss #view training loss -kernel.visualize_train() -``` - -**Gradient Attenuation：** - -**Calculate the attenuation coefficient based on the optimization counter using the attenuation function.** - -**example:https://github.com/NoteDancing/Note-documentation/blob/Note-7.0-pv/Note%207.0%20pv%20documentation/DL/neural%20network/tensorflow/nn_attenuate.py** - -## RL： -### Pool Network: -**You can download neural network example in this link,and then you can import neural network and train with kernel,link and example code are below.** - -https://github.com/NoteDancing/Note-documentation/blob/Note-7.0-pv/Note%207.0%20pv%20documentation/RL/neural%20network/tensorflow/pool%20net/thread/DQN.py - -**multithreading example:** -```python -import Note.RL.thread.kernel as k #import kernel -import DQN as d -import threading -dqn=d.DQN(4,128,2) #create neural network object -kernel=k.kernel(dqn,5) #start kernel,use 5 thread to train -kernel.action_count=2 -kernel.set_up(epsilon=0.01,pool_size=10000,batch=64,update_step=10) -kernel.PO=1 #use PO1 -kernel.threading=threading -kernel.lock=[threading.Lock(),threading.Lock(),threading.Lock()] -class thread(threading.Thread): - def run(self): - kernel.train(100) -for _ in range(5): - _thread=thread() - _thread.start() -for _ in range(5): - _thread.join() -kernel.visualize_train() -kernel.visualize_reward() -``` - -### Stop training and saving when condition is met: -**multithreading example(Stop training and saving when condition is met.):** -```python -import Note.RL.kernel as k #import kernel -import DQN as d -import threading -dqn=d.DQN(4,128,2) #create neural network object -kernel=k.kernel(dqn,5) #start kernel,use 5 thread to train -kernel.stop=True -kernel.action_count=2 -kernel.set_up(epsilon=0.01,pool_size=10000,batch=64,update_step=10,trial_count=10,criterion=200) -kernel.PO=1 -kernel.threading=threading -kernel.lock=[threading.Lock(),threading.Lock(),threading.Lock()] -class thread(threading.Thread): - def run(self): - kernel.train(100) -for _ in range(5): - _thread=thread() - _thread.start() -for _ in range(5): - _thread.join() -kernel.loss_list or kernel.loss #view training loss -kernel.visualize_train() -kernel.reward #view reward -kernel.visualize_reward() -``` - -## PO3: -**multithreading example(PO3):** -```python -import Note.DL.kernel as k #import kernel -import tensorflow as tf #import platform -import nn as n #import neural network -import threading -mnist=tf.keras.datasets.mnist -(x_train,y_train),(x_test,y_test)=mnist.load_data() -x_train,x_test =x_train/255.0,x_test/255.0 -nn=n.nn() #create neural network object -kernel=k.kernel(nn) #start kernel -kernel.platform=tf #use platform -kernel.thread=7 #thread count,use 7 threads to train -kernel.PO=3 #use PO3 -kernel.threading=threading -kernel.max_lock=7 -kernel.data(x_train,y_train) #input you data -kernel.lock=[threading.Lock(),threading.Lock()] -class thread(threading.Thread): - def run(self): - kernel.train(32,1) #batch size:32 epoch:1 -for _ in range(7): - _thread=thread() - _thread.start() -for _ in range(7): - _thread.join() -``` - -## Parallel test: -**You can download neural network example in this link,and then you can import neural network and train with kernel,link and example code are below.** - -https://github.com/NoteDancing/Note-documentation/blob/Note-7.0-pv/Note%207.0%20pv%20documentation/DL/neural%20network/tensorflow/nn_acc.py - -**multithreading example(parallel test):** -```python -import Note.DL.kernel as k #import kernel -import tensorflow as tf #import platform -import nn_acc as n #import neural network -import threading -mnist=tf.keras.datasets.mnist -(x_train,y_train),(x_test,y_test)=mnist.load_data() -x_train,x_test =x_train/255.0,x_test/255.0 -nn=n.nn() #create neural network object -kernel=k.kernel(nn) #start kernel -kernel.platform=tf #use platform -kernel.threading=threading -kernel.thread=7 #thread count,use 7 threads to train -kernel.thread_t=6 #test thread count -kernel.epoch_=6 #epoch:6 -kernel.PO=2 -kernel.data(x_train,y_train,x_test,y_test) #input you data -kernel.lock=[threading.Lock(),threading.Lock(),threading.Lock()] -class thread(threading.Thread): - def run(self): - kernel.train(32,test_batch=32) #batch size:32 -for _ in range(7): - _thread=thread() - _thread.start() -for _ in range(7): - _thread.join() -kernel.visualize_train() -``` - -## Online training: -**You can download neural network example in this link,and then you can import neural network and train with kernel,link and example code are below.** - -https://github.com/NoteDancing/Note-documentation/blob/Note-7.0-pv/Note%207.0%20pv%20documentation/DL/neural%20network/tensorflow/nn_ol_p.py - -**multithreading example:** -```python -import Note.DL.kernel as k #import kernel -import tensorflow as tf #import platform -import nn_ol_p as n #import neural network -import threading -mnist=tf.keras.datasets.mnist -(x_train,y_train),(x_test,y_test)=mnist.load_data() -x_train,x_test =x_train/255.0,x_test/255.0 -nn=n.nn(x_train,y_train) #create neural network object -kernel=k.kernel(nn) #start kernel -kernel.platform=tf #use platform -kernel.thread=7 #thread count,use 7 thread to train -kernel.PO=2 -kernel.create_t_num(7) #input you data -kernel.lock=[threading.Lock(),threading.Lock(),threading.Lock()] -class thread(threading.Thread): - def run(self): - kernel.train_ol() -for _ in range(7): - _thread=thread() - _thread.start() -for _ in range(7): - _thread.join() -``` - - -# Test neural network: -## DL: -You can test it before using the kernel training neural network. -```python -import Note.DL.dl.test_nn as t -import tensorflow as tf #import platform -import nn as n #import neural network -mnist=tf.keras.datasets.mnist -(x_train,y_train),(x_test,y_test)=mnist.load_data() -x_train,x_test =x_train/255.0,x_test/255.0 -nn=n.nn() -t.test(cnn,tf,x_train[:32],y_train[:32]) -``` - -## RL: -You can test it before using the kernel training neural network. -```python -import Note.RL.rl.test_nn as t -import tensorflow as tf #import platform -import DQN as d -dqn=d.DQN(4,128,2) #create neural network object -t.test(dqn,tf,2) -``` - - -# Online training: -**You can download neural network example in this link,and then you can import neural network and train with kernel,link and example code are below.** - -https://github.com/NoteDancing/Note-documentation/blob/Note-7.0-pv/Note%207.0%20pv%20documentation/DL/neural%20network/tensorflow/nn_ol.py - -**example:** -```python -import Note.DL.kernel as k #import kernel #import platform -import nn_ol as n #import neural network -mnist=tf.keras.datasets.mnist -(x_train,y_train),(x_test,y_test)=mnist.load_data() -x_train,x_test =x_train/255.0,x_test/255.0 -nn=n.nn(x_train,y_train) #create neural network object -kernel=k.kernel(nn) #start kernel -kernel.platform=tf #use platform -kernel.data(x_train,y_train) #input you data -kernel.train_ol() #train neural network -``` - - -# Note Compiler: -documentation:https://github.com/NoteDancing/Note-documentation/tree/Note-7.0-pv/Note%207.0%20pv%20documentation/compiler -```python -import Note.nc as nc -c=nc.compiler('nn.n') -c.Compile() -``` diff --git a/picture/Pool Net.png b/picture/Pool Net.png deleted file mode 100644 index 16c35f8f..00000000 Binary files a/picture/Pool Net.png and /dev/null differ diff --git a/picture/gradient attenuation/1/attenuation.png b/picture/gradient attenuation/1/attenuation.png deleted file mode 100644 index 2258c752..00000000 Binary files a/picture/gradient attenuation/1/attenuation.png and /dev/null differ diff --git a/picture/gradient attenuation/1/no attenuation.png b/picture/gradient attenuation/1/no attenuation.png deleted file mode 100644 index 668b38c9..00000000 Binary files a/picture/gradient attenuation/1/no attenuation.png and /dev/null differ diff --git a/picture/gradient attenuation/2/attenuation.png b/picture/gradient attenuation/2/attenuation.png deleted file mode 100644 index f834bda9..00000000 Binary files a/picture/gradient attenuation/2/attenuation.png and /dev/null differ diff --git a/picture/gradient attenuation/2/no attenuation.png b/picture/gradient attenuation/2/no attenuation.png deleted file mode 100644 index ad4f9ed4..00000000 Binary files a/picture/gradient attenuation/2/no attenuation.png and /dev/null differ diff --git a/picture/gradient attenuation/3/attenuation.png b/picture/gradient attenuation/3/attenuation.png deleted file mode 100644 index b8b21fc3..00000000 Binary files a/picture/gradient attenuation/3/attenuation.png and /dev/null differ diff --git a/picture/gradient attenuation/3/no attenuation.png b/picture/gradient attenuation/3/no attenuation.png deleted file mode 100644 index 0a5d571d..00000000 Binary files a/picture/gradient attenuation/3/no attenuation.png and /dev/null differ diff --git a/picture/time(PO).png b/picture/time(PO).png deleted file mode 100644 index 81fee6ef..00000000 Binary files a/picture/time(PO).png and /dev/null differ diff --git a/picture/time.png b/picture/time.png deleted file mode 100644 index 59c35a32..00000000 Binary files a/picture/time.png and /dev/null differ diff --git a/picture/visualization(PO).png b/picture/visualization(PO).png deleted file mode 100644 index b0bc4bc9..00000000 Binary files a/picture/visualization(PO).png and /dev/null differ diff --git a/picture/visualization.png b/picture/visualization.png deleted file mode 100644 index 399bdab9..00000000 Binary files a/picture/visualization.png and /dev/null differ diff --git a/reduced kernel/DL/kernel_reduced.py b/reduced kernel/DL/kernel_reduced.py deleted file mode 100644 index 1c06be13..00000000 --- a/reduced kernel/DL/kernel_reduced.py +++ /dev/null @@ -1,1353 +0,0 @@ -from tensorflow import function -import numpy as np -import matplotlib.pyplot as plt -import pickle -import os -import time - - -#You can analyze kernel by example. -''' -example: -import kernel_reduced as k #import kernel -import tensorflow as tf #import platform -import nn as n #import neural network -mnist=tf.keras.datasets.mnist -(x_train,y_train),(x_test,y_test)=mnist.load_data() -x_train,x_test =x_train/255.0,x_test/255.0 -nn=n.nn() #create neural network object -kernel=k.kernel(nn) #start kernel -kernel.platform=tf #use platform -kernel.data(x_train,y_train) #input you data -kernel.train(32,5) #train neural network - #batch size:32 - #epoch:5 - - -multithreading example: -import kernel_reduced as k #import kernel -import tensorflow as tf #import platform -import nn as n #import neural network -import threading -mnist=tf.keras.datasets.mnist -(x_train,y_train),(x_test,y_test)=mnist.load_data() -x_train,x_test =x_train/255.0,x_test/255.0 -nn=n.nn() #create neural network object -kernel=k.kernel(nn) #start kernel -kernel.platform=tf #use platform -kernel.process_thread=7 #thread count,use 7 threads to train -kernel.epoch_=6 #epoch:6 -kernel.PO=2 #use PO2 -kernel.data(x_train,y_train) #input you data -kernel.lock=[threading.Lock(),threading.Lock(),threading.Lock()] -class thread(threading.Thread): - def run(self): - kernel.train(32) #batch size:32 -for _ in range(7): - _thread=thread() - _thread.start() -for _ in range(7): - _thread.join() - - -multiprocessing example: -import kernel_reduced as k #import kernel -import tensorflow as tf #import platform -import nn as n #import neural network -from multiprocessing import Process,Lock -mnist=tf.keras.datasets.mnist -(x_train,y_train),(x_test,y_test)=mnist.load_data() -x_train,x_test =x_train/255.0,x_test/255.0 -nn=n.nn() #create neural network object -kernel=k.kernel(nn) #start kernel -kernel.platform=tf #use platform -kernel.process_thread=7 #thread count,use 7 processes to train -kernel.epoch_=6 #epoch:6 -kernel.PO=2 #use PO2 -kernel.data(x_train,y_train) #input you data -kernel.lock=[Lock(),Lock(),Lock()] -for _ in range(7): - p=Process(target=kernel.train(32)) #batch size:32 - p.start() -for _ in range(7): - p.join() -''' -class kernel: - def __init__(self,nn=None): - self.nn=nn #Neural network object. - self.platform=None #Platform object,kernel use it to distinguish platform you use. - self.PO=None #PO object,three parallel optimization methods correspond to three numbers. - self.lock=None #External incoming lock. - self.process_thread=None #Process thread object,threads or processes count you use. - self.multiprocessing_threading=None - self.process_thread_counter=0 - self.train_ds=None - self.data_segment_flag=False - self.batches=None - self.buffer_size=None - self.epoch_=None #Training epoch count. - self.epoch_counter=0 - self.save_flag=False - self.save_epoch=None - self.batch=None - self.epoch=0 - self.acc_flag='%' #This object be used for acc printing. - self.train_counter=0 - self.opt_counter=None - self.filename='save.dat' #Saving file name. - self.train_loss=None - self.train_acc=None - self.train_loss_list=[] #This object be used for visualization function. - self.train_acc_list=[] #This object be used for visualization function. - self.test_loss=None - self.test_acc=None - self.test_loss_list=[] #This object be used for visualization function. - self.test_acc_list=[] #This object be used for visualization function. - self.test_flag=False #If you have test data,kernel will set it to True. - self.total_epoch=0 - self.time=0 - self.total_time=0 - - - #Turn training data into kernel's instance object. - def data(self,train_data=None,train_labels=None,test_data=None,test_labels=None,train_dataset=None,test_dataset=None): - self.train_data=train_data - self.train_labels=train_labels - self.train_dataset=train_dataset - if self.data_segment_flag==True: - self.train_data,self.train_labels=self.segment_data() - self.test_data=test_data - self.test_labels=test_labels - self.test_dataset=test_dataset - try: #If have test data,kernel set test_flag=True. - if test_data==None: - self.test_flag=False - except ValueError: - self.test_flag=True - if self.train_dataset==None: - if type(self.train_data)==list: - self.shape0=train_data[0].shape[0] - else: - self.shape0=train_data.shape[0] - if self.train_counter==0 and self.process_thread!=None: - if type(self.process_thread)==list: - self.process_thread_num=np.arange(self.process_thread[0]) - self.process_thread_num=list(self.process_thread_num) - self.thread_num=np.arange(self.process_thread[0]*self.process_thread[1]).reshape(self.process_thread[0],self.process_thread[1]) - self.thread_num=list(self.thread_num) - self.thread_num=[list(self.thread_num[i]) for i in range(len(self.thread_num))] - else: - self.process_thread_num=np.arange(self.process_thread) - self.process_thread_num=list(self.process_thread_num) - if self.epoch_!=None: - if type(self.process_thread)==list: - self.batch_counter=np.zeros([self.process_thread[0]*self.process_thread[1]],dtype=np.int32) - self.total_loss=np.zeros([self.process_thread[0]*self.process_thread[1]],dtype=np.float32) - else: - self.batch_counter=np.zeros(self.process_thread,dtype=np.int32) - self.total_loss=np.zeros(self.process_thread,dtype=np.float32) - try: - if self.nn.accuracy!=None: - if type(self.process_thread)==list: - self.total_acc=np.zeros([self.process_thread[0]*self.process_thread[1]],dtype=np.float32) - else: - self.total_acc=np.zeros(self.process_thread,dtype=np.float32) - except AttributeError: - pass - try: - if self.nn.attenuate!=None: #If neural network object defining attenuate function,kernel will initialize opt_counter(optimization counter). - if type(self.process_thread)==list: - self.opt_counter=np.zeros([self.process_thread[0]*self.process_thread[1]],dtype=np.float32) - else: - self.opt_counter=np.zeros(self.process_thread,dtype=np.float32) - except AttributeError: - pass - try: - if type(self.process_thread)==list: - self.nn.bc=np.zeros([self.process_thread[0]*self.process_thread[1]],dtype=np.float32) - else: - self.nn.bc=np.zeros(self.process_thread,dtype=np.float32) - except AttributeError: - pass - return - - - def segment_data(self): - if len(self.train_data)!=self.process_thread: - data=None - labels=None - segments=int((len(self.train_data)-len(self.train_data)%self.process_thread)/self.process_thread) - for i in range(self.process_thread): - index1=i*segments - index2=(i+1)*segments - if i==0: - data=np.expand_dims(self.train_data[index1:index2],axis=0) - labels=np.expand_dims(self.train_labels[index1:index2],axis=0) - else: - data=np.concatenate((data,np.expand_dims(self.train_data[index1:index2],axis=0))) - labels=np.concatenate((labels,np.expand_dims(self.train_labels[index1:index2],axis=0))) - if len(data)%self.process_thread!=0: - segments+=1 - index1=segments*self.process_thread - index2=self.process_thread-(len(self.train_data)-segments*self.process_thread) - data=np.concatenate((data,np.expand_dims(self.train_data[index1:index2],axis=0))) - labels=np.concatenate((labels,np.expand_dims(self.train_labels[index1:index2],axis=0))) - return data,labels - - - #loss_acc function be used for calculating total loss and total acc. - def loss_acc(self,output=None,labels_batch=None,loss=None,test_batch=None,total_loss=None,total_acc=None): - if self.batch!=None: - total_loss+=loss - try: #If neural network object define accuracy function,kernel will use it to calculate accuracy. - if self.nn.accuracy!=None: - batch_acc=self.nn.accuracy(output,labels_batch) - total_acc+=batch_acc - except AttributeError: - pass - return total_loss,total_acc - else: - loss=loss.numpy() - self.train_loss=loss - self.train_loss_list.append(loss) - try: #If neural network object define accuracy function,kernel will use it to calculate accuracy. - if self.nn.accuracy!=None: - acc=self.nn.accuracy(output,self.train_labels) - acc=acc.numpy() - self.train_acc=acc - self.train_acc_list.append(acc) - except AttributeError: - pass - if self.test_flag==True: #If test_flag=True,kernel call test function. - if self.process_thread_t==None: - self.test_loss,self.test_acc=self.test(self.test_data,self.test_labels,test_batch) - else: - self.test_loss,self.test_acc=self.test(test_batch) - self.test_loss_list.append(self.test_loss) - try: - if self.nn.accuracy!=None: - self.test_acc_list.append(self.test_acc) - except AttributeError: - pass - return - - - #data_func functin be used for returning batch data and concatenating data. - def data_func(self,data_batch=None,labels_batch=None,batch=None,index1=None,index2=None,j=None,flag=None): - if flag==None: - if batch!=1: - data_batch=self.train_data[index1:index2] - else: - data_batch=self.train_data[j] - if batch!=1: - labels_batch=self.train_labels[index1:index2] - else: - labels_batch=self.train_labels[j] - else: - try: - data_batch=self.platform.concat([self.train_data[index1:],self.train_data[:index2]],0) - labels_batch=self.platform.concat([self.train_labels[index1:],self.train_labels[:index2]],0) - except: - data_batch=np.concatenate([self.train_data[index1:],self.train_data[:index2]],0) - labels_batch=np.concatenate([self.train_labels[index1:],self.train_labels[:index2]],0) - return data_batch,labels_batch - - - #Optimization subfunction,it be used for opt function,it used optimization function of tensorflow platform. - @function(jit_compile=True) - def tf_opt(self,data,labels): - try: #If neural network object define GradientTape function,kernel will use it or else use other,this design allow you to implement more complicated operations. - if self.nn.GradientTape!=None: - tape,output,loss=self.nn.GradientTape(data,labels) - except AttributeError: - with self.platform.GradientTape(persistent=True) as tape: - try: #If neural network object define one argument value fp(forward propagation) function,kernel will use it or else use other,this design allow you to implement more complicated operations. - output=self.nn.fp(data) - loss=self.nn.loss(output,labels) - except TypeError: - output,loss=self.nn.fp(data,labels) - try: #If neural network object define gradient function,kernel will use it or else use other,this design allow you to implement more complicated operations. - gradient=self.nn.gradient(tape,loss) - except AttributeError: - gradient=tape.gradient(loss,self.nn.param) - try: - self.nn.opt.apply_gradients(zip(gradient,self.nn.param)) - except AttributeError: - self.nn.opt(gradient) - return output,loss - - - #Optimization subfunction,it be used for opt function,it used optimization function of tensorflow platform and parallel optimization. - @function(jit_compile=True) - def tf_opt_t(self,data,labels,t=None,ln=None,u=None): - try: #If neural network object define GradientTape function,kernel will use it or else use other,this design allow you to implement more complicated operations. - if self.nn.GradientTape!=None: - if type(self.process_thread)==list: - tape,output,loss=self.nn.GradientTape(data,labels,u) - else: - tape,output,loss=self.nn.GradientTape(data,labels,t) - except AttributeError: - with self.platform.GradientTape(persistent=True) as tape: - try: - try: #If neural network object define one argument value fp(forward propagation) function,kernel will use it or else use other,this design allow you to implement more complicated operations. - output=self.nn.fp(data) - loss=self.nn.loss(output,labels) - except TypeError: - output,loss=self.nn.fp(data,labels) - except TypeError: - try: - if type(self.process_thread)==list: - output=self.nn.fp(data,u) - else: - output=self.nn.fp(data,t) - loss=self.nn.loss(output,labels) - except TypeError: - if type(self.process_thread)==list: - output,loss=self.nn.fp(data,labels,u) - else: - output,loss=self.nn.fp(data,labels,t) - try: - if self.nn.attenuate!=None: - if type(self.process_thread)==list: - self.opt_counter[u]=0 - else: - self.opt_counter[t]=0 - except AttributeError: - pass - if self.PO==1: - self.lock[0].acquire() - try: #If neural network object define gradient function,kernel will use it or else use other,this design allow you to implement more complicated operations. - gradient=self.nn.gradient(tape,loss) - except AttributeError: - gradient=tape.gradient(loss,self.nn.param) - try: - if self.nn.attenuate!=None: - if type(self.process_thread)==list: - gradient=self.nn.attenuate(gradient,self.opt_counter,u) - else: - gradient=self.nn.attenuate(gradient,self.opt_counter,t) - except AttributeError: - pass - try: - self.nn.opt.apply_gradients(zip(gradient,self.nn.param)) - except AttributeError: - try: - self.nn.opt(gradient) - except TypeError: - self.nn.opt(gradient,t) - try: - if self.nn.attenuate!=None: - self.opt_counter+=1 - except AttributeError: - pass - self.lock[0].release() - elif self.PO==2: - self.lock[0].acquire() - try: #If neural network object define gradient function,kernel will use it or else use other,this design allow you to implement more complicated operations. - gradient=self.nn.gradient(tape,loss) - except AttributeError: - gradient=tape.gradient(loss,self.nn.param) - self.lock[0].release() - self.lock[1].acquire() - try: - if self.nn.attenuate!=None: - if type(self.process_thread)==list: - gradient=self.nn.attenuate(gradient,self.opt_counter,u) - else: - gradient=self.nn.attenuate(gradient,self.opt_counter,t) - except AttributeError: - pass - try: - self.nn.opt.apply_gradients(zip(gradient,self.nn.param)) - except AttributeError: - try: - self.nn.opt(gradient) - except TypeError: - self.nn.opt(gradient,t) - try: - if self.nn.attenuate!=None: - self.opt_counter+=1 - except AttributeError: - pass - self.lock[1].release() - return output,loss - - - #Optimization subfunction,it be used for opt function,it used optimization function of pytorch platform. - def pytorch_opt(self,data,labels): - output=self.nn.fp(data) - loss=self.nn.loss(output,labels) - try: - self.nn.opt.zero_grad() - loss.backward() - self.nn.opt.step() - except: - self.nn.opt(loss) - return output,loss - - - #Main optimization function. - def opt(self,data,labels): - try: - if self.platform.DType!=None: - output,loss=self.tf_opt(data,labels) - except AttributeError: - output,loss=self.pytorch_opt(data,labels) - return output,loss - - - #Main optimization function,it be used for parallel optimization. - def opt_t(self,data,labels,t=None,u=None): - if type(self.process_thread)==list: - output,loss=self.tf_opt_t(data,labels,u=int(u)) - else: - output,loss=self.tf_opt_t(data,labels,int(t)) - return output,loss - - - #Main optimization function,it be used for online training. - def opt_ol(self,data,labels,t,ln=None): - try: - if self.platform.DType!=None: - if self.process_thread!=None: - output,loss=self.tf_opt_t(data,labels,int(t)) - else: - output,loss=self.tf_opt(data,labels) - except AttributeError: - output,loss=self.pytorch_opt(data,labels) - return output,loss - - - #Training subfunction,it be used for train function and no parallel training. - def _train(self,batch=None,_data_batch=None,_labels_batch=None,test_batch=None): - if batch!=None: - total_loss=0 - total_acc=0 - if self.train_dataset!=None: - for data_batch,labels_batch in self.train_dataset: - output,batch_loss=self.opt(data_batch,labels_batch) - total_loss,total_acc=self.loss_acc(output=output,labels_batch=labels_batch,loss=batch_loss,total_loss=total_loss,total_acc=total_acc) - else: - total_loss=0 - total_acc=0 - batches=int((self.shape0-self.shape0%batch)/batch) - for j in range(batches): - index1=j*batch #Use for batch data's index - index2=(j+1)*batch #Use for batch data's index - data_batch,labels_batch=self.data_func(_data_batch,_labels_batch,batch,index1,index2,j) #Return batch data. - output,batch_loss=self.opt(data_batch,labels_batch) - total_loss,total_acc=self.loss_acc(output=output,labels_batch=labels_batch,loss=batch_loss,total_loss=total_loss,total_acc=total_acc) - try: - self.nn.bc=j - except AttributeError: - pass - if self.shape0%batch!=0: - batches+=1 - index1=batches*batch #Use for batch data's index - index2=batch-(self.shape0-batches*batch) #Use for batch data's index - data_batch,labels_batch=self.data_func(_data_batch,_labels_batch,batch,index1,index2,flag=True) #Return batch data after concatenating. - output,batch_loss=self.opt(data_batch,labels_batch) - total_loss,total_acc=self.loss_acc(output=output,labels_batch=labels_batch,loss=batch_loss,total_loss=total_loss,total_acc=total_acc) - try: - self.nn.bc+=1 - except AttributeError: - pass - try: - if self.platform.DType!=None: - loss=total_loss.numpy()/batches - except AttributeError: - loss=total_loss.detach().numpy()/batches - try: - if self.nn.accuracy!=None: - train_acc=total_acc.numpy()/batches - except AttributeError: - pass - self.train_loss=loss - self.train_loss_list.append(loss) - try: - if self.nn.accuracy!=None: - self.train_acc=train_acc - self.train_acc_list.append(train_acc) - except AttributeError: - pass - if self.test_flag==True: #If test_flag=True,kernel call test function. - if self.process_thread_t==None: - self.test_loss,self.test_acc=self.test(self.test_data,self.test_labels,test_batch) - else: - self.test_loss,self.test_acc=self.test(batch=test_batch) - self.test_loss_list.append(self.test_loss) - try: - if self.nn.accuracy!=None: - self.test_acc_list.append(self.test_acc) - except AttributeError: - pass - else: - output,train_loss=self.opt(self.train_data,self.train_labels) - self.loss_acc(output=output,labels_batch=labels_batch,loss=train_loss,test_batch=test_batch,total_loss=total_loss,total_acc=total_acc) - return - - - #Training subfunction,it be used for _train_ function and parallel training. - def train_(self,_data_batch=None,_labels_batch=None,batch=None,batches=None,test_batch=None,index1=None,index2=None,j=None,t=None): - if batch!=None: - if index1==batches*batch: - data_batch,labels_batch=self.data_func(_data_batch,_labels_batch,batch,index1,index2,j,True) #Return batch data after concatenating. - output,batch_loss=self.opt_t(data_batch,labels_batch,t) - try: - self.nn.bc[t]+=1 - except AttributeError: - pass - try: #If neural network object define accuracy function,kernel will use it to calculate accuracy. - if self.nn.accuracy!=None: - batch_acc=self.nn.accuracy(output,labels_batch) - return batch_loss,batch_acc - except AttributeError: - return batch_loss,None - data_batch,labels_batch=self.data_func(_data_batch,_labels_batch,batch,index1,index2,j) #Return batch data. - output,batch_loss=self.opt_t(data_batch,labels_batch,t) - try: - self.nn.bc[t]=j - except AttributeError: - pass - try: #If neural network object define accuracy function,kernel will use it to calculate accuracy. - if self.nn.accuracy!=None: #If neural network object define accuracy function,kernel will use it to calculate accuracy.s - batch_acc=self.nn.accuracy(output,labels_batch) - return batch_loss,batch_acc - except AttributeError: - return batch_loss,None - else: - output,train_loss=self.opt_t(self.train_data,self.train_labels,t) - if self.PO==1 or self.PO==3: - self.lock[1].acquire() - self.total_epoch+=1 - train_loss=train_loss.numpy() - self.train_loss=train_loss - self.train_loss_list.append(train_loss) - try: #If neural network object define accuracy function,kernel will use it to calculate accuracy. - if self.nn.accuracy!=None: - acc=self.nn.accuracy(output,self.train_labels) - acc=acc.numpy() - self.train_acc=acc - self.train_acc_list.append(acc) - except AttributeError: - pass - if self.test_flag==True: #If test_flag=True,kernel call test function. - if self.process_thread_t==None: - self.test_loss,self.test_acc=self.test(self.test_data,self.test_labels,test_batch,t) - else: - self.test_loss,self.test_acc=self.test(batch=test_batch) - self.test_loss_list.append(self.test_loss) - try: - if self.nn.accuracy!=None: - self.test_acc_list.append(self.test_acc) - except AttributeError: - pass - self.lock[1].release() - else: - self.lock[2].acquire() - self.total_epoch+=1 - train_loss=train_loss.numpy() - self.train_loss=train_loss - self.train_loss_list.append(train_loss) - try: #If neural network object define accuracy function,kernel will use it to calculate accuracy. - if self.nn.accuracy!=None: - acc=self.nn.accuracy(output,self.train_labels) - acc=acc.numpy() - self.train_acc=acc - self.train_acc_list.append(acc) - except AttributeError: - pass - if self.test_flag==True: #If test_flag=True,kernel call test function. - if self.process_thread_t==None: - self.test_loss,self.test_acc=self.test(self.test_data,self.test_labels,test_batch,t) - else: - self.test_loss,self.test_acc=self.test(batch=test_batch) - self.test_loss_list.append(self.test_loss) - try: - if self.nn.accuracy!=None: - self.test_acc_list.append(self.test_acc) - except AttributeError: - pass - self.lock[2].release() - return - - - #Training subfunction,it be used for train function and parallel training. - def _train_(self,batch=None,data_batch=None,labels_batch=None,test_batch=None,t=None): - total_loss=0 - total_acc=0 - batches=int((self.shape0-self.shape0%batch)/batch) - if batch!=None: - for j in range(batches): - index1=j*batch #Use for index of batch data - index2=(j+1)*batch #Use for index of batch data - batch_loss,batch_acc=self.train_(data_batch,labels_batch,batch,batches,test_batch,index1,index2,j,t) - try: - if self.nn.accuracy!=None: - total_loss+=batch_loss - total_acc+=batch_acc - except AttributeError: - total_loss+=batch_loss - if self.shape0%batch!=0: - batches+=1 - index1=batches*batch #Use for index of batch data. - index2=batch-(self.shape0-batches*batch) #Use for index of batch data - batch_loss,batch_acc=self.train_(data_batch,labels_batch,batch,batches,test_batch,index1,index2,None,t) - try: - if self.nn.accuracy!=None: - total_loss+=batch_loss - total_acc+=batch_acc - except AttributeError: - total_loss+=batch_loss - loss=total_loss.numpy()/batches - try: #If neural network object define accuracy function,kernel will calculate mean accuracy. - if self.nn.accuracy!=None: - train_acc=total_acc.numpy()/batches - except AttributeError: - pass - if self.PO==1 or self.PO==3: - self.lock[1].acquire() - else: - self.lock[2].acquire() - self.total_epoch+=1 - self.train_loss=loss - self.train_loss_list.append(loss) - try: #If neural network object define accuracy function,kernel append mean accuracy to acc list. - if self.nn.accuracy!=None: - self.train_acc=train_acc - self.train_acc_list.append(train_acc) - except AttributeError: - pass - if self.test_flag==True: #If test_flag=True,kernel call test function. - if self.process_thread_t==None: - self.test_loss,self.test_acc=self.test(self.test_data,self.test_labels,test_batch,t) - else: - self.test_loss,self.test_acc=self.test(batch=test_batch) - self.test_loss_list.append(self.test_loss) - try: - if self.nn.accuracy!=None: - self.test_acc_list.append(self.test_acc) - except AttributeError: - pass - try: - self.nn.ec+=1 - except AttributeError: - pass - if self.PO==1 or self.PO==3: - self.lock[1].release() - else: - self.lock[2].release() - return - else: - batch_loss,batch_acc=self.train_(data_batch,labels_batch,batch,batches,test_batch,index1,index2,j,t) - return - - - #Training subfunction,it be used for train function and parallel training. - def train7(self,train_ds,t,test_batch): - if type(self.process_thread)==list: - if self.PO==1 or self.PO==3: - self.lock[1].acquire() - else: - self.lock[2].acquire() - u=self.thread_num[t].pop(0) - if self.PO==1 or self.PO==3: - self.lock[1].release() - else: - self.lock[2].release() - while True: - for data_batch,labels_batch in train_ds: - if type(self.process_thread)==list: - output,batch_loss=self.opt_t(data_batch,labels_batch,u=u) - else: - output,batch_loss=self.opt_t(data_batch,labels_batch,t) - try: - if type(self.process_thread)==list: - self.nn.bc[u]+=1 - else: - self.nn.bc[t]+=1 - except AttributeError: - pass - try: - if self.nn.accuracy!=None: - batch_acc=self.nn.accuracy(output,labels_batch) - except AttributeError: - pass - try: - if self.nn.accuracy!=None: - if type(self.process_thread)==list: - self.total_loss[u]+=batch_loss - self.total_acc[u]+=batch_acc - else: - self.total_loss[t]+=batch_loss - self.total_acc[t]+=batch_acc - except AttributeError: - if type(self.process_thread)==list: - self.total_loss[u]+=batch_loss - else: - self.total_loss[t]+=batch_loss - if type(self.process_thread)==list: - self.batch_counter[u]+=1 - else: - self.batch_counter[t]+=1 - if self.PO==1 or self.PO==3: - self.lock[1].acquire() - else: - self.lock[2].acquire() - batches=np.sum(self.batch_counter) - if batches>=self.batches: - self.batch_counter=self.batch_counter*0 - loss=np.sum(self.total_loss)/batches - try: - if self.nn.accuracy!=None: - train_acc=np.sum(self.total_acc)/batches - except AttributeError: - pass - self.total_epoch+=1 - self.train_loss=loss - self.train_loss_list.append(loss) - try: - if self.nn.accuracy!=None: - self.train_acc=train_acc - self.train_acc_list.append(train_acc) - except AttributeError: - pass - if self.test_flag==True: - if self.process_thread_t==None: - self.test_loss,self.test_acc=self.test(self.test_data,self.test_labels,test_batch,t) - else: - self.test_loss,self.test_acc=self.test(batch=test_batch) - self.test_loss_list.append(self.test_loss) - try: - if self.nn.accuracy!=None: - self.test_acc_list.append(self.test_acc) - except AttributeError: - pass - self.epoch_counter+=1 - try: - if type(self.process_thread)==list: - self.nn.bc[u]=0 - else: - self.nn.bc[t]=0 - except AttributeError: - pass - try: - self.nn.ec+=1 - except AttributeError: - pass - self.total_loss=self.total_loss*0 - try: - if self.nn.accuracy!=None: - self.total_acc=self.total_acc*0 - except AttributeError: - pass - if self.PO==1 or self.PO==3: - self.lock[1].release() - else: - self.lock[2].release() - if self.epoch_counter==self.epoch_: - return - - - #Main training function. - def train(self,batch=None,epoch=None,test_batch=None,save=None,one=True,p=None,s=None): - if self.process_thread!=None: - if self.PO==1 or self.PO==3: - self.lock[1].acquire() - else: - self.lock[2].acquire() - t=self.process_thread_num.pop(0) - self.process_thread_counter+=1 - if self.epoch_!=None: - if self.train_dataset==None: - if t==0: - if self.batches==None: - self.batches=int((self.shape0-self.shape0%batch)/batch) - if self.shape0%batch!=0: - self.batches+=1 - if self.PO==1 or self.PO==3: - self.lock[1].release() - else: - self.lock[2].release() - self.batch=batch - self.epoch=0 - self.train_counter+=1 - if self.epoch_!=None: - if self.train_dataset!=None: - train_ds=self.train_dataset - else: - if self.data_segment_flag==True: - train_ds=self.platform.data.Dataset.from_tensor_slices((self.train_data[t],self.train_labels[t])).batch(batch) - elif self.buffer_size!=None: - train_ds=self.platform.data.Dataset.from_tensor_slices((self.train_data,self.train_labels)).shuffle(self.buffer_size).batch(batch) - else: - train_ds=self.platform.data.Dataset.from_tensor_slices((self.train_data,self.train_labels)).batch(batch) - if p==None: #p and self.p variable be used for controlling printing count. - self.p=9 - else: - self.p=p-1 - if s==None: #s and self.s variable be used for controlling saving files. - self.s=1 - self.file_list=None - else: - self.s=s-1 - self.file_list=[] - data_batch=None - labels_batch=None - if self.process_thread!=None and self.epoch_!=None: - if self.multiprocessing_threading==None: - self.train7(train_ds,t,test_batch) - else: - train7=self.train7 - class thread(self.multiprocessing_threading.Thread): - def run(self): - train7(train_ds,t,test_batch) - for _ in range(self.process_thread[1]): - _thread=thread() - _thread.start() - for _ in range(self.process_thread[1]): - _thread.join() - elif epoch!=None: - for i in range(epoch): - t1=time.time() - if self.process_thread==None: - self._train(batch,data_batch,labels_batch,test_batch) - else: - self._train_(batch,data_batch,labels_batch,test_batch,t) - if self.process_thread==None: - try: - self.nn.ec+=1 - except AttributeError: - pass - if self.process_thread==None: - self.total_epoch+=1 - if self.process_thread==None: - if epoch%10!=0: - p=epoch-epoch%self.p - p=int(p/self.p) - s=epoch-epoch%self.s - s=int(s/self.s) - else: - p=epoch/(self.p+1) - p=int(p) - s=epoch/(self.s+1) - s=int(s) - if p==0: - p=1 - if s==0: - s=1 - if i%p==0: - if self.test_flag==False: - try: - if self.nn.accuracy!=None: - print('epoch:{0} loss:{1:.6f}'.format(i+1,self.train_loss)) - if self.acc_flag=='%': - print('epoch:{0} accuracy:{1:.1f}'.format(i+1,self.train_acc*100)) - else: - print('epoch:{0} accuracy:{1:.6f}'.format(i+1,self.train_acc)) - print() - except AttributeError: - print('epoch:{0} loss:{1:.6f}'.format(i+1,self.train_loss)) - print() - else: - try: - if self.nn.accuracy!=None: - print('epoch:{0} loss:{1:.6f},test loss:{2:.6f}'.format(i+1,self.train_loss,self.test_loss)) - if self.acc_flag=='%': - print('epoch:{0} accuracy:{1:.1f},test accuracy:{2:.1f}'.format(i+1,self.train_acc*100,self.test_acc*100)) - else: - print('epoch:{0} accuracy:{1:.1f},test accuracy:{2:.1f}'.format(i+1,self.train_acc,self.test_acc)) - print() - except AttributeError: - print('epoch:{0} loss:{1:.6f},test loss:{2:.6f}'.format(i+1,self.train_loss,self.test_loss)) - print() - if save!=None and i%s==0: - self.save(self.total_epoch,one) - t2=time.time() - if self.process_thread==None: - self.time+=(t2-t1) - else: - i=0 - while True: - t1=time.time() - if self.process_thread==None: - self._train(test_batch=test_batch) - else: - self._train_(test_batch=test_batch,t=t) - i+=1 - if self.process_thread==None: - try: - self.nn.ec+=1 - except AttributeError: - pass - if self.process_thread==None: - self.total_epoch+=1 - if self.process_thread==None: - if epoch%10!=0: - p=epoch-epoch%self.p - p=int(p/self.p) - s=epoch-epoch%self.s - s=int(s/self.s) - else: - p=epoch/(self.p+1) - p=int(p) - s=epoch/(self.s+1) - s=int(s) - if p==0: - p=1 - if s==0: - s=1 - if i%p==0: - if self.test_flag==False: - try: - if self.nn.accuracy!=None: - print('epoch:{0} loss:{1:.6f}'.format(i+1,self.train_loss)) - if self.acc_flag=='%': - print('epoch:{0} accuracy:{1:.1f}'.format(i+1,self.train_acc*100)) - else: - print('epoch:{0} accuracy:{1:.6f}'.format(i+1,self.train_acc)) - print() - except AttributeError: - print('epoch:{0} loss:{1:.6f}'.format(i+1,self.train_loss)) - print() - else: - try: - if self.nn.accuracy!=None: - print('epoch:{0} loss:{1:.6f},test loss:{2:.6f}'.format(i+1,self.train_loss,self.test_loss)) - if self.acc_flag=='%': - print('epoch:{0} accuracy:{1:.1f},test accuracy:{2:.1f}'.format(i+1,self.train_acc*100,self.test_acc*100)) - else: - print('epoch:{0} accuracy:{1:.1f},test accuracy:{2:.1f}'.format(i+1,self.train_acc,self.test_acc)) - print() - except AttributeError: - print('epoch:{0} loss:{1:.6f},test loss:{2:.6f}'.format(i+1,self.train_loss,self.test_loss)) - print() - if save!=None and i%s==0: - self.save(self.total_epoch,one) - t2=time.time() - if self.process_thread==None: - self.time+=(t2-t1) - if save!=None: - self.save() - if self.process_thread==None: - self._time=self.time-int(self.time) - if self._time<0.5: - self.time=int(self.time) - else: - self.time=int(self.time)+1 - self.total_time+=self.time - if self.process_thread==None: - if self.test_flag==False: - print('last loss:{0:.6f}'.format(self.train_loss)) - else: - print('last loss:{0:.6f},last test loss:{1:.6f}'.format(self.train_loss,self.test_loss)) - try: - if self.nn.accuracy!=None: - if self.acc_flag=='%': - if self.test_flag==False: - print('last accuracy:{0:.1f}'.format(self.train_acc*100)) - else: - print('last accuracy:{0:.1f},last test accuracy:{1:.1f}'.format(self.train_acc*100,self.test_acc*100)) - else: - if self.test_flag==False: - print('last accuracy:{0:.6f}'.format(self.train_acc)) - else: - print('last accuracy:{0:.6f},last test accuracy:{1:.6f}'.format(self.train_acc,self.test_acc)) - except AttributeError: - pass - print() - print('time:{0}s'.format(self.time)) - if self.process_thread==None: - self.training_flag=False - if self.process_thread!=None: - if self.PO==1 or self.PO==3: - self.lock[1].acquire() - else: - self.lock[2].acquire() - self.process_thread_counter-=1 - if self.PO==1 or self.PO==3: - self.lock[1].release() - else: - self.lock[2].release() - return - - - def train_ol(self): - if self.process_thread!=None: - if self.PO==1 or self.PO==3: - self.lock[1].acquire() - else: - self.lock[2].acquire() - t=self.process_thread_num.pop(0) - self.process_thread_counter+=1 - if self.PO==1 or self.PO==3: - self.lock[1].release() - else: - self.lock[2].release() - while True: - if self.process_thread!=None: - if self.save_flag==True: - if self.PO==1 or self.PO==3: - self.lock[1].acquire() - else: - self.lock[2].acquire() - self.save() - if self.PO==1 or self.PO==3: - self.lock[1].release() - else: - self.lock[2].release() - try: - data=self.nn.ol(t) - except: - self.exception_list[t]=True - continue - try: - output,loss=self.opt_ol(data[0],data[1],t) - except: - continue - loss=loss.numpy() - if self.PO==1 or self.PO==3: - self.lock[1].acquire() - else: - self.lock[2].acquire() - if len(self.nn.train_loss_list)==self.nn.max_length: - del self.nn.train_loss_list[0] - self.nn.train_loss_list.append(loss) - try: - if self.nn.accuracy!=None: - try: - train_acc=self.nn.accuracy(output,data[1]) - except: - continue - if len(self.nn.train_acc_list)==self.nn.max_length: - del self.nn.train_acc_list[0] - self.train_acc_list.append(train_acc) - except AttributeError: - pass - try: - self.nn.c+=1 - except AttributeError: - pass - if self.PO==1 or self.PO==3: - self.lock[1].release() - else: - self.lock[2].release() - else: - if self.save_flag==True: - self.save() - data=self.nn.ol() - if data=='stop': - return - output,loss=self.opt(data[0],data[1]) - loss=loss.numpy() - if len(self.nn.train_loss_list)==self.nn.max_length: - del self.nn.train_loss_list[0] - self.nn.train_loss_list.append(loss) - try: - if self.nn.accuracy!=None: - train_acc=self.nn.accuracy(output,data[1]) - if len(self.nn.train_acc_list)==self.nn.max_length: - del self.nn.train_acc_list[0] - self.train_acc_list.append(train_acc) - except AttributeError: - pass - try: - self.nn.c+=1 - except AttributeError: - pass - if self.process_thread!=None: - if self.PO==1 or self.PO==3: - self.lock[1].acquire() - else: - self.lock[2].acquire() - self.process_thread_counter-=1 - if self.PO==1 or self.PO==3: - self.lock[1].release() - else: - self.lock[2].release() - return - - - def test(self,test_data=None,test_labels=None,batch=None,t=None): - if type(test_data)==list: - data_batch=[x for x in range(len(test_data))] - if type(test_labels)==list: - labels_batch=[x for x in range(len(test_labels))] - if batch!=None: - total_loss=0 - total_acc=0 - if self.test_dataset!=None: - for data_batch,labels_batch in self.test_dataset: - if self.process_thread==None or t==None: - output=self.nn.fp(data_batch) - else: - output=self.nn.fp(data_batch,t) - batch_loss=self.nn.loss(output,labels_batch) - total_loss+=batch_loss - try: - if self.nn.accuracy!=None: - batch_acc=self.nn.accuracy(output,labels_batch) - total_acc+=batch_acc - except AttributeError: - pass - else: - total_loss=0 - total_acc=0 - if type(test_data)==list: - batches=int((test_data[0].shape[0]-test_data[0].shape[0]%batch)/batch) - shape0=test_data[0].shape[0] - else: - batches=int((test_data.shape[0]-test_data.shape[0]%batch)/batch) - shape0=test_data.shape[0] - for j in range(batches): - index1=j*batch - index2=(j+1)*batch - if type(test_data)==list: - for i in range(len(test_data)): - data_batch[i]=test_data[i][index1:index2] - else: - data_batch=test_data[index1:index2] - if type(test_labels)==list: - for i in range(len(test_labels)): - labels_batch[i]=test_labels[i][index1:index2] - else: - labels_batch=test_labels[index1:index2] - if self.process_thread==None or t==None: - output=self.nn.fp(data_batch) - else: - output=self.nn.fp(data_batch,t) - batch_loss=self.nn.loss(output,labels_batch) - total_loss+=batch_loss - try: - if self.nn.accuracy!=None: - batch_acc=self.nn.accuracy(output,labels_batch) - total_acc+=batch_acc - except AttributeError: - pass - if shape0%batch!=0: - batches+=1 - index1=batches*batch - index2=batch-(shape0-batches*batch) - try: - if type(test_data)==list: - for i in range(len(test_data)): - data_batch[i]=self.platform.concat([test_data[i][index1:],test_data[i][:index2]],0) - else: - data_batch=self.platform.concat([test_data[index1:],test_data[:index2]],0) - if type(self.test_labels)==list: - for i in range(len(test_labels)): - labels_batch[i]=self.platform.concat([test_labels[i][index1:],test_labels[i][:index2]],0) - else: - labels_batch=self.platform.concat([test_labels[index1:],test_labels[:index2]],0) - except: - if type(test_data)==list: - for i in range(len(test_data)): - data_batch[i]=self.platform.concat([test_data[i][index1:],test_data[i][:index2]],0) - else: - data_batch=self.platform.concat([test_data[index1:],test_data[:index2]],0) - if type(self.test_labels)==list: - for i in range(len(test_labels)): - labels_batch[i]=self.platform.concat([test_labels[i][index1:],test_labels[i][:index2]],0) - else: - labels_batch=self.platform.concat([test_labels[index1:],test_labels[:index2]],0) - if self.process_thread==None or t==None: - output=self.nn.fp(data_batch) - else: - output=self.nn.fp(data_batch,t) - batch_loss=self.nn.loss(output,labels_batch) - total_loss+=batch_loss - try: - if self.nn.accuracy!=None: - batch_acc=self.nn.accuracy(output,labels_batch) - total_acc+=batch_acc - except AttributeError: - pass - test_loss=total_loss.numpy()/batches - try: - if self.nn.accuracy!=None: - test_acc=total_acc.numpy()/batches - except AttributeError: - pass - else: - if self.process_thread==None or t==None: - output=self.nn.fp(test_data) - else: - output=self.nn.fp(test_data,t) - test_loss=self.nn.loss(output,test_labels) - test_loss=test_loss.numpy() - try: - if self.nn.accuracy!=None: - test_acc=self.nn.accuracy(output,test_labels) - test_acc=test_acc.numpy() - except AttributeError: - pass - try: - if self.nn.accuracy!=None: - return test_loss,test_acc - except AttributeError: - return test_loss,None - - - def visualize_train(self): - print() - plt.figure(1) - plt.plot(np.arange(self.total_epoch),self.train_loss_list) - plt.title('train loss') - plt.xlabel('epoch') - plt.ylabel('loss') - print('train loss:{0:.6f}'.format(self.train_loss)) - try: - if self.nn.accuracy!=None: - plt.figure(2) - plt.plot(np.arange(self.total_epoch),self.train_acc_list) - plt.title('train acc') - plt.xlabel('epoch') - plt.ylabel('acc') - if self.acc_flag=='%': - print('train acc:{0:.1f}'.format(self.train_acc*100)) - else: - print('train acc:{0:.6f}'.format(self.train_acc)) - except AttributeError: - pass - return - - - def visualize_test(self): - print() - plt.figure(1) - plt.plot(np.arange(self.total_epoch),self.test_loss_list) - plt.title('test loss') - plt.xlabel('epoch') - plt.ylabel('loss') - print('test loss:{0:.6f}'.format(self.test_loss)) - try: - if self.nn.accuracy!=None: - plt.figure(2) - plt.plot(np.arange(self.total_epoch),self.test_acc_list) - plt.title('test acc') - plt.xlabel('epoch') - plt.ylabel('acc') - if self.acc_flag=='%': - print('test acc:{0:.1f}'.format(self.test_acc*100)) - else: - print('test acc:{0:.6f}'.format(self.test_acc)) - except AttributeError: - pass - return - - - def comparison(self): - print() - plt.figure(1) - plt.plot(np.arange(self.total_epoch),self.train_loss_list,'b-',label='train loss') - if self.test_flag==True: - plt.plot(np.arange(self.total_epoch),self.test_loss_list,'r-',label='test loss') - plt.xlabel('epoch') - plt.ylabel('loss') - print('train loss:{0}'.format(self.train_loss)) - plt.legend() - try: - if self.nn.accuracy!=None: - plt.figure(2) - plt.plot(np.arange(self.total_epoch),self.train_acc_list,'b-',label='train acc') - if self.test_flag==True: - plt.plot(np.arange(self.total_epoch),self.test_acc_list,'r-',label='test acc') - plt.xlabel('epoch') - plt.ylabel('acc') - plt.legend() - if self.acc_flag=='%': - print('train acc:{0:.1f}'.format(self.train_acc*100)) - else: - print('train acc:{0:.6f}'.format(self.train_acc)) - except AttributeError: - pass - if self.test_flag==True: - print() - print('-------------------------------------') - print() - print('test loss:{0:.6f}'.format(self.test_loss)) - if self.acc_flag=='%': - print('test acc:{0:.1f}'.format(self.test_acc*100)) - else: - print('test acc:{0:.6f}'.format(self.test_acc)) - return - - - def save_p(self): - parameter_file=open('param.dat','wb') - pickle.dump(self.nn.param,parameter_file) - parameter_file.close() - return - - - def save(self,i=None,one=True): - if one==True: - output_file=open(self.filename,'wb') - else: - filename=self.filename.replace(self.filename[self.filename.find('.'):],'-{0}.dat'.format(i)) - output_file=open(filename,'wb') - self.file_list.append([filename]) - if len(self.file_list)>self.s+1: - os.remove(self.file_list[0][0]) - del self.file_list[0] - try: - pickle.dump(self.nn,output_file) - except: - opt=self.nn.opt - self.nn.opt=None - pickle.dump(self.nn,output_file) - self.nn.opt=opt - try: - pickle.dump(self.platform.keras.optimizers.serialize(opt),output_file) - except: - pickle.dump(self.nn.serialize(),output_file) - else: - pickle.dump(None,output_file) - pickle.dump(self.batch,output_file) - pickle.dump(self.acc_flag,output_file) - pickle.dump(self.file_list,output_file) - pickle.dump(self.train_counter,output_file) - pickle.dump(self.train_loss,output_file) - pickle.dump(self.train_acc,output_file) - pickle.dump(self.train_loss_list,output_file) - pickle.dump(self.train_acc_list,output_file) - pickle.dump(self.test_flag,output_file) - if self.test_flag==True: - pickle.dump(self.test_loss,output_file) - pickle.dump(self.test_acc,output_file) - pickle.dump(self.test_loss_list,output_file) - pickle.dump(self.test_acc_list,output_file) - pickle.dump(self.total_epoch,output_file) - pickle.dump(self.total_time,output_file) - output_file.close() - return - - - def restore(self,s_path): - input_file=open(s_path,'rb') - self.nn=pickle.load(input_file) - opt_serialized=pickle.load(input_file) - try: - self.nn.opt=self.platform.keras.optimizers.deserialize(opt_serialized) - except: - self.nn.deserialize(opt_serialized) - else: - pass - self.batch=pickle.load(input_file) - self.acc_flag=pickle.load(input_file) - self.file_list=pickle.load(input_file) - self.train_counter=pickle.load(input_file) - self.train_loss=pickle.load(input_file) - self.train_acc=pickle.load(input_file) - self.train_loss_list=pickle.load(input_file) - self.train_acc_list=pickle.load(input_file) - self.test_flag=pickle.load(input_file) - if self.test_flag==True: - self.test_loss=pickle.load(input_file) - self.test_acc=pickle.load(input_file) - self.test_loss_list=pickle.load(input_file) - self.test_acc_list=pickle.load(input_file) - self.total_epoch=pickle.load(input_file) - self.total_time=pickle.load(input_file) - input_file.close() - return diff --git a/reduced kernel/DL/kernel_reduced_no_parallel.py b/reduced kernel/DL/kernel_reduced_no_parallel.py deleted file mode 100644 index fc21c5d9..00000000 --- a/reduced kernel/DL/kernel_reduced_no_parallel.py +++ /dev/null @@ -1,647 +0,0 @@ -from tensorflow import function -import numpy as np -import matplotlib.pyplot as plt -import pickle -import os -import time - - -#Doesn't support parallelism -#You can analyze kernel by example. -''' -example: -import kernel_reduced_no_parallel as k #import kernel -import tensorflow as tf #import platform -import nn as n #import neural network -mnist=tf.keras.datasets.mnist -(x_train,y_train),(x_test,y_test)=mnist.load_data() -x_train,x_test =x_train/255.0,x_test/255.0 -nn=n.nn() #create neural network object -kernel=k.kernel(nn) #start kernel -kernel.platform=tf #use platform -kernel.data(x_train,y_train) #input you data -kernel.train(32,5) #train neural network - #batch size:32 - #epoch:5 -''' -class kernel: - def __init__(self,nn=None): - self.nn=nn #Neural network object. - self.platform=None #Platform object,kernel use it to distinguish platform you use. - self.batch=None - self.epoch=0 - self.acc_flag='%' #This object be used for acc printing. - self.train_counter=0 - self.filename='save.dat' #Saving file name. - self.train_loss=None - self.train_acc=None - self.train_loss_list=[] #This object be used for visualization function. - self.train_acc_list=[] #This object be used for visualization function. - self.test_loss=None - self.test_acc=None - self.test_loss_list=[] #This object be used for visualization function. - self.test_acc_list=[] #This object be used for visualization function. - self.test_flag=False #If you have test data,kernel will set it to True. - self.total_epoch=0 - self.time=0 - self.total_time=0 - - - #Turn training data into kernel's instance object. - def data(self,train_data=None,train_labels=None,test_data=None,test_labels=None,train_dataset=None,test_dataset=None): - self.train_data=train_data - self.train_labels=train_labels - self.train_dataset=train_dataset - self.test_data=test_data - self.test_labels=test_labels - self.test_dataset=test_dataset - try: #If have test data,kernel set test_flag=True. - if test_data==None: - self.test_flag=False - except ValueError: - self.test_flag=True - if self.train_dataset==None: - self.shape0=train_data.shape[0] - return - - - #loss_acc function be used for calculating total loss and total acc. - def loss_acc(self,output=None,labels_batch=None,loss=None,test_batch=None,total_loss=None,total_acc=None): - if self.batch!=None: - total_loss+=loss - try: #If neural network object define accuracy function,kernel will use it to calculate accuracy. - if self.nn.accuracy!=None: - batch_acc=self.nn.accuracy(output,labels_batch) - total_acc+=batch_acc - except AttributeError: - pass - return total_loss,total_acc - else: - loss=loss.numpy() - self.train_loss=loss - self.train_loss_list.append(loss) - try: #If neural network object define accuracy function,kernel will use it to calculate accuracy. - if self.nn.accuracy!=None: - acc=self.nn.accuracy(output,self.train_labels) - acc=acc.numpy() - self.train_acc=acc - self.train_acc_list.append(acc) - except AttributeError: - pass - if self.test_flag==True: #If test_flag=True,kernel call test function. - self.test_loss,self.test_acc=self.test(self.test_data,self.test_labels,test_batch) - self.test_loss_list.append(self.test_loss) - try: - if self.nn.accuracy!=None: - self.test_acc_list.append(self.test_acc) - except AttributeError: - pass - return - - - #data_func functin be used for returning batch data and concatenating data. - def data_func(self,data_batch=None,labels_batch=None,batch=None,index1=None,index2=None,j=None,flag=None): - if flag==None: - if batch!=1: - data_batch=self.train_data[index1:index2] - else: - data_batch=self.train_data[j] - if batch!=1: - labels_batch=self.train_labels[index1:index2] - else: - labels_batch=self.train_labels[j] - else: - try: - data_batch=self.platform.concat([self.train_data[index1:],self.train_data[:index2]],0) - labels_batch=self.platform.concat([self.train_labels[index1:],self.train_labels[:index2]],0) - except: - data_batch=np.concatenate([self.train_data[index1:],self.train_data[:index2]],0) - labels_batch=np.concatenate([self.train_labels[index1:],self.train_labels[:index2]],0) - return data_batch,labels_batch - - - #Optimization subfunction,it be used for opt function,it used optimization function of tensorflow platform. - @function(jit_compile=True) - def tf_opt(self,data,labels): - try: #If neural network object define GradientTape function,kernel will use it or else use other,this design allow you to implement more complicated operations. - if self.nn.GradientTape!=None: - tape,output,loss=self.nn.GradientTape(data,labels) - except AttributeError: - with self.platform.GradientTape(persistent=True) as tape: - try: #If neural network object define one argument value fp(forward propagation) function,kernel will use it or else use other,this design allow you to implement more complicated operations. - output=self.nn.fp(data) - loss=self.nn.loss(output,labels) - except TypeError: - output,loss=self.nn.fp(data,labels) - try: #If neural network object define gradient function,kernel will use it or else use other,this design allow you to implement more complicated operations. - gradient=self.nn.gradient(tape,loss) - except AttributeError: - gradient=tape.gradient(loss,self.nn.param) - try: - self.nn.opt.apply_gradients(zip(gradient,self.nn.param)) - except AttributeError: - self.nn.opt(gradient) - return output,loss - - - #Optimization subfunction,it be used for opt function,it used optimization function of pytorch platform. - def pytorch_opt(self,data,labels): - output=self.nn.fp(data) - loss=self.nn.loss(output,labels) - try: - self.nn.opt.zero_grad() - loss.backward() - self.nn.opt.step() - except: - self.nn.opt(loss) - return output,loss - - - #Main optimization function. - def opt(self,data,labels): - try: - if self.platform.DType!=None: - output,loss=self.tf_opt(data,labels) - except AttributeError: - output,loss=self.pytorch_opt(data,labels) - return output,loss - - - #Training subfunction,it be used for train function and no parallel training. - def _train(self,batch=None,_data_batch=None,_labels_batch=None,test_batch=None): - if batch!=None: - total_loss=0 - total_acc=0 - if self.train_dataset!=None: - for data_batch,labels_batch in self.train_dataset: - output,batch_loss=self.opt(data_batch,labels_batch) - total_loss,total_acc=self.loss_acc(output=output,labels_batch=labels_batch,loss=batch_loss,total_loss=total_loss,total_acc=total_acc) - else: - total_loss=0 - total_acc=0 - batches=int((self.shape0-self.shape0%batch)/batch) - for j in range(batches): - index1=j*batch #Use for index of batch data - index2=(j+1)*batch #Use for index of batch data - data_batch,labels_batch=self.data_func(_data_batch,_labels_batch,batch,index1,index2,j) #Return batch data. - output,batch_loss=self.opt(data_batch,labels_batch) - total_loss,total_acc=self.loss_acc(output=output,labels_batch=labels_batch,loss=batch_loss,total_loss=total_loss,total_acc=total_acc) - try: - self.nn.bc=j - except AttributeError: - pass - if self.shape0%batch!=0: - batches+=1 - index1=batches*batch #Use for index of batch data - index2=batch-(self.shape0-batches*batch) #Use for index of batch data - data_batch,labels_batch=self.data_func(_data_batch,_labels_batch,batch,index1,index2,flag=True) #Return batch data after concatenating. - output,batch_loss=self.opt(data_batch,labels_batch) - total_loss,total_acc=self.loss_acc(output=output,labels_batch=labels_batch,loss=batch_loss,total_loss=total_loss,total_acc=total_acc) - try: - self.nn.bc+=1 - except AttributeError: - pass - try: - if self.platform.DType!=None: - loss=total_loss.numpy()/batches - except AttributeError: - loss=total_loss.detach().numpy()/batches - try: #If neural network object define accuracy function,kernel will calculate mean accuracy. - if self.nn.accuracy!=None: - train_acc=total_acc.numpy()/batches - except AttributeError: - pass - self.train_loss=loss - self.train_loss_list.append(loss) - try: #If neural network object define accuracy function,kernel append mean accuracy to acc list. - if self.nn.accuracy!=None: - self.train_acc=train_acc - self.train_acc_list.append(train_acc) - except AttributeError: - pass - if self.test_flag==True: #If test_flag=True,kernel call test function. - self.test_loss,self.test_acc=self.test(self.test_data,self.test_labels,test_batch) - self.test_loss_list.append(self.test_loss) - try: - if self.nn.accuracy!=None: - self.test_acc_list.append(self.test_acc) - except AttributeError: - pass - else: - output,train_loss=self.opt(self.train_data,self.train_labels) - self.loss_acc(output=output,labels_batch=labels_batch,loss=train_loss,test_batch=test_batch,total_loss=total_loss,total_acc=total_acc) - return - - - #Main training function. - def train(self,batch=None,epoch=None,test_batch=None,save=None,one=True,p=None,s=None): - self.batch=batch - self.epoch=0 - self.train_counter+=1 - if p==None: #p and self.p variable be used for controlling printing count. - self.p=9 - else: - self.p=p-1 - if s==None: #s and self.s variable be used for controlling saving files. - self.s=1 - self.file_list=None - else: - self.s=s-1 - self.file_list=[] - data_batch=None - labels_batch=None - if epoch!=None: - for i in range(epoch): - t1=time.time() - self._train(batch,data_batch,labels_batch,test_batch) - try: - self.nn.ec+=1 - except AttributeError: - pass - self.total_epoch+=1 - if epoch%10!=0: - p=epoch-epoch%self.p - p=int(p/self.p) - s=epoch-epoch%self.s - s=int(s/self.s) - else: - p=epoch/(self.p+1) - p=int(p) - s=epoch/(self.s+1) - s=int(s) - if p==0: - p=1 - if s==0: - s=1 - if i%p==0: - if self.test_flag==False: - try: - if self.nn.accuracy!=None: - print('epoch:{0} loss:{1:.6f}'.format(i+1,self.train_loss)) - if self.acc_flag=='%': - print('epoch:{0} accuracy:{1:.1f}'.format(i+1,self.train_acc*100)) - else: - print('epoch:{0} accuracy:{1:.6f}'.format(i+1,self.train_acc)) - print() - except AttributeError: - print('epoch:{0} loss:{1:.6f}'.format(i+1,self.train_loss)) - print() - else: - try: - if self.nn.accuracy!=None: - print('epoch:{0} loss:{1:.6f},test loss:{2:.6f}'.format(i+1,self.train_loss,self.test_loss)) - if self.acc_flag=='%': - print('epoch:{0} accuracy:{1:.1f},test accuracy:{2:.1f}'.format(i+1,self.train_acc*100,self.test_acc*100)) - else: - print('epoch:{0} accuracy:{1:.1f},test accuracy:{2:.1f}'.format(i+1,self.train_acc,self.test_acc)) - print() - except AttributeError: - print('epoch:{0} loss:{1:.6f},test loss:{2:.6f}'.format(i+1,self.train_loss,self.test_loss)) - print() - if save!=None and i%s==0: - self.save(self.total_epoch,one) - t2=time.time() - self.time+=(t2-t1) - else: - i=0 - while True: - t1=time.time() - self._train(test_batch=test_batch) - i+=1 - try: - self.nn.ec+=1 - except AttributeError: - pass - self.total_epoch+=1 - if epoch%10!=0: - p=epoch-epoch%self.p - p=int(p/self.p) - s=epoch-epoch%self.s - s=int(s/self.s) - else: - p=epoch/(self.p+1) - p=int(p) - s=epoch/(self.s+1) - s=int(s) - if p==0: - p=1 - if s==0: - s=1 - if i%p==0: - if self.test_flag==False: - try: - if self.nn.accuracy!=None: - print('epoch:{0} loss:{1:.6f}'.format(i+1,self.train_loss)) - if self.acc_flag=='%': - print('epoch:{0} accuracy:{1:.1f}'.format(i+1,self.train_acc*100)) - else: - print('epoch:{0} accuracy:{1:.6f}'.format(i+1,self.train_acc)) - print() - except AttributeError: - print('epoch:{0} loss:{1:.6f}'.format(i+1,self.train_loss)) - print() - else: - try: - if self.nn.accuracy!=None: - print('epoch:{0} loss:{1:.6f},test loss:{2:.6f}'.format(i+1,self.train_loss,self.test_loss)) - if self.acc_flag=='%': - print('epoch:{0} accuracy:{1:.1f},test accuracy:{2:.1f}'.format(i+1,self.train_acc*100,self.test_acc*100)) - else: - print('epoch:{0} accuracy:{1:.1f},test accuracy:{2:.1f}'.format(i+1,self.train_acc,self.test_acc)) - print() - except AttributeError: - print('epoch:{0} loss:{1:.6f},test loss:{2:.6f}'.format(i+1,self.train_loss,self.test_loss)) - print() - if save!=None and i%s==0: - self.save(self.total_epoch,one) - t2=time.time() - self.time+=(t2-t1) - if save!=None: - self.save() - self._time=self.time-int(self.time) - if self._time<0.5: - self.time=int(self.time) - else: - self.time=int(self.time)+1 - self.total_time+=self.time - if self.test_flag==False: - print('last loss:{0:.6f}'.format(self.train_loss)) - else: - print('last loss:{0:.6f},last test loss:{1:.6f}'.format(self.train_loss,self.test_loss)) - try: - if self.nn.accuracy!=None: - if self.acc_flag=='%': - if self.test_flag==False: - print('last accuracy:{0:.1f}'.format(self.train_acc*100)) - else: - print('last accuracy:{0:.1f},last test accuracy:{1:.1f}'.format(self.train_acc*100,self.test_acc*100)) - else: - if self.test_flag==False: - print('last accuracy:{0:.6f}'.format(self.train_acc)) - else: - print('last accuracy:{0:.6f},last test accuracy:{1:.6f}'.format(self.train_acc,self.test_acc)) - except AttributeError: - pass - print() - print('time:{0}s'.format(self.time)) - self.training_flag=False - return - - - def test(self,test_data=None,test_labels=None,batch=None): - if type(test_data)==list: - data_batch=[x for x in range(len(test_data))] - if type(test_labels)==list: - labels_batch=[x for x in range(len(test_labels))] - if batch!=None: - total_loss=0 - total_acc=0 - if type(test_data)==list: - batches=int((test_data[0].shape[0]-test_data[0].shape[0]%batch)/batch) - shape0=test_data[0].shape[0] - else: - batches=int((test_data.shape[0]-test_data.shape[0]%batch)/batch) - shape0=test_data.shape[0] - for j in range(batches): - index1=j*batch - index2=(j+1)*batch - if type(test_data)==list: - for i in range(len(test_data)): - data_batch[i]=test_data[i][index1:index2] - else: - data_batch=test_data[index1:index2] - if type(test_labels)==list: - for i in range(len(test_labels)): - labels_batch[i]=test_labels[i][index1:index2] - else: - labels_batch=test_labels[index1:index2] - output=self.nn.fp(data_batch) - batch_loss=self.nn.loss(output,labels_batch) - total_loss+=batch_loss - try: - if self.nn.accuracy!=None: - batch_acc=self.nn.accuracy(output,labels_batch) - total_acc+=batch_acc - except AttributeError: - pass - if shape0%batch!=0: - batches+=1 - index1=batches*batch - index2=batch-(shape0-batches*batch) - try: - if type(test_data)==list: - for i in range(len(test_data)): - data_batch[i]=self.platform.concat([test_data[i][index1:],test_data[i][:index2]],0) - else: - data_batch=self.platform.concat([test_data[index1:],test_data[:index2]],0) - if type(self.test_labels)==list: - for i in range(len(test_labels)): - labels_batch[i]=self.platform.concat([test_labels[i][index1:],test_labels[i][:index2]],0) - else: - labels_batch=self.platform.concat([test_labels[index1:],test_labels[:index2]],0) - except: - if type(test_data)==list: - for i in range(len(test_data)): - data_batch[i]=self.platform.concat([test_data[i][index1:],test_data[i][:index2]],0) - else: - data_batch=self.platform.concat([test_data[index1:],test_data[:index2]],0) - if type(self.test_labels)==list: - for i in range(len(test_labels)): - labels_batch[i]=self.platform.concat([test_labels[i][index1:],test_labels[i][:index2]],0) - else: - labels_batch=self.platform.concat([test_labels[index1:],test_labels[:index2]],0) - output=self.nn.fp(data_batch) - batch_loss=self.nn.loss(output,labels_batch) - total_loss+=batch_loss - try: - if self.nn.accuracy!=None: - batch_acc=self.nn.accuracy(output,labels_batch) - total_acc+=batch_acc - except AttributeError: - pass - test_loss=total_loss.numpy()/batches - try: - if self.nn.accuracy!=None: - test_acc=total_acc.numpy()/batches - except AttributeError: - pass - else: - output=self.nn.fp(test_data) - test_loss=self.nn.loss(output,test_labels) - test_loss=test_loss.numpy() - try: - if self.nn.accuracy!=None: - test_acc=self.nn.accuracy(output,test_labels) - test_acc=test_acc.numpy() - except AttributeError: - pass - try: - if self.nn.accuracy!=None: - return test_loss,test_acc - except AttributeError: - return test_loss,None - - - def visualize_train(self): - print() - plt.figure(1) - plt.plot(np.arange(self.total_epoch),self.train_loss_list) - plt.title('train loss') - plt.xlabel('epoch') - plt.ylabel('loss') - print('train loss:{0:.6f}'.format(self.train_loss)) - try: - if self.nn.accuracy!=None: - plt.figure(2) - plt.plot(np.arange(self.total_epoch),self.train_acc_list) - plt.title('train acc') - plt.xlabel('epoch') - plt.ylabel('acc') - if self.acc_flag=='%': - print('train acc:{0:.1f}'.format(self.train_acc*100)) - else: - print('train acc:{0:.6f}'.format(self.train_acc)) - except AttributeError: - pass - return - - - def visualize_test(self): - print() - plt.figure(1) - plt.plot(np.arange(self.total_epoch),self.test_loss_list) - plt.title('test loss') - plt.xlabel('epoch') - plt.ylabel('loss') - print('test loss:{0:.6f}'.format(self.test_loss)) - try: - if self.nn.accuracy!=None: - plt.figure(2) - plt.plot(np.arange(self.total_epoch),self.test_acc_list) - plt.title('test acc') - plt.xlabel('epoch') - plt.ylabel('acc') - if self.acc_flag=='%': - print('test acc:{0:.1f}'.format(self.test_acc*100)) - else: - print('test acc:{0:.6f}'.format(self.test_acc)) - except AttributeError: - pass - return - - - def comparison(self): - print() - plt.figure(1) - plt.plot(np.arange(self.total_epoch),self.train_loss_list,'b-',label='train loss') - if self.test_flag==True: - plt.plot(np.arange(self.total_epoch),self.test_loss_list,'r-',label='test loss') - plt.xlabel('epoch') - plt.ylabel('loss') - print('train loss:{0}'.format(self.train_loss)) - plt.legend() - try: - if self.nn.accuracy!=None: - plt.figure(2) - plt.plot(np.arange(self.total_epoch),self.train_acc_list,'b-',label='train acc') - if self.test_flag==True: - plt.plot(np.arange(self.total_epoch),self.test_acc_list,'r-',label='test acc') - plt.xlabel('epoch') - plt.ylabel('acc') - plt.legend() - if self.acc_flag=='%': - print('train acc:{0:.1f}'.format(self.train_acc*100)) - else: - print('train acc:{0:.6f}'.format(self.train_acc)) - except AttributeError: - pass - if self.test_flag==True: - print() - print('-------------------------------------') - print() - print('test loss:{0:.6f}'.format(self.test_loss)) - if self.acc_flag=='%': - print('test acc:{0:.1f}'.format(self.test_acc*100)) - else: - print('test acc:{0:.6f}'.format(self.test_acc)) - return - - - def save_p(self): - parameter_file=open('param.dat','wb') - pickle.dump(self.nn.param,parameter_file) - parameter_file.close() - return - - - def save(self,i=None,one=True): - if one==True: - output_file=open(self.filename,'wb') - else: - filename=self.filename.replace(self.filename[self.filename.find('.'):],'-{0}.dat'.format(i)) - output_file=open(filename,'wb') - self.file_list.append([filename]) - if len(self.file_list)>self.s+1: - os.remove(self.file_list[0][0]) - del self.file_list[0] - try: - pickle.dump(self.nn,output_file) - except: - opt=self.nn.opt - self.nn.opt=None - pickle.dump(self.nn,output_file) - self.nn.opt=opt - try: - pickle.dump(self.platform.keras.optimizers.serialize(opt),output_file) - except: - pickle.dump(self.nn.serialize(),output_file) - else: - pickle.dump(None,output_file) - pickle.dump(self.batch,output_file) - pickle.dump(self.acc_flag,output_file) - pickle.dump(self.file_list,output_file) - pickle.dump(self.train_counter,output_file) - pickle.dump(self.train_loss,output_file) - pickle.dump(self.train_acc,output_file) - pickle.dump(self.train_loss_list,output_file) - pickle.dump(self.train_acc_list,output_file) - pickle.dump(self.test_flag,output_file) - if self.test_flag==True: - pickle.dump(self.test_loss,output_file) - pickle.dump(self.test_acc,output_file) - pickle.dump(self.test_loss_list,output_file) - pickle.dump(self.test_acc_list,output_file) - pickle.dump(self.total_epoch,output_file) - pickle.dump(self.total_time,output_file) - output_file.close() - return - - - def restore(self,s_path): - input_file=open(s_path,'rb') - self.nn=pickle.load(input_file) - opt_serialized=pickle.load(input_file) - try: - self.nn.opt=self.platform.keras.optimizers.deserialize(opt_serialized) - except: - self.nn.deserialize(opt_serialized) - else: - pass - self.batch=pickle.load(input_file) - self.acc_flag=pickle.load(input_file) - self.file_list=pickle.load(input_file) - self.train_counter=pickle.load(input_file) - self.train_loss=pickle.load(input_file) - self.train_acc=pickle.load(input_file) - self.train_loss_list=pickle.load(input_file) - self.train_acc_list=pickle.load(input_file) - self.test_flag=pickle.load(input_file) - if self.test_flag==True: - self.test_loss=pickle.load(input_file) - self.test_acc=pickle.load(input_file) - self.test_loss_list=pickle.load(input_file) - self.test_acc_list=pickle.load(input_file) - self.total_epoch=pickle.load(input_file) - self.total_time=pickle.load(input_file) - input_file.close() - return diff --git a/reduced kernel/DL/kernel_reduced_parallel.py b/reduced kernel/DL/kernel_reduced_parallel.py deleted file mode 100644 index 88d5f86d..00000000 --- a/reduced kernel/DL/kernel_reduced_parallel.py +++ /dev/null @@ -1,832 +0,0 @@ -from tensorflow import function -import numpy as np -import matplotlib.pyplot as plt - - -#Keep only parallel part. -#You can analyze kernel by example. -''' -multithreading example: -import kernel_reduced_parallel as k #import kernel -import tensorflow as tf #import platform -import nn as n #import neural network -import threading -mnist=tf.keras.datasets.mnist -(x_train,y_train),(x_test,y_test)=mnist.load_data() -x_train,x_test =x_train/255.0,x_test/255.0 -nn=n.nn() #create neural network object -kernel=k.kernel(nn) #start kernel -kernel.platform=tf #use platform -kernel.process_thread=7 #thread count,use 7 threads to train -kernel.epoch_=6 #epoch:6 -kernel.PO=2 #use PO2 -kernel.data(x_train,y_train) #input you data -kernel.lock=[threading.Lock(),threading.Lock(),threading.Lock()] -class thread(threading.Thread): - def run(self): - kernel.train(32) #batch size:32 -for _ in range(7): - _thread=thread() - _thread.start() -for _ in range(7): - _thread.join() - - -multiprocessing example: -import kernel_reduced_parallel as k #import kernel -import tensorflow as tf #import platform -import nn as n #import neural network -from multiprocessing import Process,Lock -mnist=tf.keras.datasets.mnist -(x_train,y_train),(x_test,y_test)=mnist.load_data() -x_train,x_test =x_train/255.0,x_test/255.0 -nn=n.nn() #create neural network object -kernel=k.kernel(nn) #start kernel -kernel.platform=tf #use platform -kernel.process_thread=7 #thread count,use 7 processes to train -kernel.epoch_=6 #epoch:6 -kernel.PO=2 #use PO2 -kernel.data(x_train,y_train) #input you data -kernel.lock=[Lock(),Lock(),Lock()] -for _ in range(7): - p=Process(target=kernel.train(32)) #batch size:32 - p.start() -for _ in range(7): - p.join() -''' -class kernel: - def __init__(self,nn=None): - self.nn=nn #Neural network object. - self.platform=None #Platform object,kernel use it to distinguish platform you use. - self.PO=None #PO object,three parallel optimization methods correspond to three numbers. - self.lock=None #External incoming lock. - self.process_thread=None #Process thread object,threads or processes count you use. - self.multiprocessing_threading=None - self.process_thread_counter=0 - self.train_ds=None - self.data_segment_flag=False - self.batches=None - self.buffer_size=None - self.epoch_=None #Training epoch count. - self.epoch_counter=0 - self.batch=None - self.epoch=0 - self.acc_flag='%' #This object be used for acc printing. - self.train_counter=0 - self.opt_counter=None - self.train_loss=None - self.train_acc=None - self.train_loss_list=[] #This object be used for visualization function. - self.train_acc_list=[] #This object be used for visualization function. - self.test_loss=None - self.test_acc=None - self.test_loss_list=[] #This object be used for visualization function. - self.test_acc_list=[] #This object be used for visualization function. - self.test_flag=False #If you have test data,kernel will set it to True. - self.total_epoch=0 - - - #Turn training data into kernel's instance object. - def data(self,train_data=None,train_labels=None,test_data=None,test_labels=None,train_dataset=None,test_dataset=None): - self.train_data=train_data - self.train_labels=train_labels - self.train_dataset=train_dataset - if self.data_segment_flag==True: - self.train_data,self.train_labels=self.segment_data() - self.test_data=test_data - self.test_labels=test_labels - self.test_dataset=test_dataset - try: #If have test data,kernel set test_flag=True. - if test_data==None: - self.test_flag=False - except ValueError: - self.test_flag=True - if self.train_dataset==None: - if type(self.train_data)==list: - self.shape0=train_data[0].shape[0] - else: - self.shape0=train_data.shape[0] - if self.train_counter==0 and self.process_thread!=None: - if type(self.process_thread)==list: - self.process_thread_num=np.arange(self.process_thread[0]) - self.process_thread_num=list(self.process_thread_num) - self.thread_num=np.arange(self.process_thread[0]*self.process_thread[1]).reshape(self.process_thread[0],self.process_thread[1]) - self.thread_num=list(self.thread_num) - self.thread_num=[list(self.thread_num[i]) for i in range(len(self.thread_num))] - else: - self.process_thread_num=np.arange(self.process_thread) - self.process_thread_num=list(self.process_thread_num) - if self.epoch_!=None: - if type(self.process_thread)==list: - self.batch_counter=np.zeros([self.process_thread[0]*self.process_thread[1]],dtype=np.int32) - self.total_loss=np.zeros([self.process_thread[0]*self.process_thread[1]],dtype=np.float32) - else: - self.batch_counter=np.zeros(self.process_thread,dtype=np.int32) - self.total_loss=np.zeros(self.process_thread,dtype=np.float32) - try: - if self.nn.accuracy!=None: - if type(self.process_thread)==list: - self.total_acc=np.zeros([self.process_thread[0]*self.process_thread[1]],dtype=np.float32) - else: - self.total_acc=np.zeros(self.process_thread,dtype=np.float32) - except AttributeError: - pass - try: #If neural network object defining attenuate function,kernel will initialize opt_counter(optimization counter). - if self.nn.attenuate!=None: - if type(self.process_thread)==list: - self.opt_counter=np.zeros([self.process_thread[0]*self.process_thread[1]],dtype=np.float32) - else: - self.opt_counter=np.zeros(self.process_thread,dtype=np.float32) - except AttributeError: - pass - try: - if type(self.process_thread)==list: - self.nn.bc=np.zeros([self.process_thread[0]*self.process_thread[1]],dtype=np.float32) - else: - self.nn.bc=np.zeros(self.process_thread,dtype=np.float32) - except AttributeError: - pass - return - - - def segment_data(self): - if len(self.train_data)!=self.process_thread: - data=None - labels=None - segments=int((len(self.train_data)-len(self.train_data)%self.process_thread)/self.process_thread) - for i in range(self.process_thread): - index1=i*segments - index2=(i+1)*segments - if i==0: - data=np.expand_dims(self.train_data[index1:index2],axis=0) - labels=np.expand_dims(self.train_labels[index1:index2],axis=0) - else: - data=np.concatenate((data,np.expand_dims(self.train_data[index1:index2],axis=0))) - labels=np.concatenate((labels,np.expand_dims(self.train_labels[index1:index2],axis=0))) - if len(data)%self.process_thread!=0: - segments+=1 - index1=segments*self.process_thread - index2=self.process_thread-(len(self.train_data)-segments*self.process_thread) - data=np.concatenate((data,np.expand_dims(self.train_data[index1:index2],axis=0))) - labels=np.concatenate((labels,np.expand_dims(self.train_labels[index1:index2],axis=0))) - return data,labels - - - #data_func functin be used for returning batch data and concatenating data. - def data_func(self,data_batch=None,labels_batch=None,batch=None,index1=None,index2=None,j=None,flag=None): - if flag==None: - if batch!=1: - data_batch=self.train_data[index1:index2] - else: - data_batch=self.train_data[j] - if batch!=1: - labels_batch=self.train_labels[index1:index2] - else: - labels_batch=self.train_labels[j] - else: - try: - data_batch=self.platform.concat([self.train_data[index1:],self.train_data[:index2]],0) - labels_batch=self.platform.concat([self.train_labels[index1:],self.train_labels[:index2]],0) - except: - data_batch=np.concatenate([self.train_data[index1:],self.train_data[:index2]],0) - labels_batch=np.concatenate([self.train_labels[index1:],self.train_labels[:index2]],0) - return data_batch,labels_batch - - - #Optimization subfunction,it be used for opt function,it used optimization function of tensorflow platform and parallel optimization. - @function(jit_compile=True) - def tf_opt_t(self,data,labels,t=None,ln=None,u=None): - try: #If neural network object define GradientTape function,kernel will use it or else use other,this design allow you to implement more complicated operations. - if self.nn.GradientTape!=None: - if type(self.process_thread)==list: - tape,output,loss=self.nn.GradientTape(data,labels,u) - else: - tape,output,loss=self.nn.GradientTape(data,labels,t) - except AttributeError: - with self.platform.GradientTape(persistent=True) as tape: - try: - try: #If neural network object define one argument value fp(forward propagation) function,kernel will use it or else use other,this design allow you to implement more complicated operations. - output=self.nn.fp(data) - loss=self.nn.loss(output,labels) - except TypeError: - output,loss=self.nn.fp(data,labels) - except TypeError: - try: - if type(self.process_thread)==list: - output=self.nn.fp(data,u) - else: - output=self.nn.fp(data,t) - loss=self.nn.loss(output,labels) - except TypeError: - if type(self.process_thread)==list: - output,loss=self.nn.fp(data,labels,u) - else: - output,loss=self.nn.fp(data,labels,t) - try: - if self.nn.attenuate!=None: - if type(self.process_thread)==list: - self.opt_counter[u]=0 - else: - self.opt_counter[t]=0 - except AttributeError: - pass - if self.PO==1: - self.lock[0].acquire() - try: #If neural network object define gradient function,kernel will use it or else use other,this design allow you to implement more complicated operations. - gradient=self.nn.gradient(tape,loss) - except AttributeError: - gradient=tape.gradient(loss,self.nn.param) - try: - if self.nn.attenuate!=None: - if type(self.process_thread)==list: - gradient=self.nn.attenuate(gradient,self.opt_counter,u) - else: - gradient=self.nn.attenuate(gradient,self.opt_counter,t) - except AttributeError: - pass - try: - self.nn.opt.apply_gradients(zip(gradient,self.nn.param)) - except AttributeError: - try: - self.nn.opt(gradient) - except TypeError: - self.nn.opt(gradient,t) - try: - if self.nn.attenuate!=None: - self.opt_counter+=1 - except AttributeError: - pass - self.lock[0].release() - elif self.PO==2: - self.lock[0].acquire() - try: #If neural network object define gradient function,kernel will use it or else use other,this design allow you to implement more complicated operations. - gradient=self.nn.gradient(tape,loss) - except AttributeError: - gradient=tape.gradient(loss,self.nn.param) - self.lock[0].release() - self.lock[1].acquire() - try: - if self.nn.attenuate!=None: - if type(self.process_thread)==list: - gradient=self.nn.attenuate(gradient,self.opt_counter,u) - else: - gradient=self.nn.attenuate(gradient,self.opt_counter,t) - except AttributeError: - pass - try: - self.nn.opt.apply_gradients(zip(gradient,self.nn.param)) - except AttributeError: - try: - self.nn.opt(gradient) - except TypeError: - self.nn.opt(gradient,t) - try: - if self.nn.attenuate!=None: - self.opt_counter+=1 - except AttributeError: - pass - self.lock[1].release() - return output,loss - - - #Main optimization function,it be used for parallel optimization. - def opt_t(self,data,labels,t=None,u=None): - if type(self.process_thread)==list: - output,loss=self.tf_opt_t(data,labels,u=int(u)) - else: - output,loss=self.tf_opt_t(data,labels,int(t)) - return output,loss - - - #Training subfunction,it be used for _train_ function and parallel training. - def train_(self,_data_batch=None,_labels_batch=None,batch=None,batches=None,test_batch=None,index1=None,index2=None,j=None,t=None): - if batch!=None: - if index1==batches*batch: - data_batch,labels_batch=self.data_func(_data_batch,_labels_batch,batch,index1,index2,j,True) #Return batch data after concatenating. - output,batch_loss=self.opt_t(data_batch,labels_batch,t) - try: - self.nn.bc[t]+=1 - except AttributeError: - pass - try: #If neural network object define accuracy function,kernel will use it to calculate accuracy. - if self.nn.accuracy!=None: - batch_acc=self.nn.accuracy(output,labels_batch) - return batch_loss,batch_acc - except AttributeError: - return batch_loss,None - data_batch,labels_batch=self.data_func(_data_batch,_labels_batch,batch,index1,index2,j) #Return batch data. - output,batch_loss=self.opt_t(data_batch,labels_batch,t) - try: - self.nn.bc[t]=j - except AttributeError: - pass - try: #If neural network object define accuracy function,kernel will use it to calculate accuracy. - if self.nn.accuracy!=None: - batch_acc=self.nn.accuracy(output,labels_batch) - return batch_loss,batch_acc - except AttributeError: - return batch_loss,None - else: - output,train_loss=self.opt_t(self.train_data,self.train_labels,t) - if self.PO==1 or self.PO==3: - self.lock[1].acquire() - self.total_epoch+=1 - train_loss=train_loss.numpy() - self.train_loss=train_loss - self.train_loss_list.append(train_loss) - try: #If neural network object define accuracy function,kernel will use it to calculate accuracy. - if self.nn.accuracy!=None: - acc=self.nn.accuracy(output,self.train_labels) - acc=acc.numpy() - self.train_acc=acc - self.train_acc_list.append(acc) - except AttributeError: - pass - if self.test_flag==True: - if self.process_thread_t==None: - self.test_loss,self.test_acc=self.test(self.test_data,self.test_labels,test_batch,t) - else: - self.test_loss,self.test_acc=self.test(batch=test_batch) - self.test_loss_list.append(self.test_loss) - try: - if self.nn.accuracy!=None: - self.test_acc_list.append(self.test_acc) - except AttributeError: - pass - self.lock[1].release() - else: - self.lock[2].acquire() - self.total_epoch+=1 - train_loss=train_loss.numpy() - self.train_loss=train_loss - self.train_loss_list.append(train_loss) - try: #If neural network object define accuracy function,kernel will use it to calculate accuracy. - if self.nn.accuracy!=None: - acc=self.nn.accuracy(output,self.train_labels) - acc=acc.numpy() - self.train_acc=acc - self.train_acc_list.append(acc) - except AttributeError: - pass - if self.test_flag==True: #If test_flag=True,kernel call test function. - if self.process_thread_t==None: - self.test_loss,self.test_acc=self.test(self.test_data,self.test_labels,test_batch,t) - else: - self.test_loss,self.test_acc=self.test(batch=test_batch) - self.test_loss_list.append(self.test_loss) - try: - if self.nn.accuracy!=None: - self.test_acc_list.append(self.test_acc) - except AttributeError: - pass - self.lock[2].release() - return - - - #Training subfunction,it be used for train function and parallel training. - def _train_(self,batch=None,data_batch=None,labels_batch=None,test_batch=None,t=None): - total_loss=0 - total_acc=0 - batches=int((self.shape0-self.shape0%batch)/batch) - if batch!=None: - for j in range(batches): - index1=j*batch #Use for index of batch data - index2=(j+1)*batch #Use for index of batch data - batch_loss,batch_acc=self.train_(data_batch,labels_batch,batch,batches,test_batch,index1,index2,j,t) - try: - if self.nn.accuracy!=None: - total_loss+=batch_loss - total_acc+=batch_acc - except AttributeError: - total_loss+=batch_loss - if self.shape0%batch!=0: - batches+=1 - index1=batches*batch #Use for index of batch data - index2=batch-(self.shape0-batches*batch) #Use for index of batch data - batch_loss,batch_acc=self.train_(data_batch,labels_batch,batch,batches,test_batch,index1,index2,None,t) - try: - if self.nn.accuracy!=None: - total_loss+=batch_loss - total_acc+=batch_acc - except AttributeError: - total_loss+=batch_loss - loss=total_loss.numpy()/batches - try: #If neural network object define accuracy function,kernel will calculate mean accuracy. - if self.nn.accuracy!=None: - train_acc=total_acc.numpy()/batches - except AttributeError: - pass - if self.PO==1 or self.PO==3: - self.lock[1].acquire() - else: - self.lock[2].acquire() - self.total_epoch+=1 - self.train_loss=loss - self.train_loss_list.append(loss) - try: #If neural network object define accuracy function,kernel append mean accuracy to acc list. - if self.nn.accuracy!=None: - self.train_acc=train_acc - self.train_acc_list.append(train_acc) - except AttributeError: - pass - if self.test_flag==True: #If test_flag=True,kernel call test function. - if self.process_thread_t==None: - self.test_loss,self.test_acc=self.test(self.test_data,self.test_labels,test_batch,t) - else: - self.test_loss,self.test_acc=self.test(batch=test_batch) - self.test_loss_list.append(self.test_loss) - try: - if self.nn.accuracy!=None: - self.test_acc_list.append(self.test_acc) - except AttributeError: - pass - try: - self.nn.ec+=1 - except AttributeError: - pass - if self.PO==1 or self.PO==3: - self.lock[1].release() - else: - self.lock[2].release() - return - else: - batch_loss,batch_acc=self.train_(data_batch,labels_batch,batch,batches,test_batch,index1,index2,j,t) - return - - - #Training subfunction,it be used for train function and parallel training. - def train7(self,train_ds,t,test_batch): - if type(self.process_thread)==list: - if self.PO==1 or self.PO==3: - self.lock[1].acquire() - else: - self.lock[2].acquire() - u=self.thread_num[t].pop(0) - if self.PO==1 or self.PO==3: - self.lock[1].release() - else: - self.lock[2].release() - while True: - for data_batch,labels_batch in train_ds: - if type(self.process_thread)==list: - output,batch_loss=self.opt_t(data_batch,labels_batch,u=u) - else: - output,batch_loss=self.opt_t(data_batch,labels_batch,t) - try: - if type(self.process_thread)==list: - self.nn.bc[u]+=1 - else: - self.nn.bc[t]+=1 - except AttributeError: - pass - try: - if self.nn.accuracy!=None: - batch_acc=self.nn.accuracy(output,labels_batch) - except AttributeError: - pass - try: - if self.nn.accuracy!=None: - if type(self.process_thread)==list: - self.total_loss[u]+=batch_loss - self.total_acc[u]+=batch_acc - else: - self.total_loss[t]+=batch_loss - self.total_acc[t]+=batch_acc - except AttributeError: - if type(self.process_thread)==list: - self.total_loss[u]+=batch_loss - else: - self.total_loss[t]+=batch_loss - if type(self.process_thread)==list: - self.batch_counter[u]+=1 - else: - self.batch_counter[t]+=1 - if self.PO==1 or self.PO==3: - self.lock[1].acquire() - else: - self.lock[2].acquire() - batches=np.sum(self.batch_counter) - if batches>=self.batches: - self.batch_counter=self.batch_counter*0 - loss=np.sum(self.total_loss)/batches - try: - if self.nn.accuracy!=None: - train_acc=np.sum(self.total_acc)/batches - except AttributeError: - pass - self.total_epoch+=1 - self.train_loss=loss - self.train_loss_list.append(loss) - try: - if self.nn.accuracy!=None: - self.train_acc=train_acc - self.train_acc_list.append(train_acc) - except AttributeError: - pass - if self.test_flag==True: - if self.process_thread_t==None: - self.test_loss,self.test_acc=self.test(self.test_data,self.test_labels,test_batch,t) - else: - self.test_loss,self.test_acc=self.test(batch=test_batch) - self.test_loss_list.append(self.test_loss) - try: - if self.nn.accuracy!=None: - self.test_acc_list.append(self.test_acc) - except AttributeError: - pass - self.epoch_counter+=1 - try: - if type(self.process_thread)==list: - self.nn.bc[u]=0 - else: - self.nn.bc[t]=0 - except AttributeError: - pass - try: - self.nn.ec+=1 - except AttributeError: - pass - self.total_loss=self.total_loss*0 - try: - if self.nn.accuracy!=None: - self.total_acc=self.total_acc*0 - except AttributeError: - pass - if self.PO==1 or self.PO==3: - self.lock[1].release() - else: - self.lock[2].release() - if self.epoch_counter==self.epoch_: - return - - - #Main training function. - def train(self,batch=None,epoch=None,test_batch=None): - if self.process_thread!=None: - if self.PO==1 or self.PO==3: - self.lock[1].acquire() - else: - self.lock[2].acquire() - t=self.process_thread_num.pop(0) - self.process_thread_counter+=1 - if self.epoch_!=None: - if self.train_dataset==None: - if t==0: - if self.batches==None: - self.batches=int((self.shape0-self.shape0%batch)/batch) - if self.shape0%batch!=0: - self.batches+=1 - if self.PO==1 or self.PO==3: - self.lock[1].release() - else: - self.lock[2].release() - self.batch=batch - self.epoch=0 - self.train_counter+=1 - if self.epoch_!=None: - if self.train_dataset!=None: - train_ds=self.train_dataset - else: - if self.data_segment_flag==True: - train_ds=self.platform.data.Dataset.from_tensor_slices((self.train_data[t],self.train_labels[t])).batch(batch) - elif self.buffer_size!=None: - train_ds=self.platform.data.Dataset.from_tensor_slices((self.train_data,self.train_labels)).shuffle(self.buffer_size).batch(batch) - else: - train_ds=self.platform.data.Dataset.from_tensor_slices((self.train_data,self.train_labels)).batch(batch) - data_batch=None - labels_batch=None - if self.process_thread!=None and self.epoch_!=None: - if self.multiprocessing_threading==None: - self.train7(train_ds,t,test_batch) - else: - train7=self.train7 - class thread(self.multiprocessing_threading.Thread): - def run(self): - train7(train_ds,t,test_batch) - for _ in range(self.process_thread[1]): - _thread=thread() - _thread.start() - for _ in range(self.process_thread[1]): - _thread.join() - elif epoch!=None: - for i in range(epoch): - self._train_(batch,data_batch,labels_batch,test_batch,t) - else: - while True: - self._train_(test_batch=test_batch,t=t) - if self.process_thread!=None: - if self.PO==1 or self.PO==3: - self.lock[1].acquire() - else: - self.lock[2].acquire() - self.process_thread_counter-=1 - if self.PO==1 or self.PO==3: - self.lock[1].release() - else: - self.lock[2].release() - return - - - def test(self,test_data=None,test_labels=None,batch=None,t=None): - if type(test_data)==list: - data_batch=[x for x in range(len(test_data))] - if type(test_labels)==list: - labels_batch=[x for x in range(len(test_labels))] - if batch!=None: - total_loss=0 - total_acc=0 - if self.test_dataset!=None: - for data_batch,labels_batch in self.test_dataset: - if self.process_thread==None or t==None: - output=self.nn.fp(data_batch) - else: - output=self.nn.fp(data_batch,t) - batch_loss=self.nn.loss(output,labels_batch) - total_loss+=batch_loss - try: - if self.nn.accuracy!=None: - batch_acc=self.nn.accuracy(output,labels_batch) - total_acc+=batch_acc - except AttributeError: - pass - else: - total_loss=0 - total_acc=0 - if type(test_data)==list: - batches=int((test_data[0].shape[0]-test_data[0].shape[0]%batch)/batch) - shape0=test_data[0].shape[0] - else: - batches=int((test_data.shape[0]-test_data.shape[0]%batch)/batch) - shape0=test_data.shape[0] - for j in range(batches): - index1=j*batch - index2=(j+1)*batch - if type(test_data)==list: - for i in range(len(test_data)): - data_batch[i]=test_data[i][index1:index2] - else: - data_batch=test_data[index1:index2] - if type(test_labels)==list: - for i in range(len(test_labels)): - labels_batch[i]=test_labels[i][index1:index2] - else: - labels_batch=test_labels[index1:index2] - if self.process_thread==None or t==None: - output=self.nn.fp(data_batch) - else: - output=self.nn.fp(data_batch,t) - batch_loss=self.nn.loss(output,labels_batch) - total_loss+=batch_loss - try: - if self.nn.accuracy!=None: - batch_acc=self.nn.accuracy(output,labels_batch) - total_acc+=batch_acc - except AttributeError: - pass - if shape0%batch!=0: - batches+=1 - index1=batches*batch - index2=batch-(shape0-batches*batch) - try: - if type(test_data)==list: - for i in range(len(test_data)): - data_batch[i]=self.platform.concat([test_data[i][index1:],test_data[i][:index2]],0) - else: - data_batch=self.platform.concat([test_data[index1:],test_data[:index2]],0) - if type(self.test_labels)==list: - for i in range(len(test_labels)): - labels_batch[i]=self.platform.concat([test_labels[i][index1:],test_labels[i][:index2]],0) - else: - labels_batch=self.platform.concat([test_labels[index1:],test_labels[:index2]],0) - except: - if type(test_data)==list: - for i in range(len(test_data)): - data_batch[i]=self.platform.concat([test_data[i][index1:],test_data[i][:index2]],0) - else: - data_batch=self.platform.concat([test_data[index1:],test_data[:index2]],0) - if type(self.test_labels)==list: - for i in range(len(test_labels)): - labels_batch[i]=self.platform.concat([test_labels[i][index1:],test_labels[i][:index2]],0) - else: - labels_batch=self.platform.concat([test_labels[index1:],test_labels[:index2]],0) - if self.process_thread==None or t==None: - output=self.nn.fp(data_batch) - else: - output=self.nn.fp(data_batch,t) - batch_loss=self.nn.loss(output,labels_batch) - total_loss+=batch_loss - try: - if self.nn.accuracy!=None: - batch_acc=self.nn.accuracy(output,labels_batch) - total_acc+=batch_acc - except AttributeError: - pass - test_loss=total_loss.numpy()/batches - try: - if self.nn.accuracy!=None: - test_acc=total_acc.numpy()/batches - except AttributeError: - pass - else: - if self.process_thread==None or t==None: - output=self.nn.fp(test_data) - else: - output=self.nn.fp(test_data,t) - test_loss=self.nn.loss(output,test_labels) - test_loss=test_loss.numpy() - try: - if self.nn.accuracy!=None: - test_acc=self.nn.accuracy(output,test_labels) - test_acc=test_acc.numpy() - except AttributeError: - pass - try: - if self.nn.accuracy!=None: - return test_loss,test_acc - except AttributeError: - return test_loss,None - - - def visualize_train(self): - print() - plt.figure(1) - plt.plot(np.arange(self.total_epoch),self.train_loss_list) - plt.title('train loss') - plt.xlabel('epoch') - plt.ylabel('loss') - print('train loss:{0:.6f}'.format(self.train_loss)) - try: - if self.nn.accuracy!=None: - plt.figure(2) - plt.plot(np.arange(self.total_epoch),self.train_acc_list) - plt.title('train acc') - plt.xlabel('epoch') - plt.ylabel('acc') - if self.acc_flag=='%': - print('train acc:{0:.1f}'.format(self.train_acc*100)) - else: - print('train acc:{0:.6f}'.format(self.train_acc)) - except AttributeError: - pass - return - - - def visualize_test(self): - print() - plt.figure(1) - plt.plot(np.arange(self.total_epoch),self.test_loss_list) - plt.title('test loss') - plt.xlabel('epoch') - plt.ylabel('loss') - print('test loss:{0:.6f}'.format(self.test_loss)) - try: - if self.nn.accuracy!=None: - plt.figure(2) - plt.plot(np.arange(self.total_epoch),self.test_acc_list) - plt.title('test acc') - plt.xlabel('epoch') - plt.ylabel('acc') - if self.acc_flag=='%': - print('test acc:{0:.1f}'.format(self.test_acc*100)) - else: - print('test acc:{0:.6f}'.format(self.test_acc)) - except AttributeError: - pass - return - - - def comparison(self): - print() - plt.figure(1) - plt.plot(np.arange(self.total_epoch),self.train_loss_list,'b-',label='train loss') - if self.test_flag==True: - plt.plot(np.arange(self.total_epoch),self.test_loss_list,'r-',label='test loss') - plt.xlabel('epoch') - plt.ylabel('loss') - print('train loss:{0}'.format(self.train_loss)) - plt.legend() - try: - if self.nn.accuracy!=None: - plt.figure(2) - plt.plot(np.arange(self.total_epoch),self.train_acc_list,'b-',label='train acc') - if self.test_flag==True: - plt.plot(np.arange(self.total_epoch),self.test_acc_list,'r-',label='test acc') - plt.xlabel('epoch') - plt.ylabel('acc') - plt.legend() - if self.acc_flag=='%': - print('train acc:{0:.1f}'.format(self.train_acc*100)) - else: - print('train acc:{0:.6f}'.format(self.train_acc)) - except AttributeError: - pass - if self.test_flag==True: - print() - print('-------------------------------------') - print() - print('test loss:{0:.6f}'.format(self.test_loss)) - if self.acc_flag=='%': - print('test acc:{0:.1f}'.format(self.test_acc*100)) - else: - print('test acc:{0:.6f}'.format(self.test_acc)) - return diff --git a/reduced kernel/DL/process/kernel_reduced.py b/reduced kernel/DL/process/kernel_reduced.py deleted file mode 100644 index c5bdc4b5..00000000 --- a/reduced kernel/DL/process/kernel_reduced.py +++ /dev/null @@ -1,657 +0,0 @@ -import tensorflow as tf -from tensorflow import function -from tensorflow.python.ops import state_ops -from multiprocessing import Value,Array -import numpy as np -import matplotlib.pyplot as plt -import pickle -import os - - -class kernel: - def __init__(self,nn=None): - self.nn=nn #Neural network object. - self.PO=None #PO object,two parallel optimization methods correspond to three numbers. - self.process=None #processes count you use. - self.train_ds=None - self.data_segment_flag=False - self.batches=None - self.buffer_size=None - self.epoch=None #Training epoch count. - self.epoch_counter=0 - self.stop=False - self.stop_flag=False - self.save_flag=False - self.save_epoch=None - self.batch=None - self.epoch_=0 - self.end_loss=None - self.end_acc=None - self.end_test_loss=None - self.end_test_acc=None - self.acc_flag='%' #This object be used for acc printing. - self.train_counter=0 - self.muti_p=None - self.muti_s=None - self.muti_save=1 - self.filename='save.dat' - self.train_loss=None - self.train_acc=None - self.train_loss_list=[] #This object be used for visualization function. - self.train_acc_list=[] #This object be used for visualization function. - self.test_loss=None - self.test_acc=None - self.test_loss_list=[] #This object be used for visualization function. - self.test_acc_list=[] #This object be used for visualization function. - self.test_flag=False #If you have test data,kernel will set it to True. - self.total_epoch=0 - - #Turn training data into kernel's instance object and initialize some objects. - def data(self,train_data=None,train_labels=None,test_data=None,test_labels=None,train_dataset=None,test_dataset=None): - self.train_data=train_data - self.train_labels=train_labels - self.train_dataset=train_dataset - self.test_data=test_data - self.test_labels=test_labels - self.test_dataset=test_dataset - try: #If have test data,kernel set test_flag=True. - if test_data==None: - self.test_flag=False - except ValueError: - self.test_flag=True - self.batch_counter=np.zeros(self.process,dtype=np.int32) - self.total_loss=np.zeros(self.process,dtype=np.float32) - if self.train_dataset==None: - if type(self.train_data)==list: - self.shape0=train_data[0].shape[0] - self.batches=int((self.shape0-self.shape0%self.batch)/self.batch) - if self.shape0%self.batch!=0: - self.batches+=1 - else: - self.shape0=train_data.shape[0] - self.batches=int((self.shape0-self.shape0%self.batch)/self.batch) - if self.shape0%self.batch!=0: - self.batches+=1 - if self.data_segment_flag==True: - self.train_data,self.train_labels=self.segment_data() - return - - - def segment_data(self): - if len(self.train_data)!=self.process: - data=None - labels=None - segments=int((len(self.train_data)-len(self.train_data)%self.process)/self.process) - for i in range(self.process): - index1=i*segments - index2=(i+1)*segments - if i==0: - data=np.expand_dims(self.train_data[index1:index2],axis=0) - labels=np.expand_dims(self.train_labels[index1:index2],axis=0) - else: - data=np.concatenate((data,np.expand_dims(self.train_data[index1:index2],axis=0))) - labels=np.concatenate((labels,np.expand_dims(self.train_labels[index1:index2],axis=0))) - if len(data)%self.process!=0: - segments+=1 - index1=segments*self.process - index2=self.process-(len(self.train_data)-segments*self.process) - data=np.concatenate((data,np.expand_dims(self.train_data[index1:index2],axis=0))) - labels=np.concatenate((labels,np.expand_dims(self.train_labels[index1:index2],axis=0))) - return data,labels - - #Initialize shared data for process. - def init(self,manager): - self.epoch_counter=Value('i',self.epoch_counter) #epoch counter,train7 function returns when epoch counter is equal to epoch. - self.batch_counter=Array('i',self.batch_counter) #batch counter,train7 function will do some work when the batch counter sum is equal to batches. - self.total_loss=Array('f',self.total_loss) #For calculating loss. - self.total_epoch=Value('i',self.total_epoch) - self.train_loss=Value('f',self.train_loss) - self.train_loss_list=manager.list(self.train_loss_list) - if self.test_flag==True: - self.test_loss=Value('f',self.test_loss) - self.test_loss_list=manager.list(self.test_loss_list) - try: - if self.nn.accuracy!=None: - self.train_acc=Value('f',self.train_acc) - self.train_acc_list=manager.list(self.train_acc_list) - if self.test_flag==True: - self.test_acc=Value('f',self.test_acc) - self.test_acc_list=manager.list(self.test_acc_list) - except AttributeError: - pass - self.stop_flag=Value('b',self.stop_flag) - self.save_flag=Value('b',self.save_flag) - self.file_list=manager.list([]) - self.param=manager.dict() #A dictionary to store optimized parameters. - return - - - def end(self): - if self.end_loss!=None and len(self.train_loss_list)!=0 and self.train_loss_list[-1]self.end_acc: - return True - elif self.end_loss!=None and len(self.train_loss_list)!=0 and self.end_acc!=None and self.train_loss_list[-1]self.end_acc: - return True - elif self.end_test_loss!=None and len(self.test_loss_list)!=0 and self.test_loss_list[-1]self.end_test_acc: - return True - elif self.end_test_loss!=None and len(self.test_loss_list)!=0 and self.end_test_acc!=None and self.test_loss_list[-1]self.end_test_acc: - return True - - - #Optimization subfunction,it be used for opt function,it used optimization function of tensorflow platform and parallel optimization. - @function(jit_compile=True) - def tf_opt_t(self,data,labels,p,lock): - try: #If neural network object define GradientTape function,kernel will use it or else use other,this design allow you to implement more complicated operations. - if self.nn.GradientTape!=None: - tape,output,loss=self.nn.GradientTape(data,labels,p) - except AttributeError: - with tf.GradientTape(persistent=True) as tape: - try: - try: #If neural network object define one argument value fp(forward propagation) function,kernel will use it or else use other,this design allow you to implement more complicated operations. - output=self.nn.fp(data) - loss=self.nn.loss(output,labels) - except TypeError: - output,loss=self.nn.fp(data,labels) - except TypeError: - try: - output=self.nn.fp(data,p) - loss=self.nn.loss(output,labels) - except TypeError: - output,loss=self.nn.fp(data,labels,p) - if self.PO==1: - lock[0].acquire() - if self.stop_func_(lock[0]): - return None,0 - try: #If neural network object define gradient function,kernel will use it or else use other,this design allow you to implement more complicated operations. - gradient=self.nn.gradient(tape,loss) - except AttributeError: - gradient=tape.gradient(loss,self.nn.param) - try: - param=self.nn.opt(gradient) - except TypeError: - param=self.nn.opt(gradient,p) - lock[0].release() - elif self.PO==2: - lock[0].acquire() - if self.stop_func_(lock[0]): - return None,0 - try: #If neural network object define gradient function,kernel will use it or else use other,this design allow you to implement more complicated operations. - gradient=self.nn.gradient(tape,loss) - except AttributeError: - gradient=tape.gradient(loss,self.nn.param) - lock[0].release() - lock[1].acquire() - if self.stop_func_(lock[1]): - return None,0 - try: - param=self.nn.opt(gradient) - except TypeError: - param=self.nn.opt(gradient,p) - lock[1].release() - return output,loss,param - - #Main optimization function,it be used for parallel optimization. - def opt_t(self,data,labels,p,lock): - output,loss,param=self.tf_opt_t(data,labels,p,lock) - return output,loss,param - - - def update_nn_param(self,param=None): - for i in range(len(self.nn.param)): - if param==None: - self.param[7][i]=self.param[7][i].numpy() - state_ops.assign(self.nn.param[i],self.param[7][i]) - else: - param[7][i]=param[7][i].numpy() - state_ops.assign(self.nn.param[i],param[7][i]) - return - - #Training subfunction,it be used for train function and parallel training. - def train7(self,train_ds,p,test_batch,lock): - while True: - for data_batch,labels_batch in train_ds: - output,batch_loss,param=self.opt_t(data_batch,labels_batch,p,lock) - self.param[7]=param - try: - if self.nn.accuracy!=None: - batch_acc=self.nn.accuracy(output,labels_batch) - except AttributeError: - pass - try: - if self.nn.accuracy!=None: - self.total_loss[p]+=batch_loss - self.total_acc[p]+=batch_acc - except AttributeError: - self.total_loss[p]+=batch_loss - self.batch_counter[p]+=1 - if self.PO==1: - lock[1].acquire() - else: - lock[2].acquire() - batches=np.sum(self.batch_counter) - if batches>=self.batches: - batch_counter=np.frombuffer(self.batch_counter.get_obj(),dtype='i') - batch_counter*=0 - loss=np.sum(self.total_loss)/batches - try: - if self.nn.accuracy!=None: - train_acc=np.sum(self.total_acc)/batches - except AttributeError: - pass - self.total_epoch.value+=1 - self.train_loss.value=loss - self.train_loss_list.append(loss) - try: - if self.nn.accuracy!=None: - self.train_acc.value=train_acc - self.train_acc_list.append(train_acc) - except AttributeError: - pass - if self.test_flag==True: - self.test_loss,self.test_acc=self.test(self.test_data,self.test_labels,test_batch,p) - self.test_loss_list.append(self.test_loss) - try: - if self.nn.accuracy!=None: - self.test_acc_list.append(self.test_acc) - except AttributeError: - pass - self.print_save() - self.epoch_counter.value+=1 - total_loss=np.frombuffer(self.total_loss.get_obj(),dtype='f') - total_loss*=0 - if self.PO==1: - lock[1].release() - else: - lock[2].release() - if self.epoch_counter.value==self.epoch: - self.param[7]=param - return - - #Main training function. - def train(self,p,lock,test_batch=None): - self.train_counter+=1 - if self.epoch!=None: - if self.train_dataset!=None: - train_ds=self.train_dataset - else: - if self.data_segment_flag==True: - train_ds=tf.data.Dataset.from_tensor_slices((self.train_data[p],self.train_labels[p])).batch(self.batch) - elif self.buffer_size!=None: - train_ds=tf.data.Dataset.from_tensor_slices((self.train_data,self.train_labels)).shuffle(self.buffer_size).batch(self.batch) - else: - train_ds=tf.data.Dataset.from_tensor_slices((self.train_data,self.train_labels)).batch(self.batch) - self.train7(train_ds,p,test_batch,lock) - return - - - def test(self,test_data=None,test_labels=None,batch=None,p=None): - if batch!=None: - total_loss=0 - total_acc=0 - if self.test_dataset!=None: - for data_batch,labels_batch in self.test_dataset: - try: - output=self.nn.fp(data_batch) - except TypeError: - output=self.nn.fp(data_batch,p) - batch_loss=self.nn.loss(output,labels_batch) - total_loss+=batch_loss - try: - if self.nn.accuracy!=None: - batch_acc=self.nn.accuracy(output,labels_batch) - total_acc+=batch_acc - except AttributeError: - pass - else: - total_loss=0 - total_acc=0 - batches=int((test_data.shape[0]-test_data.shape[0]%batch)/batch) - shape0=test_data.shape[0] - for j in range(batches): - index1=j*batch - index2=(j+1)*batch - data_batch=test_data[index1:index2] - labels_batch=test_labels[index1:index2] - try: - output=self.nn.fp(data_batch) - except TypeError: - output=self.nn.fp(data_batch,p) - batch_loss=self.nn.loss(output,labels_batch) - total_loss+=batch_loss - try: - if self.nn.accuracy!=None: - batch_acc=self.nn.accuracy(output,labels_batch) - total_acc+=batch_acc - except AttributeError: - pass - if shape0%batch!=0: - batches+=1 - index1=batches*batch - index2=batch-(shape0-batches*batch) - try: - data_batch=tf.concat([test_data[index1:],test_data[:index2]],0) - labels_batch=tf.concat([test_labels[index1:],test_labels[:index2]],0) - except: - data_batch=tf.concat([test_data[index1:],test_data[:index2]],0) - labels_batch=tf.concat([test_labels[index1:],test_labels[:index2]],0) - try: - output=self.nn.fp(data_batch) - except TypeError: - output=self.nn.fp(data_batch,p) - batch_loss=self.nn.loss(output,labels_batch) - total_loss+=batch_loss - try: - if self.nn.accuracy!=None: - batch_acc=self.nn.accuracy(output,labels_batch) - total_acc+=batch_acc - except AttributeError: - pass - test_loss=total_loss.numpy()/batches - try: - if self.nn.accuracy!=None: - test_acc=total_acc.numpy()/batches - except AttributeError: - pass - else: - try: - output=self.nn.fp(test_data) - except TypeError: - output=self.nn.fp(test_data,p) - test_loss=self.nn.loss(output,test_labels) - test_loss=test_loss.numpy() - try: - if self.nn.accuracy!=None: - test_acc=self.nn.accuracy(output,test_labels) - test_acc=test_acc.numpy() - except AttributeError: - pass - try: - if self.nn.accuracy!=None: - return test_loss,test_acc - except AttributeError: - return test_loss,None - - - def stop_func(self): - if self.end(): - self.save(self.total_epoch.value,True) - self.save_flag.value=True - self.stop_flag.value=True - return True - return False - - - def stop_func_(self,lock): - if self.stop==True: - if self.stop_flag.value==True or self.stop_func(): - lock.release() - return True - - - def print_save(self): - if self.epoch!=None: - if self.muti_p!=None: - muti_p=self.muti_p-1 - if self.epoch%10!=0: - p=self.epoch-self.epoch%muti_p - p=int(p/muti_p) - if p==0: - p=1 - else: - p=self.epoch/(muti_p+1) - p=int(p) - if p==0: - p=1 - if self.epoch_%p==0: - if self.test_flag==False: - try: - if self.nn.accuracy!=None: - print('epoch:{0} loss:{1:.6f}'.format(self.total_epoch.value,self.train_loss.value)) - if self.acc_flag=='%': - print('epoch:{0} accuracy:{1:.1f}'.format(self.total_epoch.value,self.train_acc.value*100)) - else: - print('epoch:{0} accuracy:{1:.6f}'.format(self.total_epoch.value,self.train_acc.value)) - print() - except AttributeError: - print('epoch:{0} loss:{1:.6f}'.format(self.total_epoch.value,self.train_loss.value)) - print() - else: - try: - if self.nn.accuracy!=None: - print('epoch:{0} loss:{1:.6f},test loss:{2:.6f}'.format(self.total_epoch.value,self.train_loss.value,self.test_loss.value)) - if self.acc_flag=='%': - print('epoch:{0} accuracy:{1:.1f},test accuracy:{2:.1f}'.format(self.total_epoch.value,self.train_acc.value*100,self.test_acc.value*100)) - else: - print('epoch:{0} accuracy:{1:.1f},test accuracy:{2:.1f}'.format(self.total_epoch.value,self.train_acc.value,self.test_acc.value)) - print() - except AttributeError: - print('epoch:{0} loss:{1:.6f},test loss:{2:.6f}'.format(self.total_epoch,self.train_loss.value,self.test_loss.value)) - print() - if self.muti_s!=None: - muti_s=self.muti_s-1 - if self.epoch%10!=0: - s=self.epoch-self.epoch%muti_s - s=int(s/muti_s) - if s==0: - s=1 - else: - s=self.epoch/(muti_s+1) - s=int(s) - if s==0: - s=1 - if self.muti_save!=None and self.epoch_%s==0: - if self.muti_save==1: - self.save(self.total_epoch.value) - else: - self.save(self.total_epoch.value,False) - self.epoch_+=1 - return - - - def train_info(self): - params=1 - total_params=0 - for i in range(len(self.nn.param)): - for j in range(len(self.nn.param[i].shape)): - params*=self.nn.param[i].shape[j] - total_params+=params - params=1 - print() - print('total params:{0}'.format(total_params)) - print() - print('batch:{0}'.format(self.batch)) - print() - print('epoch:{0}'.format(self.total_epoch.value)) - print() - try: - print('learning rate:{0}'.format(self.nn.lr)) - print() - except AttributeError: - pass - print() - print('-------------------------------------') - print() - print('train loss:{0:.6f}'.format(self.train_loss.value)) - if self.acc_flag=='%': - print('train acc:{0:.1f}'.format(self.train_acc.value*100)) - else: - print('train acc:{0:.6f}'.format(self.train_acc.value)) - return - - - def test_info(self): - print() - print('test loss:{0:.6f}'.format(self.test_loss.value)) - if self.acc_flag=='%': - print('test acc:{0:.1f}'.format(self.test_acc.value*100)) - else: - print('test acc:{0:.6f}'.format(self.test_acc.value)) - return - - - def info(self): - self.train_info() - if self.test_flag==True: - print() - print('-------------------------------------') - self.test_info() - return - - - def visualize_train(self): - print() - plt.figure(1) - plt.plot(np.arange(self.total_epoch.value),self.train_loss_list) - plt.title('train loss') - plt.xlabel('epoch') - plt.ylabel('loss') - print('train loss:{0:.6f}'.format(self.train_loss.value)) - try: - if self.nn.accuracy!=None: - plt.figure(2) - plt.plot(np.arange(self.total_epoch.value),self.train_acc_list) - plt.title('train acc') - plt.xlabel('epoch') - plt.ylabel('acc') - if self.acc_flag=='%': - print('train acc:{0:.1f}'.format(self.train_acc.value*100)) - else: - print('train acc:{0:.6f}'.format(self.train_acc.value)) - except AttributeError: - pass - return - - - def visualize_test(self): - print() - plt.figure(1) - plt.plot(np.arange(self.total_epoch.value),self.test_loss_list) - plt.title('test loss') - plt.xlabel('epoch') - plt.ylabel('loss') - print('test loss:{0:.6f}'.format(self.test_loss.value)) - try: - if self.nn.accuracy!=None: - plt.figure(2) - plt.plot(np.arange(self.total_epoch.value),self.test_acc_list) - plt.title('test acc') - plt.xlabel('epoch') - plt.ylabel('acc') - if self.acc_flag=='%': - print('test acc:{0:.1f}'.format(self.test_acc.value*100)) - else: - print('test acc:{0:.6f}'.format(self.test_acc.value)) - except AttributeError: - pass - return - - - def comparison(self): - print() - plt.figure(1) - plt.plot(np.arange(self.total_epoch.value),self.train_loss_list,'b-',label='train loss') - if self.test_flag==True: - plt.plot(np.arange(self.total_epoch.value),self.test_loss_list,'r-',label='test loss') - plt.xlabel('epoch') - plt.ylabel('loss') - print('train loss:{0}'.format(self.train_loss.value)) - plt.legend() - try: - if self.nn.accuracy!=None: - plt.figure(2) - plt.plot(np.arange(self.total_epoch.value),self.train_acc_list,'b-',label='train acc') - if self.test_flag==True: - plt.plot(np.arange(self.total_epoch.value),self.test_acc_list,'r-',label='test acc') - plt.xlabel('epoch') - plt.ylabel('acc') - plt.legend() - if self.acc_flag=='%': - print('train acc:{0:.1f}'.format(self.train_acc.value*100)) - else: - print('train acc:{0:.6f}'.format(self.train_acc.value)) - except AttributeError: - pass - if self.test_flag==True: - print() - print('-------------------------------------') - print() - print('test loss:{0:.6f}'.format(self.test_loss.value)) - if self.acc_flag=='%': - print('test acc:{0:.1f}'.format(self.test_acc.value*100)) - else: - print('test acc:{0:.6f}'.format(self.test_acc.value)) - return - - - def save_p(self): - parameter_file=open('param.dat','wb') - pickle.dump(self.param[7],parameter_file) - parameter_file.close() - return - - - def save(self,i=None,one=True): - if self.save_flag==True: - return - if one==True: - output_file=open(self.filename,'wb') - else: - filename=self.filename.replace(self.filename[self.filename.find('.'):],'-{0}.dat'.format(i)) - output_file=open(filename,'wb') - self.file_list.append([filename]) - if len(self.file_list)>self.s+1: - os.remove(self.file_list[0][0]) - del self.file_list[0] - pickle.dump(self.nn,output_file) - pickle.dump(self.param[7],output_file) - pickle.dump(self.batch,output_file) - pickle.dump(self.end_loss,output_file) - pickle.dump(self.end_acc,output_file) - pickle.dump(self.end_test_loss,output_file) - pickle.dump(self.end_test_acc,output_file) - pickle.dump(self.acc_flag,output_file) - pickle.dump(self.file_list,output_file) - pickle.dump(self.train_counter,output_file) - pickle.dump(self.train_loss.value,output_file) - pickle.dump(self.train_acc.value,output_file) - pickle.dump(self.train_loss_list,output_file) - pickle.dump(self.train_acc_list,output_file) - pickle.dump(self.test_flag,output_file) - if self.test_flag==True: - pickle.dump(self.test_loss.value,output_file) - pickle.dump(self.test_acc.value,output_file) - pickle.dump(self.test_loss_list,output_file) - pickle.dump(self.test_acc_list,output_file) - pickle.dump(self.total_epoch.value,output_file) - output_file.close() - return - - - def restore(self,s_path): - input_file=open(s_path,'rb') - self.nn=pickle.load(input_file) - self.param[7]=pickle.load(input_file) - self.batch=pickle.load(input_file) - self.end_loss=pickle.load(input_file) - self.end_acc=pickle.load(input_file) - self.end_test_loss=pickle.load(input_file) - self.end_test_acc=pickle.load(input_file) - self.acc_flag=pickle.load(input_file) - self.file_list=pickle.load(input_file) - self.train_counter=pickle.load(input_file) - self.train_loss.value=pickle.load(input_file) - self.train_acc.value=pickle.load(input_file) - self.train_loss_list=pickle.load(input_file) - self.train_acc_list=pickle.load(input_file) - self.test_flag=pickle.load(input_file) - if self.test_flag==True: - self.test_loss.value=pickle.load(input_file) - self.test_acc.value=pickle.load(input_file) - self.test_loss_list=pickle.load(input_file) - self.test_acc_list=pickle.load(input_file) - self.total_epoch.value=pickle.load(input_file) - input_file.close() - return diff --git a/reduced kernel/RL/kernel_reduced.py b/reduced kernel/RL/kernel_reduced.py deleted file mode 100644 index 498278d5..00000000 --- a/reduced kernel/RL/kernel_reduced.py +++ /dev/null @@ -1,648 +0,0 @@ -import tensorflow as tf -from tensorflow import data as tf_data -import numpy as np -import matplotlib.pyplot as plt -import statistics - - -#You can analyze kernel by example. -''' -multithreading example: -import kernel_reduced as k #import kernel -import DQN as d -import threading -dqn=d.DQN(4,128,2) #create neural network object -kernel=k.kernel(dqn,5) #start kernel,use 5 thread to train -kernel.action_count=2 -kernel.set_up(epsilon=0.01,pool_size=10000,batch=64,update_step=10) -kernel.PO=1 #use PO1 -kernel.multiprocessing_threading=threading -kernel.lock=[threading.Lock(),threading.Lock(),threading.Lock()] -class thread(threading.Thread): - def run(self): - kernel.train(100) -for _ in range(5): - _thread=thread() - _thread.start() -for _ in range(5): - _thread.join() -kernel.loss_list or kernel.loss #view training loss -kernel.visualize_train() -kernel.reward #view reward -kernel.visualize_reward() -''' -class kernel: - def __init__(self,nn=None,process_thread=None,save_episode=False): - self.nn=nn - if process_thread!=None: - self.process_thread_num=np.arange(process_thread) - self.process_thread_num=list(self.process_thread_num) - self.reward=np.zeros(process_thread,dtype=np.float32) - self.loss=np.zeros(process_thread,dtype=np.float32) - self.sc=np.zeros(process_thread,dtype=np.float32) - self.opt_counter=np.zeros(process_thread,dtype=np.float32) - self.multiprocessing_threading=None - self.state_pool={} - self.action_pool={} - self.next_state_pool={} - self.reward_pool={} - self.done_pool={} - self.episode_set=[] - self.epsilon=None - self.episode_step=None - self.pool_size=None - self.batch=None - self.episode_=None - self.episode=0 - self.update_step=None - self.trial_count=None - self.process_thread=process_thread - self.process_thread_counter=0 - self.lock=None - self.pool_lock=[] - self.probability_list=[] - self.running_flag_list=[] - self.finish_list=[] - self.running_flag=np.array(0,dtype=np.int8) - self.PN=True - self.PO=None - self.max_episode_count=None - self.save_episode=save_episode - self.filename='save.dat' - self.reward_list=[] - self.loss_list=[] - self.total_episode=0 - self.total_time=0 - - - def action_vec(self): - self.action_one=np.ones(self.action_count,dtype=np.int8) - return - - - def set_up(self,epsilon=None,episode_step=None,pool_size=None,batch=None,update_step=None,trial_count=None,criterion=None): - if epsilon!=None: - self.epsilon=np.ones(self.process_thread)*epsilon - if episode_step!=None: - self.episode_step=episode_step - if pool_size!=None: - self.pool_size=pool_size - if batch!=None: - self.batch=batch - if update_step!=None: - self.update_step=update_step - if trial_count!=None: - self.trial_count=trial_count - if criterion!=None: - self.criterion=criterion - if epsilon!=None: - self.action_vec() - return - - - def epsilon_greedy_policy(self,s,epsilon): - action_prob=self.action_one*epsilon/len(self.action_one) - best_a=np.argmax(self.nn.nn.fp(s)) - action_prob[best_a]+=1-epsilon - return action_prob - - - def pool(self,s,a,next_s,r,done,t,index): - if self.PN==True: - self.pool_lock[index].acquire() - try: - if type(self.state_pool[index])!=np.ndarray and self.state_pool[index]==None: - self.state_pool[index]=s - if type(a)==int: - a=np.array(a) - self.action_pool[index]=np.expand_dims(a,axis=0) - else: - self.action_pool[index]=a - self.next_state_pool[index]=np.expand_dims(next_s,axis=0) - self.reward_pool[index]=np.expand_dims(r,axis=0) - self.done_pool[index]=np.expand_dims(done,axis=0) - else: - try: - self.state_pool[index]=np.concatenate((self.state_pool[index],s),0) - if type(a)==int: - a=np.array(a,np.int64) - self.action_pool[index]=np.concatenate((self.action_pool[index],np.expand_dims(a,axis=0)),0) - else: - self.action_pool[index]=np.concatenate((self.action_pool[index],a),0) - self.next_state_pool[index]=np.concatenate((self.next_state_pool[index],np.expand_dims(next_s,axis=0)),0) - self.reward_pool[index]=np.concatenate((self.reward_pool[index],np.expand_dims(r,axis=0)),0) - self.done_pool[index]=np.concatenate((self.done_pool[index],np.expand_dims(done,axis=0)),0) - except: - pass - if type(self.state_pool[index])==np.ndarray and len(self.state_pool[index])>self.pool_size: - self.state_pool[index]=self.state_pool[index][1:] - self.action_pool[index]=self.action_pool[index][1:] - self.next_state_pool[index]=self.next_state_pool[index][1:] - self.reward_pool[index]=self.reward_pool[index][1:] - self.done_pool[index]=self.done_pool[index][1:] - except: - self.pool_lock[index].release() - return - self.pool_lock[index].release() - else: - if type(self.state_pool[t])==np.ndarray and self.state_pool[t]==None: - self.state_pool[t]=s - if type(a)==int: - a=np.array(a) - self.action_pool[t]=np.expand_dims(a,axis=0) - else: - self.action_pool[t]=a - self.next_state_pool[t]=np.expand_dims(next_s,axis=0) - self.reward_pool[t]=np.expand_dims(r,axis=0) - self.done_pool[t]=np.expand_dims(done,axis=0) - else: - self.state_pool[t]=np.concatenate((self.state_pool[t],s),0) - if type(a)==int: - a=np.array(a,np.int64) - self.action_pool[t]=np.concatenate((self.action_pool[t],np.expand_dims(a,axis=0)),0) - else: - self.action_pool[t]=np.concatenate((self.action_pool[t],a),0) - self.next_state_pool[t]=np.concatenate((self.next_state_pool[t],np.expand_dims(next_s,axis=0)),0) - self.reward_pool[t]=np.concatenate((self.reward_pool[t],np.expand_dims(r,axis=0)),0) - self.done_pool[t]=np.concatenate((self.done_pool[t],np.expand_dims(done,axis=0)),0) - if type(self.state_pool[t])==np.ndarray and len(self.state_pool[t])>self.pool_size: - self.state_pool[t]=self.state_pool[t][1:] - self.action_pool[t]=self.action_pool[t][1:] - self.next_state_pool[t]=self.next_state_pool[t][1:] - self.reward_pool[t]=self.reward_pool[t][1:] - self.done_pool[t]=self.done_pool[t][1:] - return - - - def get_index(self,t): - if self.PN==True: - while len(self.running_flag_list)self.process_thread_counter: - self.running_flag_list[t]=self.running_flag[1:].copy() - while len(self.probability_list)=self.trial_count: - avg_reward=statistics.mean(self.reward_list[-self.trial_count:]) - if self.criterion!=None and avg_reward>=self.criterion: - return True - - - @tf.function(jit_compile=True) - def opt(self,state_batch,action_batch,next_state_batch,reward_batch,done_batch,t,ln=None): - with tf.GradientTape(persistent=True) as tape: - try: - loss=self.nn.loss(state_batch,action_batch,next_state_batch,reward_batch,done_batch) - except TypeError: - loss=self.nn.loss(state_batch,action_batch,next_state_batch,reward_batch,done_batch,t) - try: - if self.nn.attenuate!=None: - self.opt_counter[t]=0 - except AttributeError: - pass - if self.PO==1: - self.lock[0].acquire() - try: - gradient=self.nn.gradient(tape,loss) - try: - if self.nn.attenuate!=None: - gradient=self.nn.attenuate(gradient,self.opt_counter,t) - except AttributeError: - pass - except AttributeError: - try: - if self.nn.nn!=None: - gradient=tape.gradient(loss,self.nn.param) - try: - if self.nn.attenuate!=None: - gradient=self.nn.attenuate(gradient,self.opt_counter,t) - except AttributeError: - pass - except AttributeError: - actor_gradient=tape.gradient(loss[0],self.nn.param[0]) - critic_gradient=tape.gradient(loss[1],self.nn.param[1]) - try: - if self.nn.attenuate!=None: - actor_gradient=self.nn.attenuate(actor_gradient,self.opt_counter,t) - critic_gradient=self.nn.attenuate(critic_gradient,self.opt_counter,t) - except AttributeError: - pass - try: - if self.nn.gradient!=None: - try: - self.nn.opt.apply_gradients(zip(gradient,self.nn.param)) - except AttributeError: - try: - self.nn.opt(gradient) - except TypeError: - self.nn.opt(gradient,t) - except AttributeError: - try: - if self.nn.nn!=None: - self.nn.opt.apply_gradients(zip(gradient,self.nn.param)) - except AttributeError: - self.nn.opt.apply_gradients(zip(actor_gradient,self.nn.param[0])) - self.nn.opt.apply_gradients(zip(critic_gradient,self.nn.param[1])) - try: - if self.nn.attenuate!=None: - self.opt_counter+=1 - except AttributeError: - pass - self.lock[0].release() - elif self.PO==2: - self.lock[0].acquire() - try: - gradient=self.nn.gradient(tape,loss) - except AttributeError: - try: - if self.nn.nn!=None: - gradient=tape.gradient(loss,self.nn.param) - except AttributeError: - actor_gradient=tape.gradient(loss[0],self.nn.param[0]) - critic_gradient=tape.gradient(loss[1],self.nn.param[1]) - self.lock[0].release() - self.lock[1].acquire() - try: - if self.nn.attenuate!=None: - try: - gradient=self.nn.attenuate(gradient,self.opt_counter,t) - except NameError: - actor_gradient=self.nn.attenuate(actor_gradient,self.opt_counter,t) - critic_gradient=self.nn.attenuate(critic_gradient,self.opt_counter,t) - except AttributeError: - pass - try: - if self.nn.gradient!=None: - try: - self.nn.opt.apply_gradients(zip(gradient,self.nn.param)) - except AttributeError: - try: - self.nn.opt(gradient) - except TypeError: - self.nn.opt(gradient,t) - except AttributeError: - try: - if self.nn.nn!=None: - self.nn.opt.apply_gradients(zip(gradient,self.nn.param)) - except AttributeError: - self.nn.opt.apply_gradients(zip(actor_gradient,self.nn.param[0])) - self.nn.opt.apply_gradients(zip(critic_gradient,self.nn.param[1])) - try: - if self.nn.attenuate!=None: - self.opt_counter+=1 - except AttributeError: - pass - self.lock[1].release() - return loss - - - def _train(self,t,j=None,batches=None,length=None,ln=None): - if j==batches-1: - index1=batches*self.batch - index2=self.batch-(length-batches*self.batch) - state_batch=np.concatenate((self.state_pool[t][index1:length],self.state_pool[t][:index2]),0) - action_batch=np.concatenate((self.action_pool[t][index1:length],self.action_pool[t][:index2]),0) - next_state_batch=np.concatenate((self.next_state_pool[t][index1:length],self.next_state_pool[t][:index2]),0) - reward_batch=np.concatenate((self.reward_pool[t][index1:length],self.reward_pool[t][:index2]),0) - done_batch=np.concatenate((self.done_pool[t][index1:length],self.done_pool[t][:index2]),0) - loss=self.opt(state_batch,action_batch,next_state_batch,reward_batch,done_batch,t) - self.loss[t]+=loss - try: - self.nn.bc[t]+=1 - except AttributeError: - pass - else: - index1=j*self.batch - index2=(j+1)*self.batch - state_batch=self.state_pool[t][index1:index2] - action_batch=self.action_pool[t][index1:index2] - next_state_batch=self.next_state_pool[t][index1:index2] - reward_batch=self.reward_pool[t][index1:index2] - done_batch=self.done_pool[t][index1:index2] - loss=self.opt(state_batch,action_batch,next_state_batch,reward_batch,done_batch,t) - self.loss[t]+=loss - try: - self.nn.bc[t]=j - except AttributeError: - pass - return - - - def train_(self,t,ln=None): - train_ds=tf_data.Dataset.from_tensor_slices((self.state_pool[t],self.action_pool[t],self.next_state_pool[t],self.reward_pool[t],self.done_pool[t])).shuffle(len(self.state_pool[t])).batch(self.batch) - for state_batch,action_batch,next_state_batch,reward_batch,done_batch in train_ds: - self.suspend_func(t) - loss=self.opt(state_batch,action_batch,next_state_batch,reward_batch,done_batch,t) - self.loss[t]+=loss - try: - self.nn.bc[t]+=1 - except AttributeError: - pass - return - - - def _train_(self,t): - if len(self.done_pool[t])=self.max_episode_count: - self.save_episode=False - if self.PN==True: - if self.PO==1 or self.PO==3: - self.lock[2].release() - else: - self.lock[3].release() - else: - self.lock[0].release() - try: - if self.nn.row!=None: - pass - except AttributeError: - self.running_flag[t+1]=0 - if self.PO==1 or self.PO==3: - self.lock[2].acquire() - else: - self.lock[3].acquire() - self.process_thread_counter-=1 - if t not in self.finish_list: - self.finish_list[t]=t - if self.PO==1 or self.PO==3: - self.lock[2].release() - else: - self.lock[3].release() - del self.state_pool[t] - del self.action_pool[t] - del self.next_state_pool[t] - del self.reward_pool[t] - del self.done_pool[t] - return - - - def visualize_reward(self): - print() - plt.figure(1) - plt.plot(np.arange(len(self.reward_list)),self.reward_list) - plt.xlabel('episode') - plt.ylabel('reward') - print('reward:{0:.6f}'.format(self.reward_list[-1])) - return - - - def visualize_train(self): - print() - plt.figure(1) - plt.plot(np.arange(len(self.loss_list)),self.loss_list) - plt.title('train loss') - plt.xlabel('episode') - plt.ylabel('loss') - print('loss:{0:.6f}'.format(self.loss_list[-1])) - return - - - def visualize_reward_loss(self): - print() - plt.figure(1) - plt.plot(np.arange(len(self.reward_list)),self.reward_list,'r-',label='reward') - plt.plot(np.arange(len(self.loss_list)),self.loss_list,'b-',label='train loss') - plt.xlabel('epoch') - plt.ylabel('reward and loss') - return diff --git a/reduced kernel/RL/nspn/kernel_reduced.py b/reduced kernel/RL/nspn/kernel_reduced.py deleted file mode 100644 index 5b52841e..00000000 --- a/reduced kernel/RL/nspn/kernel_reduced.py +++ /dev/null @@ -1,617 +0,0 @@ -from tensorflow import function -from tensorflow import data as tf_data -import numpy as np -import matplotlib.pyplot as plt -import statistics -import pickle -import os -import time - - -#You can analyze kernel by example. -''' -example: -import nspn.kernel_reduced as k #import kernel -import tensorflow as tf -import DQN as d -dqn=d.DQN(4,128,2) #create neural network object -kernel=k.kernel(dqn) #start kernel -kernel.platform=tf -kernel.action_count=2 -kernel.set_up(epsilon=0.01,pool_size=10000,batch=64,update_step=10) -kernel.train(500) -''' -class kernel: - def __init__(self,nn=None,save_episode=False): - self.nn=nn - self.platform=None - self.state_pool=None - self.action_pool=None - self.next_state_pool=None - self.reward_pool=None - self.done_pool=None - self.episode_set=[] - self.epsilon=None - self.episode_step=None - self.pool_size=None - self.batch=None - self.update_step=None - self.trial_count=None - self.criterion=None - self.reward_list=[] - self.max_episode_count=None - self.save_episode=save_episode - self.filename='save.dat' - self.loss=None - self.loss_list=[] - self.sc=0 - self.total_episode=0 - self.time=0 - self.total_time=0 - - - def action_vec(self): - if self.epsilon!=None: - self.action_one=np.ones(self.action_count,dtype=np.int8) - return - - - def set_up(self,epsilon=None,episode_step=None,pool_size=None,batch=None,update_step=None,trial_count=None,criterion=None): - if epsilon!=None: - self.epsilon=epsilon - if episode_step!=None: - self.episode_step=episode_step - if pool_size!=None: - self.pool_size=pool_size - if batch!=None: - self.batch=batch - if update_step!=None: - self.update_step=update_step - if trial_count!=None: - self.trial_count=trial_count - if criterion!=None: - self.criterion=criterion - self.action_vec() - return - - - def epsilon_greedy_policy(self,s): - action_prob=self.action_one*self.epsilon/len(self.action_one) - try: - if self.platform.DType!=None: - best_a=np.argmax(self.nn.nn.fp(s)) - action_prob[best_a]+=1-self.epsilon - except AttributeError: - best_a=self.nn.nn(s).argmax() - action_prob[best_a.numpy()]+=1-self.epsilon - return action_prob - - - @function(jit_compile=True) - def tf_opt(self,state_batch,action_batch,next_state_batch,reward_batch,done_batch): - with self.platform.GradientTape(persistent=True) as tape: - loss=self.nn.loss(state_batch,action_batch,next_state_batch,reward_batch,done_batch) - try: - gradient=self.nn.gradient(tape,loss) - try: - self.nn.opt.apply_gradients(zip(gradient,self.nn.param)) - except AttributeError: - self.nn.opt(gradient) - except AttributeError: - try: - if self.nn.nn!=None: - gradient=tape.gradient(loss,self.nn.param) - self.nn.opt.apply_gradients(zip(gradient,self.nn.param)) - except AttributeError: - actor_gradient=tape.gradient(loss[0],self.nn.param[0]) - critic_gradient=tape.gradient(loss[1],self.nn.param[1]) - self.nn.opt.apply_gradients(zip(actor_gradient,self.nn.param[0])) - self.nn.opt.apply_gradients(zip(critic_gradient,self.nn.param[1])) - return loss - - - def pytorch_opt(self,state_batch,action_batch,next_state_batch,reward_batch,done_batch): - loss=self.nn.loss(state_batch,action_batch,next_state_batch,reward_batch,done_batch) - self.nn.backward(loss) - self.nn.opt() - return loss - - - def opt(self,state_batch,action_batch,next_state_batch,reward_batch,done_batch): - try: - if self.platform.DType!=None: - loss=self.tf_opt(state_batch,action_batch,next_state_batch,reward_batch,done_batch) - except AttributeError: - loss=self.pytorch_opt(state_batch,action_batch,next_state_batch,reward_batch,done_batch) - return loss - - - def opt_ol(self,state,action,next_state,reward,done): - try: - if self.platform.DType!=None: - loss=self.tf_opt(state,action,next_state,reward,done) - except AttributeError: - loss=self.pytorch_opt(state,action,next_state,reward,done) - return loss - - - def pool(self,s,a,next_s,r,done): - if type(self.state_pool)!=np.ndarray and self.state_pool==None: - self.state_pool=s - if type(a)==int: - a=np.array(a) - self.action_pool=np.expand_dims(a,axis=0) - else: - self.action_pool=a - self.next_state_pool=np.expand_dims(next_s,axis=0) - self.reward_pool=np.expand_dims(r,axis=0) - self.done_pool=np.expand_dims(done,axis=0) - else: - self.state_pool=np.concatenate((self.state_pool,s),0) - if type(a)==int: - a=np.array(a) - self.action_pool=np.concatenate((self.action_pool,np.expand_dims(a,axis=0)),0) - else: - self.action_pool=np.concatenate((self.action_pool,a),0) - self.next_state_pool=np.concatenate((self.next_state_pool,np.expand_dims(next_s,axis=0)),0) - self.reward_pool=np.concatenate((self.reward_pool,np.expand_dims(r,axis=0)),0) - self.done_pool=np.concatenate((self.done_pool,np.expand_dims(done,axis=0)),0) - if len(self.state_pool)>self.pool_size: - self.state_pool=self.state_pool[1:] - self.action_pool=self.action_pool[1:] - self.next_state_pool=self.next_state_pool[1:] - self.reward_pool=self.reward_pool[1:] - self.done_pool=self.done_pool[1:] - return - - - def _train(self): - if len(self.state_pool)=self.trial_count: - avg_reward=statistics.mean(self.reward_list[-self.trial_count:]) - if self.criterion!=None and avg_reward>=self.criterion: - t2=time.time() - self.total_time+=(t2-t1) - self._time=self.total_time-int(self.total_time) - if self._time<0.5: - self.total_time=int(self.total_time) - else: - self.total_time=int(self.total_time)+1 - print('episode:{0}'.format(self.total_episode)) - print('last loss:{0:.6f}'.format(loss)) - print('average reward:{0}'.format(avg_reward)) - print() - print('time:{0}s'.format(self.total_time)) - return - self.loss=loss - self.loss_list.append(loss) - self.total_episode+=1 - if episode_count%10!=0: - p=episode_count-episode_count%self.p - p=int(p/self.p) - s=episode_count-episode_count%self.s - s=int(s/self.s) - else: - p=episode_count/(self.p+1) - p=int(p) - s=episode_count/(self.s+1) - s=int(s) - if p==0: - p=1 - if s==0: - s=1 - if i%p==0: - if len(self.state_pool)>=self.batch: - print('episode:{0} loss:{1:.6f}'.format(i+1,loss)) - if avg_reward!=None: - print('episode:{0} average reward:{1}'.format(i+1,avg_reward)) - else: - print('episode:{0} reward:{1}'.format(i+1,self.reward)) - print() - if save!=None and i%s==0: - self.save(self.total_episode,one) - if self.save_episode==True: - if done: - episode.append('done') - self.episode_set.append(episode) - if self.max_episode_count!=None and len(self.episode_set)>=self.max_episode_count: - self.save_episode=False - try: - self.nn.ec+=1 - except AttributeError: - pass - t2=time.time() - self.time+=(t2-t1) - else: - i=0 - while True: - t1=time.time() - loss,episode,done=self.train_() - if self.trial_count!=None: - if len(self.reward_list)==self.trial_count: - avg_reward=statistics.mean(self.reward_list[-self.trial_count:]) - if avg_reward>=self.criterion: - t2=time.time() - self.total_time+=(t2-t1) - self._time=self.total_time-int(self.total_time) - if self._time<0.5: - self.total_time=int(self.total_time) - else: - self.total_time=int(self.total_time)+1 - print('episode:{0}'.format(self.total_episode)) - print('last loss:{0:.6f}'.format(loss)) - print('average reward:{0}'.format(avg_reward)) - print() - print('time:{0}s'.format(self.total_time)) - return - self.loss=loss - self.loss_list.append(loss) - i+=1 - self.total_episode+=1 - if episode_count%10!=0: - p=episode_count-episode_count%self.p - p=int(p/self.p) - s=episode_count-episode_count%self.s - s=int(s/self.s) - else: - p=episode_count/(self.p+1) - p=int(p) - s=episode_count/(self.s+1) - s=int(s) - if p==0: - p=1 - if s==0: - s=1 - if i%p==0: - if len(self.state_pool)>=self.batch: - print('episode:{0} loss:{1:.6f}'.format(i+1,loss)) - if avg_reward!=None: - print('episode:{0} average reward:{1}'.format(i+1,avg_reward)) - else: - print('episode:{0} reward:{1}'.format(i+1,self.reward)) - print() - if save!=None and i%s==0: - self.save(self.total_episode,one) - if self.save_episode==True: - if done: - episode.append('done') - self.episode_set.append(episode) - if self.max_episode_count!=None and len(self.episode_set)>=self.max_episode_count: - self.save_episode=False - try: - self.nn.ec+=1 - except AttributeError: - pass - t2=time.time() - self.time+=(t2-t1) - self._time=self.time-int(self.time) - if self._time<0.5: - self.total_time=int(self.time) - else: - self.total_time=int(self.time)+1 - self.total_time+=self.time - print('last loss:{0:.6f}'.format(loss)) - print('last reward:{0}'.format(self.reward)) - print() - print('time:{0}s'.format(self.time)) - return - - - def train_ol(self): - while True: - if self.stop_flag==True: - return - if self.save_flag==True: - self.save() - self.suspend_func() - data=self.nn.ol() - if data=='stop': - return - elif data=='suspend': - while True: - self.nn.suspend=True - while True: - if self.nn.suspend==False: - break - continue - loss=self.opt_ol(data[0],data[1],data[2],data[3],data[4]) - loss=loss.numpy() - self.nn.train_loss_list.append(loss) - if len(self.nn.train_acc_list)==self.nn.max_length: - del self.nn.train_acc_list[0] - try: - self.nn.c+=1 - except AttributeError: - pass - return - - - - def visualize_reward(self): - print() - plt.figure(1) - plt.plot(np.arange(self.total_episode),self.reward_list) - plt.xlabel('episode') - plt.ylabel('reward') - print('reward:{0:.6f}'.format(self.reward_list[-1])) - return - - - def visualize_train(self): - print() - plt.figure(1) - plt.plot(np.arange(self.total_episode),self.loss_list) - plt.title('train loss') - plt.xlabel('episode') - plt.ylabel('loss') - print('loss:{0:.6f}'.format(self.loss_list[-1])) - return - - - def save_e(self): - episode_file=open('episode.dat','wb') - pickle.dump(self.episode_set,episode_file) - episode_file.close() - return - - - def save(self,i=None,one=True): - if one==True: - output_file=open(self.filename,'wb') - if self.save_episode==True: - episode_file=open('episode.dat','wb') - pickle.dump(self.episode_set,episode_file) - episode_file.close() - else: - filename=self.filename.replace(self.filename[self.filename.find('.'):],'-{0}.dat'.format(i)) - output_file=open(filename,'wb') - self.file_list.append([filename]) - if self.save_episode==True: - episode_file=open('episode-{0}.dat'.format(i),'wb') - pickle.dump(self.episode_set,episode_file) - episode_file.close() - if self.save_episode==True: - self.file_list.append([filename,'episode-{0}.dat']) - if len(self.file_list)>self.s+1: - os.remove(self.file_list[0][0]) - os.remove(self.file_list[0][1]) - del self.file_list[0] - else: - self.file_list.append([filename]) - if len(self.file_list)>self.s+1: - os.remove(self.file_list[0][0]) - del self.file_list[0] - try: - if self.platform.DType!=None: - try: - pickle.dump(self.nn,output_file) - except: - opt=self.nn.opt - self.nn.opt=None - pickle.dump(self.nn,output_file) - self.nn.opt=opt - except AttributeError: - pass - try: - pickle.dump(self.platform.keras.optimizers.serialize(opt),output_file) - except: - pickle.dump(self.nn.serialize(),output_file) - else: - pickle.dump(None,output_file) - pickle.dump(self.epsilon,output_file) - pickle.dump(self.episode_step,output_file) - pickle.dump(self.pool_size,output_file) - pickle.dump(self.batch,output_file) - pickle.dump(self.update_step,output_file) - pickle.dump(self.max_episode_count,output_file) - pickle.dump(self.save_episode,output_file) - pickle.dump(self.reward_list,output_file) - pickle.dump(self.loss,output_file) - pickle.dump(self.loss_list,output_file) - pickle.dump(self.sc,output_file) - pickle.dump(self.total_episode,output_file) - pickle.dump(self.total_time,output_file) - output_file.close() - return - - - def restore(self,s_path,e_path=None): - input_file=open(s_path,'rb') - if e_path!=None: - episode_file=open(e_path,'rb') - self.episode_set=pickle.load(episode_file) - episode_file.close() - self.nn=pickle.load(input_file) - opt_serialized=pickle.load(input_file) - try: - self.nn.opt=self.platform.keras.optimizers.deserialize(opt_serialized) - except: - self.nn.deserialize(opt_serialized) - else: - pass - self.epsilon=pickle.load(input_file) - self.episode_step=pickle.load(input_file) - self.pool_size=pickle.load(input_file) - self.batch=pickle.load(input_file) - self.update_step=pickle.load(input_file) - self.max_episode_count=pickle.load(input_file) - self.save_episode=pickle.load(input_file) - self.reward_list=pickle.load(input_file) - self.loss=pickle.load(input_file) - self.loss_list=pickle.load(input_file) - self.sc=pickle.load(input_file) - self.total_episode=pickle.load(input_file) - self.total_time=pickle.load(input_file) - input_file.close() - return