def process_vision_models():
data_dir = "../base-models/vision"
if not os.path.exists(data_dir):
os.makedirs(data_dir)
for name, _ in torch_vision_models:
model = torch.hub.load("pytorch/vision:v0.4.2", name, pretrained=True)
layers = []
get_layers(model, layers)
sizes = get_layers_size(layers)
model_dir = os.path.join(data_dir, name)
if not os.path.exists(model_dir):
os.makedirs(model_dir)
torch.save(model.state_dict(), os.path.join(model_dir, "model.pt"))
meta_obj = {
"name": name,
"total_size": sum(sizes),
"layer_sizes": sizes
}
with open(os.path.join(model_dir, "meta.json"), "w") as ofile:
json.dump(meta_obj, ofile, indent=2)
print("processed model", name, "total size",
sum(sizes) / (1024.0 * 1024), "MB")
def vision_model_time():
""""""
for name, _ in torch_vision_models:
_t = time.time()
model = torch.hub.load("pytorch/vision:v0.4.2", name, pretrained=True)
print("load ", name, 'cost', time.time() - _t, 's')
_t = time.time()
model = model.to("cuda")
print('to cuda cost', time.time() - _t)
model.eval()
layers = []
get_layers(model, layers)
sizes = get_layers_size(layers)
# random data
for i in range(10):
# pylint: disable=no-member
data = torch.rand((1, 3, 224, 224)).to("cuda")
torch.cuda.synchronize()
t1 = time.time()
outputs = model(data)
torch.cuda.synchronize()
t2 = time.time()
del data
del outputs
torch.cuda.empty_cache()
trans_time = sum(sizes) * 8.0 / bw
print(name, ":: foward cost ", t2 - t1, "est. transition time",
trans_time)
del model
torch.cuda.empty_cache()
def main():
wide = int(sys.stdin.readline().strip())
tall = int(sys.stdin.readline().strip())
data = sys.stdin.readline().strip()
layers = get_layers(data, wide, tall)
print(merge_layers(layers))
def test_simple(self):
wide = 3
tall = 2
data = "123456789012"
layers = list(get_layers(data, wide, tall))
self.assertEqual(len(layers), 2)
self.assertEqual(layers[0], "123456")
self.assertEqual(layers[1], "789012")
def process_nlp_models():
data_dir = "../base-models/nlp"
if not os.path.exists(data_dir):
os.makedirs(data_dir)
for model_class, tokenizer_class, pretrained_weights, _ in nlp_models:
t1 = time.time()
tokenizer = tokenizer_class.from_pretrained(
pretrained_weights, cache_dir="./huggingface-cache")
t2 = time.time()
model = model_class.from_pretrained(pretrained_weights,
cache_dir="./huggingface-cache")
t3 = time.time()
print("loading tokenizer cost", t2 - t1, "loading model cost: ",
t3 - t2)
# tokenizer_layers = []
model_layers = []
# get_layers(tokenizer, tokenizer_layers)
get_layers(model, model_layers)
# tokenizer_sizes = get_layers_size(tokenizer_layers)
model_sizes = get_layers_size(model_layers)
model_dir = os.path.join(data_dir, pretrained_weights)
if not os.path.exists(model_dir):
os.makedirs(model_dir)
# tokenizer.save_pretrained(model_dir)
torch.save(model.state_dict(), os.path.join(model_dir, "model.pt"))
meta_obj = {
"model": model.__class__.__name__,
"tokenizer": tokenizer.__class__.__name__,
"total_size": sum(model_sizes),
"layer_sizes": model_sizes
}
with open(os.path.join(model_dir, "meta.json"), "w") as ofile:
json.dump(meta_obj, ofile, indent=2)
print("processed model", pretrained_weights, "total size",
sum(model_sizes) / (1024.0 * 1024), "MB")
def _nlp_exp(model_class, tokenizer_class, pretrained_weights, config):
# Load pretrained model/tokenizer
tokenizer = tokenizer_class.from_pretrained(
pretrained_weights, cache_dir="./huggingface-cache")
model = model_class.from_pretrained(pretrained_weights,
cache_dir="./huggingface-cache")
layers = []
get_layers(model, layers)
sizes = get_layers_size(layers)
model = model.to('cuda')
model.eval()
for i in range(10):
# pylint: disable=not-callable
input_ids = torch.tensor([
tokenizer.encode(
"Let's see all hidden-states and attentions on this text",
add_space_before_punct_symbol=True)
] * 8).to('cuda')
torch.cuda.synchronize()
t1 = time.time()
outputs = model(input_ids)
torch.cuda.synchronize()
t2 = time.time()
del outputs
del input_ids
torch.cuda.empty_cache()
trans_time = sum(sizes) * 8.0 / bw
print(model_class.__name__, ":: foward cost ", t2 - t1,
"est. transition time", trans_time)
del model
del tokenizer
del layers
del sizes
torch.cuda.empty_cache()
def main():
wide = int(sys.stdin.readline().strip())
tall = int(sys.stdin.readline().strip())
data = sys.stdin.readline().strip()
layers = get_layers(data, wide, tall)
layers_infos = [parse_infos(layer) for layer in layers]
for info in layers_infos:
print(info)
def get_zero(info):
return info.get("0", 0)
min_layer = min(layers_infos, key=get_zero)
print(min_layer)
print(min_layer["1"] * min_layer["2"])