def __init__(self, freq, activation, input, target_idx, task_loss, surrogate_loss, hyperparameter, learning_rate, batch_generator, n_batches, factor=1.5, n_updates=10): Extension.__init__(self, 'adapt_zloss', freq) self.batch_generator = batch_generator self.n_batches = n_batches self.learning_rate = learning_rate self.hyperparameter = hyperparameter self.factor = factor self.n_updates = n_updates # grad = theano.grad(surrogate_loss, activation) # new_activation = activation - learning_rate * grad self.fun_activation = theano.function([input], activation) activation_bis = tensor.matrix() surr_loss_bis = theano.clone(surrogate_loss, replace={activation: activation_bis}) grad = theano.grad(surr_loss_bis, activation_bis) new_activation = activation_bis - 100*learning_rate * grad task_loss_bis = theano.clone(task_loss, replace={activation: new_activation}) self.fun_update_task_loss = theano.function( [activation_bis, target_idx], [task_loss_bis, new_activation])
def __init__(self, freq, words, embedding_matrix, knn, vocab, inv_vocab): Extension.__init__(self, 'Nearest neighbours of words', freq) self.words = words self.embedding_matrix = embedding_matrix self.knn = knn self.vocab = vocab self.inv_vocab = inv_vocab self.word_ids = [] for word in words: self.word_ids.append(self.vocab[word])
def __init__(self, freq, activation, input, target_idx, task_loss, surrogate_loss, hyperparameter, learning_rate, batch_generator, n_batches, factor=1.5, n_updates=10): Extension.__init__(self, 'adapt_zloss', freq) self.batch_generator = batch_generator self.n_batches = n_batches self.learning_rate = learning_rate self.hyperparameter = hyperparameter self.factor = factor self.n_updates = n_updates # grad = theano.grad(surrogate_loss, activation) # new_activation = activation - learning_rate * grad self.fun_activation = theano.function([input], activation) activation_bis = tensor.matrix() surr_loss_bis = theano.clone(surrogate_loss, replace={activation: activation_bis}) grad = theano.grad(surr_loss_bis, activation_bis) new_activation = activation_bis - 100 * learning_rate * grad task_loss_bis = theano.clone(task_loss, replace={activation: new_activation}) self.fun_update_task_loss = theano.function( [activation_bis, target_idx], [task_loss_bis, new_activation])
def server_hello(self): record_bytes, hello_bytes = self.read(return_record=True) assert record_bytes[:1] == constants.CONTENT_TYPE_HANDSHAKE, 'Server return {}'.format( print_hex(record_bytes[:1])) self.messages.append(hello_bytes) assert len(hello_bytes) > 0, 'No response from server' assert hello_bytes[:1] == b'\x02', 'Not server hello' tls_version = hello_bytes[4:6] assert tls_version == self.tls_version, 'Not a desired tls version' # Parse hello bytes self.server_random, hello_bytes = hello_bytes[6:6 + 32], hello_bytes[6 + 32:] session_id_length = int.from_bytes(hello_bytes[:1], 'big') session_id, hello_bytes = hello_bytes[:session_id_length + 1], hello_bytes[session_id_length + 1:] # This session_id can be reused for the session_id in the client Hello for the next request # Reusing a session_id results in no certificate sent after Server Hello server_cipher_suite, hello_bytes = hello_bytes[:2], hello_bytes[2:] compression_method, hello_bytes = hello_bytes[:1], hello_bytes[1:] extensions_length, hello_bytes = int.from_bytes(hello_bytes[:2], 'big'), hello_bytes[2:] extensions = hello_bytes[:extensions_length] self.extensions = Extension.parse_extensions(extensions) alpn = list(filter(lambda x: isinstance(x, ALPN), self.extensions)) self.http_version = alpn[0].protocols[0] if len(alpn) > 0 else constants.EXTENSION_ALPN_HTTP_1_1 assert self.http_version == constants.EXTENSION_ALPN_HTTP_1_1, 'Not support http2 yet' certificate_bytes = self.read() cached_cert_path = r'./debug/{}.crt'.format(self.host) if certificate_bytes[0] == 0x0B: self.messages.append(certificate_bytes) certificate_bytes = certificate_bytes[7:] os.path.exists(r'./debug') or os.makedirs(r'./debug') self.server_certificate = get_certificate(certificate_bytes, open(cached_cert_path, 'wb+'), match_hostname=self.match_hostname, host=self.host) next_bytes = self.read() elif os.path.exists(cached_cert_path): self.server_certificate = load(open(cached_cert_path, 'rb')) next_bytes = certificate_bytes else: raise ValueError('No certificate was received.') self.cipher_suite = CipherSuite.get_from_id(self.tls_version, self.client_random, self.server_random, self.server_certificate, server_cipher_suite) self.messages.append(next_bytes) self.is_server_key_exchange = next_bytes[:1] == b'\x0c' if self.is_server_key_exchange: # Server key exchange self.cipher_suite.parse_key_exchange_params(next_bytes) hello_done_bytes = self.read() self.messages.append(hello_done_bytes) elif self.session_id: # @todo handle sessions raise ValueError('No server key exchange has received. # @todo') self.debug_print('Cipher suite negotiated', ' {}({})'.format(self.cipher_suite, print_hex(server_cipher_suite))) self.debug_print('TLS version', self.tls_version) self.debug_print('Server random', print_hex(self.server_random)) self.debug_print('Key exchange', self.cipher_suite.key_exchange.__class__.__name__) self.debug_print('Server cert not before (UTC)', self.server_certificate.not_valid_before) self.debug_print('Server cert not after (UTC)', self.server_certificate.not_valid_after) self.debug_print('Server cert fingerprint (sha256)', print_hex(self.server_certificate.fingerprint(SHA256()))) if self.is_server_key_exchange: public_key = self.cipher_suite.key_exchange.public_key self.debug_print('Key Exchange Server Public Key ({!s} bytes)'.format(len(public_key)), print_hex(public_key))
import sys import os from extensions import Extension import re import importlib EXTENSION = Extension() def get_the_getters(given_list, getter='GET'): getters = [i for i, x in enumerate(given_list) if x == getter] for g in getters: print('getters: ', given_list[g], g, end=', ') if getters != []: for getter in getters: getter_var = getter + 1 getter_val = given_list[getter_var] value = getattr(EXTENSION, given_list[getter])(given_list[getter_var]) print('value: ', value) given_list[getter_var] = value del given_list[getter] # given_list = [value if given == getter_val else given for given in given_list] # print('pt', given_list) return given_list else: return given_list def remove_space_or_not(part): while part.startswith(' '):