Zilun Peng zilunpeng

## use_ray_to_get_pred.py
predictions = ray.get(prediction_futures)

## ray_process_data_sample.py
prediction_futures, ground_truths = [], []
for i, batch in enumerate(data_loader):
    prediction_future = remote_process_batch_element.remote(batch, model_id, decoder_id, target_dict)
    prediction_futures.append(prediction_future)
    ground_truths.append(batch[2][0])

## share_model_decoder.py
model_id = ray.put(model)
decoder_id = ray.put(decoder)

## remote_process_data_sample.py
@ray.remote
def remote_process_data_sample(batch, model, generator, target_dict):
 result = process_data_sample(batch, model, generator, target_dict)
 return result

## import_init_ray.py
import ray
ray.init()

## call_viterbi_decode.py
def decode(self, emissions):
    B, T, N = emissions.size()
    hypos = list()

    if self.asg_transitions is None:
        transitions = torch.FloatTensor(N, N).zero_()
    else:
        transitions = torch.FloatTensor(self.asg_transitions).view(N, N)

    viterbi_path = torch.IntTensor(B, T)

## import_wav2letter.py
from wav2letter.criterion import CpuViterbiPath, get_data_ptr_as_bytes

## call_wav2vec2_decoder.py
decoder_out = decoder.decode(emissions)

## quantize_wav2vec2.py
quantized_model = torch.quantization.quantize_dynamic(pt_wav2vec2, {torch.nn.Linear}, dtype=torch.qint8, inplace=True)
quantized_model.prepare_for_inference_after_quantization()

## prepare_quantized_wav2vec2_for_inf.py
def prepare_for_inference_after_quantization(self):
    dequantizer = torch.nn.quantized.DeQuantize()
    for trans_layer in self.encoder.layers:
        trans_layer.self_attn.q_proj_bias = trans_layer.self_attn.q_proj.bias()
        trans_layer.self_attn.k_proj_bias = trans_layer.self_attn.k_proj.bias()
        trans_layer.self_attn.v_proj_bias = trans_layer.self_attn.v_proj.bias()
        trans_layer.self_attn.in_proj_bias = torch.cat((trans_layer.self_attn.q_proj_bias, trans_layer.self_attn.k_proj_bias, trans_layer.self_attn.v_proj_bias))
        trans_layer.self_attn.out_proj_bias = trans_layer.self_attn.out_proj.bias()
        trans_layer.self_attn.out_proj_weight = dequantizer(trans_layer.self_attn.out_proj.weight())
        trans_layer.self_attn.q_proj_weight = dequantizer(trans_layer.self_attn.q_proj.weight())
	prediction_futures, ground_truths = [], []
	for i, batch in enumerate(data_loader):
	prediction_future = remote_process_batch_element.remote(batch, model_id, decoder_id, target_dict)
	prediction_futures.append(prediction_future)
	ground_truths.append(batch[2][0])
	@ray.remote
	def remote_process_data_sample(batch, model, generator, target_dict):
	result = process_data_sample(batch, model, generator, target_dict)
	return result
	def decode(self, emissions):
	B, T, N = emissions.size()
	hypos = list()

	if self.asg_transitions is None:
	transitions = torch.FloatTensor(N, N).zero_()
	else:
	transitions = torch.FloatTensor(self.asg_transitions).view(N, N)

	viterbi_path = torch.IntTensor(B, T)
	quantized_model = torch.quantization.quantize_dynamic(pt_wav2vec2, {torch.nn.Linear}, dtype=torch.qint8, inplace=True)
	quantized_model.prepare_for_inference_after_quantization()
	def prepare_for_inference_after_quantization(self):
	dequantizer = torch.nn.quantized.DeQuantize()
	for trans_layer in self.encoder.layers:
	trans_layer.self_attn.q_proj_bias = trans_layer.self_attn.q_proj.bias()
	trans_layer.self_attn.k_proj_bias = trans_layer.self_attn.k_proj.bias()
	trans_layer.self_attn.v_proj_bias = trans_layer.self_attn.v_proj.bias()
	trans_layer.self_attn.in_proj_bias = torch.cat((trans_layer.self_attn.q_proj_bias, trans_layer.self_attn.k_proj_bias, trans_layer.self_attn.v_proj_bias))
	trans_layer.self_attn.out_proj_bias = trans_layer.self_attn.out_proj.bias()
	trans_layer.self_attn.out_proj_weight = dequantizer(trans_layer.self_attn.out_proj.weight())
	trans_layer.self_attn.q_proj_weight = dequantizer(trans_layer.self_attn.q_proj.weight())