matrix1 = graph1.create_matrix(amount_nodes)
edges1 = graph1.generate_edges(amount_nodes, percent_edges)
matrix1 = graph1.add_edges(matrix1, edges1)
list_edges = graph1.make_list_edges_distances(matrix1)
netxgraph1 = graph1.build_networkx_graph(list_edges)
# +
# matrix1
# -
# This initializes regular SOM grid matrix, it needs to be passes instead of matrix1 for it to work
# Also one needs to experiment with sigma to achieve good results learning rate
matrix2 = graph1.standard_som_distance_matrix(length, width)
matrix2
map1 = MapClass(data, length, width, learning_rate, number_epochs, matrix2,
sigma, data_lables, batch_size, shuffle, netxgraph1)
# +
# ### Drawing configuration
# drawtype="rbg" tries to draw colors on map - needs an input data with 3 vectors
# drawtype="black-white" draws black-white
# drawtype="networkx" graph drawing using the networkx library
# drawtype="None" - default draws empty space
# Also there is networkx graph drawing
# labels=True or False draws labels on the map... labels are necessary...
# draw_every_epoch=0 Don't draw anything
data_lables = color_names
batch_size = 2
length = 10
width = 10
number_iterations = 100
shuffle = True
learning_rate = 0.01
# + {}
# trainloader = ""
# def load_data(data, batch_size=4):
# dim = len(data[0])
# number_rows_data = len(data)
# trainloader = torch.utils.data.DataLoader(data, batch_size=batch_size, shuffle=True)
# return trainloader, dim, number_rows_data
# -
map1 = MapClass(data, length, width, learning_rate, number_iterations, matrix1,
data_lables, batch_size, shuffle)
# +
# training, dim, number_rows_data = load_data(data, batch_size)
# -
plt.rcParams['figure.dpi'] = 150
map1.large_cycle(draw_every_epoch=10, rgb=True)
if dim == 1:
return map_.view(length, width)
else:
return map_.view(dim, length, width)
def large_cycle(map_, training_data):
basic_visualization(map_display(map_.map))
print(map_display(map_.map))
for i in range(number_iterations):
cycle(map_, training_data)
basic_visualization(map_display(map_.map))
print(map_display(map_.map))
training = load_data(data)
map1 = MapClass(length, width, dim, move_closer_coef)
map1.map
map1.cycle(training)
map1.map
map1.distance_matrix
map1.impact_matrix
basic_visualization(map1.map)
def mk_map(res, map_grid_vars, map_prop_vars):
mapSize = (map_grid_vars['height'], map_grid_vars['width']) # (height, width) --> (rows, cols)
myMap = MapClass(res,mapSize)
"""
Begin initializing board, everything is first initialized to:
empty, not path, black, driving surface, and ground level.
"""
for y in xrange(0,map_grid_vars['height']):
for x in xrange(0,map_grid_vars['width']):
myMap.grid[y][x]['level'] = map_prop_vars['ground']
myMap.grid[y][x]['desc'] = map_prop_vars['driv_srfc']
myMap.grid[y][x]['color'] = map_prop_vars['black']
myMap.grid[y][x]['path'] = map_prop_vars['not_path']
myMap.grid[y][x]['status'] = map_prop_vars['empty']
#define upper platform
for y in xrange(0,map_grid_vars['upPltH']):
for x in xrange(0,map_grid_vars['upPltW']):
myMap.grid[y][x]['level'] = map_prop_vars['upp_plat']
#define upper ramp
for y in xrange(0, map_grid_vars['upRmpH']):
for x in xrange(map_grid_vars['upPltW'], map_grid_vars['width'] - map_grid_vars['loPltW']):
myMap.grid[y][x]['level'] = map_prop_vars['ramp']
#define lower platform
for y in xrange(0, map_grid_vars['loPltH']):
for x in xrange(map_grid_vars['width'] - map_grid_vars['loPltW'], map_grid_vars['width']):
myMap.grid[y][x]['level'] = map_prop_vars['lwr_plat']
#define lower ramp
for y in xrange(map_grid_vars['loPltH'], map_grid_vars['loPltH'] + map_grid_vars['loRmpH']):
for x in xrange(map_grid_vars['width'] - map_grid_vars['loRmpW'], map_grid_vars['width']):
myMap.grid[y][x]['level'] = map_prop_vars['ramp']
#define edge between upper platform and ground and long ramp and ground
y = map_grid_vars['upPltH'] - 1;
for x in xrange(0, map_grid_vars['upPltW'] + map_grid_vars['upRmpW'] + 1):
#Map[x][y].level = 9
myMap.grid[y][x]['desc'] = map_prop_vars['edge']
#define edge between short ramp and ground
x = map_grid_vars['upPltW'] + map_grid_vars['upRmpW']
for y in xrange(map_grid_vars['loPltH'], (map_grid_vars['loPltH'] + map_grid_vars['loRmpH'])):
#Map[x][y].level = 9
myMap.grid[y][x]['desc'] = map_prop_vars['edge']
"""walls"""
#define long wall along width of course (south side)
for y in xrange(map_grid_vars['height'] - map_grid_vars['wall'], map_grid_vars['height']):
for x in xrange(0, map_grid_vars['width']):
myMap.grid[y][x]['desc'] = map_prop_vars['wall']
#define short wall along width of course (north side)
for y in xrange(map_grid_vars['upPltH'], map_grid_vars['upPltH'] + map_grid_vars['wall']):
for x in xrange(0, map_grid_vars['upPltW'] + map_grid_vars['upRmpW']):
myMap.grid[y][x]['desc'] = map_prop_vars['wall']
#define long wall along height of course (west side)
for y in xrange(map_grid_vars['upPltH'], map_grid_vars['height']):
for x in xrange(0, map_grid_vars['wall']):
myMap.grid[y][x]['desc'] = map_prop_vars['wall']
#short wall along height of course (east side)
for y in xrange(map_grid_vars['loPltH'] + map_grid_vars['loRmpH'] - map_grid_vars['RampWall'], map_grid_vars['height']):
for x in xrange(map_grid_vars['width'] - map_grid_vars['wall'], map_grid_vars['width']):
myMap.grid[y][x]['desc'] = map_prop_vars['wall']
"""start area"""
#start area - white outHine - includes start area, next loop fixes enclosed area
for y in xrange(map_grid_vars['height'] - map_grid_vars['wall'] - map_grid_vars['startH'] - map_grid_vars['whiteLine'], map_grid_vars['height'] - map_grid_vars['wall']):
for x in xrange(map_grid_vars['wall'], map_grid_vars['wall'] + map_grid_vars['startW'] + map_grid_vars['whiteLine']):
myMap.grid[y][x]['desc'] = map_prop_vars['line']
myMap.grid[y][x]['color'] = map_prop_vars['white']
#start area - fix enclosed area
for y in xrange(map_grid_vars['height'] - map_grid_vars['wall'] - map_grid_vars['startH'], map_grid_vars['height'] - map_grid_vars['wall']):
for x in xrange(map_grid_vars['wall'], map_grid_vars['wall'] + map_grid_vars['startW']):
myMap.grid[y][x]['desc'] = map_prop_vars['start']
myMap.grid[y][x]['color'] = map_prop_vars['black']
"""air loading zone"""
#air loading zone - white outline - includes enclosed space, next 2 loops fix
for y in xrange(map_grid_vars['upPlt_2_Air'], map_grid_vars['upPltH']-map_grid_vars['upPlt_2_Air']):
for x in xrange(0, map_grid_vars['air_long']+map_grid_vars['whiteLine']):
myMap.grid[y][x]['desc'] = map_prop_vars['line']
myMap.grid[y][x]['color'] = map_prop_vars['white']
#air loading zone - fix enclosure - use two loops to account for seperating white line
for y in xrange(map_grid_vars['upPlt_2_Air']+map_grid_vars['whiteLine'], map_grid_vars['upPlt_2_Air']+map_grid_vars['whiteLine']+map_grid_vars['zone_short']):
for x in xrange(0,map_grid_vars['air_long']):
myMap.grid[y][x]['desc'] = map_prop_vars['air']
myMap.grid[y][x]['color'] = map_prop_vars['unk'] #color unknown
for y in xrange(map_grid_vars['upPlt_2_Air']+map_grid_vars['whiteLine']+map_grid_vars['zone_short']+map_grid_vars['whiteLine'], map_grid_vars['upPltH']-map_grid_vars['upPlt_2_Air']-map_grid_vars['whiteLine']):
for x in xrange(0,map_grid_vars['air_long']):
myMap.grid[y][x]['desc'] = map_prop_vars['air']
myMap.grid[y][x]['color'] = map_prop_vars['unk'] #color unknown
"""cargo area"""
#cargo storage - white outline - includes enclosed area, next loop fixes
for y in xrange(map_grid_vars['upPltH']+map_grid_vars['wall'], map_grid_vars['upPltH']+map_grid_vars['wall']+map_grid_vars['stor_long']+map_grid_vars['whiteLine']):
for x in xrange(map_grid_vars['wall']+map_grid_vars['edge2storage'], map_grid_vars['wall']+map_grid_vars['edge2storage']+map_grid_vars['cargoL']):
myMap.grid[y][x]['desc'] = map_prop_vars['line']
myMap.grid[y][x]['color'] = map_prop_vars['white']
#fix enclosed storage area and make separating white lines
k = 0 #variable to count the nth seperating line being implemented
m = map_grid_vars['wall'] + map_grid_vars['edge2storage']+map_grid_vars['whiteLine'] #number of tiles until the first seperating white line
#print("width=", width, "height=", height) #debug
while k<=13: #there are thirteen seperating lines (14 storage slots)
p = m + (map_grid_vars['zone_short'] + map_grid_vars['whiteLine'])*k
#m = m + map_grid_vars['air_long']*k
for y in xrange(map_grid_vars['upPltH']+map_grid_vars['wall'], map_grid_vars['upPltH']+map_grid_vars['wall']+map_grid_vars['stor_long']):
for x in xrange(p,p+map_grid_vars['zone_short']):
#print("k=", k,"m=", m, "x=", x, "y=", y) #debug
myMap.grid[y][x]['desc'] = map_prop_vars['storage']
myMap.grid[y][x]['color'] = map_prop_vars['unk'] #color unknown
k = k + 1
"""sea loading zone"""
#white outline of sea loading zone
for y in xrange(map_grid_vars['upPltH']+map_grid_vars['wall']+map_grid_vars['EdgetoSea'], map_grid_vars['upPltH']+map_grid_vars['wall']+map_grid_vars['EdgetoSea']+map_grid_vars['seaH']):
for x in xrange(map_grid_vars['wall'], map_grid_vars['wall']+map_grid_vars['sea_long']+map_grid_vars['whiteLine']):
myMap.grid[y][x]['desc'] = map_prop_vars['line']
myMap.grid[y][x]['color'] = map_prop_vars['white']
#fix enclosed sea area and make seperating white lines
k = 0 #variable to count the ntinth seperating line being implemented
m = map_grid_vars['upPltH'] + map_grid_vars['wall']+map_grid_vars['EdgetoSea']+map_grid_vars['whiteLine']
while k<=5:
p = m + map_grid_vars['air_long']*k
#m = m + map_grid_vars['air_long']*k
for y in xrange(p, p + map_grid_vars['zone_short']):
for x in xrange(map_grid_vars['wall'], map_grid_vars['wall'] + map_grid_vars['sea_long']):
myMap.grid[y][x]['desc'] = map_prop_vars['sea']
myMap.grid[y][x]['color'] = map_prop_vars['unk'] #color unknown
k = k + 1
"""land loading zone"""
#white outline of land zone
for y in xrange(map_grid_vars['height']-map_grid_vars['wall']-map_grid_vars['land_long']-map_grid_vars['whiteLine'], map_grid_vars['height'] - map_grid_vars['wall']):
for x in xrange(map_grid_vars['wall']+map_grid_vars['startW']+map_grid_vars['whiteLine']+map_grid_vars['start2land'],map_grid_vars['wall']+map_grid_vars['startW']+map_grid_vars['whiteLine']+map_grid_vars['start2land']+map_grid_vars['landW']):
myMap.grid[y][x]['desc'] = map_prop_vars['line'] #marker
myMap.grid[y][x]['color'] = map_prop_vars['white'] #white
#fix enclosed land storage
k = 0
m = map_grid_vars['wall'] + map_grid_vars['startW']+map_grid_vars['whiteLine']+map_grid_vars['start2land']+map_grid_vars['whiteLine']
while k<=5:
p = m + (map_grid_vars['zone_short']+map_grid_vars['whiteLine'])*k
#m = m+map_grid_vars['air_long']*k
for y in xrange(map_grid_vars['height']-map_grid_vars['wall']-map_grid_vars['land_long'],map_grid_vars['height']-map_grid_vars['wall']):
for x in xrange(p,p+map_grid_vars['zone_short']):
myMap.grid[y][x]['desc'] = map_prop_vars['land'] #land
myMap.grid[y][x]['color'] = map_prop_vars['unk'] #color unknown
k = k+1
return(myMap)
classification = map_.classify_all(map_.convert_data_tensor(data))
for i in range(len(classification)):
loc_tuple = map_.get_location(classification[i])
plt.text(loc_tuple[1], loc_tuple[0], color_names[i], ha='center', va='center',
bbox=dict(facecolor='white', alpha=0.5, lw=0))
# plt.text(0, 1, color_names[1], ha='center', va='center',
# bbox=dict(facecolor='white', alpha=0.5, lw=0))
plt.show()
training, dim, number_rows_data = load_data(data)
map1 = MapClass(length, width, dim, move_closer_coef, number_iterations)
large_cycle_rgb(map1, training)
map1.weights
map1.cycle(training)
map1.distance_matrix
map1.impact_matrix
visualize_rgb(map1.weights)
def large_cycle(map_, training_data):
basic_visualization(map_display(map_.map))
print(map_display(map_.map))
for i in range(number_iterations):
cycle(map_, training_data)
basic_visualization(map_display(map_.map))
print(map_display(map_.map))
training = load_data(data)
map1 = MapClass(length, width, dim, move_closer_coef)
cycle(map1, training)
large_cycle(map1, training)
map2 = MapClass(length, width, dim, move_closer_coef)
map2.map
locs = map2.initialize_locations(map2.map)
# print(map_view(map_.map))
if display_step == True:
basic_visualization(map_display(map_.map))
print(map_display(map_.map))
def large_cycle(map_, training_data):
basic_visualization(map_display(map_.map))
print(map_display(map_.map))
for i in range(number_iterations):
cycle(map_, training_data)
basic_visualization(map_display(map_.map))
print(map_display(map_.map))
training = load_data(data)
map1 = MapClass(length, width, dim, move_closer_coef)
map1.map
map2.map.view(dim, length, width)
map1 = MapClass(length, width, dim, move_closer_coef)
map1.map
basic_visualization(numpy_array)
shuffle=True)
return trainloader, dim, number_rows_data
# -
def large_cycle(map_, training_data):
basic_visualization(map_display(map_.map))
print(map_display(map_.map))
for i in range(number_iterations):
cycle(map_, training_data)
basic_visualization(map_display(map_.map))
print(map_display(map_.map))
training, dim, number_rows_data = load_data(data)
map1 = MapClass(length, width, dim, move_closer_coef, number_iterations)
map1.weights_to_map()
map1.step(training, verbose=True)
map1.cycle(training, verbose=True)
map1.classify_all(map1.convert_data_tensor(data))
map1.convert_data_tensor(data)
learning_rate = 0.01
# + {}
# trainloader = ""
# def load_data(data, batch_size=4):
# dim = len(data[0])
# number_rows_data = len(data)
# trainloader = torch.utils.data.DataLoader(data, batch_size=batch_size, shuffle=True)
# return trainloader, dim, number_rows_data
# -
map1 = MapClass(data,
length,
width,
learning_rate,
number_iterations,
matrix1,
batch_size=batch_size,
shuffle=shuffle)
# training, dim, number_rows_data = load_data(data, batch_size)
map1.basic_visualization()
plt.rcParams['figure.dpi'] = 150
map1.large_cycle(draw_every_epoch=10, rgb=False)
map1.basic_visualization()
import numpy as np from constants import area_definition #Area as matrix and matrix blocks from constants import constant_speed from constants import length_of_runway,max_value, intersection_x, intersection_y, intersection_w, intersection_h from constants import car_width, car_length import matplotlib.pyplot as plt from helper_functions import print_image_bw from car_class import CarClass from map_class import MapClass from constants import playback_speed from constants import start_1, start_2, start_3, start_4, start_5, start_6, start_7, start_8 PATH = "C:/Users/JustinSanJuan/Desktop/Workspace/python/Centralized Traffic/" #path to files folder #Define Areas #area_definition A = MapClass(area_definition) #print_image_bw(A,5,5) #%% #Define Actions #action_dictonary = define_actions(A) #Define Areas to Clear #Randomly generated source & target points car_1 = CarClass(*start_1, [0,0],[0,3],A.intersection_collision_map,[0,9*playback_speed]) #car_2 = CarClass(*start_2) car_3 = CarClass(*start_3,[3,0],[0,0],A.intersection_collision_map,[-10*playback_speed,0]) car_4 = CarClass(*start_4,[3,1],[0,1],A.intersection_collision_map,[-10*playback_speed,0]) #car_5 = CarClass(*start_5)
return trainloader, dim, number_rows_data
# -
def large_cycle(map_, training_data):
basic_visualization(map_display(map_.map))
print(map_display(map_.map))
for i in range(number_iterations):
cycle(map_, training_data)
basic_visualization(map_display(map_.map))
print(map_display(map_.map))
training, dim, number_rows_data = load_data(data)
map1 = MapClass(length, width, dim, move_closer_coef)
map1.weights
map1.step(training, verbose=True)
map1.weights
map1.distance_matrix
map1.impact_matrix
map1.basic_visualization()
