code stringlengths 17 6.64M |
|---|
def tokenExtraction(window_size_list, data, mode):
'\n given data, extract the corresponing feature\n :param window_size_list: [list] define the window size of the n-grams\n :param data: [list] input data needs to be in a form of (tweet, tagging, ner) tuple\n :param mode: define how to extract feature... |
def convertFeature2Idx(actual_features, train_feature_dict):
'\n convert actual features into idx\n :param actual_features: real features extracted from tweets\n :param train_feature_dict: train_ngram_dict\n :return:\n '
features_idx = []
for line in actual_features:
curr_feature = ... |
def buildTrainDict(train_ngram_all, verbose=False, set_threshold=False, threshold=1):
'\n build up train ngram dictionary\n :param train_ngram_all: all extracted ngram features\n :param verbose:\n :param set_threshold: if we want to move ngrams with low frequency\n :param threshold: define low freq... |
def trainLRModel(train_all, train_label, window_size_list, ngram_extract_mode, flag, save_model=False):
'\n given cyber threat data with severe / non-severe label, train a LR classifier\n :param train_all: training data\n :param train_label: training label\n :param window_size_list: n-gram window size... |
def evalLRModel(window_size_list, val_all, train_ngram_dict, ngram_extract_mode, model):
'\n cyber threat existence classifier\n :param window_size_list: define feature extraction window size\n :param val_all: data to be tested\n :param ngram_extract_mode: how the features are extracted\n :return:\... |
def readTXTFile(path, verbose=False):
'\n TODO: It is not the best way of reading txt files\n\n :param path:\n :param verbose:\n :return:\n '
with open(path, 'r') as f:
data = f.readlines()
if verbose:
print('[I] file read complete with length', len(data))
return data
|
def readJSONFile(path, verbose=False):
with open(path, 'r') as f:
data = json.load(f)
if verbose:
print('[I] file read complete')
return data
|
def writeJSONFile(data, path, verbose=False):
with open(path, 'w') as f:
json.dump(data, f)
if verbose:
print(('[I] file written complete: ' + path))
|
def readTSVFile(path, verbose=False):
with open(path, 'r') as f:
data = [line.strip().split('\t') for line in f]
if verbose:
print('[I] file read complete with length', len(data))
return data
|
def readJSONLine(path, verbose=False):
input = readTXTFile(path)
data = []
for each_line in input:
each_line = each_line.strip()
each_line = json.loads(each_line)
data.append(each_line)
if verbose:
print('[I] file read complete')
return data
|
def writeJSONLine(path, data, verbose=False):
with open(path, 'w') as f:
for i in data:
json.dump(i, f)
f.write('\n')
if verbose:
print(('[I] file written complete: ' + path))
|
def taggingSeperate(line):
"\n split tagging results into [token], [tags] format\n :param data: results from tagging tools\n :return:\n\n EXAMPLE\n\n Input: james/B-person ball/I-person |/O citigroup/O incorporated/O |/O email/O vice/O president/O of/O web/O application/O vulnerability/O analysis/O... |
def getEntitySegClass(tweet, annot, lower=False, getIndices=True):
"\n get segments containing ENTITYs\n :param tweet: a specific tweet (NEED TO BE SPLITTED)\n :param annot: corresponding tags (NEED TO BE SPLITTED)\n :param lower:\n :param getIndices:\n :return: [segs]\n\n ATT: input should b... |
def replaceEntityTarget(ent_tuple, tweet, tag):
"\n replace ENTITY with TARGET\n :param ent: target words needed to be replaced\n :param tweet: tweet tokens (NEED TO BE SPLITTED)\n :param tag: corresponding tags (NEED TO BE SPLITTED)\n :return: tweet (target words marked as TARGET), tag (target wor... |
class CFGTrainer(object):
def __init__(self, node_init_dims, data_dir, device, log_file, best_model_file, args):
super(CFGTrainer, self).__init__()
self.max_epoch = args.epochs
self.batch_size = args.batch_size
self.lr = args.lr
self.device = device
self.log_file =... |
class GEDTrainer(object):
def __init__(self, data_dir, device, best_model_path, args, log_path):
super(GEDTrainer, self).__init__()
self.max_iterations = args.iterations
self.iter_val_start = args.iter_val_start
self.iter_val_every = args.iter_val_every
self.batch_size = a... |
class DenseGGNN(nn.Module):
def __init__(self, out_channels, num_layers=1):
super(DenseGGNN, self).__init__()
self.model = GatedGraphConv(out_channels=out_channels, num_layers=num_layers)
def forward(self, x, adj, **kwargs):
B = x.size()[0]
N = x.size()[1]
D = x.size(... |
class MultiLevelGraphMatchNetwork(torch.nn.Module):
def __init__(self, node_init_dims, arguments, device):
super(MultiLevelGraphMatchNetwork, self).__init__()
self.node_init_dims = node_init_dims
self.args = arguments
self.device = device
self.dropout = arguments.dropout
... |
def train(model, train_loader, val_loader, batch_size, criterion, optimizer, target_accr=None, err_margin=(0.01, 0.01), best_accr=(0, 0), topk=(1, 5), lr_decay=0.1, saved_epoch=0, log='train.csv', pname='model.pth'):
meters = {}
for i in topk:
meters[i] = AverageMeter()
with open(log, 'a') as f:
... |
def validate(model, batch_size, val_loader, topk=(1, 5), cuda=True):
meters = {}
for i in topk:
meters[i] = AverageMeter()
model.eval()
start = time.time()
num_data = (len(val_loader) * batch_size)
print('Validating on {} data'.format(num_data))
for (i, (input, target)) in enumerat... |
class AverageMeter(object):
'Computes and stores the average and current value'
def __init__(self):
self.reset()
def reset(self):
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
def update(self, val, n=1):
self.val = val
self.sum += (val... |
def accuracy(output, target, topk=(1,)):
'Computes the precision@k for the specified values of k'
maxk = max(topk)
batch_size = target.size(0)
(_, pred) = output.topk(maxk, 1, True, True)
pred = pred.t()
correct = pred.eq(target.view(1, (- 1)).expand_as(pred))
res = []
for k in topk:
... |
def gen_loaders(path, BATCH_SIZE, NUM_WORKERS):
traindir = os.path.join(path, 'train')
valdir = os.path.join(path, 'val')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
train_dataset = datasets.ImageFolder(traindir, transforms.Compose([transforms.RandomSizedCro... |
def main():
global args
args = parser.parse_args()
use_cp = (args.decomp == 'cp')
use_model = (args.model is not None)
use_param = (args.resume is not None)
use_state = (args.state is not None)
eval_mode = args.val
decomp_func = (torch_cp_decomp if use_cp else tucker_decomp)
if (ar... |
def tucker_rank(layer):
W = layer.weight.data
mode3 = tl.base.unfold(W, 0)
mode4 = tl.base.unfold(W, 1)
diag_0 = EVBMF(mode3)
diag_1 = EVBMF(mode4)
d1 = diag_0.shape[0]
d2 = diag_1.shape[1]
del mode3
del mode4
del diag_0
del diag_1
return [int((np.ceil((d1 / 16)) * 16))... |
def est_rank(layer):
W = layer.weight.data
mode3 = tl.base.unfold(W, 0)
mode4 = tl.base.unfold(W, 1)
diag_0 = EVBMF(mode3)
diag_1 = EVBMF(mode4)
return int((np.ceil((max([diag_0.shape[0], diag_1.shape[0]]) / 16)) * 16))
|
def decomp_alexnet(net, rank_func, decomp_func):
i = 1
while (i < len(net.features)):
layer_i = net.features[i]
if (not isinstance(layer_i, nn.Conv2d)):
i += 1
continue
layer_i = net.features[i]
rank = rank_func(layer_i)
print('rank of the {}th l... |
def decomp_resnet(net, rank_func, decomp_func):
mulfunc = (lambda x, y: (x * y))
for (n, m) in net.named_children():
num_children = sum((1 for i in m.children()))
if (num_children != 0):
layer = getattr(net, n)
for i in range(num_children):
bottleneck = ... |
def torch_cp_decomp(layer, rank):
W = layer.weight.data
(last, first, vertical, horizontal) = parafac(W, rank=rank, init='random')
pointwise_s_to_r_layer = nn.Conv2d(in_channels=first.shape[0], out_channels=first.shape[1], kernel_size=1, padding=0, bias=False)
depthwise_r_to_r_layer = nn.Conv2d(in_cha... |
def tucker_decomp(layer, rank):
W = layer.weight.data
(core, [last, first]) = partial_tucker(W, modes=[0, 1], ranks=rank, init='svd')
first_layer = nn.Conv2d(in_channels=first.shape[0], out_channels=first.shape[1], kernel_size=1, padding=0, bias=False)
core_layer = nn.Conv2d(in_channels=core.shape[1],... |
def get_gm(acc, cs, ppl):
return (((max(acc, 0) * max(cs, 0)) * max((1 / ppl), 0)) ** (1 / 3))
|
def tokenize(text, tags=False, lemmas=False):
processed = process_pipeline.process(text)
content = [l for l in processed.split('\n') if (not l.startswith('#'))]
tagged = [w.split('\t') for w in content if w]
tokens = []
for token in tagged:
if (token[3] == 'PUNCT'):
continue
... |
def get_sentence_vector(text):
tokens = tokenize(text, lemmas=True)
embd = [model[token] for token in tokens]
return np.mean(embd, axis=0).reshape(1, (- 1))
|
def get_cosine_sim(text1, text2):
try:
return cosine_similarity(get_sentence_vector(text1), get_sentence_vector(text2))
except:
return 0
|
def get_cosine_sim_corpus(original_sentences, transferred_sentences):
results = []
for index in tqdm(range(len(original_sentences))):
results.append(get_cosine_sim(original_sentences[index], transferred_sentences[index]))
return np.mean(results)
|
def get_word_overlap(text1, text2):
tokens1 = tokenize(text1, lemmas=True)
tokens2 = tokenize(text2, lemmas=True)
union = set((tokens1 + tokens2))
intersection = list((set(tokens1) & set(tokens2)))
return (len(intersection) / len(union))
|
def get_word_overlap_corpus(original_sentences, transferred_sentences):
results = []
for index in tqdm(range(len(original_sentences))):
results.append(get_word_overlap(original_sentences[index], transferred_sentences[index]))
return np.mean(results)
|
def get_bleu_corpus(original_sentences, transferred_sentences):
references = []
hypothesises = []
for sentence in original_sentences:
references.append([[sentence]])
for sentence in transferred_sentences:
hypothesises.append([sentence])
return corpus_bleu(references, hypothesises, ... |
def calc_bleu(inputs, preds):
bleu_sim = 0
counter = 0
print('Calculating BLEU similarity')
for i in range(len(inputs)):
if ((len(inputs[i]) > 3) and (len(preds[i]) > 3)):
bleu_sim += sentence_bleu([inputs[i]], preds[i])
counter += 1
return float((bleu_sim / counter... |
class Args():
def __init__(self):
self.model_type = 'gpt2'
self.model_name_or_path = 'sberbank-ai/rugpt2large'
self.prompt = ''
self.length = 50
self.stop_token = '</s>'
self.k = 5
self.p = 0.95
self.temperature = 1
self.repetition_penalty =... |
def get_gpt2_ppl_corpus(test_sentences):
args = Args()
args.model_name_or_path = 'sberbank-ai/rugpt2large'
(model_class, tokenizer_class) = MODEL_CLASSES[args.model_type]
tokenizer = tokenizer_class.from_pretrained(args.model_name_or_path)
model = model_class.from_pretrained(args.model_name_or_pat... |
def classify_preds(args, preds):
print('Calculating style of predictions')
results = []
tokenizer = BertTokenizer.from_pretrained('SkolkovoInstitute/russian_toxicity_classifier')
model = BertForSequenceClassification.from_pretrained('SkolkovoInstitute/russian_toxicity_classifier')
for i in tqdm.tq... |
class condBERT():
def __init__(self, device='cuda', from_pretrained=True):
def adjust_logits(logits):
return (logits - (token_toxicities * 100))
model_name = 'Geotrend/bert-base-ru-cased'
tokenizer_ru = BertTokenizer.from_pretrained(model_name)
model = BertForMaskedLM... |
def cosine(v1, v2):
return (np.dot(v1, v2) / np.sqrt(((sum((v1 ** 2)) * sum((v2 ** 2))) + 1e-10)))
|
class EmbeddingSimilarityChooser():
def __init__(self, sim_coef=100, tokenizer=None):
self.glove_embedding = WordEmbeddings('glove')
self.sim_coef = sim_coef
self.tokenizer = tokenizer
def embed(self, text):
toks = self.glove_embedding.embed(Sentence(text))[0]
return ... |
class RuEmbeddingSimilarityChooser():
def __init__(self, sim_coef=100, tokenizer=None):
self.glove_embedding = WordEmbeddings('glove')
self.sim_coef = sim_coef
self.tokenizer = tokenizer
def embed(self, text):
toks = self.glove_embedding.embed(Sentence(text))[0]
retur... |
def group_by_first_token(texts, tokenizer):
seqs = [tokenizer.encode(x, add_special_tokens=False) for x in texts]
grouped = defaultdict(list)
for seq in seqs:
grouped[seq[0]].append(seq)
return grouped
|
def default_chooser(hypotheses, original=None, **kwargs):
return hypotheses[0]
|
class CondBertRewriter():
def __init__(self, model, tokenizer, device, neg_words, pos_words, word2coef, token_toxicities, predictor=None):
self.model = model
self.tokenizer = tokenizer
self.device = device
self.neg_words = neg_words
self.pos_words = pos_words
self.... |
def bpe_tokenize(bpe_tokenizer, sentence):
sent_bpe_tokens = []
sent_bpe_offsets = []
for token in sentence:
token_bpes = bpe_tokenizer.tokenize(token.text)
sent_bpe_offsets += [(token.begin, token.end) for _ in range(len(token_bpes))]
sent_bpe_tokens += token_bpes
return (sent... |
def nlargest_indexes(arr, n_top):
arr_ids = np.argpartition(arr, (- n_top))[(- n_top):]
sel_arr = arr[arr_ids]
top_ids = arr_ids[np.argsort((- sel_arr))]
return top_ids
|
def remove_masked_token_subwords(masked_position, bpe_tokens, bpe_offsets):
'\n If the masked token has been tokenied into multiple subwords: like dieting-->diet and ##ing\n keep the first subword and remove others.\n '
logger.debug(f'bpe tokens: {bpe_tokens}')
logger.debug(f'bpe offsets: {bpe_of... |
def merge_sorted_results(objects_left, scores_left, objects_right, scores_right, max_elems):
result_objects = []
result_scores = []
j = 0
i = 0
while True:
if (len(result_scores) == max_elems):
break
if (i == len(scores_left)):
result_objects += objects_righ... |
class MaskedTokenPredictorBert():
def __init__(self, model, bpe_tokenizer, max_len=250, mask_in_multiunit=False, device=None, label=0, logits_postprocessor=None, contrast_penalty=0):
self._model = model
self._bpe_tokenizer = bpe_tokenizer
self._max_len = max_len
self._mask_in_mult... |
def get_masked_tokens_from_tagged_text(tagged_text):
chunks = tagged_text.split('__')
masks = []
curr_offset = 0
clean_text = ''
for (chunk_num, chunk) in enumerate(chunks):
if ((chunk_num % 2) == 1):
masks.append((curr_offset, (curr_offset + len(chunk))))
curr_offset +... |
def preprocess_tagged_text(t_text, ppl):
(masked_tokens, clean_text) = get_masked_tokens_from_tagged_text(t_text)
logger.debug(f'Clean text: {clean_text}')
lng_ann = ppl(clean_text)
sentences = [CSentence(lng_ann['tokens'], sent) for sent in lng_ann['sentences']]
if (masked_tokens == []):
... |
def process_batch(b_text, predictor, ppl, *args, **kwargs):
l_masked_position = []
l_bpe_tokens = []
l_masked_tokens = []
for j in range(len(b_text)):
(masked_position, tokens) = preprocess_tagged_text(b_text[j], ppl)
l_masked_position.append(masked_position)
l_bpe_tokens.appen... |
def analyze_tagged_text(tagged_text, predictor, ppl, batch_size=10, progress_bar=None, n_units=0, n_top=5, fix_multiunit=True, mask_token=True, n_tokens=[1], max_multiunit=10, multiunit_lookup=100, contexts=None):
'\n - tagged_text (str): a text with a masked tokens highlighted as "__something__" .\n - pred... |
def find_bpe_position_by_offset(bpe_offsets, target_offset):
bpe_nums = []
for (sent_num, sent) in enumerate(bpe_offsets):
if (sent[(- 1)][0] < target_offset[0]):
continue
for (bpe_num, bpe) in enumerate(sent):
if ((target_offset[0] <= bpe[0]) and (bpe[1] <= target_offs... |
def generate_seq_indexes(indexes):
if (not indexes):
(yield [])
return
for ind in indexes[0]:
for seq in generate_seq_indexes(indexes[1:]):
(yield ([ind] + seq))
|
def bpe_tokenize(bpe_tokenizer, sentence):
sent_bpe_tokens = []
sent_bpe_offsets = []
for token in sentence:
token_bpes = bpe_tokenizer.tokenize(token.text)
sent_bpe_offsets += [(token.begin, token.end) for _ in range(len(token_bpes))]
sent_bpe_tokens += token_bpes
return (sent... |
def nlargest_indexes(arr, n_top):
arr_ids = np.argpartition(arr, (- n_top))[(- n_top):]
sel_arr = arr[arr_ids]
top_ids = arr_ids[np.argsort((- sel_arr))]
return top_ids
|
def remove_masked_token_subwords(masked_position, bpe_tokens, bpe_offsets):
'\n If the masked token has been tokenied into multiple subwords: like dieting-->diet and ##ing\n keep the first subword and remove others.\n '
logger.debug(f'bpe tokens: {bpe_tokens}')
logger.debug(f'bpe offsets: {bpe_of... |
def merge_sorted_results(objects_left, scores_left, objects_right, scores_right, max_elems):
result_objects = []
result_scores = []
j = 0
i = 0
while True:
if (len(result_scores) == max_elems):
break
if (i == len(scores_left)):
result_objects += objects_righ... |
class MaskedTokenPredictorBert():
def __init__(self, model, bpe_tokenizer, max_len=250, mask_in_multiunit=False, device=None, label=0, logits_postprocessor=None, contrast_penalty=0):
self._model = model
self._bpe_tokenizer = bpe_tokenizer
self._max_len = max_len
self._mask_in_mult... |
def add_sys_path(p):
p = os.path.abspath(p)
print(p)
if (p not in sys.path):
sys.path.append(p)
|
def create_parsers():
return PipelineCommon([(ProcessorTokenizerNltkEn(), ['text'], {0: 'tokens'}), (ProcessorSentenceSplitter(), ['tokens'], {0: 'sentences'})])
return ppl
|
def embed(text):
toks = glove_embedding.embed(Sentence(text))[0]
return np.mean([t.embedding.cpu().numpy() for t in toks], axis=0)
|
def cosine(v1, v2):
return (np.dot(v1, v2) / np.sqrt(((sum((v1 ** 2)) * sum((v2 ** 2))) + 1e-10)))
|
def group_by_first_token(texts):
seqs = [tokenizer.encode(x, add_special_tokens=False) for x in texts]
grouped = defaultdict(list)
for seq in seqs:
grouped[seq[0]].append(seq)
return grouped
|
def get_mask_fast(inp: str, bad_words=neg_complex_tokens, min_bad_score=0, aggressive=True):
sentences = [tokenizer.encode(inp, add_special_tokens=True)]
sentences_torch = torch.tensor(sentences)
masks = torch.zeros_like(sentences_torch)
for (sent_id, sent) in enumerate(sentences):
for (first_... |
def toks_to_words(token_ids):
' Merge subword tokens into whole words '
indices = []
for (i, token_id) in enumerate(token_ids):
token_text = v[token_id]
if token_text.startswith('##'):
indices.append(i)
else:
if indices:
toks = [v[token_ids[t... |
def convert_mask(tok_ids, mask_ids, tokenizer, duplicate=False):
toks_tmp = [tokenizer.convert_ids_to_tokens(tok_ids[0])[1:(- 1)]]
mask_pos = None
toks = []
mask_toks = []
has_mask = False
for (i, is_masked) in enumerate(mask_ids[0][1:(- 1)]):
if is_masked:
mask_toks.append... |
def get_hypotheses(text, top=10, duplicate=False, mask_token=False, reorder=True, sim_coef=30):
tokenizer = predictor._bpe_tokenizer
(tok_ids, mask_ids) = get_mask_fast(text)
(toks, mask_pos, mask_toks) = convert_mask(tok_ids, mask_ids, tokenizer=tokenizer, duplicate=duplicate)
mask_text = tokenizer.c... |
def get_masked_tokens_from_tagged_text(tagged_text):
chunks = tagged_text.split('__')
masks = []
curr_offset = 0
clean_text = ''
for (chunk_num, chunk) in enumerate(chunks):
if ((chunk_num % 2) == 1):
masks.append((curr_offset, (curr_offset + len(chunk))))
curr_offset +... |
def preprocess_tagged_text(t_text, ppl):
(masked_tokens, clean_text) = get_masked_tokens_from_tagged_text(t_text)
logger.debug(f'Clean text: {clean_text}')
lng_ann = ppl(clean_text)
sentences = [CSentence(lng_ann['tokens'], sent) for sent in lng_ann['sentences']]
if (masked_tokens == []):
... |
def process_batch(b_text, predictor, ppl, *args, **kwargs):
l_masked_position = []
l_bpe_tokens = []
l_masked_tokens = []
for j in range(len(b_text)):
(masked_position, tokens) = preprocess_tagged_text(b_text[j], ppl)
l_masked_position.append(masked_position)
l_bpe_tokens.appen... |
def analyze_tagged_text(tagged_text, predictor, ppl, batch_size=10, progress_bar=None, n_units=0, n_top=5, fix_multiunit=True, mask_token=True, n_tokens=[1], max_multiunit=10, multiunit_lookup=100, contexts=None):
'\n - tagged_text (str): a text with a masked tokens highlighted as "__something__" .\n - pred... |
def find_bpe_position_by_offset(bpe_offsets, target_offset):
bpe_nums = []
for (sent_num, sent) in enumerate(bpe_offsets):
if (sent[(- 1)][0] < target_offset[0]):
continue
for (bpe_num, bpe) in enumerate(sent):
if ((target_offset[0] <= bpe[0]) and (bpe[1] <= target_offs... |
def generate_seq_indexes(indexes):
if (not indexes):
(yield [])
return
for ind in indexes[0]:
for seq in generate_seq_indexes(indexes[1:]):
(yield ([ind] + seq))
|
class Args():
def __init__(self):
self.model_type = 'gpt2'
self.model_name_or_path = 'sberbank-ai/rugpt3large_based_on_gpt2'
self.prompt = ''
self.length = 50
self.stop_token = '</s>'
self.k = 5
self.p = 0.95
self.temperature = 1
self.repeti... |
class detoxGPT():
def __init__(self, device='cuda', model_path='rugpt3_large_200'):
self.args = Args()
self.args.device = device
self.args.model_name_or_path = model_path
if (not os.path.isdir(self.args.model_name_or_path)):
print('Loading fine-tuned weights.')
... |
def get_pooling_types_dict():
'Get dictionary mapping pooling type number to type name\n '
desc = caffe_pb2.PoolingParameter.PoolMethod.DESCRIPTOR
d = {}
for (k, v) in desc.values_by_name.items():
d[v.number] = k
return d
|
def get_edge_label(layer):
'Define edge label based on layer type.\n '
if (layer.type == 'Data'):
edge_label = ('Batch ' + str(layer.data_param.batch_size))
elif ((layer.type == 'Convolution') or (layer.type == 'Deconvolution')):
edge_label = str(layer.convolution_param.num_output)
... |
def get_layer_label(layer, rankdir):
"Define node label based on layer type.\n\n Parameters\n ----------\n layer : ?\n rankdir : {'LR', 'TB', 'BT'}\n Direction of graph layout.\n\n Returns\n -------\n string :\n A label for the current layer\n "
if (rankdir in ('TB', 'BT'... |
def choose_color_by_layertype(layertype):
'Define colors for nodes based on the layer type.\n '
color = '#6495ED'
if ((layertype == 'Convolution') or (layertype == 'Deconvolution')):
color = '#FF5050'
elif (layertype == 'Pooling'):
color = '#FF9900'
elif (layertype == 'InnerProd... |
def get_pydot_graph(caffe_net, rankdir, label_edges=True):
"Create a data structure which represents the `caffe_net`.\n\n Parameters\n ----------\n caffe_net : object\n rankdir : {'LR', 'TB', 'BT'}\n Direction of graph layout.\n label_edges : boolean, optional\n Label the edges (defau... |
def draw_net(caffe_net, rankdir, ext='png'):
"Draws a caffe net and returns the image string encoded using the given\n extension.\n\n Parameters\n ----------\n caffe_net : a caffe.proto.caffe_pb2.NetParameter protocol buffer.\n ext : string, optional\n The image extension (the default is 'pn... |
def draw_net_to_file(caffe_net, filename, rankdir='LR'):
"Draws a caffe net, and saves it to file using the format given as the\n file extension. Use '.raw' to output raw text that you can manually feed\n to graphviz to draw graphs.\n\n Parameters\n ----------\n caffe_net : a caffe.proto.caffe_pb2.... |
def param_name_dict():
'Find out the correspondence between layer names and parameter names.'
layer = caffe_pb2.LayerParameter()
param_names = [s for s in dir(layer) if s.endswith('_param')]
param_type_names = [type(getattr(layer, s)).__name__ for s in param_names]
param_names = [s[:(- len('_param... |
def to_proto(*tops):
'Generate a NetParameter that contains all layers needed to compute\n all arguments.'
layers = OrderedDict()
autonames = Counter()
for top in tops:
top.fn._to_proto(layers, {}, autonames)
net = caffe_pb2.NetParameter()
net.layer.extend(layers.values())
retur... |
def assign_proto(proto, name, val):
'Assign a Python object to a protobuf message, based on the Python\n type (in recursive fashion). Lists become repeated fields/messages, dicts\n become messages, and other types are assigned directly.'
if isinstance(val, list):
if isinstance(val[0], dict):
... |
class Top(object):
'A Top specifies a single output blob (which could be one of several\n produced by a layer.)'
def __init__(self, fn, n):
self.fn = fn
self.n = n
def to_proto(self):
'Generate a NetParameter that contains all layers needed to compute\n this top.'
... |
class Function(object):
'A Function specifies a layer, its parameters, and its inputs (which\n are Tops from other layers).'
def __init__(self, type_name, inputs, params):
self.type_name = type_name
self.inputs = inputs
self.params = params
self.ntop = self.params.get('ntop... |
class NetSpec(object):
'A NetSpec contains a set of Tops (assigned directly as attributes).\n Calling NetSpec.to_proto generates a NetParameter containing all of the\n layers needed to produce all of the assigned Tops, using the assigned\n names.'
def __init__(self):
super(NetSpec, self).__s... |
class Layers(object):
'A Layers object is a pseudo-module which generates functions that specify\n layers; e.g., Layers().Convolution(bottom, kernel_size=3) will produce a Top\n specifying a 3x3 convolution applied to bottom.'
def __getattr__(self, name):
def layer_fn(*args, **kwargs):
... |
class Parameters(object):
'A Parameters object is a pseudo-module which generates constants used\n in layer parameters; e.g., Parameters().Pooling.MAX is the value used\n to specify max pooling.'
def __getattr__(self, name):
class Param():
def __getattr__(self, param_name):
... |
class TestLayerTypeList(unittest.TestCase):
def test_standard_types(self):
for type_name in ['Data', 'Convolution', 'InnerProduct']:
self.assertIn(type_name, caffe.layer_type_list(), ('%s not in layer_type_list()' % type_name))
|
def simple_net_file(num_output):
'Make a simple net prototxt, based on test_net.cpp, returning the name\n of the (temporary) file.'
f = tempfile.NamedTemporaryFile(mode='w+', delete=False)
f.write((("name: 'testnet' force_backward: true\n layer { type: 'DummyData' name: 'data' top: 'data' top: 'labe... |
class TestNet(unittest.TestCase):
def setUp(self):
self.num_output = 13
net_file = simple_net_file(self.num_output)
self.net = caffe.Net(net_file, caffe.TRAIN)
self.net.blobs['label'].data[...] = np.random.randint(self.num_output, size=self.net.blobs['label'].data.shape)
o... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.