def __init__(self,
numTilings=1,
parameters=2,
rlAlpha=0.5,
rlLambda=0.9,
rlGamma=0.9,
cTableSize=0):
""" If you want to run an example of the code, simply just leave the parameters blank and it'll automatically set based on the parameters. """
self.numTilings = numTilings
self.tileWidths = list()
self.parameters = parameters
self.rlAlpha = rlAlpha
self.rlLambda = rlLambda
self.rlGamma = rlGamma
self.prediction = None
self.lastS = None
self.lastQ = None
self.lastPrediction = None
self.lastReward = None
self.traceH = TraceHolder((self.numTilings**(self.parameters) + 1),
self.rlLambda, 1000)
self.F = [0 for item in range(self.numTilings)
] # the indices of the returned tiles will go in here
self.theta = [
0 for item in range((self.numTilings**(self.parameters + 1)) + 1)
] # weight vector.
self.cTable = CollisionTable(cTableSize, 'safe') # look into this...
self.verifier = Verifier(self.rlGamma)
def __init__(self,
numTilings=2,
parameters=2,
rlAlpha=0.5,
rlLambda=0.9,
rlGamma=0.9,
cTableSize=0):
self.numTilings = numTilings
self.tileWidths = list()
self.parameters = parameters
self.rlAlpha = rlAlpha
self.rlLambda = rlLambda
self.rlGamma = rlGamma
self.prediction = None
self.lastS = None
self.lastQ = None
self.lastPrediction = None
self.lastReward = None
self.F = [0 for item in range(self.numTilings)]
self.F2 = [0 for item in range(self.numTilings)]
self.theta = [
0 for item in range((self.numTilings**(self.parameters + 1)) + 1)
]
self.cTable = CollisionTable(cTableSize, 'safe')
self.update(None, None)
self.e = [
0 for item in range((self.numTilings**(self.parameters + 1)) + 1)
]
self.verifier = Verifier(self.rlGamma)
def verify_backup(self, host, dir_to_verify, logger):
verifier_obj = Verifier(host=host,
dir_to_verify=dir_to_verify,
logger=logger)
verifier_obj.setup()
return verifier_obj.verify()
def __init__(self, binary):
self.binary = os.path.abspath(binary)
self.payloads = []
self.bug_finder = BugFinder(self.binary)
self.analyzer = Analyzer(self.binary)
self.exploiter = Exploiter(self.binary)
self.verifier = Verifier(self.binary)
def test_verify_timestamp(self):
v = Verifier(None)
v.tsRequest = os.path.join(
settings.VERIFIED_ZIP,
"1679091c5a880faf6fb5e6087eb1b2dc.tsrequest")
v.tsResponse = os.path.join(settings.VERIFIED_ZIP,
"1679091c5a880faf6fb5e6087eb1b2dc.p7s")
self.assertTrue(v.verifyTimestamp())
def __init__(this): Verifier.__init__(this) # below we add two vectors for comparing between what feature vector is of the ideal Booter # and what feature vector is of the ideal non-Booter. # currently they are defined as completely 0.0 or 1.0; experimenting wtih different values e.g. # averages of Booter training dataset, numbers more often associated with Booters and so on did # not generate consistently better results (sometimes it did, sometimes it didn't). We thus keep # the [1.0,...,1.0] vector as this directly corresponds with the individual distance each element # has to its maximum value. this.vector_booter = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
def verify_backup(self, host, dir_to_verify, logger):
verifier_obj = Verifier(host=host, dir_to_verify=dir_to_verify,
logger=logger)
backup_lock.acquire()
try:
verifier_obj.setup()
finally:
backup_lock.release()
return verifier_obj.verify()
def test_adv_attack(self):
debug = True
src = 'testing/tests/data/master2_4s_1080.mp4'
rend_path = 'testing/tests/data/rend2_4s_1080_adv_attack.mp4'
verifier = Verifier(
10,
'http://storage.googleapis.com/verification-models/verification-metamodel-2020-07-06.tar.xz',
False, False, debug)
verification_result = verifier.verify(src, [{'uri': rend_path}])
print(verification_result)
assert verification_result[0]['tamper'] == 1
def verify_backup(self, host, dir_to_verify, logger):
verifier_obj = Verifier(host=host,
dir_to_verify=dir_to_verify,
logger=logger)
backup_lock.acquire()
try:
verifier_obj.setup()
finally:
backup_lock.release()
return verifier_obj.verify()
def test_classification(self):
source_dir = '../data/renditions/1080p/'
rendition_dirs = [
('../data/renditions/720p_watermark/', True),
('../data/renditions/720p_60-24fps/', False),
]
files = None
debug = False
n_samples = 10
gpu = False
src_videos = sorted(glob.glob(source_dir + '/*'))
results = []
verifier = Verifier(
n_samples,
'http://storage.googleapis.com/verification-models/verification-metamodel-2020-07-06.tar.xz',
gpu, False, debug)
for src in tqdm.tqdm(src_videos):
filename = src.split(os.path.sep)[-1]
if files is not None and not filename in files:
continue
i = 0
for rendition_dir, tamper in rendition_dirs:
rendition_name = rendition_dir.strip(os.path.sep).split(
os.path.sep)[-1]
rend_path = rendition_dir + os.path.sep + filename
if not os.path.exists(rend_path):
continue
np.random.seed(123)
random.seed(123)
verification_result = verifier.verify(src, [{
'uri': rend_path
}])
score_meta = float(verification_result[0]["tamper"])
score_ul = float(verification_result[0]["tamper_ul"])
score_sl = float(verification_result[0]["tamper_sl"])
res = {
'score': score_meta,
'score_ul': score_ul,
'score_sl': score_sl
}
res['master_filename'] = filename
res['rendition_type'] = rendition_name
res['is_tamper'] = tamper
results.append(res)
df_res: pd.DataFrame = pd.DataFrame(results)
df_res.set_index(['master_filename', 'rendition_type'], inplace=True)
df_res.sort_index(inplace=True)
df_res['prediction'] = df_res['score'] > 0
print(df_res)
# assert accuracy
assert np.sum(
df_res.prediction == df_res.is_tamper) / len(df_res) >= 0.8
def __init__(this):
Verifier.__init__(this)
this.p_booter = 0.1001
this.p_non_booter = 0.8999
# calculated: see 'naive_bayes_probabilities.txt'
this.p_booter_characteristics = [
0.97, 0.93, 0.94, 0.37, 0.89, 0.89, 0.38, 0.72, 0.85, 0.74, 0.92, 0.52, 0.22, 0.44, 0.82
]
this.p_non_booter_characteristics = [
0.23, 0.80, 0.67, 0.06, 0.14, 0.62, 0.28, 0.18, 0.35, 0.16, 0.20, 0.19, 0.19, 0.36, 0.66
]
def __init__(this):
Verifier.__init__(this)
# below we add two vectors for comparing between what feature vector is of the ideal Booter
# and what feature vector is of the ideal non-Booter.
# currently they are defined as completely 0.0 or 1.0; experimenting wtih different values e.g.
# averages of Booter training dataset, numbers more often associated with Booters and so on did
# not generate consistently better results (sometimes it did, sometimes it didn't). We thus keep
# the [1.0,...,1.0] vector as this directly corresponds with the individual distance each element
# has to its maximum value.
this.vector_booter = [
1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0
]
def __init__(self, numTilings = 1, num_bins = 2, rlAlpha = 0.5, rlLambda = 0.9, rlGamma = 0.9, cTableSize=0):
""" If you want to run an example of the code, simply just leave the parameters blank and it'll automatically set based on the parameters. """
self.numTilings = numTilings
self.num_bins = num_bins
self.rlAlpha = rlAlpha
self.rlLambda = rlLambda
self.rlGamma = rlGamma
self.mem_size = 1048576 # 16,384 or 8,192 or 1,048,576 or 8,388,608 or 16,777,216 or 33,554,432
self.prediction = None
self.current_prediction = 0
self.delta = 0
self.lastS = None
self.previous_tiles = [0 for item in range(self.numTilings)]
# self.previous_state = [None for item in range(self.numTilings*(self.num_bins)**10)]
self.previous_prediction = None
self.lastQ = None
self.lastPrediction = None
self.lastReward = None
self.traceH = TraceHolder(self.mem_size, 0.01, 1000) # TraceHolder(mem, minT, maxN)
self.F = [0 for item in range(self.numTilings)] # the indices of the returned tiles will go in here
self.theta = [0 for item in range(self.mem_size)] # weight vector.
# self.weights = [0 for item in range(self.numTilings*(self.num_bins)**10)]
# self.e_trace = [0 for item in range(self.numTilings*(self.num_bins)**10)] # added by Ann
self.cTable = CollisionTable(cTableSize, 'super safe') # look into this...
# stats = self.cTable.stats()
# print stats
self.verifier = Verifier(self.rlGamma)
def test_verification_speed(self):
"""
Sanity test to ensure that transcoding speed is significantly lower than verification
@return:
"""
np.random.seed(123)
random.seed(123)
n_samples = 10
n_tests = 10
codec = 'libx264'
v = Verifier(
n_samples,
'http://storage.googleapis.com/verification-models/verification-metamodel-fps2.tar.xz',
False, False, False)
res_2s = self.get_verification_and_transcoding_speed(
v, 'testing/tests/data/master_2s_1080.mp4',
'testing/tests/data/rend_2s_720_bw.mp4', n_tests, codec)
res_4s = self.get_verification_and_transcoding_speed(
v, 'testing/tests/data/master_4s_1080.mp4',
'testing/tests/data/rend_4s_720_bw.mp4', n_tests, codec)
print(f'Verification vs transcoding for 2s video (1080 to 720):')
print(res_2s)
print(f'Verification vs transcoding for 4s video (1080 to 720):')
print(res_4s)
assert res_2s['best_verification_time'] < res_2s[
'best_transcoding_time']
assert res_4s['best_verification_time'] < res_4s[
'best_transcoding_time']
def init(conf):
"""Creates all the required object to run the program
Args:
conf: Config object.
Returns:
ControlServer object.
"""
# Setup logger
logPath = path.join(conf['dataDir'], 'logs/server.log')
logFile = DailyLogFile.fromFullPath(logPath)
log.startLogging(logFile)
# Create DHT Server
server = yield initServer(conf['serverPort'], conf['bootStrapServer'],
8468)
dht = DHTServer(server)
# Create key and cert management objects
keyStore = keystore.KeyStore(conf['dataDir'])
keys = KeyManager(dht, keyStore)
certs = CertManager(dht, keyStore)
aclDir = path.join(conf['dataDir'], 'acl')
verifier = Verifier(certs, keyStore, aclDir, conf["searchDepth"])
# Return value so it doesn't get garbage collected
returnValue(
ControlServer(conf['localPort'], dht, keys, certs, verifier, keyStore,
reactor))
def __init__(actions, self, numTilings = 1, parameters = 2,rlAlpha = 0.5, rlLambda = 0.9,
rlGamma = 0.9, rlEpsilon = 0.1, cTableSize=0, action_selection = 'softmax'):
""" If you want to run an example of the code, simply just leave the parameters blank and it'll automatically set based on the parameters. """
self.numTilings = numTilings
self.tileWidths = list()
self.parameters = parameters
self.rlAlpha = rlAlpha
self.rlLambda = rlLambda
self.rlGamma = rlGamma
self.rlEpsilon = rlEpsilon
self.action_selection = action_selection
self.lastS = None
self.lastQ = None
self.lastPrediction = None
self.lastReward = None
self.lastAction = None
self.currentAction = None
self.actions = actions # an array of actions which we can select from
self.traceH = TraceHolder((self.numTilings**(self.parameters)+1), self.rlLambda, 1000)
self.F = [[0 for item in range(self.numTilings)] for i in range(actions)] # the indices of the returned tiles will go in here
self.q_vals = [0 for i in range(actions)]
for action in actions:
self.q.append(action,[0 for item in range((self.numTilings**(self.parameters+1))+1)]) # action and weight vec
self.cTable = CollisionTable(cTableSize, 'safe') # look into this...
self.verifier = Verifier(self.rlGamma)
def __init__(self, data_loader, config, val_loader):
# Data loader
self.data_loader = data_loader
self.verifier = Verifier(val_loader, config)
# Model hyper-parameters
self.imsize = config.imsize
self.parallel = config.parallel
self.arch = config.arch
# tensorboard
self.writer = SummaryWriter('runs/training' + '_' + self.arch)
self.epochs = config.epochs
self.batch_size = config.batch_size
self.num_workers = config.num_workers
self.total_iters = self.epochs * len(self.data_loader)
self.classes = config.classes
self.g_lr = config.g_lr
self.momentum = config.momentum
self.weight_decay = config.weight_decay
self.pretrained_model = config.pretrained_model # int type
self.indicator = False if self.pretrained_model > 0 else True
self.img_path = config.img_path
self.label_path = config.label_path
self.model_save_path = config.model_save_path
self.sample_path = config.sample_path
self.sample_step = config.sample_step
self.tb_step = config.tb_step
# Path
self.sample_path = osp.join(config.sample_path, self.arch)
self.model_save_path = osp.join(config.model_save_path, self.arch)
self.build_model()
# Start with trained model
if self.pretrained_model:
self.load_pretrained_model()
self.lr_scheduler = WarmupPolyLR(
self.g_optimizer, max_iters=self.total_iters, power=0.9,
warmup_factor=1.0 / 3, warmup_iters=500,
warmup_method='linear')
def __init__(self, connection_string):
super(VerifyTalent, self).__init__('VerifyTalent', connection_string)
self.register_function('verify', self.__verify)
self.register_function('sign', self.__sign)
self.register_function('signerdid', self.__signerdid)
self.verifier = Verifier()
jwk_raw = os.getenv('JWK')
if jwk_raw and jwk_raw != '':
try:
self.key = jwk.JWK.from_json(jwk_raw)
self.logger.info('Successfully stored Key from JWK: {}'.format(
self.key))
# pylint: disable=broad-except
except Exception as ex:
self.logger.error('Could not import JWK: {}'.format(ex))
def main():
while True:
while True:
try:
inputFile = input("input file path: ")
ifhand = open(inputFile)
except FileNotFoundError:
print("File not Found.")
continue
break
message = ifhand.readline()
genFunc = ifhand.readline()
## handling wrong inputs-> eg: extra spaces or \n
message = message.replace(" ", "")
message = message.replace("\n", '')
genFunc = genFunc.replace(" ", "")
genFunc = genFunc.replace("\n", "")
print(
"Commands:\n Generator only -> 1\n Generator-verifier -> 2\n Generator-Verifier-Alter-Verifier->3\n"
)
command = input("Enter command number:")
if command == '1':
print("Transmitted message: " + generator(message, genFunc))
elif command == '2':
transmittedMessage = generator(message, genFunc)
print("transmitted message: " + transmittedMessage)
Verifier(transmittedMessage, genFunc)
elif command == '3':
transmittedMessage = generator(message, genFunc)
print("transmitted message: " + transmittedMessage)
Verifier(transmittedMessage, genFunc)
bit_position = input("Which bit to alter? ")
altered_msg = Alter(transmittedMessage, bit_position)
Verifier(altered_msg, genFunc)
else:
print("Choose a valid command number")
continue
exit = input("exit?Y/N\n")
if exit == 'y' or exit == 'Y':
break
else:
print("__________________________\n\n")
continue
class VerifyTalent(FunctionTalent):
def __init__(self, connection_string):
super(VerifyTalent, self).__init__('VerifyTalent', connection_string)
self.register_function('verify', self.__verify)
self.register_function('sign', self.__sign)
self.register_function('signerdid', self.__signerdid)
self.verifier = Verifier()
jwk_raw = os.getenv('JWK')
if jwk_raw and jwk_raw != '':
try:
self.key = jwk.JWK.from_json(jwk_raw)
self.logger.info('Successfully stored Key from JWK: {}'.format(
self.key))
# pylint: disable=broad-except
except Exception as ex:
self.logger.error('Could not import JWK: {}'.format(ex))
# pylint: disable=unused-argument
def __verify(self, payload, ev, evtctx):
self.logger.info(
'Received verification request for value {}'.format(payload))
result = self.verifier.verify(payload)
# If error message
if isinstance(result, str):
self.logger.error('Verify failed: {}'.format(result))
return result
else:
return self.verifier.verify(payload).decode('utf-8')
# pylint: disable=unused-argument
async def __sign(self, payload, ev, evtctx):
if self.key is None or self.key == '':
return 'no key given'
return await self.verifier.sign(payload, self.key)
# pylint: disable=unused-argument
async def __signerdid(self, payload, ev, evtctx):
return await self.verifier.signer_did(payload)
class AEGG(object):
def __init__(self, binary):
self.binary = os.path.abspath(binary)
self.payloads = []
self.bug_finder = BugFinder(self.binary)
self.analyzer = Analyzer(self.binary)
self.exploiter = Exploiter(self.binary)
self.verifier = Verifier(self.binary)
def _save(self, payload, file_name):
with open(file_name, 'w') as f:
f.write(payload)
def exploit_gen(self, path):
analysis = self.analyzer.analyze(path)
for payload in self.exploiter.generate(path, analysis):
if not payload:
break
if self.verifier.verify(payload):
self.payloads.append(payload)
l.info('Generated!')
return True
l.info('Can not generate any payload.')
return False
def hack(self, n=None, paths=None):
"""
n: number paths want to check
paths: angr path object
"""
n = 1 if n is None else n
paths = [] if paths is None else paths
l.info('Start hacking ...')
while len(paths) < n:
found_paths = self.bug_finder.find()
if found_paths is None:
break
paths.extend(found_paths)
for path in paths:
self.exploit_gen(path)
l.info('Completed.')
def save(self, file_name=None):
file_name = self.binary if file_name is None else file_name
if len(self.payloads) == 1:
ext = 'py' if self.payloads[0].ptype == 'script' else 'exp'
self._save(self.payloads[0].content, '%s.%s' % (file_name, ext))
else:
for i in xrange(len(self.payloads)):
ext = 'py' if self.payloads[0].ptype == 'script' else 'exp'
self._save(self.payloads[i].content,
'%s-%d.%s' % (file_name, i, ext))
def __init__(actions,
self,
numTilings=1,
parameters=2,
rlAlpha=0.5,
rlLambda=0.9,
rlGamma=0.9,
rlEpsilon=0.1,
cTableSize=0,
action_selection='softmax'):
""" If you want to run an example of the code, simply just leave the parameters blank and it'll automatically set based on the parameters. """
self.numTilings = numTilings
self.tileWidths = list()
self.parameters = parameters
self.rlAlpha = rlAlpha
self.rlLambda = rlLambda
self.rlGamma = rlGamma
self.rlEpsilon = rlEpsilon
self.action_selection = action_selection
self.lastS = None
self.lastQ = None
self.lastPrediction = None
self.lastReward = None
self.lastAction = None
self.currentAction = None
self.actions = actions # an array of actions which we can select from
self.traceH = TraceHolder((self.numTilings**(self.parameters) + 1),
self.rlLambda, 1000)
self.F = [[0 for item in range(self.numTilings)]
for i in range(actions)
] # the indices of the returned tiles will go in here
self.q_vals = [0 for i in range(actions)]
for action in actions:
self.q.append(action, [
0
for item in range((self.numTilings**(self.parameters + 1)) + 1)
]) # action and weight vec
self.cTable = CollisionTable(cTableSize, 'safe') # look into this...
self.verifier = Verifier(self.rlGamma)
class VerifiedTxDb(BaseTxDb):
def __init__(self, model, config):
super(VerifiedTxDb, self).__init__(model, config)
self.verifier = Verifier(self.model.get_blockchain_state())
self.confirmed_txs = set()
def identify_tx_status(self, txhash):
if txhash in self.confirmed_txs:
return TX_STATUS_CONFIRMED
try:
verified = self.verifier.verify_merkle(txhash)
except HTTPError:
verified = False
if verified:
confirmations = self.verifier.get_confirmations(txhash)
if confirmations == 0:
return TX_STATUS_UNCONFIRMED
else:
self.confirmed_txs.add(txhash)
return TX_STATUS_CONFIRMED
else:
return TX_STATUS_INVALID
class VerifiedTxDb(BaseTxDb):
def __init__(self, model, config):
super(VerifiedTxDb, self).__init__(model, config)
self.verifier = Verifier(self.model.get_blockchain_state())
self.confirmed_txs = set()
def identify_tx_status(self, txhash):
if txhash in self.confirmed_txs:
return TX_STATUS_CONFIRMED
try:
verified = self.verifier.verify_merkle(txhash)
except HTTPError:
verified = False
if verified:
confirmations = self.verifier.get_confirmations(txhash)
if confirmations == 0:
return TX_STATUS_UNCONFIRMED
else:
self.confirmed_txs.add(txhash)
return TX_STATUS_CONFIRMED
else:
return TX_STATUS_INVALID
def main():
print("Programa desarrollado en Python 3.7 por:")
print("David Armando Rodríguez Varón - 20181020041")
print("Juan Sebastián Sánchez Tabares - 20181020008")
print("")
print("Bienvenido al verificador de expresiones lógicas.")
print(
"Este programa realiza la verificación de si una expresión lógica se encuentra bien escrita."
)
print("Para lo cual debe tener en cuenta lo siguiente:")
print(
"1. No debe utilizar los siguientes paréntesis para encerrar '{' '}'")
print("2. De igual forma tampoco los siguientes '[' ']'")
print("3. Por ende únicamente es válido el uso de los paréntesis. '(' ')'")
print("4. Como ejemplo de la manera en la que debe escribir la expresión:")
print("((p and q) then (q iff (r or not s)))")
print(
"5. Como se puede observar todo va entre parentesis de forma ordenada."
)
print(
"6. No son considerados válidos los espacios antes o despues de los paréntesis."
)
print(
"Si se incumple cualquiera de las condiciones anteriores se considerará como una expresión no válida."
)
print("")
print("EMPECEMOS")
print("Ingrese la expresión lógica a ser verificada:")
expr = input()
ver = Verifier()
valid, chars, variables, conds = ver.evaluate(expr)
if valid == True:
print("La expresión es válida")
print("Los términos son: \n{}".format(chars))
print("Las variables usadas son: ", variables)
print("Los condicionales usados son: ", conds)
else:
print("La expresión NO es válida")
def test_zip_verifier(self):
token = AccessToken.objects.get(id=4)
zipName = Download.objects.get(tokenID=token).folder
v = Verifier(token)
v.createZIPtoVerify()
#now the DB should be updated
dUp = Download.objects.get(tokenID=token)
self.assertTrue(dUp.verificationZIP)
#now create the same zip and verify the signatures
tempZip = os.path.join(settings.VERIFIED_ZIP, zipName + ".zip.test")
newVerifier = Verifier(token)
newVerifier.createZIP(".zip.test")
# add path for crypto
cryptoPath = os.path.join(os.path.dirname(settings.BASE_DIR), "finder")
if not cryptoPath in sys.path:
sys.path.insert(1, cryptoPath)
del cryptoPath
import crypto
#verify the signature
h = crypto.sha256File(tempZip)
res = crypto.verifyRSAsignatureSHA256(h, dUp.verificationZIPSignature,
settings.PUB_KEY)
self.assertTrue(res)
#generate a timestamp request
v.createTimestampRequest()
requestCreated = os.path.isfile(
os.path.join(settings.VERIFIED_ZIP, dUp.folder + ".tsrequest"))
self.assertTrue(requestCreated)
def __init__(self, *args, **kwargs):
super(Multijet, self).__init__(*args, **kwargs)
self.dp = None
'''
the verifiers is a thread dict of cpid=>verify_thread
'''
self.verifiers = {}
# f = FlowServer()
# f.start()
t = TriggerServer(self.on_trigger)
t.start()
self.msg_buf = {}
'''
add more cps here to start multi verify threads
'''
self.cps = [100]
self.queue = Queue()
for cp in self.cps:
verifier = Verifier(int(cp), queue=self.queue)
self.verifiers[int(cp)] = verifier
verifier.start()
def set_up_scene():
global simulation
gui.clear_scene()
gui.textEdits[0].clear()
s = gui.get_field(0)
scene = read_scene.read_scene(s)
verifier = Verifier(*scene)
gui_robots = []
gui_objectives = []
gui_obstacles = []
points = []
draw_grid(100)
blue = Color("blue")
colors = list(blue.range_to(Color("red"), len(scene[0])))
colors = [QColor(color.get_hex()) for color in colors]
for i, robot in enumerate(scene[0]):
color = colors[i % len(colors)]
gui_robots.append(
gui.add_polygon(unit_square(robot),
line_color=QtCore.Qt.transparent,
fill_color=color))
points.append(tuple(robot))
for obstacle in scene[2]:
color = QtCore.Qt.gray
gui_obstacles.append(
gui.add_polygon(unit_square(obstacle),
line_color=QtCore.Qt.transparent,
fill_color=color))
points.append(tuple(obstacle))
for i, objective in enumerate(scene[1]):
color = colors[i % len(colors)]
gui_objectives.append(
gui.add_polygon(unit_square(objective),
line_color=QColor(color),
fill_color=QtCore.Qt.transparent))
points.append(tuple(objective))
simulation = Simulation(gui_robots, gui_objectives, gui_obstacles,
verifier)
center = bounding_rect_center(points)
gui.graphicsView.translate(center[0], center[1])
gui.graphicsView.centerOn(center[0], center[1])
def __init__(self, numTilings = 1, parameters = 2, rlAlpha = 0.5, rlLambda = 0.9, rlGamma = 0.9, cTableSize=0):
""" If you want to run an example of the code, simply just leave the parameters blank and it'll automatically set based on the parameters. """
self.numTilings = numTilings
self.tileWidths = list()
self.parameters = parameters
self.rlAlpha = rlAlpha
self.rlLambda = rlLambda
self.rlGamma = rlGamma
self.prediction = None
self.lastS = None
self.lastQ = None
self.lastPrediction = None
self.lastReward = None
self.traceH = TraceHolder((self.numTilings**(self.parameters)+1), self.rlLambda, 1000)
self.F = [0 for item in range(self.numTilings)] # the indices of the returned tiles will go in here
self.theta = [0 for item in range((self.numTilings**(self.parameters+1))+1)] # weight vector.
self.cTable = CollisionTable(cTableSize, 'safe') # look into this...
self.verifier = Verifier(self.rlGamma)
def __init__(self, numTilings = 2, num_bins = 2, rlAlpha = 0.5, rlLambda = 0.9, rlGamma = 0.9, cTableSize=0):
self.numTilings = numTilings
self.tileWidths = list()
self.num_bins = num_bins
self.rlAlpha = rlAlpha
self.rlLambda = rlLambda
self.rlGamma = rlGamma
self.prediction = None
self.lastS = None
self.lastQ = None
self.lastPrediction = None
self.lastReward = None
self.F = [0 for item in range(self.numTilings)]
self.F2 = [0 for item in range(self.numTilings)]
self.theta = [0 for item in range((self.numTilings**(self.num_bins+1))+1)]
self.cTable = CollisionTable(cTableSize, 'safe')
self.update(None, None)
self.e = [0 for item in range((self.numTilings**(self.num_bins+1))+1)]
self.verifier = Verifier(self.rlGamma)
def test_verifier(self):
verifier = Verifier(self.crs)
self.assertEqual(verifier.verify(self.ciphertexts, self.proof),
(True, True, True))
prevshuffle = self.proof['shuffled_ciphertexts']
g1 = self.crs.lff.gen1()
g2 = self.crs.lff.gen2()
self.proof['shuffled_ciphertexts'][3] = ((g1, g1, g1), (g2, g2, g2))
self.assertEqual(verifier.verify(self.ciphertexts, self.proof),
(True, False, False))
self.proof['shuffled_ciphertexts'] = prevshuffle
self.crs.g1alpha = self.crs.g1alpha * 2
verifier = Verifier(self.crs)
self.assertEqual(verifier.verify(self.ciphertexts, self.proof),
(False, False, False))
def test_zip_verifier(self):
token = AccessToken.objects.get(id=4)
zipName = Download.objects.get(tokenID=token).folder
v = Verifier(token)
v.createZIPtoVerify()
#now the DB should be updated
dUp = Download.objects.get(tokenID=token)
self.assertTrue(dUp.verificationZIP)
#now create the same zip and verify the signatures
tempZip = os.path.join(settings.VERIFIED_ZIP,zipName+".zip.test")
newVerifier = Verifier(token)
newVerifier.createZIP(".zip.test")
# add path for crypto
cryptoPath = os.path.join(os.path.dirname(settings.BASE_DIR), "finder")
if not cryptoPath in sys.path:
sys.path.insert(1, cryptoPath)
del cryptoPath
import crypto
#verify the signature
h = crypto.sha256File(tempZip)
res = crypto.verifyRSAsignatureSHA256(h,dUp.verificationZIPSignature,settings.PUB_KEY)
self.assertTrue(res)
#generate a timestamp request
v.createTimestampRequest()
requestCreated = os.path.isfile(os.path.join(settings.VERIFIED_ZIP,dUp.folder+".tsrequest"))
self.assertTrue(requestCreated)
def create_app():
app = Flask(__name__, instance_relative_config=True)
app.config.from_pyfile(os.path.join(os.path.dirname(__file__),
'config.py'),
silent=False)
JWTManager(app)
CORS(app)
import auth
import student
import teacher
import admin
app.extensions['student_reset_password_verifier'] = Verifier(
'Ось код для відновлення паролю:', 'Відновлення паролю')
app.extensions['teacher_reset_password_verifier'] = Verifier(
'Ось код для відновлення паролю:', 'Відновлення паролю')
app.extensions['student_account_changes_verifier'] = Verifier(
'Ось код для підтвердження змін данних аккаунту:',
'Підтвердження змін')
app.extensions['teacher_account_changes_verifier'] = Verifier(
'Ось код для підтвердження змін данних аккаунту:',
'Підтвердження змін')
app.extensions['teacher_email_verifier'] = Verifier(
'Ось код для підтвердження електронної пошти:', 'Підтвердження пошти')
app.extensions['student_email_verifier'] = Verifier(
'Ось код для підтвердження електронної пошти:', 'Підтвердження пошти')
@app.errorhandler(HTTPException)
def handle_exception(e):
return jsonify({
"code": e.code,
"name": e.name,
"description": e.description,
}), e.code
app.register_blueprint(auth.bp, url_prefix="/api/auth")
app.register_blueprint(student.bp, url_prefix="/api/student")
app.register_blueprint(teacher.bp, url_prefix="/api/teacher")
app.register_blueprint(admin.bp, url_prefix="/api/admin")
return app
def verify_backup(self, host, dir_to_verify, logger):
verifier_obj = Verifier(host=host, dir_to_verify=dir_to_verify,
logger=logger)
verifier_obj.setup()
return verifier_obj.verify()
def check_errors(file):
verifier = Verifier()
errors = verifier.check_errors(file)
return errors
def __init__(this, use_weights = True): Verifier.__init__(this) this.LoadData(use_weights)
class Q_learning(Learner):
def __init__(actions, self, numTilings = 1, parameters = 2,rlAlpha = 0.5, rlLambda = 0.9,
rlGamma = 0.9, rlEpsilon = 0.1, cTableSize=0, action_selection = 'softmax'):
""" If you want to run an example of the code, simply just leave the parameters blank and it'll automatically set based on the parameters. """
self.numTilings = numTilings
self.tileWidths = list()
self.parameters = parameters
self.rlAlpha = rlAlpha
self.rlLambda = rlLambda
self.rlGamma = rlGamma
self.rlEpsilon = rlEpsilon
self.action_selection = action_selection
self.lastS = None
self.lastQ = None
self.lastPrediction = None
self.lastReward = None
self.lastAction = None
self.currentAction = None
self.actions = actions # an array of actions which we can select from
self.traceH = TraceHolder((self.numTilings**(self.parameters)+1), self.rlLambda, 1000)
self.F = [[0 for item in range(self.numTilings)] for i in range(actions)] # the indices of the returned tiles will go in here
self.q_vals = [0 for i in range(actions)]
for action in actions:
self.q.append(action,[0 for item in range((self.numTilings**(self.parameters+1))+1)]) # action and weight vec
self.cTable = CollisionTable(cTableSize, 'safe') # look into this...
self.verifier = Verifier(self.rlGamma)
def chooseAction(self, features):
for action in range(self.actions):
self.loadFeatures(featureVector=self.F[action], stateVars=features)
self.q_vals[action] = self.computeQ(action)
return self.eGreedy()
def eGreedy(self):
if random.random() < self.rlEpsilon:
return random.randrange(self.actions) # random action
else:
max_index, max_value = max(enumerate(self.q_vals), key=operator.itemgetter(1))
return max_index # best action
def update(self, features, target=None):
# learning step
if features != None:
self.learn(features, target, self.currentAction)
self.lastAction = self.currentAction
self.currentAction = self.chooseAction(features)
# action selection step
return self.currentAction
def learn(self, features, reward, action):
self.loadFeatures(features, self.F)
currentq = self.computeQ(action)
if self.lastS != None and self.lastAction != None: # if we're past the first step
delta = reward - self.lastQ
delta += self.rlGamma * currentq
amt = delta * (self.rlAlpha / self.numTilings)
for i in self.traceH.getTraceIndices():
self.theta[i] += amt * self.traceH.getTrace(i)
max_action, max_value = max(enumerate(self.q_vals), key=operator.itemgetter(1))
if action == max_action:
self.traceH.decayTraces(self.rlGamma*self.rlLambda)
else:
self.traceH.decayTraces(0)
self.traceH.replaceTraces(self.F[action])
self.lastQ = currentq
self.lastS = features
self.num_steps+=1
self.verifier.updateReward(reward)
self.verifier.updatePrediction(self.prediction)
def loadFeatures (self, stateVars, featureVector):
loadtiles(featureVector, 0, self.numTilings, self.numTilings**(self.parameters), stateVars)
print "featureVector " + str(len(self.theta))
"""
As provided in Rich's explanation
tiles ; a provided array for the tile indices to go into
starting-element ; first element of "tiles" to be changed (typically 0)
num-tilings ; the number of tilings desired
memory-size ; the number of possible tile indices
floats ; a list of real values making up the input vector
ints) ; list of optional inputs to get different hashings
"""
def computeQ (self, a):
"compute value of action for current F and theta"
q = 0
for i in self.F[a]:
q += self.theta[i]
return q
class TDLambdaLearner(Learner):
"""
Note: the TileCoder is Rich's Python version, which is still in Alpha.
See more at: http://webdocs.cs.ualberta.ca/~sutton/tiles2.html#Python%20Versions
Collision Table notes:
cTableSize is the size that the collision table will be instantiated to. The size must be a power of two.
In calls for get tiles, the collision table is used in stead of memory_size, as it already has it.
"""
def __init__(self, numTilings = 1, parameters = 2, rlAlpha = 0.5, rlLambda = 0.9, rlGamma = 0.9, cTableSize=0):
""" If you want to run an example of the code, simply just leave the parameters blank and it'll automatically set based on the parameters. """
self.numTilings = numTilings
self.tileWidths = list()
self.parameters = parameters
self.rlAlpha = rlAlpha
self.rlLambda = rlLambda
self.rlGamma = rlGamma
self.prediction = None
self.lastS = None
self.lastQ = None
self.lastPrediction = None
self.lastReward = None
self.traceH = TraceHolder((self.numTilings**(self.parameters)+1), self.rlLambda, 1000)
self.F = [0 for item in range(self.numTilings)] # the indices of the returned tiles will go in here
self.theta = [0 for item in range((self.numTilings**(self.parameters+1))+1)] # weight vector.
self.cTable = CollisionTable(cTableSize, 'safe') # look into this...
self.verifier = Verifier(self.rlGamma)
def update(self, features, target=None):
if features != None:
self.learn(features, target)
return self.prediction
else: return None
def learn(self, state, reward):
self.loadFeatures(state, self.F)
currentq = self.computeQ()
if self.lastS != None:
delta = reward - self.lastQ
delta += self.rlGamma * currentq
amt = delta * (self.rlAlpha / self.numTilings)
for i in self.traceH.getTraceIndices():
self.theta[i] += amt * self.traceH.getTrace(i)
self.traceH.decayTraces(self.rlGamma)
self.traceH.replaceTraces(self.F)
self.lastQ = currentq
self.lastS = state
self.prediction = currentq
self.num_steps+=1
self.verifier.updateReward(reward)
self.verifier.updatePrediction(self.prediction)
def computeQ(self):
q = 0
for i in self.F:
q += self.theta[i]
return q
def loadFeatures(self, stateVars, featureVector):
loadtiles(featureVector, 0, self.numTilings, self.numTilings**(self.parameters), stateVars)
print "featureVector " + str(len(self.theta))
"""
As provided in Rich's explanation
tiles ; a provided array for the tile indices to go into
starting-element ; first element of "tiles" to be changed (typically 0)
num-tilings ; the number of tilings desired
memory-size ; the number of possible tile indices
floats ; a list of real values making up the input vector
ints) ; list of optional inputs to get different hashings
"""
def loss(self, x, r, prev_state=None):
"""
Returns the TD error assuming reward r given for
transition from prev_state to x
If prev_state is None will use leftmost element in exp_queue
"""
if prev_state is None:
if len(self.exp_queue) < self.horizon:
return None
else:
prev_state = self.exp_queue[0][0]
vp = r + self.gamma * self.value(x)
v = self.value(prev_state)
delta = vp - v
return delta
def predict (self,x):
self.loadFeatures(x, self.F)
return self.computeQ()
def __init__(self, model, config):
super(VerifiedTxDb, self).__init__(model, config)
self.verifier = Verifier(self.model.get_blockchain_state())
self.confirmed_txs = set()
class Trainer(object):
"""Training pipline"""
def __init__(self, data_loader, config, val_loader):
# Data loader
self.data_loader = data_loader
self.verifier = Verifier(val_loader, config)
# Model hyper-parameters
self.imsize = config.imsize
self.parallel = config.parallel
self.arch = config.arch
# tensorboard
self.writer = SummaryWriter('runs/training' + '_' + self.arch)
self.epochs = config.epochs
self.batch_size = config.batch_size
self.num_workers = config.num_workers
self.total_iters = self.epochs * len(self.data_loader)
self.classes = config.classes
self.g_lr = config.g_lr
self.momentum = config.momentum
self.weight_decay = config.weight_decay
self.pretrained_model = config.pretrained_model # int type
self.indicator = False if self.pretrained_model > 0 else True
self.img_path = config.img_path
self.label_path = config.label_path
self.model_save_path = config.model_save_path
self.sample_path = config.sample_path
self.sample_step = config.sample_step
self.tb_step = config.tb_step
# Path
self.sample_path = osp.join(config.sample_path, self.arch)
self.model_save_path = osp.join(config.model_save_path, self.arch)
self.build_model()
# Start with trained model
if self.pretrained_model:
self.load_pretrained_model()
self.lr_scheduler = WarmupPolyLR(
self.g_optimizer, max_iters=self.total_iters, power=0.9,
warmup_factor=1.0 / 3, warmup_iters=500,
warmup_method='linear')
def train(self):
if self.pretrained_model:
start = self.pretrained_model + 1
else:
start = 0
criterion = CriterionAll()
criterion.cuda()
best_miou = 0
# Data iterator
for epoch in range(start, self.epochs):
self.G.train()
for i_iter, batch in enumerate(self.data_loader):
i_iter += len(self.data_loader) * epoch
# lr = adjust_learning_rate(self.g_lr,
# self.g_optimizer, i_iter, self.total_iters)
imgs, labels, edges = batch
size = labels.size()
imgs = imgs.cuda()
labels = labels.cuda()
if self.arch in __BA__:
edges = edges.cuda()
preds = self.G(imgs)
c_loss = criterion(preds, [labels, edges])
labels_predict = preds[0][-1]
else:
labels_predict = self.G(imgs)
c_loss = cross_entropy2d(
labels_predict, labels.long(), reduction='mean')
self.reset_grad()
c_loss.backward()
# Note：这里为了简便没有对优化器进行参数断点记录！！！
self.g_optimizer.step()
self.lr_scheduler.step(epoch=None)
# info on tensorboard
if (i_iter + 1) % self.tb_step == 0:
# scalr info on tensorboard
self.writer.add_scalar(
'cross_entrophy_loss', c_loss.data, i_iter)
self.writer.add_scalar(
'learning_rate', self.g_optimizer.param_groups[0]['lr'], i_iter)
# image info on tensorboard
labels = labels[:, :, :].view(size[0], 1, size[1], size[2])
oneHot_size = (size[0], self.classes, size[1], size[2])
labels_real = torch.cuda.FloatTensor(torch.Size(oneHot_size)).zero_()
labels_real = labels_real.scatter_(1, labels.data.long().cuda(), 1.0)
label_batch_predict = generate_label(labels_predict, self.imsize)
label_batch_real = generate_label(labels_real, self.imsize)
img_combine = imgs[0]
real_combine = label_batch_real[0]
predict_combine = label_batch_predict[0]
for i in range(1, self.batch_size):
img_combine = torch.cat([img_combine, imgs[i]], 2)
real_combine = torch.cat([real_combine, label_batch_real[i]], 2)
predict_combine = torch.cat([predict_combine, label_batch_predict[i]], 2)
all_combine = torch.cat([denorm(img_combine.cpu().data), real_combine, predict_combine], 1)
self.writer.add_image('imresult/img-gt-pred', all_combine, i_iter)
# self.writer.add_image('imresult/img', (img_combine.data + 1) / 2.0, i_iter)
# self.writer.add_image('imresult/real', real_combine, i_iter)
# self.writer.add_image('imresult/predict', predict_combine, i_iter)
# Sample images in folder
if (i_iter + 1) % self.sample_step == 0:
# labels_sample = generate_label(labels_predict, self.imsize)
compare_predict_color = generate_compare_results(imgs, labels_real, labels_predict, self.imsize)
# save_image((labels_sample.data), osp.join(self.sample_path, '{}_predict.png'.format(i_iter + 1)))
save_image((compare_predict_color.data), osp.join(self.sample_path, '{}_predict.png'.format(i_iter + 1)))
print('Train iter={} of {} completed, loss={}'.format(
i_iter, self.total_iters, c_loss.data))
print('----- Train epoch={} of {} completed -----'.format(epoch+1, self.epochs))
# miou = self.verifier.validation(self.G)
score = self.verifier.validation(self.G)
# oacc = score["Overall Acc: \t"]
miou = score["Mean IoU : \t"]
print("----------------- Total Performance --------------------")
for k, v in score.items():
print(k, v)
print("---------------------------------------------------")
if miou > best_miou:
best_miou = miou
torch.save(self.G.state_dict(), osp.join(
self.model_save_path, '{}_{}_G.pth'.format(str(epoch), str(round(best_miou, 4)))))
def build_model(self):
self.G = get_model(self.arch, pretrained=self.indicator).cuda()
if self.parallel:
self.G = nn.DataParallel(self.G)
# Loss and optimizer
self.g_optimizer = torch.optim.SGD(filter(
lambda p: p.requires_grad, self.G.parameters()), self.g_lr, self.momentum, self.weight_decay)
def load_pretrained_model(self):
self.G.load_state_dict(torch.load(osp.join(
self.model_save_path, '{}_G.pth'.format(self.pretrained_model))))
print('Loaded trained models (step: {})...!'.format(self.pretrained_model))
def reset_grad(self):
self.g_optimizer.zero_grad()
def setUp(self):
self.verifier = Verifier(MODEL_PATH, ARCHITECTURE, MODEL_WEIGHTS)
def test_verify_timestamp(self): v = Verifier(None) v.tsRequest = os.path.join(settings.VERIFIED_ZIP,"1679091c5a880faf6fb5e6087eb1b2dc.tsrequest") v.tsResponse = os.path.join(settings.VERIFIED_ZIP,"1679091c5a880faf6fb5e6087eb1b2dc.p7s") self.assertTrue(v.verifyTimestamp())
def create_verifier():
verifier = Verifier(config.VERIFICATION_MAX_SAMPLES, config.VERIFICATION_MODEL_URI, False, False, False)
return verifier
class True_Online_TD2(TDLambdaLearner):
"""
True online TD implementation
* Has Dutch traces
"""
def __init__(self, numTilings = 2, num_bins = 2, rlAlpha = 0.5, rlLambda = 0.9, rlGamma = 0.9, cTableSize=0):
self.numTilings = numTilings
self.tileWidths = list()
self.num_bins = num_bins
self.rlAlpha = rlAlpha
self.rlLambda = rlLambda
self.rlGamma = rlGamma
self.prediction = None
self.lastS = None
self.lastQ = None
self.lastPrediction = None
self.lastReward = None
self.F = [0 for item in range(self.numTilings)]
self.F2 = [0 for item in range(self.numTilings)]
self.theta = [0 for item in range((self.numTilings**(self.num_bins+1))+1)]
self.cTable = CollisionTable(cTableSize, 'safe')
self.update(None, None)
self.e = [0 for item in range((self.numTilings**(self.num_bins+1))+1)]
self.verifier = Verifier(self.rlGamma)
def update(self, features, target=None):
if features != None:
self.learn(features, target)
return self.prediction
else: return None
def learn(self, state, reward):
self.loadFeatures(state, self.F)
self.currentq = 0
for i in self.F: # create V(s)
self.currentq += self.theta[i]
if self.lastS != None:
delta = reward + self.rlGamma * self.currentq - self.lastQ # create delta
self.loadFeatures(self.lastS, self.F2)
lastQ_2 = 0
for i in self.F2:
lastQ_2 += self.theta[i] # create new
for i in range(len(self.e)):
self.e[i] *= self.rlGamma*self.rlGamma
ephi = 0
for i in self.F2:
ephi += self.e[i]
for i in self.F2:
self.e[i] += self.rlAlpha*(1-self.rlGamma*self.rlLambda*ephi)
for i in self.F2:
self.theta[i] += self.rlAlpha*(self.lastQ - lastQ_2)
for i in range(len(self.theta)):
self.theta[i] += delta*self.e[i]
self.lastQ = self.currentq
self.lastS = state
self.prediction = self.currentq
self.num_steps+=1
self.verifier.updateReward(reward)
self.verifier.updatePrediction(self.prediction)
parser.add_argument("--infile", default="in.csv", help="csv file to calculate diff features.")
parser.add_argument("--calctype", default=0, type=int, help="csv file to calculate diff features.")
args = parser.parse_args()
#infile = args.infile
infile = "data/test_data.csv"
srcdir = args.srcdir
renddir = args.renddir
calctype = args.calctype
#calctype: 0-difffeture 1-accuracy 2-negative(skip or zero)
max_samples = 10
debug = False
logcount = 0
#'http://storage.googleapis.com/verification-models/verification-metamodel-fps2.tar.xz'
verifier = Verifier(10, 'http://storage.googleapis.com/verification-models/verification-metamodel-2020-07-06.tar.xz', False, False, debug)
outcsv = "accuracy" + datetime.datetime.now().strftime("%m%d%H%M%S") + ".csv"
fileout = open(outcsv, 'w', newline='')
wr = csv.writer(fileout)
wr.writerow(['source', 'rendition', 'infertarget'])
with open(infile, newline='') as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
if row['target'] == '0':
wrow = []
srcfile = srcdir + "/" + row['source']
rendfile = renddir + "/" + row['id']
result = verifier.verify(srcfile, [{'uri': rendfile}])
wrow.append(row['id'])
class TDLambdaLearner(Learner):
"""
Note: the TileCoder is Rich's Python version, which is still in Alpha.
See more at: http://webdocs.cs.ualberta.ca/~sutton/tiles2.html#Python%20Versions
Collision Table notes:
cTableSize is the size that the collision table will be instantiated to. The size must be a power of two.
In calls for get tiles, the collision table is used in stead of memory_size, as it already has it.
"""
def __init__(self, numTilings = 1, num_bins = 2, rlAlpha = 0.5, rlLambda = 0.9, rlGamma = 0.9, cTableSize=0):
""" If you want to run an example of the code, simply just leave the parameters blank and it'll automatically set based on the parameters. """
self.numTilings = numTilings
self.num_bins = num_bins
self.rlAlpha = rlAlpha
self.rlLambda = rlLambda
self.rlGamma = rlGamma
self.mem_size = 1048576 # 16,384 or 8,192 or 1,048,576 or 8,388,608 or 16,777,216 or 33,554,432
self.prediction = None
self.current_prediction = 0
self.delta = 0
self.lastS = None
self.previous_tiles = [0 for item in range(self.numTilings)]
# self.previous_state = [None for item in range(self.numTilings*(self.num_bins)**10)]
self.previous_prediction = None
self.lastQ = None
self.lastPrediction = None
self.lastReward = None
self.traceH = TraceHolder(self.mem_size, 0.01, 1000) # TraceHolder(mem, minT, maxN)
self.F = [0 for item in range(self.numTilings)] # the indices of the returned tiles will go in here
self.theta = [0 for item in range(self.mem_size)] # weight vector.
# self.weights = [0 for item in range(self.numTilings*(self.num_bins)**10)]
# self.e_trace = [0 for item in range(self.numTilings*(self.num_bins)**10)] # added by Ann
self.cTable = CollisionTable(cTableSize, 'super safe') # look into this...
# stats = self.cTable.stats()
# print stats
self.verifier = Verifier(self.rlGamma)
# def Ann_update(self, current_state, numstates, reward=None):
# if current_state != None:
# self.Ann_learn(current_state, reward, numstates)
# return self.current_prediction
# else:
# return None
#
# def Ann_learn(self, current_state, reward, numstates):
# active_tiles = simple_tiles(self.numTilings, self.numTilings*self.num_bins, current_state, numstates) # returns index of active features
# print "active tiles = " + str(active_tiles)
# print "previous tiles = " + str(self.previous_tiles)
# if self.previous_prediction != None:
# # self.current_prediction = 0
# for index in active_tiles:
# print 'index = ' + str(index)
# self.current_prediction = self.weights[index] # not sure if this is right
# # print 'weights[index] = ' + str(self.weights[index])
# self.delta = reward + self.rlGamma * self.current_prediction - self.previous_prediction
# print 'self.delta = ' + str(self.delta)
# if self.previous_state != None:
# self.previous_state = [0 for item in range(self.numTilings*(self.num_bins)**10)]
# for index in self.previous_tiles:
# self.previous_state[index] = 1
# # print 'previous state = ' + str(self.previous_state)
# self.e_trace = [x + y for x, y in zip(self.previous_state, [i * self.rlLambda * self.rlGamma for i in self.e_trace])]
# # print 'e_trace = ' + str(self.e_trace)
# self.weights = [x + y for x, y in zip(self.weights, [i * self.rlAlpha * self.delta for i in self.e_trace])] # alpha needs to be divided by N
# # print 'weights = ' + str(self.weights)
# self.previous_tiles = active_tiles
# self.previous_prediction = self.current_prediction
# print 'current prediction = ' + str(self.current_prediction)
# self.verifier.updateReward(reward)
# self.verifier.updatePrediction(self.current_prediction)
# self.normalized_prediction = self.current_prediction * (1-self.rlGamma)
# print 'normalized prediction = ' + str(self.normalized_prediction)
def update(self, features, target=None):
if features != None:
self.learn(features, target)
return self.prediction
else: return None
def learn(self, state, reward):
self.loadFeatures(state, self.F)
currentq = self.computeQ() # computeQ returns w*x' (current prediction)
if self.lastS != None:
# print 'reward = ' + str(reward)
delta = reward + self.rlGamma*currentq - self.lastQ # delta = r + gamma*w*x' - w*x
for i in self.traceH.getTraceIndices():
self.theta[i] += delta * (self.rlAlpha / self.numTilings) * self.traceH.getTrace(i) # delta * alpha/N * e
# print 'traces = ' + str(self.traceH.getTrace(i))
self.traceH.decayTraces(self.rlGamma)
self.traceH.replaceTraces(self.F)
# self.e_trace = min(rlLambda*self.e_trace + x, 1) # added by Ann
# print 'delta = ' + str(delta)
# print 'trace indices = ' + str(self.traceH.getTraceIndices())
# print 'theta' + str(self.theta)
# print 'self.F'+ str(self.F)
# print 'lastS' + str(self.lastS)
self.lastQ = currentq
self.lastS = state
self.prediction = currentq
self.num_steps+=1
self.verifier.updateReward(reward)
self.verifier.updatePrediction(self.prediction)
self.normalized_prediction = self.prediction * (1 - self.rlGamma)
def computeQ(self):
q = 0
for i in self.F:
q += self.theta[i]
return q
def loadFeatures(self, stateVars, featureVector):
# loadtiles(featureVector, 0, self.numTilings, self.num_bins, stateVars)
# active_tiles = loadtiles([0], 0, self.numTilings*self.num_bins, 1024, stateVars)
# buffer = [0] # array of length numtilings
# tiles(1,512,stateVars)
# active_tiles = loadtiles([0], 0, self.numTilings, self.num_bins, stateVars)
self.F = active_tiles = tiles(self.numTilings,self.mem_size,stateVars)
# print 'tiles = ' + str(active_tiles)
# active_tiles = simple_tiles(self.numTilings, self.numTilings*self.num_bins, stateVars)
# simple_tiles(self.numTilings, self.numTilings*self.num_bins, stateVars)
# print "featureVector " + str(len(self.theta))
# print 'active tiles = ' + str(active_tiles)
# print 'numTilings = ' + str(self.numTilings)
# print 'stateVars = ' + str(stateVars)
"""
As provided in Rich's explanation
tiles ; a provided array for the tile indices to go into
starting-element ; first element of "tiles" to be changed (typically 0)
num-tilings ; the number of tilings desired
memory-size ; the number of possible tile indices
floats ; a list of real values making up the input vector
ints) ; list of optional inputs to get different hashings
"""
def loss(self, x, r, prev_state=None):
"""
Returns the TD error assuming reward r given for
transition from prev_state to x
If prev_state is None will use leftmost element in exp_queue
"""
if prev_state is None:
if len(self.exp_queue) < self.horizon:
return None
else:
prev_state = self.exp_queue[0][0]
vp = r + self.gamma * self.value(x)
v = self.value(prev_state)
delta = vp - v
return delta
def predict (self,x):
self.loadFeatures(x, self.F)
return self.computeQ()
def check_errors(file):
verifier = Verifier()
errors = verifier.check_errors(file)
return errors
