def __init__(self, iterate, **kwargs):
self.iterate = iterate
self.startState = file.read()
self.neighbor = Neighbor(self.startState)
self.update_states = None
if "update_states" in kwargs:
self.update_states = True
def nearest_text(self, *args):
"""
arg[0] = type (user, photo, poi)
arg[1] = id
arg[2] = model (tf, df, tf-idf)
arg[3] = k
"""
if not self.database:
print("[ERROR] The database must be loaded for this action.")
return
if not len(args) is 4:
print("Nearest Text expected 4 arguments but got " + str(len(args)) + ".")
print("\targs = " + str(args))
return
# Get the first argument
try:
k = int(args[3])
except:
print("[ERROR] K Value provided is invalid.")
print("\tk = " + str(args[0]))
return
# Get the type of item we are considering.
itype = args[0]
if not itype in self.valid_types:
print("[ERROR] Item Type value provided was invalid.")
print("\tItem Type = " + str(args[1]))
return
# Get the model to use. We do this before the item as it is easier
# to differentiate valid from invalid
model = args[2]
model = model.lower()
if not model in self.valid_txt_models:
print("[ERROR] Model Type value provided was invalid.")
print("\tModel Type = " + str(args[2]))
return
try:
# get vector representing item associated w/ id
an_id = args[1]
this_vector = Vectorizer.text_vector(an_id, self.database, model, itype)
except:
print("[ERROR] The ID specified was not found in the dataset.")
print("\tID = " + an_id + "; Type = " + itype + "; Model = " + model)
return
nearest = Neighbor.knn_textual(k, an_id, model, itype, self.database, this_vector=this_vector)
contribs = Neighbor.similarity_by_id(this_vector, nearest.keys(),
self.database, model, itype)
print(str(k) + " Nearest Neighbors:")
for i, (an_id, distance) in enumerate(nearest.items()):
print('\t' + str(i) + ". " + str(an_id) + "; Distance = " + str(distance))
print('Top 3 Features:')
for i, item in enumerate(contribs):
print('\t' + str(i) + '. ' + str(item))
def hill(self):
currentState = self.startState
nextEval = Heuristic(currentState).attacks()
i = 0
while i < self.iterate and nextEval != 0:
newState = self.neighbor.generateState()
currentEval = Heuristic(newState).attacks()
if self.update_states:
print Heuristic(currentState).queensPosition(
), " -> ", Heuristic(newState).queensPosition()
if currentEval <= nextEval:
currentState = newState
nextEval = Heuristic(currentState).attacks()
i += 1
self.neighbor = Neighbor(currentState)
file.write(Heuristic(currentState).queensPosition(),
self.neighbor.createBoard(),
url="./resource/newBoard.txt")
print "Hill Comum > Iteracao : ", i
print "Posicao Inicial das ", len(
self.startState), " rainhas : ", Heuristic(
self.startState).queensPosition()
print "Posicao Final das ", len(
self.startState), " rainhas : ", Heuristic(
currentState).queensPosition()
print "\tNumero de rainhas atacando : ", Heuristic(
currentState).attacks()
self.startState = currentState
return Heuristic(currentState).attacks()
def _calculate_cost_of_swapping_items(self, first, second):
i = min(first, second)
j = max(first, second)
# set up weights
weight_diff = self.trip[i][utils.WEIGHT] - self.trip[j][utils.WEIGHT]
cum_weight_before_i = np.sum(
self.trip[i:][:, utils.WEIGHT]) + utils.SLEIGH_WEIGHT
cum_weight_before_j = np.sum(
self.trip[j:][:, utils.WEIGHT]) + utils.SLEIGH_WEIGHT
weight_i = self.trip[i][utils.WEIGHT]
weight_j = self.trip[j][utils.WEIGHT]
# set up locations
before_i = tuple(self.trip[i - 1][[utils.LAT, utils.LON
]]) if i > 0 else utils.NORTH_POLE
before_j = tuple(self.trip[j - 1][[utils.LAT, utils.LON
]]) if j > 0 else utils.NORTH_POLE
at_i = tuple(self.trip[i][[utils.LAT, utils.LON]])
at_j = tuple(self.trip[j][[utils.LAT, utils.LON]])
after_i = tuple(self.trip[i + 1][[
utils.LAT, utils.LON
]]) if i < len(self.trip) - 1 else utils.NORTH_POLE
after_j = tuple(self.trip[j + 1][[
utils.LAT, utils.LON
]]) if j < len(self.trip) - 1 else utils.NORTH_POLE
if i + 1 == j:
# swap adjacent locations is simplified
improvement = self._get_cost_of_swapping_adjacent(
before_i, at_i, at_j, after_j, cum_weight_before_i, weight_i,
weight_j)
else:
# cost of the old segments around i/j
old_i = Neighbor.get_cost_of_tour_of_three(before_i, at_i, after_i,
cum_weight_before_i,
weight_i)
old_j = Neighbor.get_cost_of_tour_of_three(before_j, at_j, after_j,
cum_weight_before_j,
weight_j)
# cost of the new segments around i/j
new_j = Neighbor.get_cost_of_tour_of_three(before_i, at_j, after_i,
cum_weight_before_i,
weight_j)
new_i = Neighbor.get_cost_of_tour_of_three(
before_j, at_i, after_j, cum_weight_before_j + weight_diff,
weight_i)
# cost difference from weight between i and j (sub-self.trip between i+1..j-1)
distance = 0
for k in range(i + 1, j - 1):
distance += utils.distance(
tuple(self.trip[k][[utils.LAT, utils.LON]]),
tuple(self.trip[k + 1][[utils.LAT, utils.LON]]))
diff = distance * weight_diff
improvement = new_j + new_i - old_j - old_i + diff
return improvement
def task3(self, *args):
"""
Command:\ttask3 <vis model> <k> <method> <j> <id>
Description:\tIdentifies k latent semantics using model and methodology. Given an \
id, finds the top j most related items to that id.
Arguments:
\tVisual Space - What visual description model to pull. ('CM', 'CM3x3', 'CN', \
'CN3x3', 'CSD', 'GLRLM', 'GLRLM3x3', 'HOG', 'LBP', 'LBP3x3')
\tK - Number of latent semantics to return.
\tMethod - The decomposition method to use. (PCA, SVD, LDA).
\tJ - Number of nearest terms to find.
\tID - The id of the image to find nearest neighbors to using the latent semantics.
"""
if len(args) < 5:
print("[ERROR] Not enough args were provided. Expected 5 but got " + str(len(args)))
print("\targs = " + str(args))
return
if len(args) > 5:
print("[ERROR] Too many arguments were provided. Expected 5 but got " + str(len(args)))
print("\targs = " + str(args))
return
if not self.__database__:
print("[ERROR] The Database must be loaded before this can be run.")
print("\tCommand: load <filepath>")
return
try:
vis_model = args[0]
k = int(args[1])
method = args[2]
j = int(args[3])
anid = int(args[4])
except:
print("[ERROR] One or more arguments could not be parsed: " + str(args))
# Get latent semantics.
matrix = Decompose.decompose_vis(vis_model, k, method, self.__database__)
# Get nearest images from latent semantics.
vector = matrix.loc[anid]
vector1 = []
for i in range(k):
vector1.append(vector[i])
nearest_img = "5 nearest images to " + str(args[3]) + " are:\n"
nearest = Neighbor.knn_dot(5, vector1, matrix)
nearest_img += "IMAGE ID\t\tSCORE\n"
for values in nearest:
nearest_img += str(values[1]) + "\t\t" + str(values[0]) + '\n'
print(nearest_img)
# Get nearest locations from latent semantics.
nearest_loc = "5 nearest locations to " + str(args[3]) + " are:"
nearest = Neighbor.knn_loc(5, vector1, vis_model, k, method, self.__database__)
nearest_loc += "LOCATION ID\t\tSCORE"
for values in nearest:
nearest_loc += str(values[1]) + "\t\t\t" + str(values[0]) + "\n"
print(nearest_loc)
return nearest_img + '\n\n' + nearest_loc
def simulate(self):
i = 0
success = sys.maxsize
currentState = self.startState
t = self.startTemp
solutions = []
while not (success == 0) and i < self.iterate:
j = 0
success = 0
while success <= self.maxSuc and j < self.maxDis:
f1 = Heuristic(currentState).attacks()
newState = self.neighbor.generateState()
if Heuristic(newState).attacks() == 0:
if not Heuristic(newState).queensPosition() in solutions:
solutions.append(Heuristic(newState).queensPosition())
if self.state_update:
print Heuristic(currentState).queensPosition(
), " -> ", Heuristic(newState).queensPosition()
f2 = Heuristic(newState).attacks()
deltaF = f2 - f1
if not t == 0.0:
if (deltaF <= 0) or (exp(-deltaF / t) > random.random()):
currentState = newState
success += 1
j += 1
self.neighbor = Neighbor(currentState)
t = self.alpha * t
i += 1
file.write(Heuristic(currentState).queensPosition(),
self.neighbor.createBoard(),
url='./resource/newBoard.txt')
print "Contagem final de sucessos : ", success
print "Temperatura final : ", t
print "Numero de iteracoes : ", i
print "Posicao Inicial das ", len(
self.startState), " rainhas : ", Heuristic(
self.startState).queensPosition()
print "Posicao Final das ", len(
self.startState), " rainhas : ", Heuristic(
currentState).queensPosition()
print "\tNumero de rainhas atacando : ", Heuristic(
currentState).attacks()
print "Solucoes encontradas: "
for solution in solutions:
print solution
return Heuristic(currentState).attacks()
def nearest_visual(self, *args):
"""
arg[0] = locationid
arg[1] = model (CM, CM3x3, CN, CN3x3, CSD, GLRLM, GLRLM3x3, HOG, LBP, LBP3x3, ALL)
arg[2] = k
"""
if not self.database:
print("[ERROR] The database must be loaded for this action.")
return
if not len(args) == 3:
print("[ERROR] Expected three arguments but got " + str(len(args)) + ".")
print("\targ = " + str(args))
# Get the first argument
try:
k = int(args[2])
except:
print("[ERROR] K Value provided is invalid.")
print("\tk = " + str(args[2]))
return
# Get the model to use. We do this before the item as it is easier
# to differentiate valid from invalid
model = args[1]
if not model in self.valid_vis_models:
print("[ERROR] Model Type value provided was invalid.")
print("\tModel Type = " + str(args[1]))
return
try:
locationid = int(args[0])
except:
print("[ERROR] The ID specified was not valid")
print("\tID = " + str(locationid) + "; Model = " + model)
return
start = time()
if model == 'ALL':
this_vector = Vectorizer.visual_vector_multimodel(locationid, self.database, self.valid_vis_models)
nearest = Neighbor.knn_visual_all(k, locationid, self.valid_vis_models, self.database, this_vector = this_vector)
else:
# get vector representing item associated w/ id
this_vector = Vectorizer.visual_vector(locationid, self.database, model)
nearest = Neighbor.knn_visual(k, locationid, model, self.database, this_vector=this_vector)
contribs = Neighbor.visual_sim_contribution(this_vector, nearest.keys(), self.database,
model, k=3)
print("The Visual Descriptor Nearest Neighbor took " + str(time() - start))
print(str(k) + " Nearest Neighbors:")
for i, (an_id, distance) in enumerate(nearest.items()):
print('\t' + str(i) + ". " + str(an_id) + "; Distance = " + str(distance))
print('Top 3 Image Pairs:')
for i, item in enumerate(contribs):
print('\t' + str(i) + '. ' + str(item))
def cost_delta(self):
if self.cost is not None:
return self.cost
# find second trip to exchange gifts with and valid gifts to swap
first_gifts_to_try = np.random.permutation(
len(self.trips[self.first_trip]))
for fg in first_gifts_to_try:
self.second_trip = np.random.randint(len(self.trips))
while len(self.trips[self.second_trip]
) < 3 or self.first_trip == self.second_trip:
self.second_trip = np.random.randint(len(self.trips))
self.first_gift = fg
self.second_gift = self._get_valid_swapee()
if self.second_gift is not None:
break
# find insertion indexes with minimum cost
self.first_trip_insertion_index, cost_to_insert_first = Neighbor.find_best_insertion_index(
self.trips[self.first_trip],
self.trips[self.second_trip][self.second_gift],
index_to_be_removed=self.first_gift)
self.second_trip_insertion_index, cost_to_insert_second = Neighbor.find_best_insertion_index(
self.trips[self.second_trip],
self.trips[self.first_trip][self.first_gift],
index_to_be_removed=self.second_gift)
# update temporary trips with new insertion to accurately calculate the cost of deletion
temporary_first_trip = self.trips[self.first_trip]
temporary_first_trip = np.insert(
temporary_first_trip,
self.first_trip_insertion_index,
self.trips[self.second_trip][self.second_gift],
axis=0)
temporary_second_trip = self.trips[self.second_trip]
temporary_second_trip = np.insert(
temporary_second_trip,
self.second_trip_insertion_index,
self.trips[self.first_trip][self.first_gift],
axis=0)
# calculate (negative) cost of deletion
cost_to_remove_first = self._cost_to_remove_gift(
temporary_first_trip, self.first_gift
if self.first_gift < self.first_trip_insertion_index else
self.first_gift + 1)
cost_to_remove_second = self._cost_to_remove_gift(
temporary_second_trip, self.second_gift
if self.second_gift < self.second_trip_insertion_index else
self.second_gift + 1)
self.cost = cost_to_insert_first + cost_to_insert_second + cost_to_remove_first + cost_to_remove_second
return self.cost
def __init__(self, iterate, maxDis, maxSuc, alpha, startTemp, **kwargs):
self.iterate = iterate
self.maxDis = maxDis
self.maxSuc = maxSuc
self.alpha = alpha
self.startState = file.read()
self.neighbor = Neighbor(self.startState)
self.startTemp = startTemp
self.state_update = None
if 'state_update' in kwargs:
self.state_update = True
def buildFourChildTreeTopology():
print("\n\nBuilding four-child-tree topology")
nodeA = Node("A")
nodeB = Node("B")
nodeC = Node("C")
nodeD = Node("D")
nodeE = Node("E", router=True)
# Add connection to parent
nodeA.addNeighbor(Neighbor(nodeE))
nodeB.addNeighbor(Neighbor(nodeE))
nodeC.addNeighbor(Neighbor(nodeE))
nodeD.addNeighbor(Neighbor(nodeE))
# Add reverse connection
nodeE.addNeighbor(Neighbor(nodeA))
nodeE.addNeighbor(Neighbor(nodeB))
nodeE.addNeighbor(Neighbor(nodeC))
nodeE.addNeighbor(Neighbor(nodeD))
topologyName = "four-child-tree"
nodes = [nodeA, nodeB, nodeC, nodeD, nodeE]
printTopology(nodes)
NlsrBuilder(topologyName).buildNlsrFiles(nodes)
ComposeBuilder(topologyName, nodes).buildComposeFile()
def buildLinearTwoTopology():
print("\n\nBuilding linear-two topology")
# A <--10--> B
nodeA = Node("A")
nodeB = Node("B")
nodeA.addNeighbor(Neighbor(nodeB))
nodeB.addNeighbor(Neighbor(nodeA))
topologyName = "linear"
nodes = [nodeA, nodeB]
printTopology(nodes)
NlsrBuilder(topologyName).buildNlsrFiles(nodes)
ComposeBuilder(topologyName, nodes).buildComposeFile()
def main():
with open('config.json') as data:
config = json.load(data)
neighbors = []
for item in config['neighbor_list']:
neighbors.append(Neighbor(str(item)))
ip, p2p_port = neighbors[0].getP2PConfig()
diff = config['target']
beneficiary = config['beneficiary']
delay = config['delay']
is_miner = config['mining']
public_key = config['wallet']['public_key']
private_key = config['wallet']['private_key']
fee = config['fee']
chain = minichain(diff)
user_wallet = wallet(public_key, private_key)
node1 = node(config['p2p_port'], config['user_port'], neighbors, chain,
beneficiary, user_wallet, fee, delay, is_miner)
try:
node1.start_node()
except KeyboardInterrupt:
sys.exit(1)
except:
print("[ERROR] UNKNOWN ERROR")
sys.exit(1)
def get_optimally_sorted_trips(self, trips):
self.log.warning("THIS DOESN'T WORK")
self.log.info("Putting trips into optimal order")
total_trip_count = len(trips)
all_trips = []
for i, trip in enumerate(trips.values()):
self.log.debug("Processing trip {}/{} with length {}".format(
i + 1, total_trip_count, len(trip[1])))
sorted_trip = sorted(trip[1],
key=lambda tup: tup.Weight,
reverse=True)
this_trip = []
for gift in sorted_trip:
if len(this_trip) == 0:
this_trip.append(gift)
continue
gift[utils.TRIP] = len(all_trips)
best_index, _ = Neighbor.find_best_insertion_index(
np.asarray(this_trip),
gift.values,
lat_index=1,
lon_index=2,
weight_index=3)
this_trip.insert(best_index, gift)
if this_trip:
all_trips.append(this_trip)
# extract gift/trip mapping
combined_trips = np.concatenate(all_trips)[:, [utils.GIFT, utils.TRIP]]
return pd.DataFrame(combined_trips, columns=["GiftId", "TripId"])
def cost_delta(self):
if self.cost is not None:
return self.cost
if self.trip is None:
self.trip = np.random.randint(len(self.trips))
while len(self.trips[self.trip]) < 2:
self.trip = np.random.randint(len(self.trips))
source = self.trips[self.trip]
if self.gift_to_move is not None or self.destination_trip is not None or self.destination_insertion_index is not None or self.cost_to_insert_in_destination is not None:
# we should have *all* of these set
return self.cost_to_insert_in_destination + self._cost_to_remove_gift(
source, self.gift_to_move)
self.gift_to_move = np.random.randint(len(source))
self.destination_trip = self._get_valid_target_trip()
gift = source[self.gift_to_move]
self.destination_insertion_index, cost_to_insert = Neighbor.find_best_insertion_index(
self.trips[self.destination_trip], gift)
cost_to_remove = self._cost_to_remove_gift(source, self.gift_to_move)
self.cost = cost_to_insert + cost_to_remove
return self.cost
def hill_random(self):
colision = sys.maxsize
count = 0
stagnate = sys.maxsize
old_col = -1
while colision != 0 and not stagnate == 100:
print "Hill Random > Iteracao: ", count + 1
print "------------------------------------------\n"
start = time.time()
colision = self.hill()
end = time.time() - start
print "\tTempo de execucao : ", end, " segundos"
self.neighbor = Neighbor(self.startState)
count += 1
print "\n------------------------------------------\n"
if not old_col == colision:
old_col = colision
stagnate = 0
else:
stagnate += 1
def buildLinearThreeTopology():
print("\n\nBuilding linear-three topology")
"""
A <--10--> B <--20--> C
|
10
X
"""
nodeA = Node("A")
nodeB = Node("B")
nodeC = Node("C")
# Adding my local machine to the mix
nodeX = Node("X")
nodeX.addNeighbor(Neighbor(nodeB))
nodeA.addNeighbor(Neighbor(nodeB))
nodeB.addNeighbor(Neighbor(nodeA))
nodeB.addNeighbor(Neighbor(nodeC))
nodeB.addNeighbor(Neighbor(nodeX))
nodeC.addNeighbor(Neighbor(nodeB))
topologyName = "linear-three"
nodes = [nodeA, nodeB, nodeC, nodeX]
printTopology(nodes)
NlsrBuilder(topologyName).buildNlsrFiles(nodes)
ComposeBuilder(topologyName, nodes).buildComposeFile()
def buildDumbbellTopology():
print("\n\nBuilding dumbbell topology")
# Left side
nodeA = Node("A")
nodeB = Node("B")
# Right side
nodeC = Node("C")
nodeD = Node("D")
# Left router
nodeE = Node("E", router=True)
# Right router
nodeF = Node("F", router=True)
# Each of left nodes are connected to E
nodeA.addNeighbor(Neighbor(nodeE))
nodeB.addNeighbor(Neighbor(nodeE))
# Each of right nodes are connected to F
nodeC.addNeighbor(Neighbor(nodeF))
nodeD.addNeighbor(Neighbor(nodeF))
# E is connected to all left nodes and F
nodeE.addNeighbor(Neighbor(nodeA))
nodeE.addNeighbor(Neighbor(nodeB))
nodeE.addNeighbor(Neighbor(nodeF))
# F is connected to all right nodes and E
nodeF.addNeighbor(Neighbor(nodeC))
nodeF.addNeighbor(Neighbor(nodeD))
nodeF.addNeighbor(Neighbor(nodeE))
topologyName = "dumbbell"
nodes = [nodeA, nodeB, nodeC, nodeD, nodeE, nodeF]
printTopology(nodes)
NlsrBuilder(topologyName).buildNlsrFiles(nodes)
ComposeBuilder(topologyName, nodes).buildComposeFile()
def make_bldg_neighbor(self, name):
bldg_powers = self.building_powers[name]
# Create neighbor
bldg = Neighbor()
bldg.name = name
bldg.maximumPower = bldg_powers[
0] # Remember loads have negative power [avg.kW]
bldg.minimumPower = bldg_powers[1] # [avg.kW]
_log.debug("{} has minPower of {} and maxPower of {}".format(
bldg.name, bldg.minimumPower, bldg.maximumPower))
# Create neighbor model
bldg_model = NeighborModel()
bldg_model.name = name + '_Model'
bldg_model.location = self.name
bldg_model.convergenceThreshold = 0.02
bldg_model.friend = True
bldg_model.transactive = True
bldg_model.costParameters = [0, 0, 0]
# This is different building to building
bldg_model.defaultPower = bldg.minimumPower / 2 # bldg_powers[2] # [avg.kW]
bldg_model.defaultVertices = [
Vertex(float("inf"), 0, bldg_model.defaultPower, True)
]
# Cross reference object & model
bldg.model = bldg_model
bldg_model.object = bldg
return bldg
def cost_delta(self):
if self.cost is not None:
return self.cost
trip = self.trips[self.trip]
gift = trip[self.gift_index]
cost_to_remove = self._cost_to_remove_gift(trip, self.gift_index)
trip_without_gift = np.delete(trip, self.gift_index, axis=0)
self.new_index, cost_to_insert = Neighbor.find_best_insertion_index(
trip_without_gift, gift, index_to_be_removed=self.gift_index + 1)
self.cost = cost_to_insert + cost_to_remove
return self.cost
def _parse_config_file(self, config_file):
''' Config file has general configuration, such as href prefix.
Config file has information for Switches
- Name
- Connection info
- List of reserved bridge numbers
- Neighbors
'''
with open(config_file) as data_file:
data = json.load(data_file)
self.base_url = data['adaptor-href-base']
for switch in data['switches']:
switch_name = switch['name']
connection_info = switch['connection-info']
reserved_bridges = switch['reserved-bridges']
neighbors = switch['neighbors']
# Determine the correct href for the switch we're creating
switch_href = self.base_url + "switches/" + switch_name
# Create Switch object
switch = Switch(switch_name, switch_href, self.no_switch)
# Create the ConnectionInfo object and add it to the switch
cxn_info_object = ConnectionInfo(connection_info['address'],
connection_info['rest_key'])
switch.set_connection_info(cxn_info_object)
# Add list of reserved bridges
switch.set_reserved_bridges(reserved_bridges)
# Create all the neighbors and add them to the switch object
for neighbor in neighbors:
neighbor_name = neighbor['name']
neighbor_type = neighbor['type']
neighbor_physport = neighbor['port']
neighbor_vlans = neighbor['vlans']
neighbor_href = switch_href + "/neighbors/" + neighbor_name
neighbor_object = Neighbor(neighbor_name, neighbor_href,
neighbor_vlans, neighbor_physport,
neighbor_type)
switch.add_neighbor(neighbor_object)
# Save off switch
self.switches[switch_name] = switch
def task2(self, *args):
"""
Command:\ttask2 <term space> <k> <method> <j> <id>
Description:\tIdentifies the top k latent semantics uses an id in the term \
space to identify the most related j ids.
Arguments:
\tTerm Space - What text description type to pull. (user, photo, poi).
\tK - Number of latent semantics to return.
\tMethod - The decomposition method to use. (PCA, SVD, LDA).
\tJ - Number of nearest terms to find.
\tID - The id to find nearest neighbors to using the latent semantics.
"""
if len(args) < 5:
print("[ERROR] Not enough args were provided. Expected 5 but got " + str(len(args)))
print("\targs = " + str(args))
return
if len(args) > 5:
print("[ERROR] Too many arguments were provided. Expected 5 but got " + str(len(args)))
print("\targs = " + str(args))
return
if not self.__database__:
print("[ERROR] The Database must be loaded before this can be run.")
print("\tCommand: load <filepath>")
return
try:
term_space = args[0]
k = int(args[1])
method = args[2]
j = int(args[3])
anid = args[4]
if term_space == 'photo' or term_space == 'poi':
anid = int(anid)
except:
print("[ERROR] One or more arguments could not be parsed: " + str(args))
reduced_table, latent_semantics = Decompose.decompose_text(term_space, k, method.lower(), self.__database__)
ls_str = self.__latent_semantic_string__(latent_semantics)
print(ls_str)
vector = reduced_table.loc[anid]
neighbors = Neighbor.knn(j, vector, reduced_table)
neighbors_str = ""
neighbors_str += "NEIGHBORS to " + str(anid)
for i, neighbor in enumerate(neighbors):
neighbors_str += f"{i}: ID = {neighbor.id}, DIST = {neighbor.dist}"
print(neighbors_str)
return ls_str + '\n' + neighbors_str
def compute(self, system: System, binning: Binning,
neighbor: Neighbor) -> None:
neigh_list: NeighList2D = neighbor.get_neigh_list()
self.num_neighs_view: pk.View1D = neigh_list.num_neighs
self.neighs_view: pk.View2D = neigh_list.neighs
self.N_local = system.N_local
self.x = system.x
self.f = system.f
self.f_a = system.f
self.type = system.type
self.id = system.id
self.parallel_for = True
pk.execute(pk.ExecutionSpace.Default, self)
self.step += 1
def task4(self, *args):
"""
Command:\ttask4 <locationid> <vis model> <k> <method>
Description:\tIdentifies the top k latent semantics for the given location \
and lists the five most related locations.
Arguments:
\tLocation Id - A valid location id. (1 - 30)
\tVisual Space - What visual description model to pull. ('CM', 'CM3x3', 'CN', \
'CN3x3', 'CSD', 'GLRLM', 'GLRLM3x3', 'HOG', 'LBP', 'LBP3x3').
\tK - Number of latent semantics to identify.
\tMethod - The decomposition method to use. (PCA, SVD, LDA).
"""
if len(args) < 4:
print("[ERROR] Not enough args were provided. Expected 4 but got " + str(len(args)))
print("\targs = " + str(args))
return
if len(args) > 4:
print("[ERROR] Too many arguments were provided. Expected 4 but got " + str(len(args)))
print("\targs = " + str(args))
return
if not self.__database__:
print("[ERROR] The Database must be loaded before this can be run.")
print("\tCommand: load <filepath>")
return
try:
locationid = int(args[0])
vis_model = args[1]
k = int(args[2])
method = args[3]
except:
print("[ERROR] One or more arguments could not be parsed: " + str(args))
# Get latent semantics.
matrix = Decompose.decompose_loc_vis(vis_model, k, method, locationid, self.__database__)
# Get nearest 5 locations from latent semantics. Neighbor.knn may be useful for you.
nearest = Neighbor.knn_vd(5, matrix, vis_model, k, method, locationid, self.__database__)
nearest_loc = "5 nearest locations to " + str(args[0]) + " are:\n"
nearest_loc += "LOCATION ID\t\tSCORE\n"
for values in nearest:
nearest_loc += str(values[1]) + "\t\t\t" + str(values[0]) + '\n'
print(nearest_loc)
return nearest_loc
def cost_delta(self):
if self.cost is not None:
return self.cost
self.trip_to_merge, self.trip_assignments_for_gifts = self._find_trip_to_merge()
if self.trip_to_merge is None:
return 0
trip = self.trips[self.trip_to_merge]
self.gift_insertions = []
cost_of_insertions = 0
for trip_index, gift in self.trip_assignments_for_gifts.items():
index_in_trip, cost = Neighbor.find_best_insertion_index(self.trips[trip_index], gift)
self.gift_insertions.append((gift, trip_index, index_in_trip))
cost_of_insertions += cost
self.cost = cost_of_insertions - utils.weighted_trip_length(trip[:, utils.LOCATION], trip[:, utils.WEIGHT])
return self.cost
def main(self, L=2, k=3, imageId=5175916261, vectors=[], t=5, database=()):
# imageId = imageId[0]
# imageId = int(imageId[1:-1])
image_dict = pd.DataFrame(database.get_vis_table())
image_dict = image_dict.T
image_dict = image_dict.to_dict('list')
index_structure, vectors = self.get_index_structure(L, k, image_dict)
# print(index_structure['h(0, 0)'])
# get all the imageIds which are in the same bucket as the given imageId
imageId_set = set(image_dict.keys())
# print(imageId_set)
num_total_images = 0
for i in range(L):
for j in range(k):
temp_imageId = set()
for bucket in index_structure['h(' + str(i) + ', ' + str(j) +
')']:
if imageId in index_structure['h(' + str(i) + ', ' +
str(j) + ')'][str(bucket)]:
temp_imageId = temp_imageId.intersection(
set(index_structure['h(' + str(i) + ', ' + str(j) +
')'][str(bucket)]))
num_total_images = num_total_images + len(temp_imageId)
imageId_set = imageId_set.union(temp_imageId)
# print(imageId_set)
# calculate similarity and get t nearest images
nearest, num_comparisons = Neighbor.knn_visual_LSH(
t, imageId, database, list(imageId_set))
print("Number of non-unique images considered\t: " +
str(num_total_images))
print("Number of unique images compared\t: " + str(num_comparisons))
for image in nearest:
print(image)
return [int(n.id) for n in nearest]
def particleCalculations(self):
for i in range(len(self.particles)):
# Density calculations
densityFar = densityNear = 0
targetParticle = self.particles[i]
targetParticle.rho = targetParticle.rhoNear = 0
for j in range(i + 1, len(self.particles)):
neighborParticle = self.particles[j]
distanceVector = neighborParticle.pos - targetParticle.pos
distance = np.linalg.norm(distanceVector)
if distance**2 < self.supportRadius**2:
weightedDistance = 1 - distance / self.supportRadius
densityFar += weightedDistance**2
densityNear += weightedDistance**3
neighborParticle.rho += weightedDistance**2
neighborParticle.rhoNear += weightedDistance**3
newNeighbor = Neighbor(neighborParticle, weightedDistance)
targetParticle.neighbors.append(newNeighbor)
targetParticle.rho += densityFar
targetParticle.rhoNear += densityNear
# Pressure calculations
targetParticle.press = self.k * (targetParticle.rho -
self.restDensity)
targetParticle.pressNear = self.kNear * targetParticle.rhoNear
dX = np.array([0, 0])
for neighborEntry in targetParticle.neighbors:
neighborParticle = neighborEntry.particle
distanceVector = neighborParticle.pos - targetParticle.pos
dm = (targetParticle.pressure + neighborParticle.pressure
) * neighborEntry.weightedDistance + (
targetParticle.pressNear + neighborParticle.
pressureNear) * (neighborEntry.weightedDistance**2)
directionOfForce = (distanceVector /
np.linalg.norm(distanceVector)) * dm
dX = dX + directionOfForce
neighborParticle.force = neighborParticle.force + directionOfForce
targetParticle.force = targetParticle.force - dX
def make_campus(self):
# Campus object
campus = Neighbor()
campus.name = 'PNNL_Campus'
campus.description = 'PNNL_Campus'
campus.maximumPower = 0.0 # Remember loads have negative power [avg.kW]
campus.minimumPower = -20000 # [avg.kW]
# Campus model
campus_model = NeighborModel()
campus_model.name = 'PNNL_Campus_Model'
campus_model.location = self.name
campus_model.defaultPower = -10000 # [avg.kW]
campus_model.defaultVertices = [Vertex(0.045, 0.0, -10000.0)]
#campus_model.demandThreshold = 0.8 * campus.maximumPower
campus_model.transactive = True
# Cross-reference object & model
campus_model.object = campus
campus.model = campus_model
return campus
def make_supplier(self):
# Add supplier
supplier = Neighbor()
supplier.name = 'BPA'
supplier.description = 'The Bonneville Power Administration as electricity supplier to the City of Richland, WA'
supplier.lossFactor = self.supplier_loss_factor
supplier.maximumPower = 200800 # [avg.kW, twice the average COR load]
supplier.minimumPower = 0.0 # [avg.kW, will not export]
# Add supplier model
supplierModel = BulkSupplier_dc()
supplierModel.name = 'BPAModel'
#supplierModel.demandThreshold = 0.75 * supplier.maximumPower
supplierModel.converged = False # Dynamically assigned
supplierModel.convergenceThreshold = 0 # Not yet implemented
supplierModel.effectiveImpedance = 0.0 # Not yet implemented
supplierModel.friend = False # Separate business entity from COR
supplierModel.transactive = False # Not a transactive neighbor
# Add vertices
# The first default vertex is, for now, based on the flat COR rate to
# PNNL. The second vertex includes 2# losses at a maximum power that
# is twice the average electric load for COR. This is helpful to
# ensure that a unique price, power point will be found. In this
# model the recipient pays the cost of energy losses.
# The first vertex is based on BPA Jan HLH rate at zero power
# importation.
d1 = Vertex(0, 0, 0) # create first default vertex
d1.marginalPrice = 0.04196 # HLH BPA rate Jan 2018 [$/kWh]
d1.cost = 2000.0 # Const. price shift to COR customer rate [$/h]
d1.power = 0.0 # [avg.kW]
# The second default vertex represents imported and lost power at a power
# value presumed to be the maximum deliverable power from BPA to COR.
d2 = Vertex(0, 0, 0) # create second default vertex
# COR pays for all sent power but receives an amount reduced by
# losses. This creates a quadratic term in the production cost and
# a slope to the marginal price curve.
d2.marginalPrice = d1.marginalPrice / (1 - supplier.lossFactor
) # [$/kWh]
# From the perspective of COR, it receives the power sent by BPA,
# less losses.
d2.power = (1 -
supplier.lossFactor) * supplier.maximumPower # [avg.kW]
# The production costs can be estimated by integrating the
# marginal-price curve.
d2.cost = d1.cost + d2.power * (d1.marginalPrice + 0.5 *
(d2.marginalPrice - d1.marginalPrice)
) # [$/h]
supplierModel.defaultVertices = [d1, d2]
# COST PARAMTERS
# A constant cost parameter is being used here to account for the
# difference between wholesale BPA rates to COR and COR distribution
# rates to customers like PNNL. A constant of $2,000/h steps the rates
# from about 0.04 $/kWh to about 0.06 $/kWh. This may be refined later.
# IMPORTANT: This shift has no affect on marginal pricing.
supplierModel.costParameters[0] = 2000.0 # [$/h]
# Cross-reference object & model
supplierModel.object = supplier
supplier.model = supplierModel
# Meter
bpaElectricityMeter = MeterPoint() # Instantiate an electricity meter
bpaElectricityMeter.name = 'BpaElectricityMeter'
bpaElectricityMeter.description = 'BPA electricity to COR'
bpaElectricityMeter.measurementType = MeasurementType.PowerReal
bpaElectricityMeter.measurementUnit = MeasurementUnit.kWh
supplierModel.meterPoints = [bpaElectricityMeter]
return supplier
class SimulatedAnnealing(object):
# maxDisc -> Numero maximo de perturbacoes na temperatura
# maxSuc -> Numero maximo de sucessos por iteracao
# alpha -> fator de reducao da temperatura
def __init__(self, iterate, maxDis, maxSuc, alpha, startTemp, **kwargs):
self.iterate = iterate
self.maxDis = maxDis
self.maxSuc = maxSuc
self.alpha = alpha
self.startState = file.read()
self.neighbor = Neighbor(self.startState)
self.startTemp = startTemp
self.state_update = None
if 'state_update' in kwargs:
self.state_update = True
def simulate(self):
i = 0
success = sys.maxsize
currentState = self.startState
t = self.startTemp
solutions = []
while not (success == 0) and i < self.iterate:
j = 0
success = 0
while success <= self.maxSuc and j < self.maxDis:
f1 = Heuristic(currentState).attacks()
newState = self.neighbor.generateState()
if Heuristic(newState).attacks() == 0:
if not Heuristic(newState).queensPosition() in solutions:
solutions.append(Heuristic(newState).queensPosition())
if self.state_update:
print Heuristic(currentState).queensPosition(
), " -> ", Heuristic(newState).queensPosition()
f2 = Heuristic(newState).attacks()
deltaF = f2 - f1
if not t == 0.0:
if (deltaF <= 0) or (exp(-deltaF / t) > random.random()):
currentState = newState
success += 1
j += 1
self.neighbor = Neighbor(currentState)
t = self.alpha * t
i += 1
file.write(Heuristic(currentState).queensPosition(),
self.neighbor.createBoard(),
url='./resource/newBoard.txt')
print "Contagem final de sucessos : ", success
print "Temperatura final : ", t
print "Numero de iteracoes : ", i
print "Posicao Inicial das ", len(
self.startState), " rainhas : ", Heuristic(
self.startState).queensPosition()
print "Posicao Final das ", len(
self.startState), " rainhas : ", Heuristic(
currentState).queensPosition()
print "\tNumero de rainhas atacando : ", Heuristic(
currentState).attacks()
print "Solucoes encontradas: "
for solution in solutions:
print solution
return Heuristic(currentState).attacks()
def init_objects(self):
# Add meter
# meter = MeterPoint()
# meter.name = 'BuildingElectricMeter'
# meter.measurementType = MeasurementType.PowerReal
# meter.measurementUnit = MeasurementUnit.kWh
# self.meterPoints.append(meter)
# Add weather forecast service
weather_service = TemperatureForecastModel(self.config_path, self)
self.informationServiceModels.append(weather_service)
# # Add inelastive asset
# inelastive_load = LocalAsset()
# inelastive_load.name = 'InelasticBldgLoad'
# inelastive_load.maximumPower = 0 # Remember that a load is a negative power [kW]
# inelastive_load.minimumPower = -200
#
# # Add inelastive asset model
# inelastive_load_model = LocalAssetModel()
# inelastive_load_model.name = 'InelasticBuildingModel'
# inelastive_load_model.defaultPower = -100 # [kW]
# inelastive_load_model.defaultVertices = [Vertex(float("inf"), 0, -100, True)]
#
# # Cross-reference asset & asset model
# inelastive_load_model.object = inelastive_load
# inelastive_load.model = inelastive_load_model
# Add elastive asset
elastive_load = LocalAsset()
elastive_load.name = 'TccLoad'
elastive_load.maximumPower = 0 # Remember that a load is a negative power [kW]
elastive_load.minimumPower = -self.max_deliver_capacity
# Add inelastive asset model
# self.elastive_load_model = LocalAssetModel()
self.elastive_load_model = TccModel()
self.elastive_load_model.name = 'TccModel'
self.elastive_load_model.defaultPower = -0.5*self.max_deliver_capacity # [kW]
self.elastive_load_model.defaultVertices = [Vertex(0.055, 0, -self.elastive_load_model.defaultPower, True),
Vertex(0.06, 0, -self.elastive_load_model.defaultPower/2, True)]
# Cross-reference asset & asset model
self.elastive_load_model.object = elastive_load
elastive_load.model = self.elastive_load_model
# Add inelastive and elastive loads as building' assets
self.localAssets.extend([elastive_load])
# Add Market
market = Market()
market.name = 'dayAhead'
market.commitment = False
market.converged = False
market.defaultPrice = 0.0428 # [$/kWh]
market.dualityGapThreshold = self.duality_gap_threshold # [0.02 = 2#]
market.initialMarketState = MarketState.Inactive
market.marketOrder = 1 # This is first and only market
market.intervalsToClear = 1 # Only one interval at a time
market.futureHorizon = timedelta(hours=24) # Projects 24 hourly future intervals
market.intervalDuration = timedelta(hours=1) # [h] Intervals are 1 h long
market.marketClearingInterval = timedelta(hours=1) # [h]
market.marketClearingTime = Timer.get_cur_time().replace(hour=0,
minute=0,
second=0,
microsecond=0) # Aligns with top of hour
market.nextMarketClearingTime = market.marketClearingTime + timedelta(hours=1)
self.markets.append(market)
# Campus object
campus = Neighbor()
campus.name = 'PNNL_Campus'
campus.description = 'PNNL_Campus'
campus.maximumPower = self.max_deliver_capacity
campus.minimumPower = 0. # [avg.kW]
campus.lossFactor = self.campus_loss_factor
# Campus model
campus_model = NeighborModel()
campus_model.name = 'PNNL_Campus_Model'
campus_model.location = self.name
campus_model.defaultVertices = [Vertex(0.045, 25, 0, True), Vertex(0.048, 0, self.max_deliver_capacity, True)]
campus_model.demand_threshold_coef = self.demand_threshold_coef
# campus_model.demandThreshold = self.demand_threshold_coef * self.monthly_peak_power
campus_model.demandThreshold = self.monthly_peak_power
campus_model.transactive = True
campus_model.inject(self, system_loss_topic=self.system_loss_topic)
# Avg building meter
building_meter = MeterPoint()
building_meter.name = self.name + ' ElectricMeter'
building_meter.measurementType = MeasurementType.AverageDemandkW
building_meter.measurementUnit = MeasurementUnit.kWh
campus_model.meterPoints.append(building_meter)
# Cross-reference object & model
campus_model.object = campus
campus.model = campus_model
self.campus = campus
# Add campus as building's neighbor
self.neighbors.append(campus)
