Spectra copy 2.py

import os
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
from sklearn.preprocessing import StandardScaler, normalize

# Función para aplicar Min-Max a cada columna
def min_max_normalize(column):
    return (column - column.min()) / (column.max() - column.min())

# Función para aplicar Normax
def normax_normalize(column):
    return column / column.max()



# Obtener la ruta del directorio donde se encuentra el script
current_dir = os.path.dirname(os.path.abspath(__file__))

# Construir la ruta completa al archivo Excel
file_path = os.path.join(current_dir, "Rice_Spectral.xlsx")

# Leer el archivo Excel
data = pd.read_excel(file_path, sheet_name="Spectral")


# Asegurarse de que los valores de "Location" sean numéricos
data['Location'] = pd.to_numeric(data['Location'], errors='coerce')

# Separar los datos de los números de onda (Wavenumbers)
wavenumbers = data['Location'].dropna()  # Eliminar posibles NaN en wavenumbers

# Filtrar las columnas que pertenecen a Java y Bangka Belitung
java_columns = [col for col in data.columns if "Java" in col]
belitung_columns = [col for col in data.columns if "Bangka Belitung" in col]

# Asegurarse de que todas las columnas de datos sean numéricas
data[java_columns] = data[java_columns].apply(pd.to_numeric, errors='coerce')
data[belitung_columns] = data[belitung_columns].apply(pd.to_numeric, errors='coerce')

# Aplicar normalización Min-Max y Normax
data_minmax = data.copy()
data_normax = data.copy()

data_minmax[java_columns] = data_minmax[java_columns].apply(min_max_normalize)
data_minmax[belitung_columns] = data_minmax[belitung_columns].apply(min_max_normalize)

data_normax[java_columns] = data_normax[java_columns].apply(normax_normalize)
data_normax[belitung_columns] = data_normax[belitung_columns].apply(normax_normalize)

# Preparar los datos para PCA y t-SNE
all_columns = java_columns + belitung_columns

# Normalización de datos (Min-Max)
spectral_data_minmax = data_minmax[all_columns].dropna().transpose()

# Estandarización de datos
scaler = StandardScaler()
spectral_data_standardized = scaler.fit_transform(spectral_data_minmax)

# Normalización Normax
spectral_data_normax = data_normax[all_columns].dropna().transpose()

# Calcular el valor máximo permitido para n_components
n_samples, n_features = spectral_data_minmax.shape
n_components = min(n_samples, n_features)

# PCA para reducir a un máximo de n_components antes de t-SNE
pca_50_minmax = PCA(n_components=n_components).fit_transform(spectral_data_minmax)
pca_50_normax = PCA(n_components=n_components).fit_transform(spectral_data_normax)
pca_50_standardized = PCA(n_components=n_components).fit_transform(spectral_data_standardized)

# PCA
pca_minmax = PCA(n_components=2).fit_transform(spectral_data_minmax)
pca_normax = PCA(n_components=2).fit_transform(spectral_data_normax)
pca_standardized = PCA(n_components=2).fit_transform(spectral_data_standardized)

# t-SNE después de reducir a n_components con PCA
tsne_minmax = TSNE(n_components=2, random_state=42).fit_transform(pca_50_minmax)
tsne_normax = TSNE(n_components=2, random_state=42).fit_transform(pca_50_normax)
tsne_standardized = TSNE(n_components=2, random_state=42).fit_transform(pca_50_standardized)

# Crear subplots
fig, axs = plt.subplots(3, 2, figsize=(14, 18))

# Gráfico de PCA Min-Max
axs[0, 0].scatter(pca_minmax[:len(java_columns), 0], pca_minmax[:len(java_columns), 1], color='blue', label='Java')
axs[0, 0].scatter(pca_minmax[len(java_columns):, 0], pca_minmax[len(java_columns):, 1], color='green', label='Bangka Belitung')
axs[0, 0].set_title('PCA Min-Max')
axs[0, 0].legend()

# Gráfico de t-SNE Min-Max
axs[0, 1].scatter(tsne_minmax[:len(java_columns), 0], tsne_minmax[:len(java_columns), 1], color='blue', label='Java')
axs[0, 1].scatter(tsne_minmax[len(java_columns):, 0], tsne_minmax[len(java_columns):, 1], color='green', label='Bangka Belitung')
axs[0, 1].set_title('t-SNE Min-Max')
axs[0, 1].legend()

# Gráfico de PCA Normax
axs[1, 0].scatter(pca_normax[:len(java_columns), 0], pca_normax[:len(java_columns), 1], color='blue', label='Java')
axs[1, 0].scatter(pca_normax[len(java_columns):, 0], pca_normax[len(java_columns):, 1], color='green', label='Bangka Belitung')
axs[1, 0].set_title('PCA Normax')
axs[1, 0].legend()

# Gráfico de t-SNE Normax
axs[1, 1].scatter(tsne_normax[:len(java_columns), 0], tsne_normax[:len(java_columns), 1], color='blue', label='Java')
axs[1, 1].scatter(tsne_normax[len(java_columns):, 0], tsne_normax[len(java_columns):, 1], color='green', label='Bangka Belitung')
axs[1, 1].set_title('t-SNE Normax')
axs[1, 1].legend()

# Gráfico de PCA Estandarizado
axs[2, 0].scatter(pca_standardized[:len(java_columns), 0], pca_standardized[:len(java_columns), 1], color='blue', label='Java')
axs[2, 0].scatter(pca_standardized[len(java_columns):, 0], pca_standardized[len(java_columns):, 1], color='green', label='Bangka Belitung')
axs[2, 0].set_title('PCA Estandarizado')
axs[2, 0].legend()

# Gráfico de t-SNE Estandarizado
axs[2, 1].scatter(tsne_standardized[:len(java_columns), 0], tsne_standardized[:len(java_columns), 1], color='blue', label='Java')
axs[2, 1].scatter(tsne_standardized[len(java_columns):, 0], tsne_standardized[len(java_columns):, 1], color='green', label='Bangka Belitung')
axs[2, 1].set_title('t-SNE Estandarizado')
axs[2, 1].legend()

# Ajustar los subplots
plt.tight_layout()
plt.show()