def receiveFromInternet(self):
try:
self.transportServerSocket = socket(AF_INET, SOCK_STREAM)
self.transportServerSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
self.transportServerSocket.bind(Layer.TransportServer)
self.transportServerSocket.listen(1)
print 'Listening...'
while True:
self.segment, success = Layer.receive(self.transportServerSocket)
self.transportProtocol = json.loads(self.segment)['transportProtocol']
self.msg.emit('Received a ' + self.transportProtocol + ' segment.')
if success:
if self.transportProtocol == 'TCP':
if not self.interpretTCPSegment(self.segment):
self.errorMsg.emit('Error trying to interpret TCP segment')
else: #UDP protocol
self.interpretUDPSegment(self.segment)
self.sendToApplication()
if self.receiveAnswer():
self.createSegment(self.transportProtocol, self.applicationPack)
sent = Layer.send(Layer.NetworkServer, self.segment)
print 'Answer sent to internet layer'
except KeyboardInterrupt:
print 'Shutting down transport server'
except Exception as exc:
exc_type, exc_obj, exc_tb = sys.exc_info()
error = exc_tb.tb_frame
line = exc_tb.tb_lineno
fileName = error.f_code.co_filename
print "Error! " + str(exc)
print 'error line = ' + str(line)
self.transportServerSocket.close()
def run(self):
self.getMyIPMAC()
self.physicalClientSocket = socket(AF_INET, SOCK_STREAM)
self.physicalClientSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
self.physicalClientSocket.bind(Layer.PhysicalClient)
self.physicalClientSocket.listen(1)
while True:
self.msg.emit('Waiting datagram from Network layer')
self.package, success = Layer.receive(self.physicalClientSocket)
if success:
self.msg.emit('Received package from Network layer.')
destiny = json.loads(self.package)['destiny']
self.destiny = (destiny[0], destiny[1])
self.msg.emit ('Destiny = ' + str(self.destiny))
self.getDstMAC(self.destiny)
self.package = json.loads(self.package)['datagram']
if success:
if not self.mtuReceived:
self.connectAsClient(self.destiny)
self.createFrame_BinaryFile(self.package, 'binaryRequestClient.txt', 'blue')
if self.probCollision != 0:
while random.randint(0, 10) <= self.probCollision:
rand = random.randint(0, 10)
self.msg.emit('Collision detected, ' + str(rand) + ' seconds to retry...')
time.sleep(rand)
sent = Layer.send(self.destiny, 'binaryRequestClient.txt', self.myMTU)
self.msg.emit('Sent binary file to Physical server.')
if self.receiveFile(self.physicalClientSocket, 'binaryAnswer.txt'):
self.msg.emit('Received binary file from server')
self.answer = self.interpretPackage('binaryAnswer.txt', 'red')
sent = Layer.send(Layer.NetworkClient, self.answer)
def get_layer(self, name):
try:
lyr = Layer(self, name)
lyr.fetch()
return lyr
except FailedRequestError:
return None
def build(self, X, y):
"""
Builds the neural network in tensorflow
"""
## First, create a placeholder for the targets
self.targets = tf.placeholder(tf.float32, shape=[None, self.n_categories])
## First, create the input layer
self.input_layer = Layer(n_neurons=self.n_features)
self.input_layer.build()
## Then create all the hidden layers
current_input_layer = self.input_layer
for layer in self.hidden_layers:
layer.build(current_input_layer)
current_input_layer = layer
## Create the output layer
self.output_layer = Layer(n_neurons=self.n_categories, activation=self.output_activation)
self.output_layer.build(current_input_layer)
## Define the cost function
self.cost = None
if self.cost_function == 'log-likelihood':
self.cost = tf.reduce_mean(-tf.log(1e-37 + tf.reduce_sum(self.targets * self.output_layer.output, reduction_indices=[1])))
else: ## cross-entropy
self.cost = tf.reduce_mean(-tf.reduce_sum(self.targets * tf.log(1e-37 + self.output_layer.output), reduction_indices=[1]))
## Define the regularization parameters and function
self.reg_lambda_param = tf.placeholder(tf.float32)
self.batch_size = tf.placeholder(tf.float32)
if self.regularization == 'l1':
self.reg_term = tf.reduce_sum(tf.abs(self.output_layer.weights))
for layer in self.hidden_layers:
self.reg_term += tf.reduce_sum(tf.abs(layer.weights))
elif self.regularization == 'l2':
self.reg_term = tf.reduce_sum(self.output_layer.weights * self.output_layer.weights)
for layer in self.hidden_layers:
self.reg_term += tf.reduce_sum(layer.weights * layer.weights)
else:
self.reg_term = None
## Add the regularization term to the cost function
if self.reg_term is None:
self.reg_cost = self.cost
else:
self.reg_cost = self.cost + (self.reg_lambda_param/(2*self.batch_size))*self.reg_term
## Define the train step
self.train_step = getattr(tf.train, '{0}Optimizer'.format(self.learning_algorithm))(self.learning_rate).minimize(self.reg_cost)
## Initialize everything
self.session.run(tf.initialize_all_variables())
def run(self):
while not self.exit:
self.clock.tick(GameConfig.FRAMES_PER_SECOND)
self.controls.poll_event()
self.draw_menu()
Layer.update()
return None
def load(path):
"""
Loads a neural network from a json file
@param (String) path - The path to load the neural network from
@returns (Network) - The neural network that was loaded
"""
network = Network()
try:
with open(path, "r+") as f:
network_data = "\n".join(f.readlines())
network_json = json.loads(network_data)
layers = network_json["layers"]
# For every layer in the network ...
for layer in layers:
neurons = []
# For every neuron in the layer ...
for neuron in layer["neurons"]:
weights = neuron["weights"]
bias = neuron["bias"]
activation = neuron["activation"]
# Choose the proper activation function and corresponding derivative
activation_func = None
derivative_func = None
if activation == Network.LINEAR:
activation_func = Network.ACTIVATION_LINEAR
derivative_func = Network.DERIVATIVE_LINEAR
elif activation == Network.SIGMOID:
activation_func = Network.ACTIVATION_SIGMOID
derivative_func = Network.DERIVATIVE_SIGMOID
elif activation == Network.TANH:
activation_func = Network.ACTIVATION_TANH
derivative_func = Network.DERIVATIVE_TANH
elif activation == Network.STEP:
activation_func = Network.ACTIVATION_STEP
derivative_func = Network.DERIVATIVE_STEP
# Create a neuron with the desired info
neuron = Neuron(0, activation_func, derivative_func)
neuron.weights = weights
neuron.bias = bias
# Add the processed neuron to the collection
neurons.append(neuron)
# Create a layer with the desired neurons
layer = Layer(0, 0, None, None)
layer.neurons = neurons
# Add the processed layer to the collection
network.layers.append(layer)
except:
raise Exception("Invalid Neural Network File @ {}!".format(path))
return network
def run(self):
try:
self.msg.emit('starting router')
self.physicalRouterSocket = socket(AF_INET, SOCK_STREAM)
self.physicalRouterSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
self.physicalRouterSocket.bind(Layer.PhysicalRouter)
self.host, self.port = Layer.PhysicalRouter
self.physicalRouterSocket.listen(1)
self.msg.emit("Setup:\nIP = " + str(self.host) + '\tPort = ' + str(self.port) + '\nListening...')
except Exception as exc:
self.errorMsg.emit('ERROR! It was not possible start the execution: \n' + str(exc))
try:
while True:
if not self.mtuSent:
self.getMyIPMAC()
self.connectAsServer(self.physicalRouterSocket)
#receive request file from client
if self.receiveFile(self.physicalRouterSocket, 'binaryRouterClientRequest.txt'):
self.package = self.interpretPackage('binaryRouterClientRequest.txt', 'blue')
#Sending to and receiving from network layer
Layer.send(Layer.NetworkRouter, self.package)
self.msg.emit('Waiting answer...')
self.answer, success = Layer.receive(self.physicalRouterSocket)
self.msg.emit('Received package from Network layer.')
serverIP = json.loads(self.answer)['destiny']
self.getDstMAC(serverIP[0])
self.answer = json.loads(self.answer)['datagram']
#Creating binary file of request from client and sending to server
self.createFrame_BinaryFile(self.answer, 'binaryRouterRequest.txt','green')
self.msg.emit ('Sending to server IP = ' + str(Layer.PhysicalServer))
self.connectAsClient(Layer.PhysicalServer)
self.msg.emit ('Request sent.');
success = Layer.send(Layer.PhysicalServer, 'binaryRouterRequest.txt', self.mtu)
#receiving answer from server
if success and self.receiveFile(self.physicalRouterSocket, 'binaryRouterServerAnswer.txt'):
self.package = self.interpretPackage('binaryRouterServerAnswer.txt', 'blue')
#sending to and receiving from network layer
Layer.send(Layer.NetworkRouter, self.package)
self.msg.emit('Waiting answer...')
self.answer, success = Layer.receive(self.physicalServerSocket)
self.msg.emit('Received package from Network layer.')
destiny = json.loads(self.answer)['destiny']
self.answer = json.loads(self.answer)['datagram']
#creating binary file of answer from server and sending to client
self.createFrame_BinaryFile(self.answer, 'binaryRouterAnswer.txt','green')
Layer.send(Layer.PhysicalClient, 'binaryRouterAnswer.txt', self.mtu)
except Exception as exc:
exc_type, exc_obj, exc_tb = sys.exc_info()
error = exc_tb.tb_frame
line = exc_tb.tb_lineno
fileName = error.f_code.co_filename
self.errorMsg.emit('ERROR! It was not possible run the server: \n' + str(exc)+
'\nLine = ' + str(line))
return False
def __init__(self,neuron_count_list = [1,1,1]):
self.layer_list = []
for i in xrange(1,len(neuron_count_list)):
#new layer with input count determined by the prev layer neuron count
new_layer = Layer(neuron_count_list[i-1])
for j in xrange(neuron_count_list[i]):
new_layer.add_neuron(weights=None,bias=None)
self.layer_list.append(new_layer)
def load(filename, input): fptr = open(filename,'r') data = json.load(fptr) hidden_layer = [] for layer_data in data[:-1]: layer = Layer.load(layer_data, input=input) hidden_layer.append(layer) input = layer.output output_layer = Layer.load(data[-1], input=hidden_layer[-1].output) fptr.close() nnet = Network(new_network=False) nnet.create_network(hidden_layer, output_layer) return nnet
def __init__(self, data=None, projection=None, geotransform=None,
name=None, keywords=None, style_info=None):
"""Initialise object with either data or filename
NOTE: Doc strings in constructor are not harvested and exposed in
online documentation. Hence the details are specified in the
class docstring.
"""
# Invoke common layer constructor
Layer.__init__(self,
name=name,
projection=projection,
keywords=keywords,
style_info=style_info)
# Input checks
if data is None:
# Instantiate empty object
self.geotransform = None
self.rows = self.columns = 0
return
# Initialisation
if isinstance(data, basestring):
self.read_from_file(data)
elif isinstance(data, QgsRasterLayer):
self.read_from_qgis_native(data)
else:
# Assume that data is provided as a numpy array
# with extra keyword arguments supplying metadata
self.data = numpy.array(data, dtype='d', copy=False)
proj4 = self.get_projection(proj4=True)
if 'longlat' in proj4 and 'WGS84' in proj4:
# This is only implemented for geographic coordinates
# Omit check for projected coordinate systems
check_geotransform(geotransform)
self.geotransform = geotransform
self.rows = data.shape[0]
self.columns = data.shape[1]
self.number_of_bands = 1
# We assume internal numpy layers are using nan correctly
# FIXME (Ole): If read from file is refactored to load the data
# this should be taken care of there
self.nodata_value = numpy.nan
def add_layer(self, layer=None, prev_layer=None, next_layer=None):
if len(self.layers) >= MAX_LAYERS_NUM:
return False
if (prev_layer is None) or (next_layer is None):
return False
if layer == None:
layer = Layer(next=next_layer)
else:
if (next_layer in layer.next_layer) or (prev_layer in layer.prev_layer):
print 'DA',
return False
self.layers.append(layer)
self.connect_layers(prev_layer, layer)
layer.modify(-1) # add random weight
return True
class TrainingResultsTest( unittest.TestCase ):
def setUp( self ):
self.tr = TrainingResults()
from opencl import OpenCL
from layer import InputLayer, Layer, OutputLayer, ExecutionContext
self.ocl = OpenCL( pyopencl.create_some_context() )
self.i = InputLayer( 2, self.ocl )
self.h = Layer( 3, self.ocl )
self.o = OutputLayer( 1, self.ocl )
self.i.link_next( self.h )
self.h.link_next( self.o, 0, 3 )
self.nnc = ExecutionContext( self.i, self.o, allow_training = True )
self.i.set_weights( numpy.array( [ 0.1 ] * self.i.weights_count, numpy.float32 ) )
self.h.set_weights( numpy.array( [ 0.2 ] * self.h.weights_count, numpy.float32 ) )
self.o.set_weights( numpy.array( [ 0.3 ] * self.o.weights_count, numpy.float32 ) )
def assertArrayEqual( self, ar1, ar2 ):
self.assertEqual( len( ar1 ), len( ar2 ) )
for x, y in zip( numpy.array( ar1, numpy.float32 ), numpy.array( ar2, numpy.float32 ) ):
self.assertAlmostEqual( x, y, places = 5 )
def test_store( self ):
self.tr.reset()
self.assertEqual( self.tr.iterations, numpy.int32( 0 ) )
self.assertGreater( self.tr.minimal_error, numpy.float32( 1e6 ) )
self.assertIsNone( self.tr.optimal_weights )
self.assertAlmostEqual( self.tr.total_time, 0.0 )
self.assertAlmostEqual( self.tr.opencl_time, 0.0 )
self.i.set_inputs( numpy.array( [1.0, 1.0], numpy.float32 ), is_blocking = True )
self.i.process()
initial_result = self.o.get_outputs()
self.tr.store_weights( self.nnc )
self.i.set_weights( numpy.array( [ 0.4 ] * self.i.weights_count, numpy.float32 ) )
self.i.process()
self.assertNotEqual( initial_result, self.o.get_outputs() )
self.tr.apply_weights( self.nnc )
self.i.process()
self.assertArrayEqual( initial_result , self.o.get_outputs() )
def run(self):
self.networkServerSocket = socket(AF_INET, SOCK_STREAM)
self.networkServerSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
self.networkServerSocket.bind (Layer.NetworkServer)
self.networkServerSocket.listen(1)
while True:
self.package, success = Layer.receive(self.networkServerSocket)
if success:
self.interpretPackage(self.package, 'blue')
sent = Layer.send(Layer.TransportServer, self.datagram['data'])
if sent:
self.answer, success = Layer.receive(self.networkServerSocket)
self.msg.emit ('Received answer')
networkPackage = self.createNetworkPackage(Layer.PhysicalClient,self.createDatagram(self.answer, 'red'))
sent = Layer.send(Layer.PhysicalServer, networkPackage)
self.msg.emit ('Answer sent to physical layer')
def run(self):
#TODO change ip
self.transportClientSocket = socket(AF_INET, SOCK_STREAM)
self.transportClientSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
self.transportClientSocket.bind(Layer.TransportClient)
#while True:
self.transportClientSocket.listen(1)
self.msg.emit ('Listening...')
try:
while True:
if self.receiveFromApplicationLayer():
if self.transportProtocol == 'TCP':
if not self.TCPConnected :
if self.threeWayHandshake():
self.msg.emit('TCP connection established successfully'\
' through TreeWayHandshake protocol')
else:
self.errorMsg.emit ('The ThreeWayHandshake protocol could not be completed.'\
'\nVerify you connection and try again.')
break;
else:
self.sendTCPPackage()
else: #transport protocol = UDP
if self.createSegment(self.transportProtocol, self.applicationPack):
sent = Layer.send(Layer.NetworkClient, self.segment)
if self.receiveAnswer():
#TODO recognize datagram
self.sendAnswerToApplicationLayer()
except KeyboardInterrupt:
self.transportClientSocket.close()
def __init__(self, input_num, output_num, lnum=3, delta=0):
super(NeuroNet, self).__init__()
self.input_layer = Layer(input_num)
self.output_layer = Layer(output_num)
self.layers = [Layer()]
self.connect_layers(self.input_layer, self.layers[0])
for i in xrange(lnum - 1):
self.layers.append(Layer())
self.connect_layers(self.layers[-2], self.layers[-1])
self.connect_layers(self.layers[-1], self.output_layer)
for i in self.layers:
i.modify(-1)
# for i in i.neurons:
# print i
self.set_input_delta(delta)
def rimap(n, N = 30, alpha = [0.01,0.3], sigma = [1.1,1.4], dt = 0.1,
pg = 0.01, pu = 0.05, su = 0.315, boundary = ""):
"""Creates an irregular maps
:param n: number of areas
:type n: integer
:param N: number of points sampled from each irregular polygon (MR-Polygon)
:type N: integer
:param alpha: min and max value to sampled alpha; default is (0.1,0.5)
:type alpha: List
:param sigma: min and max value to sampled sigma; default is (1.2,1.5)
:type sigma: List
:param dt: time delta to be used to create irregular polygons (MR-Polygons)
:type dt: Float
:param pg: parameter to define the scaling factor of each polygon before being introduced as part of the irregular map
:type pg: Float
:param pu: parameter to define the probability of increase the number of areas of each polygon before being introduced into the irregular map
:type pu: Float
:param su: parameter to define how much is increased the number of areas of each polygon before being introduced into the irregular map
:type su: Float
:param boundary: Initial irregular boundary to be used into the recursive irregular map algorithm
:type boundary: Layer
:rtype: Layer
:return: RI-Map instance
**Examples** ::
import clusterpy
lay = clusterpy.rimap(1000)
lay.exportArcData("rimap_1000")
"""
rm = rim(n, N, alpha, sigma, dt, pg, pu, su, boundary)
areas = rm.carteAreas
areas = fixIntersections(areas)
Wqueen,Wrook, = weightsFromAreas(areas)
layer = Layer()
layer.areas = areas
layer.Wqueen = Wqueen
layer.Wrook = Wrook
layer.shpType = 'polygon'
layer.name = "rimap_" + str(len(areas))
layer.fieldNames = ["Id","nw"]
layer.Y = {}
for i in Wrook:
layer.Y[i] = [i,len(Wrook[i])]
return layer
def threeWayHandshake(self):
if self.receive(self.SYN):
if self.send_SYN_ACK():
self.segment, success = Layer.receive(self.transportServerSocket)
self.segment = json.loads(self.segment)
if self.receive(self.ACK):
self.msg.emit('Three way handshake protocol established connection!')
#self.receive_Data()
return True
return False
def receiveAnswer(self):
self.answer, success = Layer.receive(self.transportClientSocket)
if success:
self.msg.emit('Received answer from Network layer.')
if self.transportProtocol == 'UDP':
self.interpretUDPSegment(self.answer)
else:
self.interpretTCPSegment(self.answer)
print 'received answer' + str(success)
#self.answer = json.loads(self.answer)
return success
class NormalIntermediateFeature(Filter):
def __init__(self, filter_size, input_size, scales, features, orientations, folder_name, mode):
self.filter_size = filter_size # size of patch
self.input_size = input_size
self.orientations = orientations # number of orientation
self.scales = scales
self.features = features
self.folder_name = folder_name
self.mode = mode
def compute_s2(self, input_layer, output_layer):
class_number = 1
data_number = 1
exi1 = path.isdir(self.folder_name + "/" + str(class_number) + "_" + str(data_number)
+ "_" + str(self.input_size))
print "\n", "normal_s2"
while exi1:
exi2 = path.isdir(self.folder_name + "/" + str(class_number) + "_" + str(data_number)
+ "_" + str(self.input_size))
while exi2:
self.prototype = Layer(self.filter_size, self.scales, self.orientations, "learning_s2",
self.features, self.filter_size, input_layer)
self.prototype.set_layer(self.folder_name, str(class_number) + "_" + str(data_number)
+ "_" + str(self.input_size))
print "feature set " + str(class_number) + "_" + str(data_number)
self.compute_layer(input_layer, output_layer)
data_number += 1
exi2 = path.isdir(self.folder_name + "/" + str(class_number) + "_" + str(data_number)
+ "_" + str(self.input_size))
data_number = 1
class_number += 1
exi1 = path.isdir(self.folder_name + "/" + str(class_number) + "_" + str(data_number)
+ "_" + str(self.input_size))
def compute_unit(self, input_layer, scale, feature, x, y, orientation):
patch = input_layer.get_array(scale)[0, x:x + self.filter_size, y:y + self.filter_size, orientation]
p_patch = self.prototype.get_array(scale)[feature, 0:self.filter_size, 0:self.filter_size, orientation]
alpha = (self.filter_size / 4) ** 2.0
res = np.exp(-np.linalg.norm(p_patch - patch) * 1.0 / (2 * alpha))
return res
def init_layer(self, num_iter, alpha, epsilon, minibatch):
"""Initializes the layer and adds an initial node to it."""
self.layer = Layer()
node = OptimalNode(self.X_train_node, self.Y_train_node, bias=True,
num_iter=num_iter, alpha=alpha, minibatch=minibatch)
node.early_stop(self.X_validate_node, self.Y_validate_node)
node.lr = epsilon
node.is_useful(self.layer, self.X_validate_node, self.Y_validate_node)
self.layer.add_node(node)
node.train_err = get_error(self.Y_train_node,
self.layer._predict(self.X_train_node))
def test_getchunk(self):
self.testobject = Layer()
random.seed()
chunk = self.testobject.getChunk(random.randint(-sys.maxint-1, sys.maxint - 1),random.randint(-sys.maxint -1, sys.maxint - 1))
self.assertEquals(type(chunk), Chunk)
validate_chunk_fields(chunk)
try:
self.testobject.getChunk(None, False)
except Exception as e:
pass
else:
self.fail("filter getChunk should fail on bad input ")
def train(self, X, y):
"""
Iteratively construct the multi-layer chain. Datapoints for which
a trusted prediction could not be found fall through to next layer.
"""
data = X.copy()
labels = y.copy()
count = 0
while count < 5:
try:
layer = Layer(data, labels)
except ValueError:
""" The number of classes has to be greater than one. """
break
else:
self.layers.append(layer)
results = [layer.predict(x) for x in data]
to_next_layer = [i for (i, r) in enumerate(results) if r is None]
data = np.array(data[to_next_layer])
labels = np.array(labels[to_next_layer])
count += 1
def setup(self):
self.surface = Layer(GameConfig.SCREEN_SIZE)
self.surface.fill(GameConfig.MENU_COLOR)
self.clock = pygame.time.Clock()
self.controls = EventControl({
pygame.QUIT: self.quit,
pygame.MOUSEMOTION: self.mouse_movement_event
})
self.font = pygame.font.Font(None, GameConfig.MENU_FONT_SIZE)
self.buttons = [
self.font.render("Start", True, GameConfig.MENU_TEXT_COLOR),
self.font.render("Options", True, GameConfig.MENU_TEXT_COLOR),
self.font.render("Exit", True, GameConfig.MENU_TEXT_COLOR)
]
def run(self):
self.networkRouterSocket = socket(AF_INET, SOCK_STREAM)
self.networkRouterSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
self.networkRouterSocket.bind (Layer.NetworkRouter)
self.networkRouterSocket.listen(1)
self.msg.emit('Starting router network layer.')
while True:
self.package, success = Layer.receive(self.networkRouterSocket)
if success:
self.interpretPackage(self.package, 'blue')
#maintain port
# return to physical layer
self.srcIP = json.loads(self.package)['srcIP']
dstIP = self.consultTable(self.srcIP, self.mask)
self.msg.emit ('Source IP = ' + str(self.srcIP))
transpPackage = json.loads(self.package)['data']
port = json.loads(transpPackage)['dstPort']
Layer.PhysicalServer = (dstIP, int(port))
print 'PhysicalServer = ' + str(Layer.PhysicalServer)
destiny = self.consultTable(self.srcIP, self.mask), Layer.PhysicalServer[1]
networkPackage = self.createNetworkPackage(destiny, self.package)
sent = Layer.send(Layer.PhysicalRouter, networkPackage)
self.msg.emit ('Answer sent to physical layer')
class LayerTestCase(unittest.TestCase):
"""
Layer: Implements a layer of minecraft blocks.
- Constructor should work with no arguments
- getChunk() should return a valid chunk.
- getChunk() should fail on bad inputs.
Depends on chunk unit tests.
"""
testobject = None # this gets set in setUp, and tested in the subsequent tests. This allows subclassing of the tested object!
def setUp(self):
self.testobject = self.construct(Layer)
def construct(self, thisclass):
"""
self.construct: the solution to re-testing the superclasses' constructor. Usually we test the class's constructor in setUp,
but this way we leave a nice hook to override setUp as needed, and to allow the subclass to call the constructor using
the superclass's test.
Don't call the superclass's construct() method if you're changing the rules for constructing.
"""
return thisclass()
def test_getchunk(self):
self.testobject = Layer()
random.seed()
chunk = self.testobject.getChunk(random.randint(-sys.maxint-1, sys.maxint - 1),random.randint(-sys.maxint -1, sys.maxint - 1))
self.assertEquals(type(chunk), Chunk)
validate_chunk_fields(chunk)
try:
self.testobject.getChunk(None, False)
except Exception as e:
pass
else:
self.fail("filter getChunk should fail on bad input ")
def send(layer: Layer, instruction: Instruction, transmitting: list):
if len(instruction.details) > 2:
print("\nWRONG SEND INSTRUCTION FORMAT.")
raise Exception
host = instruction.details[0]
details = instruction.details[1]
data = [int(details[i]) for i in range(len(details))]
for i in range(len(data)):
if data[i] != 0 and data[i] != 1:
print("\nUNRECOGNIZED DATA TYPE.")
raise Exception
device = layer.send(instruction.time, host, data)
if device is not None:
transmitting.append(device)
write(instruction.time, "send, host={}, data={}\n".format(host, details))
def load(zip_source):
boundary_fields = [{
'boundary_field1': 'boundary_field1'
}, {
'boundary_field2': 'boundary_field2'
}]
table_name = os.path.splitext(os.path.basename(zip_source))[0]
if pg_util.check_table_exists(table_name):
logging.info('{} data already in PostGIS'.format(zip_source))
else:
gadm28_shp = download_gadm28(zip_source)
pg_util.insert_into_postgis(gadm28_shp, boundary_fields)
conn, cursor = pg_util.conn_to_postgis()
pg_util.fix_geom(table_name, cursor, False)
conn.close()
print "For whatever reason, we're unable to truly update " \
"the input gadm geometry.\nPlease enter the postgres shell " \
"and run UPDATE <gadm table name> SET geom = ST_CollectionExtract(" \
"ST_MakeValid(geom), 3) WHERE ST_IsValid(geom) <> '1';"
sys.exit()
l = Layer(table_name, [])
l.tile_list = [
Tile(l.input_dataset, boundary_fields, None, None, l.input_dataset)
]
return l
def __init__(self,
input_dim=2,
hidden_layer=[3],
output_dim=2,
activation=["relu"],
momentum=None):
assert len(hidden_layer) == len(activation)
self.layers = [
Layer(input_dim,
hidden_layer[0],
activation=activation[0],
momentum=momentum)
]
for i in range(len(hidden_layer) - 1):
self.layers.append(
Layer(hidden_layer[i],
hidden_layer[i + 1],
activation[i + 1],
momentum=momentum))
self.layers.append(
Layer(hidden_layer[-1],
output_dim,
activation="softmax",
momentum=momentum))
def run(self):
self.networkClientSocket = socket(AF_INET, SOCK_STREAM)
self.networkClientSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
self.networkClientSocket.bind (Layer.NetworkClient)
self.networkClientSocket.listen(1)
try:
while True:
self.frame, success = Layer.receive(self.networkClientSocket)
if success:
self.msg.emit ('Received UDP package from Transport Layer')
networkPackage = self.createNetworkPackage(Layer.PhysicalServer, self.createDatagram(self.frame, 'blue'))
Layer.send(Layer.PhysicalClient, networkPackage)
self.msg.emit('Datagram sent to Physical layer.')
self.answer, success = Layer.receive(self.networkClientSocket)
if success:
self.msg.emit('Received answer')
self.interpretPackage(self.answer, 'red')
sent = Layer.send(Layer.TransportClient, json.loads(self.answer)['data'])
self.msg.emit ('Sent msg to transport client ' + str(sent))
except KeyboardInterrupt:
print 'Shutting down Internet Layer Client'
self.saveRouterTable()
#self.transportSocket.close()
self.networkClientSocket.close()
def __init__(
self,
layer_structure: List[int],
learning_rate: float,
activation_function: Callable[[float], float] = sigmoid,
derivative_activation_function: Callable[[float],
float] = derivative_sigmoid
) -> None:
if len(layer_structure) < 3:
raise ValueError(
"Error: Should be at least 3 layers (1 input, 1 hidden, 1 output)"
)
self.layers: List[Layer] = []
# input layer
input_layer: Layer = Layer(None, layer_structure[0], learning_rate,
activation_function,
derivative_activation_function)
self.layers.append(input_layer)
# hidden layers and output layer
for previous, num_neurons in enumerate(layer_structure[1::]):
next_layer = Layer(self.layers[previous], num_neurons,
learning_rate, activation_function,
derivative_activation_function)
self.layers.append(next_layer)
def perform_two_layers_nn(train_input, train_output, test_input, test_output):
print(
'Perform two layers neural network [784 x 300 x 10] with sigmoid at start and softmax at the end'
)
nn = NeuralNetwork()
nn.add_layer(
Layer(shape=(784, 300),
activation_function=ActivationFunction.SIGMOID))
nn.add_layer(
Layer(shape=(300, 10), activation_function=ActivationFunction.SOFTMAX))
start = time()
print('Start pre-training')
nn.learn(train_input[:100], train_output[:100], 0.01, 0.49, 100)
print('Start main training')
nn.learn(train_input, train_output, 0.1, 0.7, 100)
nn.learn(train_input, train_output, 0.01, 0.8, 100)
val = time() - start
print("Time:", val)
print("Mse: ", nn.mse(test_input, test_output))
print("Accuracy: ", nn.accuracy(test_input, test_output))
return val
def receive_SYN_ACK (self):
try:
self.answer, success = Layer.receive(self.transportClientSocket)
if success:
self.msg.emit('Checking SYN_ACK')
self.answer = json.loads(self.answer)
self.html.emit(PDUPrinter.TCP(self.answer, 'blue'))
if self.answer['flags'] == self.SYN_ACK:
return True
else:
self.msg.emit('Acknowledge sequence number doesn\'t check')
return False
except Exception as exc:
self.errorMsg.emit('DID NOT Receive SYN_ACK\n' + str(exc))
return False
def add_layer(self, size, actname='sigmoid', bias_neuron=True, dropout=0):
'''
Add a layer.
:param size: (*int*) Neuron number.
:param actname: (*string*) Activation function name ['sigmoid' | 'bipolar' | 'bipolarss' |
'clippedlinear' | 'competitive' | 'elliott' | 'elliotts' | 'gaussian' | 'log' |
'linear' | 'ramp' | 'relu' | 'sin' | 'softmax' | 'ssigmoid' | 'step' | 'tanh'].
:param bias_neuron: (*bool*) Using bias neuron or not. Default is True.
:param dropout: (*float*) Dropout ratio
:returns: The added layer.
'''
layer = Layer(size, actname, bias_neuron, dropout)
self._layers.append(layer)
def start_agent():
rospy.init_node('agent', anonymous=True)
# Create publisher to control
controlPub = rospy.Publisher(
'control/control', Control,
queue_size=1) # Queue size one due to hard real-time deadline
# Create Layers
lka_layer = Layer(10, 'lka', [('steering', Float64)])
acc_layer = Layer(5, 'acc', [('throttle', Float64), ('brake', Float64)])
object_layer = Layer(10, 'object_avoid', [('brake', Float64)])
# Create Tasks
highway_driving = Task(
controlPub,
[
object_layer, # highest priority
acc_layer,
lka_layer
])
highway_driving.run()
rospy.spin()
def __init__(self, layer_structure, taxa, ativacoes):
'''(list[int], float, Tuple[Callable]) -> None
Cria a Rede Perceptron, de acordo com a estrutura desejada
Sendo que no mínimo espera uma estrutura de 3 camadas,
sendo 1 camada de entrada, 1 oculta e 1 de saída.
A estrutura é uma lista de inteiros, contendo a
qtde de neurônios de cada camada.
O parametro ativacoes recebe uma tupla com 4 Callables,
que representam, em ordem, as funçoes de ativação e a sua derivada
para a(s) camada(s) oculta(s), e as funçoes de ativação e
a sua derivada para a camada de saída.
'''
l = len(layer_structure)
if l < 3:
raise ValueError("Erro: são necessárias ao menos 3 camadas!")
if ativacoes is None or len(ativacoes) != 4:
raise ValueError("Erro: deve definir as funções de ativação!")
self.layers = np.array([], dtype=np.float64)
self.estrutura = layer_structure
# camada de entrada =>
# não há camada anterior e nem função de ativação
input_layer = Layer(None, self.estrutura[0], taxa)
self.layers = np.append(self.layers, input_layer)
# camadas oculta(s)
for previous, qtd_neurons in np.ndenumerate(self.estrutura[1::l]):
next_layer = Layer(self.layers[previous[0]], qtd_neurons, taxa,
ativacoes[0], ativacoes[1])
self.layers = np.append(self.layers, next_layer)
# camada de saída
output_layer = Layer(self.layers[-1], self.estrutura[-1], taxa,
ativacoes[2], ativacoes[3])
self.layers = np.append(self.layers, output_layer)
def run(self):
try:
self.physicalServerSocket = socket(AF_INET, SOCK_STREAM)
self.physicalServerSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
self.physicalServerSocket.bind(Layer.PhysicalServer)
self.host, self.port = Layer.PhysicalServer
self.physicalServerSocket.listen(1)
self.msg.emit("Setup:\nIP = " + str(self.host) + '\tPort = ' + str(self.port) + '\nListening...')
except Exception as exc:
self.errorMsg.emit('ERROR! It was not possible start the execution: \n' + str(exc))
try:
while True:
if not self.mtuSent:
self.getMyIPMAC()
self.connectAsServer(self.physicalServerSocket)
if self.receiveFile(self.physicalServerSocket, 'binaryRequestServer.txt'):
self.package = self.interpretPackage('binaryRequestServer.txt', 'blue')
Layer.send(Layer.NetworkServer, self.package)
self.msg.emit('Waiting answer...')
self.answer, success = Layer.receive(self.physicalServerSocket)
self.msg.emit('Received package from Network layer.')
destiny = json.loads(self.answer)['destiny']
self.getDstMAC(destiny[0])
self.answer = json.loads(self.answer)['datagram']
if success:
self.createFrame_BinaryFile(self.answer, 'server_binary.txt', 'red')
#self.sendAnswer()
Layer.send(Layer.PhysicalClient, 'server_binary.txt', self.mtu)
except Exception as exc:
exc_type, exc_obj, exc_tb = sys.exc_info()
error = exc_tb.tb_frame
line = exc_tb.tb_lineno
fileName = error.f_code.co_filename
self.errorMsg.emit('ERROR! It was not possible run the server: \n' + str(exc)+
'\nLine = ' + str(line))
return False
class GameMenu(State):
def __init__(self, *args, **kwargs):
State.__init__(self, *args, **kwargs)
self.state_vars["MENU"] = self
self.surface = None
self.clock = None
self.controls = None
self.font = None
self.exit = False
self.buttons = None
self.setup()
def setup(self):
self.surface = Layer(GameConfig.SCREEN_SIZE)
self.surface.fill(GameConfig.MENU_COLOR)
self.clock = pygame.time.Clock()
self.controls = EventControl({
pygame.QUIT: self.quit,
pygame.MOUSEMOTION: self.mouse_movement_event
})
self.font = pygame.font.Font(None, GameConfig.MENU_FONT_SIZE)
self.buttons = [
self.font.render("Start", True, GameConfig.MENU_TEXT_COLOR),
self.font.render("Options", True, GameConfig.MENU_TEXT_COLOR),
self.font.render("Exit", True, GameConfig.MENU_TEXT_COLOR)
]
def run(self):
while not self.exit:
self.clock.tick(GameConfig.FRAMES_PER_SECOND)
self.controls.poll_event()
self.draw_menu()
Layer.update()
return None
def draw_menu(self):
offset = 0
for button in self.buttons:
self.surface.blit(button, ((self.surface.get_width() - button.get_width()) / 2,
(self.surface.get_height() - button.get_height()) / 2 + offset))
offset += button.get_height() + GameConfig.MENU_TEXT_OFFSET
def mouse_movement_event(self, event):
for button in self.buttons:
if button.get_rect(left=self.surface.get_width() - 100).collidepoint(event.pos):
print button
def quit(self, event):
self.exit = True
def __init__(self, path=None):
data = {
'name': '<name>',
'layers': [],
'tunnels': [],
'enemies': [],
'items': []
}
if path:
with open(path) as f:
loaded_data = json.load(f)
data = {**data, **loaded_data}
self.name = data['name']
self.layers = [Layer(l) for l in data['layers']]
self.tunnels = data['tunnels']
self.items = data['items']
def __init__(self, nodes_per_layer):
self.layers = []
for i in range(len(nodes_per_layer)):
if (i==0):
prev = 'start'
else:
prev = nodes_per_layer[i-1]
if (i==len(nodes_per_layer) - 1):
next = 'end'
else:
next = nodes_per_layer[i+1]
self.layers.append(Layer(nodes_per_layer[i],next_layer_number = next, previous_layer_number = prev))
def init_net(self, config):
"""config is an instance of class Config"""
import os
self.config = config
if config.is_output and (not os.path.exists(config.output_dir)):
os.makedirs(config.output_dir)
self.train_data = self.read_data(config.train_data_file)
if config.is_val:
self.val_data = self.read_data(config.val_data_file)
if config.is_test:
self.test_data = self.read_data(config.test_data_file)
[num_total_cases, input_dim] = self.train_data.X.shape
self.num_total_cases = num_total_cases
self.input_dim = input_dim
self.num_minibatches = num_total_cases / config.minibatch_size
if self.num_minibatches < 1:
self.num_minibatches = 1
# initialize the network
self.num_layers = config.num_layers
self.layer = []
in_dim = input_dim
for i in range(0, self.num_layers):
self.layer.append(
Layer(in_dim, config.layer[i].out_dim,
config.layer[i].act_type))
in_dim = config.layer[i].out_dim
self.output = OutputLayer(in_dim, config.output.out_dim,
config.output.output_type)
# To use multi-class hinge output, we need to specify the loss function
if isinstance(self.output.act_type, act.MulticlassHingeOutput):
if config.loss_file != None:
self.output.act_type.set_loss(self.read_loss(config.loss_file))
else:
self.output.act_type.set_loss(1 - np.eye(self.train_data.K))
# initialize the weights in every layer
self._init_weights(config.init_scale, config.random_seed)
def add_layer(self, size, activation='leaky_relu', activation_deriv=None):
"""Adds a single layer to the network at the end
Parameters provided are provided to Layer to create layer. See Layer class
for more information
Parameters
----------
size: The amount of neurons in the layer.
activation: The activation function used by this layer,
valid predefined strings are 'leaky_relu' and 'tanh'.
activation_deriv: The derivative of the activation function with respect to each logit.
"""
self.layers.append(
Layer(size, self.lastsize, activation, activation_deriv))
self.lastsize = size
def make_nvmnet(programs=None, registers=None):
# default program
if programs is None:
programs = {
"test":
"""
mov d2 true
loop: mov d1 here
jmp d1
here: mov d0 d2
exit
"""
}
# set up activator
activator, learning_rule = logistic_activator, hebbian
# activator, learning_rule = tanh_activator, hebbian
# make network
layer_shape = (16, 16)
layer_size = layer_shape[0] * layer_shape[1]
pad = 0.01
act = activator(pad, layer_size)
# default devices
# changing devices to registers
if registers is None:
registers = {
"d%d" % d: Layer("d%d" % d, layer_shape, act, Coder(act))
for d in range(3)
}
# assemble and link programs
# changing devices to registers
nvmnet = NVMNet(layer_shape, pad, activator, learning_rule, registers)
for name, program in programs.items():
nvmnet.assemble(program, name, verbose=1)
nvmnet.link(verbose=1)
# initialize pointer at last program
nvmnet.activity["ip"] = nvmnet.layers["ip"].coder.encode(name)
return nvmnet
def parse_layers(self, lines):
"""
Go through the g-code and find layer start points.
Store each layer to list.
:return:
"""
prev_layer = None
prev_height = 0
current_layer = FirstLayer(0, 0.2, 0.2)
layer_start = False
layer_num = 0
layer_z = 0
for line in lines:
cmd, comment = gcode.read_gcode_line(line)
if comment:
ret = self.check_layer_change(comment, None)
if ret:
layer_num, layer_z = ret
layer_start = True
if cmd and layer_start:
if gcode.is_z_move(cmd):
layer_start = False
if current_layer.num == 1 and layer_num == 0:
current_layer.z = layer_z
else:
if prev_layer:
prev_z = prev_layer.z
else:
prev_z = 0
height = current_layer.z - prev_z
if height:
prev_height = height
else:
height = prev_height
self.layers.append(current_layer)
prev_layer = current_layer
current_layer = Layer(layer_num, layer_z, height)
current_layer.add_line(cmd, comment)
# last layer
self.layers.append(current_layer)
def __init__(self, layers):
self.connections = Connections()
self.layers = []
layer_count = len(layers)
node_count = 0
for i in range(layer_count):
self.layer.append(Layer(i, layers[i]))
for layer in range(layer_count - 1):
connections = [
Connection(upstream_node, downstream_node)
for upstream_node in self.layers[layer].nodex
for downstream_node in self.layers[layer + 1].nodes[:-1]
]
for conn in connections:
self.connections.add_connection(conn)
conn.downstream_node.append_upstream_connection(conn)
conn.upstream_node.append_downstream_connection(conn)
def test_get_error():
lay = Layer(1, 1)
lay.output = np.zeros((1, 1))
target = np.ones((1, 1))
expected_error = 0.5
actual_error = lay.get_error(target)
assert expected_error == actual_error
target = target * 0
expected_error = 0
actual_error = lay.get_error(target)
assert expected_error == actual_error
lay = Layer(2, 2)
lay.output = np.zeros((2, 2))
target = np.array([
[1, 2], # batch 1
[3, 4] # batch 2
])
expected_error = 0.5 * (1 * 1 + 2 * 2 + 3 * 3 + 4 * 4)
actual_error = lay.get_error(target)
assert expected_error == actual_error
def __init__(self,
model,
struct,
activation="sigmoid",
cost="quadratic",
load_weights=False,
weight_range=[-1, 1],
bias_range=[0.5, 0.95]):
self.model = model
self.struct = struct
self.activation = activation
self.cost = cost
# size is the number of weight matrices
self.size = len(self.struct) - 1
# init of layers
self.layers = []
for l in range(self.size):
if l == self.size - 1:
self.layers.append(
OutputLayer(model=self.model,
ID=l,
activation=self.activation,
load_weights=load_weights,
in_size=self.struct[l],
out_size=self.struct[l + 1],
weight_range=weight_range,
bias_range=bias_range,
cost=self.cost))
else:
self.layers.append(
Layer(model=self.model,
ID=l,
activation=self.activation,
load_weights=load_weights,
in_size=self.struct[l],
out_size=self.struct[l + 1],
weight_range=weight_range,
bias_range=bias_range))
def __init__(self, opt):
super(SynthesisNetwork, self).__init__()
self.opt = opt
self.resolution = opt.resolution
self.feature_maps = self.cliped_features(1)
self.lmul = 1
self.layers = []
self.in_channel = self.cliped_features(1)
self.out_rgb_channel = 3
self.dlatent_size = 512
self.resolution_log2 = int(np.log2(self.resolution))
self.num_layers = self.resolution_log2 * 2 - 2
# コンテンツデータの作成
c = self.Tensor(np.random.normal(loc=0, scale=1, size=(1, 512, 4, 4)))
# c = c.repeat([self.opt.batch_size, 1, 1, 1])
# c.requires_grad = False
self.const = nn.Parameter(c)
self.layer = Layer(x_channel=self.in_channel,
style_layer_index=0,
style_in_dim=self.dlatent_size,
style_out_dim=self.dlatent_size,
feature_map=self.feature_maps,
res=1)
self.to_rgb = ToRGB(x_channel=self.in_channel,
out_channel=self.out_rgb_channel,
kernel=1,
style_dim=self.dlatent_size,
res=2)
self.block_dict = nn.ModuleDict()
self.to_rgb_dict = nn.ModuleDict()
self.upsample_2d_dict = nn.ModuleDict()
for res in range(3, self.resolution_log2 + 1):
self.block_dict[str(res)] = Block(res, style_dim=self.dlatent_size)
self.upsample_2d_dict[str(res)] = UpSample2d(
res, resample_kernel=[1, 3, 3, 1])
self.to_rgb_dict[str(res)] = ToRGB(self.cliped_features(res - 1),
self.out_rgb_channel,
kernel=1,
style_dim=self.dlatent_size,
res=res)
def _load(self, model):
'''Initialize the guide from given model
Args:
model (str): Pass a model to initialize existing guide.
'''
self._model = cmds.ls(model, long=True)[0]
if not cmds.ls(model + "." + DATA_ATTRIBUTE):
raise RuntimeError("Invalide Guide. Missing Data Attribute.")
# Load Settings
data = json.loads(cmds.getAttr(model + "." + DATA_ATTRIBUTE))
self._settings.update(data["settings"])
# Load Layers
for data in data["layers"]:
layer = Layer(self, data["name"], data)
self._layers.append(layer)
def __init__(self, layers_dim):
self.layers = []
self.layerdim = layers_dim
self.SM = Softmax()
self.MB = MiniBatch()
for i in range(len(layers_dim) - 1):
#For TanH activation ensure weights are positive
#wx = np.random.randint(0, 100, size=(layers_dim[i], layers_dim[i+1])) / 10000
#bx = np.atleast_2d(np.array([np.random.randint(0, 100) / 1000 for i in range(layers_dim[i+1])]))
#For leaky relu we want both positive and negative weights
wx = np.random.randn(layers_dim[i], layers_dim[i + 1]) / np.sqrt(
layers_dim[i])
bx = np.atleast_2d(
np.random.randn(layers_dim[i + 1]).reshape(
1, layers_dim[i + 1]))
self.layers.append(Layer(wx, bx))
class Dots(Layer):
___ = Layer.Register('dots', lambda d: Dots(d))
def __init__(self, d, verbose=False):
Layer.__init__(self, d, verbose)
self.color = Layer.arg(d)
self.r1 = self.attr('radius', 2)
self.r2 = self.attr('distance', 5) + self.r1
self.grad = self.attr('grad', True)
self.opacity = int(255 * min(self.attr('opacity', 100.0), 100.0) /
100.0)
assert self.attr('box')
self.attr('units')
def apply(self, ctxt, image):
dots(image, self.box, self.r1, self.r2, self.color, self.grad,
self.opacity)
return image
def __init__(self, **kwargs):
self.shape = kwargs.get("shape", [(3,), (3,), (3,), (3,)])
self.activations = kwargs.get('activations', ['relu', 'sigmoid', 'softmax'])
self.layers = [Input_layer()]
self.output_labels = kwargs.get('output_labels', ["1", "2", "3"])
weights = kwargs.get('weights', None)
for i, shape in enumerate(self.shape[1:]):
self.layers.append(
Layer(
shape=shape,
prev_shape=self.shape[i],
activation=self.activations[i],
weights=weights[i] if weights else None
)
)
self.layers = np.array(self.layers)
self.error = 1
self.learning_rate = kwargs.get('learning_rate',0.001)
def loadModel(self, model):
file = []
with open(model, "r") as f:
for line in f:
if line == "\n":
file.append("break")
else:
file.append(float(line[:-1]))
file[0] = str(int(file[0]))
sizes = []
for layer in list(file[0]):
sizes.append(int(layer))
weights = []
weightSet = []
prev = 0
index = 0
for value in file[1:]:
if value == "break":
if prev == "break":
break
weights.append(weightSet)
weightSet = []
else:
weightSet.append(value)
prev = value
index += 1
biases = []
for value in file[index + 2:]:
biases.append(value)
self.sizes = sizes
self.layers = []
for i in range(len(sizes) - 1):
self.layers.append(Layer(sizes, i + 1))
index = 0
for layer in self.layers:
for neuron in layer.neurons:
neuron.weights = weights[index]
neuron.bias = biases[index]
index += 1
def predict(self, data):
nn = NeuralNetwork()
l1 = Layer(56, 54)
l2 = Layer(54, 25)
nn.add(l1)
nn.add(ActivationLayer(relu, relu_derivative))
nn.add(l2)
nn.add(ActivationLayer(sigmoid, sigmoid_derivative))
l1.weights = np.load('weights1.npy')
l2.weights = np.load('weights2.npy')
l1.bias = np.load('bias1.npy')
l2.bias = np.load('bias2.npy')
out = nn.predict(data)
pred = np.argmax(out)
return pred
def __init__(self, dims, FLAGS, env, policy, agent_params, rollout_params, eval_params, monitor=True):
# print("@ Agent, FLAGS={}, dims={}, env={}, policy={}, agent_params={}, rollout_params={}, eval_params={}".format(FLAGS, dims, env, policy, agent_params, rollout_params, eval_params))
self.FLAGS = FLAGS
self.sess = tf.Session()
# Set subgoal testing ratio each layer will use
self.subgoal_test_perc = agent_params["subgoal_test_perc"]
# Create agent with number of levels specified by user
self.layers = [Layer(i, dims, FLAGS, env, self.sess, policy, agent_params, rollout_params, eval_params, monitor=True) for i in range(FLAGS.layers)]
# Below attributes will be used help save network parameters
self.saver = None
self.model_dir = None
self.model_loc = None
# Initialize actor/critic networks. Load saved parameters if not retraining
# self.initialize_networks()
# goal_array will store goal for each layer of agent.
self.goal_array = [None for i in range(FLAGS.layers)]
self.current_state = None
# Track number of low-level actions executed
self.steps_taken = 0
# Below hyperparameter specifies number of Q-value updates made after each episode
self.num_updates = 40
# Below parameters will be used to store performance results
self.performance_log = []
self.other_params = agent_params
##
self.goal_space_train = [[-np.pi,np.pi],[-np.pi/4,0],[-np.pi/4,np.pi/4]]
self.goal_space_test = [[-np.pi,np.pi],[-np.pi/4,0],[-np.pi/4,np.pi/4]]
self.subgoal_bounds = np.array([[-2*np.pi,2*np.pi],[-2*np.pi,2*np.pi],[-2*np.pi,2*np.pi],[-4,4],[-4,4],[-4,4]])
self.end_goal_dim = len(self.goal_space_test)
self.subgoal_dim = len(self.subgoal_bounds)
def insert_layer(self, index, image, colormap=None, opacity=1.0):
""" Insert a new layer at specified position. The colormap defaults to
a gray colormap. If the colormap's display range is None, it
defaults to the image range.
"""
if colormap is None:
colormap = Colormap(colormaps["gray"], None, False, False, False)
if colormap.display_range is None:
colormap.display_range = (image.data.min(), image.data.max())
# Find out which layer class we will use
LayerClass = Layer.get_derived_class(image)
if LayerClass is None:
raise medipy.base.Exception("Cannot create layer")
# Create the layer and insert it
if self._layers and index == 0:
self._layers[0].remove_observer("colormap",
self._on_layer_colormap)
layer = LayerClass(self.world_to_slice, image,
self.display_coordinates, colormap, opacity)
self._layers.insert(index, layer)
# Update the physical extent
self._compute_extent()
# The scalar bar will always reflect layer 0
if index == 0:
self._on_layer_colormap(None)
self._layers[0].add_observer("colormap", self._on_layer_colormap)
# Adjust layer w.r.t. the current state.
self._update_layers_positions()
if self._cursor_physical_position is not None:
layer.physical_position = self._cursor_physical_position
# if isinstance(layer, ImageLayer) :
# layer.actor.SetInterpolate(self._interpolation)
# And finally add it to the renderer
self._renderer.AddActor(layer.actor)
def __init__(self,
ratio=1.73,
layers=[
Layer(0.0, 3.77),
Layer(1.0, 4.64),
Layer(3.0, 5.34),
Layer(6.0, 5.75),
Layer(14.0, 6.22),
Layer(25.0, 7.98)
]):
"""Initialization method for the velocity model class.
"""
self.ratio = ratio
self.layers = layers
def __init__(self,layers):
if layers==None:
raise TypeError('layers is none')
length=len(layers)
tmp_layers=[]
for i in xrange(length):
n_in=layers[i]
n_out=layers[i+1]
fanin=n_in*n_out
sd=1.0/sqrt(fanin)
w=sd*random.random_sample((n_in,n_out))
b=zeros((1,n_out))
this_layer=Layer(w,b)
tmp_layers.append(this_layer)
self.layers=tmp_layers
self.active=sigmoid()
self.Lambda=exp(-4)
self.n_out=layers[len(layers)-1]
self.eta=0.01
return
class Filter(Layer):
Names = {
'BLUR': ImageFilter.BLUR,
'CONTOUR': ImageFilter.CONTOUR,
'DETAIL': ImageFilter.DETAIL,
'EDGE_ENHANCE': ImageFilter.EDGE_ENHANCE,
'EDGE_ENHANCE_MORE': ImageFilter.EDGE_ENHANCE_MORE,
'FIND_EDGES': ImageFilter.FIND_EDGES,
'SHARPEN': ImageFilter.SHARPEN,
'SMOOTH': ImageFilter.SMOOTH,
'SMOOTH_MORE': ImageFilter.SMOOTH_MORE
}
___ = Layer.Register('filter', lambda d: Filter(d))
def __init__(self, d, verbose=False):
Layer.__init__(self, d, verbose)
self.filter = Layer.arg(d)
def apply(self, ctxt, image):
return image.filter(Filter.Names[self.filter])
def __init__(self, data):
self.resolution = data['resolution']
self.frames = data['frames']
self.width = data['output']['width']
self.extname = data['output']['extname']
self.format = data['output']['format']
self.stills = None
if 'stills' in data:
self.stills = {}
for name, still in data['stills'].items():
self.stills[name] = Still(still, resolution=self.resolution)
self.anims = None
if 'anims' in data:
self.anims = {}
for name, anim in data['anims'].items():
self.anims[name] = Still(anim, resolution=self.resolution)
for lyr in data['layers']:
self.layers = [Layer(lyr, self) for lyr in data['layers']]
def send_SYN_ACK(self):
self.msg.emit('Sending SYN_ACK')
tcpSegment = {'transportProtocol': 'TCP',
'srcPort': self.srcPort,
'dstPort' : self.dstPort,
'seq' : 0,
'ackSeq' : 1,
'offsetRes': 'offset',
'window': 'window',
'checksum': 'checksum',
'urgPtr': 'urgPtr',
'flags' : self.SYN_ACK,
'opcoes': 'opcoes',
'data' : 'NULL'}
self.answer = json.dumps(tcpSegment)
sent = Layer.send(Layer.NetworkServer, self.answer)
if sent:
self.msg.emit('Sent SYN_ACK to network layer.')
return True
return False
