| import numpy as np | |
| from .float import FPNumber | |
| def generate_inverse_lut( | |
| input_exp_bits: int, input_man_bits: int, output_exp_bits: int, output_man_bits: int | |
| ) -> dict: | |
| """Generate LUT for inverse function (1/x)""" | |
| lut = {} | |
| input_bits = input_man_bits # We only need mantissa bits since 1.mmm format | |
| for i in range(1 << input_bits): | |
| # Convert i to FP12 number (1.mmm format) | |
| input_val = 1.0 + (i / (1 << input_bits)) | |
| inv_val = 1.0 / input_val | |
| # Convert result to output format | |
| fp_result = FPNumber.from_float(inv_val, output_exp_bits, output_man_bits) | |
| lut[i] = fp_result.to_bits() | |
| return lut | |
| def generate_inverse_lut_subnormal( | |
| input_exp_bits: int, input_man_bits: int, output_exp_bits: int, output_man_bits: int | |
| ) -> dict: | |
| """Generate LUT for inverse function (1/x), where x have exp=0 and man!=0""" | |
| lut = {} | |
| input_bits = input_man_bits # We only need mantissa bits since 0.mmm format | |
| for i in range(1 << input_bits): | |
| # Convert i to FP12 number (0.mmm format) | |
| input_val = 2 ** (0 - 2 ** (input_exp_bits - 1) + 2) * (i / (1 << input_bits)) | |
| if input_val == 0: | |
| inv_val = 0 | |
| else: | |
| inv_val = 1.0 / input_val | |
| print((i / (1 << input_bits)), input_val, inv_val) | |
| # Convert result to output format | |
| fp_result = FPNumber.from_float(inv_val, output_exp_bits, output_man_bits) | |
| lut[i] = fp_result.to_bits() | |
| return lut | |
| def generate_log_lut( | |
| input_man_bits: int, output_exp_bits: int, output_man_bits: int | |
| ) -> dict: | |
| """Generate LUT for log(1.mmm)""" | |
| lut = {} | |
| for i in range(1 << input_man_bits): | |
| # Convert i to 1.mmm format | |
| input_val = 1.0 + (i / (1 << input_man_bits)) | |
| log_val = np.log(input_val) | |
| print(input_val, log_val) | |
| # Convert result to output format | |
| fp_result = FPNumber.from_float(log_val, output_exp_bits, output_man_bits) | |
| lut[i] = fp_result.to_bits() | |
| return lut | |
| def generate_log_lut_subnorm( | |
| input_man_bits: int, output_exp_bits: int, output_man_bits: int | |
| ) -> dict: | |
| """Generate LUT for log(1.mmm)""" | |
| lut = {} | |
| for i in range(1 << input_man_bits): | |
| # Convert i to 1.mmm format | |
| input_val = 0.0 + (i / (1 << input_man_bits)) | |
| log_val = np.log(input_val) | |
| print(input_val, log_val) | |
| # Convert result to output format | |
| try: | |
| fp_result = FPNumber.from_float(log_val, output_exp_bits, output_man_bits) | |
| lut[i] = fp_result.to_bits() | |
| except (ValueError, OverflowError): | |
| lut[i] = int("0" + "1" * (output_exp_bits + output_man_bits), 2) | |
| return lut | |
| def generate_log_exp_lut( | |
| input_exp_bits: int, output_exp_bits: int, output_man_bits: int | |
| ) -> dict: | |
| """Generate LUT for e*log(2) e can be positive or negative""" | |
| lut = {} | |
| # convert i to exponent, when we have n exp bits, the offset is 2^(n-1)-1. | |
| exp_offset = (1 << (input_exp_bits - 1)) - 1 | |
| for i in range(1 << input_exp_bits): | |
| e = i - exp_offset | |
| log_val = np.log(2) * e | |
| fp_result = FPNumber.from_float(log_val, output_exp_bits, output_man_bits) | |
| lut[i] = fp_result.to_bits() | |
| return lut | |
| def generate_exp_lut_int( | |
| input_bits: int, output_exp_bits: int, output_man_bits: int | |
| ) -> dict: | |
| """Generate LUT for exp(x) where x is in [0, ln(2))""" | |
| lut = {} | |
| for sign in [0, 1]: | |
| for i in range(1 << input_bits): | |
| input_val = float(i) * (-1) ** sign | |
| exp_val = np.exp(input_val) | |
| # Convert result to output format | |
| fp_result = FPNumber.from_float(exp_val, output_exp_bits, output_man_bits) | |
| lut[i + (sign << input_bits)] = fp_result.to_bits() | |
| return lut | |
| def generate_exp_lut_high_frac( | |
| input_bits: int, output_exp_bits: int, output_man_bits: int | |
| ) -> dict: | |
| """Generate LUT for exp(x) where x is in [0, ln(2))""" | |
| lut = {} | |
| for sign in [0, 1]: | |
| for i in range(1 << input_bits): | |
| input_val = float(i) / (2**input_bits) * (-1) ** sign | |
| exp_val = np.exp(input_val) | |
| # Convert result to output format | |
| fp_result = FPNumber.from_float(exp_val, output_exp_bits, output_man_bits) | |
| lut[i + (sign << input_bits)] = fp_result.to_bits() | |
| return lut | |
| def generate_exp_lut_low_frac( | |
| input_bits: int, output_exp_bits: int, output_man_bits: int | |
| ) -> dict: | |
| """Generate LUT for exp(x) where x is in [0, ln(2))""" | |
| lut = {} | |
| for sign in [0, 1]: | |
| for i in range(1 << input_bits): | |
| input_val = float(i) / (2 ** (input_bits * 2)) * (-1) ** sign | |
| exp_val = np.exp(input_val) | |
| # Convert result to output format | |
| fp_result = FPNumber.from_float(exp_val, output_exp_bits, output_man_bits) | |
| lut[i + (sign << input_bits)] = fp_result.to_bits() | |
| return lut | |
| # Example usage and test | |
| if __name__ == "__main__": | |
| # Generate inverse LUT (FP12 to FP16) | |
| # inv_lut = generate_inverse_lut(5, 6, 5, 10) # FP12(E5M6) to FP16 | |
| # results = [] | |
| # for i in range(1 << 6): | |
| # results.append(f"{inv_lut[i]:016b}") | |
| # print(f"{inv_lut[i]:016b}: {FPNumber.from_bits(inv_lut[i], 5, 10).to_float()}") | |
| # for i in zip(*results): | |
| # print("".join(reversed(list(i)))) | |
| invlut_subnorm = generate_inverse_lut_subnormal(5, 6, 5, 10) | |
| results = [] | |
| for i in range(1 << 6): | |
| print(i) | |
| results.append(f"{invlut_subnorm[i]:016b}") | |
| print( | |
| f"{invlut_subnorm[i]:016b}: {FPNumber.from_bits(invlut_subnorm[i], 5, 10).to_float()}" | |
| ) | |
| for i in zip(*results): | |
| print("".join(reversed(list(i)))) | |
| # Generate log LUT and log-exp LUT | |
| # log(x) = log(1.mmmmmm) + e*log(2) | |
| # log_lut = generate_log_lut(6, 5, 10) # 6-bit mantissa input to FP16 | |
| # log_lut_subnorm = generate_log_lut_subnorm(6, 5, 10) # 6-bit mantissa input to FP16 | |
| # log_exp_lut = generate_log_exp_lut(5, 5, 10) # 5-bit exp input to FP16 | |
| # results = [] | |
| # for i in range(1 << 6): | |
| # results.append(f"{log_lut[i]:016b}") | |
| # # print(f"{log_lut[i]:016b}: {FPNumber.from_bits(log_lut[i], 5, 10).to_float()}") | |
| # for i in zip(*results): | |
| # print("".join(reversed(list(i)))) | |
| # print() | |
| # results = [] | |
| # for i in range(1 << 6): | |
| # results.append(f"{log_lut_subnorm[i]:016b}") | |
| # print(f"{log_lut_subnorm[i]:016b}: {FPNumber.from_bits(log_lut_subnorm[i], 5, 10).to_float()}") | |
| # for i in zip(*results): | |
| # print("".join(reversed(list(i)))) | |
| # print() | |
| # results = [] | |
| # for i in range(1 << 5): | |
| # results.append(f"{log_exp_lut[i]:016b}") | |
| # # print(f"{log_exp_lut[i]:016b}: {FPNumber.from_bits(log_exp_lut[i], 5, 10).to_float()}") | |
| # for i in zip(*results): | |
| # print("".join(reversed(list(i)))) | |
| # Generate exp LUT | |
| # exp_lut_int = generate_exp_lut_int(5, 5, 10) | |
| # exp_lut_high_frac = generate_exp_lut_high_frac(5, 5, 10) | |
| # exp_lut_low_frac = generate_exp_lut_low_frac(5, 5, 10) | |
| # results = [] | |
| # for i in range(1 << 6): | |
| # results.append(f"{exp_lut_int[i]:016b}") | |
| # print(f"{exp_lut_int[i]:016b}: {FPNumber.from_bits(exp_lut_int[i], 5, 10).to_float()}") | |
| # for i in zip(*results): | |
| # print("".join(reversed(list(i)))) | |
| # print() | |
| # results = [] | |
| # for i in range(1 << 6): | |
| # results.append(f"{exp_lut_high_frac[i]:016b}") | |
| # print(f"{exp_lut_high_frac[i]:016b}: {FPNumber.from_bits(exp_lut_high_frac[i], 5, 10).to_float()}") | |
| # for i in zip(*results): | |
| # print("".join(reversed(list(i)))) | |
| # print() | |
| # results = [] | |
| # for i in range(1 << 6): | |
| # results.append(f"{exp_lut_low_frac[i]:016b}") | |
| # print(f"{exp_lut_low_frac[i]:016b}: {FPNumber.from_bits(exp_lut_low_frac[i], 5, 10).to_float()}") | |
| # for i in zip(*results): | |
| # print("".join(reversed(list(i)))) | |
| # print() | |
| # # Test inverse function | |
| # print("\nTesting inverse LUT:") | |
| # test_values = [1.0, 1.25, 1.5, 1.75, 3.14] | |
| # for val in test_values: | |
| # fp12 = FPNumber.from_float(val, 5, 6) | |
| # lut_result = FPNumber.from_bits(inv_lut[fp12.mantissa], 5, 10) | |
| # print(f"1/{val:.3f} = {lut_result.to_float():.6f}") | |
| # # Test log function | |
| # print("\nTesting log LUT:") | |
| # for val in test_values: | |
| # fp_in = FPNumber.from_float(val, 5, 6) | |
| # lut_result_man = FPNumber.from_bits(log_lut[fp_in.mantissa], 5, 10) | |
| # lut_result_exp = FPNumber.from_bits(log_exp_lut[fp_in.exponent], 5, 10) | |
| # final_result = lut_result_man.to_float() + lut_result_exp.to_float() | |
| # diff = np.log(val) - final_result | |
| # APE = abs(diff) / np.log(val) * 100 if diff else 0 | |
| # print( | |
| # f"log({val:.3f}) = {final_result:.6f}" | |
| # f" (actual = {np.log(val):.6f}, APE = {APE:.2f}%)" | |
| # ) | |
| # Test exp function | |
| # print("\nTesting exp LUT:") | |
| # test_values = [0.0, 0.2, 0.4, 0.6] | |
| # for val in test_values: | |
| # idx = int((val) * (1 << 6)) | |
| # lut_result = FPNumber.from_bits(exp_lut[idx], 5, 10) | |
| # diff = np.exp(val) - lut_result.to_float() | |
| # APE = abs(diff) / np.exp(val) * 100 if diff else 0 | |
| # print( | |
| # f"exp({val:.3f}) = {lut_result.to_float():.6f}" | |
| # f" (actual = {np.exp(val):.6f}, APE = {APE:.2f}%)" | |
| # ) | |