Miscelanea 1

Aburto López Francisco Javier, Ayala Carreño Oscar,

Bolaños Benitez Enrique, Gomez Henandez Omar Alejandro,
Mares Marroquin David Denilson, Narvaez Guerrero Sunny Karlo

8 de marzo del 2025

1. Extrapolación
1.1. Extrapolación
Es una técnica que estudia patrones o tendencias para poder hacer predicciones o
estimaciones dentro de un conjunto de datos que tengamos, el punto clave de esta
técnica es que no tiene como limite el rango que se tiene, si no que sobresale para
poder sacar suposiciones en un area del conjunto donde no hay registros, el problema
de la tećnica es que puede generar cierta incertidumbre de las predicciones ya que estas
no pueden ser asumidas por el hecho de que siempre tendran la misma tendencia.

La diferencia de cada una de estas técnicas es que la extrapolación hace un estudio de

las tendencias para sacar predicciones, estas fuera del rango o intervalo del conjunto
de datos, por lo contrario la interpolación lo hace dentro del rango o intervalo del
conjunto de datos que se tiene, como resumen de la ultima, es que hace el estudio
de las tendencias para sacar predicciones o valores intermedios de datos conocidos y
teniendo como idea que tienen una relación predecible entre estos datos.

Importancia de la extrapolación e interpolación en la vida laboral Estas herramientas

matemáticas son fundamentales en diversas aplicaciones profesionales, especialmente
en disciplinas como la ciencia de datos, la ingenierı́a, la economı́a y la fı́sica. En par-
ticular, en áreas como la modelación computacional y la predicción de tendencias, la
interpolación permite reconstruir datos faltantes con alta precisión, mientras que la
extrapolación ayuda a prever escenarios futuros basándose en patrones previos.
Por ejemplo, en la industria financiera, la interpolación es clave para construir cur-
vas de rendimiento de bonos a partir de tasas de interés observadas, mientras que la
extrapolación permite estimar el comportamiento de activos en escenarios de crisis o
expansión económica.

1
 Un ejemplo donde se puede aplicar la extrapolación es en la predicción del calentamien-
to global. Si se tienen registros de temperatura media global desde 1900 hasta 2020,
se puede ajustar un modelo matemático basado en estos datos y utilizar extrapolación
para estimar la temperatura en el año 2050. Sin embargo, dado que existen factores
externos impredecibles, como cambios en las polı́ticas ambientales o eventos catastrófi-
cos, la extrapolación debe realizarse con cautela y en combinación con modelos más
complejos que incluyan incertidumbre.

1.2. Regresión Lineal Simple

1.

2
3
 2.
#i n c l u d e <s t d i o . h>
#i n c l u d e < s t d l i b . h>

i n t IngresoDatos ( f l o a t ∗∗ , f l o a t ∗ ∗ ) ;
v o i d ImprimirDatos ( f l o a t ∗ , f l o a t ∗ , i n t ) ;
f l o a t CalcularBetaUno ( f l o a t ∗ , f l o a t ∗ , i n t ) ;
f l o a t CalcularBetaCero ( f l o a t ∗ , f l o a t ∗ , int , f l o a t ) ;

i n t main ( ) {

i n t opc = 0 , n = 0 ;
f l o a t ∗x = ( f l o a t ∗ ) m a l l o c ( s i z e o f ( f l o a t ) ) ;
f l o a t ∗y = ( f l o a t ∗ ) m a l l o c ( s i z e o f ( f l o a t ) ) ;
f l o a t beta uno , b e t a c e r o ;

do{
system ( ” c l s ” ) ;
p r i n t f (”\ t . : Menu : . \ n\n1 . I n g r e s a r d a t o s \n2 . Imprimir d a t o s \n
3 . C a l c u l a r e s t i m a d o r e s \n4 . S a l i r \n? ” ) ;
s c a n f (” %d ” , &opc ) ;
s w i t c h ( opc ){
case 1:
system ( ” c l s ” ) ;
n = I n g r e s o D a t o s (&x , &y ) ;
system ( ” pause ” ) ;
break ;
case 2:
system ( ” c l s ” ) ;
ImprimirDatos ( x , y , n ) ;
system ( ” pause ” ) ;
break ;
case 3:
system ( ” c l s ” ) ;
b e t a u n o = CalcularBetaUno ( x , y , n ) ;
b e t a c e r o = CalcularBetaCero (x , y , n , beta uno ) ;
p r i n t f ( ” 3 . C a l c u l a r e s t i m a d o r e s \n\n ” ) ;
p r i n t f ( ” Beta Uno = %.2 f \ tBeta Cero = %.2 f \n\n ” , beta uno ,
beta cero );
system ( ” pause ” ) ;
break ;
case 4:
break ;
default :

4
 p r i n t f (”\ n I n g r e s e un v a l o r v a l i d o \n\n ” ) ;
system ( ” pause ” ) ;
}
} w h i l e ( opc ! = 4 ) ;
free (x );
free (y );

return 0;

i n t I n g r e s o D a t o s ( f l o a t ∗∗x , f l o a t ∗∗ y ){

int n , i ;

p r i n t f ( ” 1 . I n g r e s o de d a t o s \n\n ” ) ;
p r i n t f ( ” Cantidad de d a t o s : ” ) ;
s c a n f (” %d ” , &n ) ;
∗x = ( f l o a t ∗ ) r e a l l o c ( ∗ x , n ∗ s i z e o f ( f l o a t ) ) ;
∗y = ( f l o a t ∗ ) r e a l l o c ( ∗ y , n ∗ s i z e o f ( f l o a t ) ) ;
i f ( ∗ x == NULL | | ∗y == NULL) {
p r i n t f ( ” E r r o r a l a s i g n a r memoria . \ n ” ) ;
exit (1);
}
p r i n t f (”\ n I n g r e s o de d a t o s : \ n\n ” ) ;
f o r ( i =0; i <n ; i ++){
p r i n t f ( ” x%d : ” , i + 1 ) ;
s c a n f (” % f ” , ( ∗ x ) + i ) ;
p r i n t f ( ” y%d : ” , i + 1 ) ;
s c a n f (” % f ” , ( ∗ y ) + i ) ;
p r i n t f (”\ n ” ) ;
}

return n ;
}

v o i d ImprimirDatos ( f l o a t ∗x , f l o a t ∗y , i n t n ){

int i ;

p r i n t f ( ” 2 . I m p r e s i o n de d a t o s \n\n ” ) ;
i f ( n == 0){
p r i n t f ( ”No hay d a t o s \n\n ” ) ;
return ;
}

5
 f o r ( i =0; i <n ; i ++){
p r i n t f ( ” x%d = %.2 f \ t y%d = %.2 f \n ” , i +1, ∗ ( x+i ) , i +1, ∗ ( y+i ) ) ;
}
p r i n t f (”\ n ” ) ;

f l o a t CalcularBetaUno ( f l o a t ∗x , f l o a t ∗y , i n t n ){

int i ;
f l o a t x mean = 0 , y mean = 0 , num = 0 , den = 0 ;

f o r ( i =0; i <n ; i ++){

x mean += ∗ ( x+i ) ;
y mean += ∗ ( y+i ) ;
}
x mean = x mean / n ;
y mean = y mean / n ;

f o r ( i =0; i <n ; i ++){

num += ( ∗ ( x+i ) − x mean ) ∗ ( ∗ ( y+i ) − y mean ) ;
den += ( ∗ ( x+i ) − x mean ) ∗ ( ∗ ( x+i ) − x mean ) ;
}

r e t u r n num/ den ;

f l o a t C a l c u l a r B e t a C e r o ( f l o a t ∗x , f l o a t ∗y , i n t n , f l o a t b e t a u n o ){

int i ;
f l o a t x mean = 0 , y mean = 0 ;

f o r ( i =0; i <n ; i ++){

x mean += ∗ ( x+i ) ;
y mean += ∗ ( y+i ) ;
}
x mean = x mean / n ;
y mean = y mean / n ;

r e t u r n y mean − b e t a u n o ∗ x mean ;

6
3.

7
8
5.

9
10
11
12
13
14
15
16
 4.

import pandas as pd
import [Link] as plt

df = pd.read_csv("Problema_2.csv")

df["x-mean"] = df["age"] - df["age"].mean()

df["y-mean"] = df["charges"] - df["charges"].mean()
df["x-mean_squared"] = df["x-mean"] ** 2
df["x-mean*y-mean"] = df["x-mean"] * df["y-mean"]

beta_1 = df["x-mean*y-mean"].sum() / df["x-mean_squared"].sum()

beta_0 = df["charges"].mean() - df["age"].mean() * beta_1

print(beta_1, beta_0)

132.87216029142903 9196.110482348551

df["predicted"] = beta_0 + beta_1 * df["bmi"]

df["abs_error"] = abs(df["predicted"] - df["charges"])

error = df["abs_error"].sum()
error

12150315.038997978

[Link](figsize=(12, 8))
[Link](df["age"], df["charges"], color='blue',marker='o', label='Datos')
[Link](df["age"], df["predicted"], color='red', linestyle='--')
# Personalizar la gráfica
[Link]('Eje X')
[Link]('Eje Y')
[Link]('Regresión Lineal Calculada Manualmente')
[Link]()
[Link](True)
# Mostrar la gráfica
[Link]()

17
1.3. Regresion Lineal Multiple
1. La fórmula para estimar el vector β en la regresión lineal múltiple es:

β = (X T X)−1 (X T Y )

Siendo:
X T : La matriz transpuesta de observaciones de las k variables regresoras con dimensión
(k + 1) x n.
X : La matriz de observaciones de las k variables regresoras con dimensión n x (k + 1).
(X T X)−1 : La matriz inversa del producto matricial de X T y X.
Y : El vector columna de los parámetros desconocidos de dimensión n x 1.

2.

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
import [Link] as plt
from [Link] import mean_squared_error, r2_score

df_pandas = pd.read_csv("[Link]")
df_pandas.head()

18
 Date Close High Low
0 2020-03-09 90.030502 93.138496 88.064499
1 2020-03-10 94.591003 94.713501 90.908501
2 2020-03-11 91.042999 93.566002 90.074997
3 2020-03-12 83.830498 88.250000 83.750000
4 2020-03-13 89.250000 89.315498 84.030998

Open Volume
0 88.693001 156264000
1 93.543999 142666000
2 92.892502 112496000
3 86.098999 226924000
4 87.750000 176194000

df_pandas = df_pandas[["Date","Close","Open","High","Low"]]
df_pandas = df_pandas.dropna()

Y = df_pandas["Close"]
X = df_pandas[["Open","High","Low"]]

X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2,

random_state=42)

model = LinearRegression()
[Link](X_train, y_train)

y_pred = [Link](X_test)

[Link]( y_test, y_pred, color="blue")

[Link]([min(y_test), max(y_test)], [min(y_test), max(y_test)], color="red",
linestyle="--")
[Link]("Valores Reales")
[Link]("Predicciones")
[Link]("Regresión Lineal Múltiple - Amazon dataset")
[Link]()

19
df_prueba = [Link](X_test)

df_prueba["y_1"] = y_test
df_prueba["y_2"] = y_pred

df_prueba.head(5)

20
 Open High Low y_1 y_2
435 180.104996 181.675003 175.207504 175.227997 177.561937
101 162.199997 162.341003 157.550003 158.233994 158.629834
51 123.893501 125.000504 123.363503 124.897003 124.384014
63 125.010002 126.500000 124.366997 126.203003 125.736032
1072 187.059998 187.770004 184.539993 187.229996 185.680998

r2_score(y_pred,y_test)
0.9989421982450787
import numpy as np
import pandas as pd
# Crear un DataFrame de ejemplo (simulando la lectura de un CSV)
[Link](42)
n = 100
df = [Link]({'X1': [Link](n) * 10,
'X2': [Link](n) * 5,
'Y': 3 + 2.5 * [Link](n) * 10 + 1.8 * [Link](n) * 5 +
[Link](n) * 2
})
# Extraer la matriz de datos y separar variables independientes y dependiente
# Suponiendo que las dos primeras columnas son X y la última es Y
data = df.to_numpy()
X_data = data[:, :-1] # Variables independientes (X1 y X2)
y_data = data[:, -1] # Variable dependiente (Y)
# Agregar una columna de unos a X_data para el intercepto
X_data = np.column_stack(([Link](X_data.shape[0]), X_data))
y_data = y_data.reshape(-1, 1)
# Resolver en formato matricial:
# 1. Calcular X^T * X
XT_X = X_data.T @ X_data
# 2. Invertir la matriz (X^T * X)^-1
XT_X_inv = [Link](XT_X)
# 3. Calcular X^T * y
XT_y = X_data.T @ y_data
# 4. Calcular los coeficientes beta
beta = XT_X_inv @ XT_y
print("Coeficientes beta (formato matricial):")
print(beta)
Coeficientes beta (formato matricial):
[[24.01801075]
[-0.33912102]
[-0.79788576]]

21
[Link]()

X1 X2 Y
0 3.745401 0.157146 22.126884
1 9.507143 3.182052 9.927698
2 7.319939 1.571780 13.270340
3 5.986585 2.542853 30.580190
4 1.560186 4.537832 25.343881

list(beta[0])[0]

24.0180107484869

beta[0][0] , beta[1][0] ,beta[2][0]

(24.0180107484869, -0.33912101585646154, -0.7978857569020334)

df["Y_predict"] = beta[0][0]+beta[1][0]*df["X1"] + beta[2][0]*df["X2"]

[Link]()

X1 X2 Y Y_predict
0 3.745401 0.157146 22.126884 22.622482
1 9.507143 3.182052 9.927698 18.255025
2 7.319939 1.571780 13.270340 20.281565
3 5.986585 2.542853 30.580190 19.958927
4 1.560186 4.537832 25.343881 19.868247

Interpretación de la prediccion de la variable ”Close”:

Primero definimos a Y como la variable dependiente, esta será la columna ”Close”, esta
es la comuna que deseamos predecir con el modelo, posteriormente asignamos las variables
independientes como X y estás serán ”Open”, ”High”, y ”Low”.

Después ajustamos el conjunto de datos con la ley de pareto de 80 y 20, esto dirigido a
un 20 de entrenamiento y el 80 del porcentaje al test.

Como tercera parte creamos un objeto que nos sirva para instanciar el modelo de regre-
sion lineal en este caso usaremos ”model”.

Como cuarta parte asignamos el modelo de entrenamiento del 20 a las variables de X y Y.

Como quinta parte usamos otro objeto para instanciar el modelo del 80 que es el test,
esta es la parte de la regresion lienal que usa el modelo ya entrenado para predecir los valores
de ”Close”.

22
 Como sexta parte se programa la aprte gráfica para poder ver los puntos y otra parte
dond ese traza la recta de manera que representa el caso ideal en el que las predicciones
coinciden.

Como septima parte agregamos las varibles de y pred y y prueba al csv, para poder usar-
las mas adelante en las betas.

Para terminar, importamos las librerias de pandas y numpy, esta ultima para ayudar con
la parte programativa de las matrices, primero usamos un dataframe para extraer de el los
datos de manera matricial y obtener los coeficientes beta, al final se crea una nueva columna
donde obtendremos y predict sumando beta[0][0] y beta[1][0] y multiplicando la suma por el
df[”X1”] y sumando el resultado del prodcuto de beta [2][0] y el dataframe [”X2”].

2. Modelación Supervisada
2.1. Regresión Logı́stica
Código en Python:

import pandas as pd
from [Link] import StandardScaler
from sklearn.linear_model import LinearRegression
from [Link] import mean_squared_error, r2_score, accuracy_score,
confusion_matrix
from sklearn.linear_model import LogisticRegression

# La tabla esa
df = pd.read_csv("Migrantes_recientes_y_no_migrantes_por_sexo_segun_entidad_
federativa__1990_-_2010.csv")

#filas
print([Link]())

# Variables dependientes
y = df["MRTOT"]

# Variables independientes
X = [Link](columns=["MRTOT", "A~
NO", "NOM_ENT"])

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Regresión Lineal
model = LinearRegression()
[Link](X_scaled, y)

23
print("\nIntercepto:", model.intercept_)
print("\nCoeficientes:", model.coef_)
y_pred = [Link](X_scaled)
err = mean_squared_error(y, y_pred)
r2 = r2_score(y, y_pred)
print("\nError cuadratico medio:", err)
print("\nR^2:", r2)

# Para la regresion logistica, si no me equivoco, eso de dependiente a binaria

y_binary = (df["MRTOT"] > 1000000).astype(int)

# regresion logistica
logistic_model = LogisticRegression()
logistic_model.fit(X_scaled, y_binary)
print("\nIntercepto de regresion logistica:", logistic_model.intercept_)
print("\nCoeficientes de regresion logistica:", logistic_model.coef_)
y_log_pred = logistic_model.predict(X_scaled)
accuracy = accuracy_score(y_binary, y_log_pred)
print("\nPrecisión del modelo de regresion logistica:", accuracy)

# Matriz
conf_matriz = confusion_matrix(y_binary, y_log_pred)
print("\nMatriz de confusion de regresion logistica:\n\n", conf_matriz)

Salida del código:

NOM_ENT MRH_ABS MRH_REL MRM_ABS MRM_REL MRTOT \

0 Aguascalientes 21196 48.159593 22816 51.840407 44012
1 Baja California 113632 51.452583 107216 48.547417 220848
2 Baja California Sur 15569 52.706591 13970 47.293409 29539
3 Campeche 17707 51.324638 16793 48.675362 34500
4 Coahuila 34532 49.845550 34746 50.154450 69278

NMH_ABS NMH_REL NMM_ABS NMM_REL NMTOT A~

NO
0 275935 48.333757 294960 51.666243 570895 1990
1 584785 49.610899 593958 50.389101 1178743 1990
2 123258 50.669243 120002 49.330757 243260 1990
3 209685 50.096042 208881 49.903958 418566 1990
4 816471 49.464025 834165 50.535975 1650636 1990

Intercepto: 209181.898989899

Coeficientes: [ 2.88585199e+05 3.78349796e-10 2.97264264e+05

3.09228199e-11 -6.83940016e-10 1.29148248e-10 2.32830644e-10
7.45785655e-11 -1.60071068e-10]

24
Error cuadratico medio: 3.6584123021865283e-19

R^2: 1.0

Intercepto de regresion logistica: [-6.85203091]

Coeficientes de regresion logistica: [[ 0.42132506 -0.01289231 0.42385772

0.01289231 0.37410015 0.00598889
0.37057114 -0.00598889 0.37228722]]

Precisión del modelo de regresion logistica: 1.0

Matriz de confusion de regresion logistica:

[[96 0]
[ 0 3]]

Pues esta regresión lineal puede solucionar la predicción del total de migrante en función
de otras variables que están como para cualquier entidad federativa estando basado en otras
caracterı́sticas, como el número de migrantes recientes o no migrantes. Y lo que se puede
entender es que se puede determinar qué factores tienen un mayor impacto en los totales de
migrantes o en la clasificación de las entidades.

3. Bibliografı́a
Gautschi, W. (2011). Numerical analysis. Springer Science & Business Media.

25