Alexander Miller Rojas Sanchez 20190574H

Introducción
El objetivo de este proyecto es predecir si una persona será aprobada para un préstamo bancario utilizando
el modelo de Hypernetwork, una arquitectura basada en interacciones moleculares. Este enfoque se basa
en el trabajo presentado en el artículo:

Graph Learning with the Hypernetwork, a Molecule Interaction Based Architecture

José Segovia-Juárez, Silvano Colombano, Alex Flores, Miguel Mejía
Computer Science Department, National Engineering University of Peru
Intelligent Systems Division, NASA Ames Research Center

El modelo de Hypernetwork es una red biológica artificial que simula interacciones moleculares pa-
ra procesar información. En este contexto, utilizaremos el modelo para clasificar solicitudes de préstamo
basándonos en diversos atributos de los solicitantes.

1
 Estructura Original del Conjunto de Datos
La estructura original del conjunto de datos es la siguiente:
ID Gen Mar Dep Edu SelfEmp Inc CoappInc LoanAmt
Term CredHist Prop Status
LP001002 M No 0 Grad No 5849 0 360 1 Urb Y
LP001003 M Yes 1 Grad No 4583 1508 128 360 1 Rur N
LP001005 M Yes 0 Grad Yes 3000 0 66 360 1 Urb Y
LP001006 M Yes 0 NotGrad No 2583 2358 120 360 1 Urb Y
LP001008 M No 0 Grad No 6000 0 141 360 1 Urb Y
LP001011 M Yes 2 Grad Yes 5417 4196 267 360 1 Urb Y
LP001013 M Yes 0 NotGrad No 2333 1516 95 360 1 Urb Y
LP001014 M Yes 3+ Grad No 3036 2504 158 360 0 Semi N
LP001018 M Yes 2 Grad No 4006 1526 168 360 1 Urb Y
LP001020 M Yes 1 Grad No 12841 10968 349 360 1 Semi N
LP001024 M Yes 2 Grad No 3200 700 70 360 1 Urb Y
LP001027 M Yes 2 Grad 2500 1840 109 360 1 Urb Y

Leyenda de Abreviaturas:
2

ID: Loan_ID
Gen: Gender
Mar: Married
Dep: Dependents
Edu: Education
SelfEmp: Self_Employed
Inc: ApplicantIncome
CoappInc: CoapplicantIncome
LoanAmt: LoanAmount
Term: Loan_Amount_Term
CredHist: Credit_History
Prop: Property_Area
Status: Loan_Status
Descripción del Proceso ETL
Transformaciones de Características
Gender (Género):
• Se mapea ’Male’ a 1 y ’Female’ a 0.
• Código: data['Gender'] = data['Gender'].map({'Male': 1, 'Female': 0}).
• Representación binaria: 1 bit.
Married (Estado Civil):
• Se mapea ’Yes’ a 1 y ’No’ a 0.
• Código: data['Married'] = data['Married'].map({'Yes': 1, 'No': 0}).
• Representación binaria: 1 bit.
Dependents (Personas a Cargo):
• Se codifican las opciones en 2 bits:
◦ ’0’ → ’00’
◦ ’1’ → ’01’
◦ ’2’ → ’10’
◦ ’3+’ → ’11’
• Se utiliza la función encode_dependents para esta conversión.
• Representación binaria: 2 bits.
Education (Nivel Educativo):
• Se mapea ’Graduate’ a 1 y ’Not Graduate’ a 0.
• Código: data['Education'] = data['Education'].map({'Graduate': 1, 'Not Graduate': 0}).
• Representación binaria: 1 bit.
Self_Employed (Trabaja por Cuenta Propia):
• Se mapea ’Yes’ a 1 y ’No’ a 0.
• Código: data['Self_Employed'] = data['Self_Employed'].map({'Yes': 1, 'No': 0}).
• Representación binaria: 1 bit.
ApplicantIncome (Ingreso del Solicitante):
• Se agrupan los ingresos en categorías y se codifican en 2 bits:
◦ Menos de 2500 → ’00’
◦ Entre 2500 y 5000 → ’01’
◦ Más de 5000 → ’10’
• Función utilizada: bin_applicant_income.
• Representación binaria: 2 bits.
LoanAmount (Monto del Préstamo):
• Se agrupan los montos en categorías y se codifican en 2 bits:
◦ Menos de 100 → ’00’
◦ Entre 100 y 200 → ’01’
◦ Más de 200 → ’10’

3
 • Función utilizada: bin_loan_amount.
• Representación binaria: 2 bits.
Credit_History (Historial de Crédito):
• Se asegura que los valores sean enteros (0 o 1).
• Código: data['Credit_History'] = data['Credit_History'].astype(int).
• Representación binaria: 1 bit.
Property_Area (Zona de la Propiedad):
• Se codifican las áreas en 2 bits:
◦ ’Urban’ → ’00’
◦ ’Semiurban’ → ’01’
◦ ’Rural’ → ’10’
• Función utilizada: encode_property_area.
• Representación binaria: 2 bits.

Loan_Amount_Term (Plazo del Préstamo):

• Se codifica en 1 bit:
◦ Plazo menor o igual a 180 → ’0’ (Corto Plazo)
◦ Plazo mayor a 180 → ’1’ (Largo Plazo)
• Función utilizada: encode_loan_term.
• Representación binaria: 1 bit.

4
 Código del Proceso ETL
1 import pandas as pd
2

3 # Cargar los datos desde el archivo

4 data = pd. read_csv ('loan_data_set .csv ')
5 data. dropna ( inplace =True , axis =0)
6

7 # Eliminar la columna 'Loan_ID '

8 [Link]('Loan_ID ', axis =1, inplace =True)
9

10 # Mapear 'Loan_Status ' a 0 y 1

11 data['Loan_Status '] = data['Loan_Status ']. map ({ 'N': 0, 'Y': 1})
12

13 # Mapear 'Gender ' a 0 y 1

14 data['Gender '] = data['Gender ']. map ({ 'Male ': 1, 'Female ': 0})
15

16 # Mapear 'Married ' a 0 y 1

17 data['Married '] = data['Married ']. map ({ 'Yes ': 1, 'No ': 0})
18

19 # Mapear 'Dependents ' a códigos binarios

20 def encode_dependents (x):
21 if x == '0':
22 return '00 '
23 elif x == '1':
24 return '01 '
25 elif x == '2':
26 return '10 '
27 else: # '3+'
28 return '11 '
29

30 data['Dependents '] = data['Dependents ']. apply ( encode_dependents )

31

32 # Mapear 'Education ' a 0 y 1

33 data['Education '] = data['Education ']. map ({ 'Graduate ': 1, 'Not Graduate ': 0})
34

35 # Mapear 'Self_Employed ' a 0 y 1

36 data['Self_Employed '] = data['Self_Employed ']. map ({ 'Yes ': 1, 'No ': 0})
37

38 # Mapear 'Credit_History ' a 0 y 1

39 data['Credit_History '] = data['Credit_History ']. astype (int)
40

41 # Mapear 'Property_Area ' a códigos binarios

42 def encode_property_area (x):
43 if x == 'Urban ':
44 return '00 '
45 elif x == 'Semiurban ':
46 return '01 '
47 else: # 'Rural '
48 return '10 '
49

50 data['Property_Area '] = data['Property_Area ']. apply( encode_property_area )

51

52 # Agrupar 'ApplicantIncome ' en categorías y codificar

53 def bin_applicant_income (x):
54 if x < 2500:
55 return '00 '
56 elif x <= 5000:

5
57 return '01 '
58 else:
59 return '10 '
60

61 data['ApplicantIncome '] = data['ApplicantIncome ']. apply ( bin_applicant_income )

62

63 # Agrupar 'LoanAmount ' en categorías y codificar

64 def bin_loan_amount (x):
65 if x < 100:
66 return '00 '
67 elif x <= 200:
68 return '01 '
69 else:
70 return '10 '
71

72 data['LoanAmount '] = data['LoanAmount ']. apply ( bin_loan_amount )

73

74 # Codificar 'Loan_Amount_Term ' en 1 bit

75 def encode_loan_term (x):
76 if x <= 180:
77 return '0' # Corto Plazo
78 else:
79 return '1' # Largo Plazo
80

81 data['Loan_Amount_Term '] = data['Loan_Amount_Term ']. apply( encode_loan_term )

82

83 # Combinar todas las características en una sola cadena binaria por fila
84 def combine_features (row):
85 binary_string = ''
86 binary_string += str(row['Gender ']) # 1 bit
87 binary_string += str(row['Married ']) # 1 bit
88 binary_string += row['Dependents '] # 2 bits
89 binary_string += str(row['Education ']) # 1 bit
90 binary_string += str(row['Self_Employed ']) # 1 bit
91 binary_string += row['ApplicantIncome '] # 2 bits
92 binary_string += row['LoanAmount '] # 2 bits
93 binary_string += str(row['Credit_History ']) # 1 bit
94 binary_string += row['Property_Area '] # 2 bits
95 binary_string += row['Loan_Amount_Term '] # 1 bit
96 return binary_string
97

98 data['Binary_Features '] = data. apply( combine_features , axis =1)

99

100 # Seleccionar solo las características binarias y la variable objetivo

101 final_data = data [[ 'Binary_Features ', 'Loan_Status ']]
102

103 # Guardar los datos finales en un archivo de texto

104 with open('binary_input .txt ', 'w') as f:
105 f. write (f"{len( final_data )} 14 1\n")
106 for index , row in final_data . iterrows ():
107 f. write (f"{row[' Binary_Features ']} {row[' Loan_Status ']}\n")

Parámetros del Programa Hypernetwork

El programa Hypernetwork utiliza los siguientes parámetros:
1 create_organism 10
2 threshold_activation 60

6
3 threshold_inhibition 60
4 mutation_rate_mol_cell 2
5 mutation_rate_atom_mol 20
6 molecular_shape_size 14
7

8 create_cell 1 20 rect 5 4 input 0

9 n_receptors_cell 1 4
10 n_effectors_cell 1 4
11 n_internal_cell 1 12
12 p_inhibitors_cell 1 20
13

14 create_cell 2 20 rect 5 4 input 0

15 n_receptors_cell 2 4
16 n_effectors_cell 2 4
17 n_internal_cell 2 12
18 p_inhibitors_cell 2 20
19

20 create_cell 3 20 rect 5 4 input 0

21 n_receptors_cell 3 4
22 n_effectors_cell 3 4
23 n_internal_cell 3 12
24 p_inhibitors_cell 3 20
25

26 create_cell 4 20 rect 5 4 internal1 0

27 n_receptors_cell 4 4
28 n_effectors_cell 4 4
29 n_internal_cell 4 12
30 p_inhibitors_cell 4 20
31

32 create_cell 5 20 rect 5 4 internal1 0

33 create_cell 6 20 rect 5 4 internal1 0
34 copy_structure_cell 4 5
35 copy_structure_cell 4 6
36

37 create_cell 7 20 rect 5 4 internal2 0

38 n_receptors_cell 7 4
39 n_effectors_cell 7 4
40 n_internal_cell 7 12
41 p_inhibitors_cell 7 20
42

43 create_cell 8 20 rect 5 4 internal2 0

44 create_cell 9 20 rect 5 4 internal2 0
45 copy_structure_cell 7 8
46 copy_structure_cell 7 9
47

48 create_cell 10 25 rect 5 5 output 5

49 n_receptors_cell 10 5
50 n_effectors_cell 10 5
51 n_internal_cell 10 15
52 p_inhibitors_cell 10 20
53

54 cell_cell 1 4
55 cell_cell 1 5
56 cell_cell 1 6
57

58 cell_cell 2 4
59 cell_cell 2 5
60 cell_cell 2 6
61

7
62 cell_cell 3 4
63 cell_cell 3 5
64 cell_cell 3 6
65

66 cell_cell 4 7
67 cell_cell 4 8
68 cell_cell 4 9
69

70 cell_cell 5 7
71 cell_cell 5 8
72 cell_cell 5 9
73

74 cell_cell 6 7
75 cell_cell 6 8
76 cell_cell 6 9
77

78 cell_cell 7 10
79 cell_cell 8 10
80 cell_cell 9 10
81

82 fraction_input_vector 2
83

84 minimal_global_error 0.001
85 seeds clock clock
86

87 end.

Ejecución del Modelo Hypernetwork

El modelo Hypernetwork se ejecuta utilizando el siguiente comando:
1 Input : parameter_file input_file # epochs result_file [ Optional plotting : 1 =
display learning , 2 =Plot organism ]

Donde se especifican los archivos de parámetros, el archivo de entrada binario, el número de épocas y el
archivo de resultados.
Al ejecutar el modelo con 100,000 épocas, se obtiene la siguiente salida parcial al final del entrenamiento:
1 99978 0.8438 0.8438 0.8438 0.8438
2 99979 0.8438 0.8438 0.8438 0.8438
3 99980 0.8438 0.8438 0.8438 0.8438
4 99981 0.8438 0.8438 0.8438 0.8438
5 99982 0.8417 0.8438 0.8417 0.8438
6 99983 0.8438 0.8438 0.8438 0.8438
7 99984 0.8438 0.8438 0.8438 0.8438
8 99985 0.7771 0.8438 0.7771 0.8438
9 99986 0.8438 0.8438 0.8438 0.8438
10 99987 0.8104 0.8438 0.8104 0.8438
11 99988 0.7812 0.8438 0.7812 0.8438
12 99989 0.8 0.8438 0.8 0.8438
13 99990 0.6 0.8438 0.6 0.8438
14 99991 0.7354 0.8438 0.7354 0.8438
15 99992 0.8229 0.8438 0.8229 0.8438
16 99993 0.7146 0.8438 0.7146 0.8438
17 99994 0.7146 0.8438 0.7146 0.8438
18 99995 0.8438 0.8438 0.8438 0.8438
19 99996 0.8313 0.8438 0.8313 0.8438
20 99997 0.8438 0.8438 0.8438 0.8438

8
21 99998 0.8083 0.8438 0.8083 0.8438
22 99999 0.8063 0.8438 0.8063 0.8438
23 100000 0.8396 0.8438 0.8396 0.8438

Los valores representan el error en el entrenamiento y la validación a lo largo de las épocas.

Formato del Input Binario

El input para el modelo debe estar en formato binario como el siguiente:
1 480 14 1
2 11011001011101 0
3 11001101001001 1
4 11000001011001 1
5 10001010011001 1
6 11101110101001 1
7 11000000001001 1
8 11111001010011 0
9 11101001011001 1
10 11011010101011 0
11 11101001001001 1
12 11101001011001 1
13 10001000011101 0
14 11101000001000 1
15 10001001011001 1
16 00001001000001 0
17 11000001011101 0
18 11000010010001 0
19 11011010101001 1
20 11000001010011 0
21 11001110011011 1
22 11001001011011 1
23 11100001011001 1
24 10000000001001 0
25 10001001001001 0
26 10011101011101 0
27 11001001011011 1

Donde la primera fila indica el número de muestras, el número de bits de las características y el número
de bits de la etiqueta.

Conclusiones
Después de entrenar el modelo Hypernetwork durante 100,000 épocas, observamos que el error no
disminuye más allá de un cierto punto, alcanzando una precisión máxima de aproximadamente 84.38 %.
Esto sugiere que el problema podría estar en la conversión de las características ApplicantIncome
(Ingreso del Solicitante) y LoanAmount (Monto del Préstamo) a solo 2 bits. Al reducir estas características
a categorías tan amplias, es posible que estemos perdiendo información valiosa que podría ayudar al modelo
a realizar predicciones más precisas.
Para mejorar el rendimiento, se podrían considerar las siguientes acciones:

Aumentar la granularidad de las categorías: En lugar de usar solo 2 bits (4 categorías), podríamos
aumentar el número de categorías para capturar más detalles de los ingresos y montos.

Normalización de datos: Aplicar técnicas de normalización o estandarización a las variables numé-

ricas antes de la codificación binaria.

9
 Utilizar codificación binaria directa: Convertir los valores numéricos directamente a su represen-
tación binaria sin agruparlos en categorías.
Incluir más características: Considerar otras variables del conjunto de datos que puedan aportar
información relevante al modelo.

Es importante encontrar un equilibrio entre la simplicidad del modelo y la cantidad de información que
se proporciona para evitar la pérdida de datos esenciales que puedan afectar el desempeño del modelo.

10