El ajuste lineal en lote permite procesar múltiples conjuntos de datos de manera eficiente utilizando Python. Se emplea el método de mínimos cuadrados con la biblioteca SciPy, junto con NumPy para manejo numérico y Matplotlib para visualización opcional.

Método de mínimos cuadrados con SciPy

El método de mínimos cuadrados encuentra los parámetros que minimizan la suma de los errores al cuadrado. En SciPy, la función leastsq se utiliza para esta optimización. Se define una función de modelo lineal y una función de error, proporcionando un punto inicial para los parámetros.

import numpy as np
from scipy.optimize import leastsq

def modelo_lineal(x, parametros):
    """Modelo lineal: y = m*x + c"""
    pendiente, intercepto = parametros
    return pendiente * x + intercepto

def funcion_error(parametros, datos_y, datos_x):
    """Calcula la diferencia entre datos observados y modelo"""
    return datos_y - modelo_lineal(datos_x, parametros)

# Ejemplo de ajuste para un conjunto de datos único
x_ejemplo = np.array([1.0, 2.0, 3.0, 4.0])
y_ejemplo = np.array([1.5, 3.2, 4.8, 6.0])
estimacion_inicial = [1.0, 0.0]
resultado = leastsq(funcion_error, estimacion_inicial, args=(y_ejemplo, x_ejemplo))
print(f"Pendiente ajustada: {resultado[0][0]:.4f}")
print(f"Intercepto ajustado: {resultado[0][1]:.4f}")

Procesamiento en lote con archivos

Para el ajuste en lote, se lee un archivo de texto donde cada línea contiene pares de valores x e y separados por espacios. Los parámetros ajustados se escriben en un archivo de salida.

import matplotlib.pyplot as plt

def ajustar_lote_desde_archivo(archivo_entrada, archivo_salida):
    """Procesa múltiples datasets lineales desde un archivo"""
    with open(archivo_entrada, 'r') as f_entrada, open(archivo_salida, 'w') as f_salida:
        for num_linea, linea in enumerate(f_entrada):
            valores = linea.strip().split()
            if len(valores) < 2 or len(valores) % 2 != 0:
                continue  # Saltar líneas con formato inválido
            
            # Extraer pares x, y
            x_datos = []
            y_datos = []
            for i in range(0, len(valores), 2):
                x_datos.append(float(valores[i]))
                y_datos.append(float(valores[i+1]))
            
            x_array = np.array(x_datos)
            y_array = np.array(y_datos)
            
            # Ajuste lineal
            res = leastsq(funcion_error, [1.0, 0.0], args=(y_array, x_array))
            pendiente, intercepto = res[0]
            
            # Guardar resultados
            f_salida.write(f"{pendiente:.6f} {intercepto:.6f}\n")
            
            # Visualización opcional para las primeras líneas
            if num_linea < 3:  # Graficar solo las primeras 3 líneas
                plt.figure()
                plt.plot(x_array, y_array, 'ro', label='Datos')
                plt.plot(x_array, modelo_lineal(x_array, res[0]), 'b-', label='Ajuste')
                plt.title(f"Línea {num_linea+1}: m={pendiente:.3f}, c={intercepto:.3f}")
                plt.xlabel('X')
                plt.ylabel('Y')
                plt.legend()
                plt.show()

# Ejemplo de uso
ajustar_lote_desde_archivo("datos_entrada.txt", "parametros_salida.txt")

Este script lee cada línea del archivo de entrada, realiza un ajuste lineal independiente y almacena los parámetros. La visualización se limita a las primeras entradas para evitar ventanas múltiples durante el procesamiento.