在huggingface上制作小demo

在huggingface上制作小demo

今天好兄弟让我帮他搞一个模型，他有小样本的化学数据，想让我根据这些数据训练一个小模型，他想用这个模型预测一些值
最终我简单训练了一个小模型，起初想把这个模型和GUI界面打包成exe发给他，但是发现打包后3.9GB,太大了吧！！！后来我又找了别的方案，即将训练好的模型以及相关代码、环境配置文件上传到huggingface上，通过hf的界面端直接使用这个模型，接下来我回顾一下整个流程

1.训练模型并写一个简单的GUI

训练数据

模型输入值：substance、N、C、C/N、K、Cellulose、Hemicellulose、Lignin
模型输出值：Alkaliniy400、Alkalinity600

训练代码train.py
由于样本较小，为了减小误差，这里采用5折交叉验证

import pandas as pd
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import TensorDataset, DataLoader
from sklearn.model_selection import KFold
from sklearn.preprocessing import StandardScaler, OneHotEncoder
import joblib# 定义神经网络模型
class AlkalinityNet(nn.Module):def __init__(self, input_dim):super(AlkalinityNet, self).__init__()self.model = nn.Sequential(nn.Linear(input_dim, 64),nn.ReLU(),nn.Dropout(0.2),nn.Linear(64, 32),nn.ReLU(),nn.Dropout(0.2),nn.Linear(32, 2)  # 输出两个值：400℃ 和 600℃ 碱度)def forward(self, x):return self.model(x)def train_model(model, train_loader, criterion, optimizer, device):model.train()running_loss = 0.0for X_batch, y_batch in train_loader:X_batch = X_batch.to(device)y_batch = y_batch.to(device)optimizer.zero_grad()outputs = model(X_batch)loss = criterion(outputs, y_batch)loss.backward()optimizer.step()running_loss += loss.item() * X_batch.size(0)return running_lossdef evaluate_model(model, val_loader, criterion, device):model.eval()running_loss = 0.0with torch.no_grad():for X_batch, y_batch in val_loader:X_batch = X_batch.to(device)y_batch = y_batch.to(device)outputs = model(X_batch)loss = criterion(outputs, y_batch)running_loss += loss.item() * X_batch.size(0)return running_lossdef main():# 读取 Excel 数据data = pd.read_excel('~/PycharmProjects/Alkalinity/datasets/data.xlsx')# 假设第一列为物质名称，列名为 "Substance"# 数值特征num_features = ["N", "C", "C/N", "K", "Cellulose", "Hemicellulose", "Lignin"]targets = ["Alkalinity400", "Alkalinity600"]# 提取物质类别和数值特征substances = data["Substance"].values.reshape(-1, 1)X_num = data[num_features].valuesy = data[targets].values.astype(np.float32)# 对物质类别使用 OneHotEncoder 编码encoder = OneHotEncoder(sparse_output=False, handle_unknown='ignore')X_cat = encoder.fit_transform(substances)joblib.dump(encoder, 'encoder.pkl')# 对数值特征进行标准化scaler_X = StandardScaler()X_num_scaled = scaler_X.fit_transform(X_num)joblib.dump(scaler_X, 'scaler_X.pkl')# 拼接类别特征和数值特征X_combined = np.hstack([X_cat, X_num_scaled]).astype(np.float32)# 对目标值进行标准化scaler_y = StandardScaler()y_scaled = scaler_y.fit_transform(y)joblib.dump(scaler_y, 'scaler_y.pkl')# 转换为 PyTorch tensorX_tensor = torch.from_numpy(X_combined)y_tensor = torch.from_numpy(y_scaled)# 设置设备device = torch.device("cuda" if torch.cuda.is_available() else "cpu")# 交叉验证设置kf = KFold(n_splits=5, shuffle=True, random_state=42)num_epochs = 100batch_size = 8criterion = nn.MSELoss()fold_losses = []print("开始 5 折交叉验证...")for fold, (train_index, val_index) in enumerate(kf.split(X_tensor), 1):X_train, X_val = X_tensor[train_index], X_tensor[val_index]y_train, y_val = y_tensor[train_index], y_tensor[val_index]train_dataset = TensorDataset(X_train, y_train)val_dataset = TensorDataset(X_val, y_val)train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)model = AlkalinityNet(input_dim=X_tensor.shape[1]).to(device)optimizer = optim.Adam(model.parameters(), lr=0.001)for epoch in range(num_epochs):train_loss = train_model(model, train_loader, criterion, optimizer, device)val_loss = evaluate_model(model, val_loader, criterion, device)# 这里可以打印每折每轮的损失，也可以选择每隔一定轮数打印一次# print(f"Fold {fold}, Epoch {epoch+1}/{num_epochs}, Train Loss: {train_loss/len(train_dataset):.4f}, Val Loss: {val_loss/len(val_dataset):.4f}")avg_val_loss = val_loss / len(val_dataset)print(f"第 {fold} 折验证 Loss: {avg_val_loss:.4f}")fold_losses.append(avg_val_loss)print("5 折交叉验证平均 Loss:", np.mean(fold_losses))# 在全数据集上训练最终模型final_dataset = TensorDataset(X_tensor, y_tensor)final_loader = DataLoader(final_dataset, batch_size=batch_size, shuffle=True)final_model = AlkalinityNet(input_dim=X_tensor.shape[1]).to(device)optimizer = optim.Adam(final_model.parameters(), lr=0.001)print("开始在全数据集上训练最终模型...")for epoch in range(num_epochs):train_loss = train_model(final_model, final_loader, criterion, optimizer, device)# 可打印训练进度# print(f"Epoch {epoch+1}/{num_epochs}, Loss: {train_loss/len(final_dataset):.4f}")# 保存最终模型参数torch.save(final_model.state_dict(), 'final_model.pth')print("最终模型已保存到 final_model.pth")if __name__ == '__main__':main()

推理代码eval.py

import numpy as np
import torch
import torch.nn as nn
import joblib
from sklearn.preprocessing import StandardScaler, OneHotEncoder# 定义与训练时相同的网络结构
class AlkalinityNet(nn.Module):def __init__(self, input_dim):super(AlkalinityNet, self).__init__()self.model = nn.Sequential(nn.Linear(input_dim, 64),nn.ReLU(),nn.Dropout(0.2),nn.Linear(64, 32),nn.ReLU(),nn.Dropout(0.2),nn.Linear(32, 2))def forward(self, x):return self.model(x)def predict_alkalinity(input_data):"""参数 input_data 为字典，包含以下键值："Substance": 物质名称，例如 "玉米秸秆""N", "C", "C/N", "K", "Cellulose", "Hemicellulose", "Lignin"返回预测的 [400℃ 碱度, 600℃ 碱度]"""# 数值特征顺序与训练时一致num_features = ["N", "C", "C/N", "K", "Cellulose", "Hemicellulose", "Lignin"]# 提取物质名称与数值特征substance = np.array([[input_data["Substance"]]])X_num = np.array([input_data[feat] for feat in num_features]).reshape(1, -1).astype(np.float32)# 加载保存的 OneHotEncoder 和 StandardScalerencoder = joblib.load('encoder.pkl')scaler_X = joblib.load('scaler_X.pkl')scaler_y = joblib.load('scaler_y.pkl')X_cat = encoder.transform(substance)X_num_scaled = scaler_X.transform(X_num)# 拼接类别特征和数值特征X_combined = np.hstack([X_cat, X_num_scaled]).astype(np.float32)# 转换为 tensorX_tensor = torch.from_numpy(X_combined)# 加载模型，注意输入维度需与训练时保持一致input_dim = X_combined.shape[1]model = AlkalinityNet(input_dim=input_dim)# 加载模型参数model.load_state_dict(torch.load('final_model.pth', map_location=torch.device('cpu'), weights_only=True))model.eval()with torch.no_grad():y_pred_tensor = model(X_tensor)y_pred_scaled = y_pred_tensor.numpy()# 将预测结果反标准化y_pred = scaler_y.inverse_transform(y_pred_scaled)return y_pred[0]if __name__ == '__main__':# 示例输入，请根据实际物质成分调整数值input_data = {"Substance": "鸡粪","N": 1.0,"C": 40.0,"C/N": 40.0,"K": 2.5,"Cellulose": 29.0,"Hemicellulose": 25.0,"Lignin": 12.0}result = predict_alkalinity(input_data)print("预测 400℃ 碱度：", result[0])print("预测 600℃ 碱度：", result[1])

本地推理看看

GUI界面代码app.py

import tkinter as tk
from tkinter import messagebox
import tkinter.font as tkFont
import joblib
import numpy as np
import torch
import torch.nn as nn# 定义与训练时一致的模型结构
class AlkalinityNet(nn.Module):def __init__(self, input_dim):super(AlkalinityNet, self).__init__()self.model = nn.Sequential(nn.Linear(input_dim, 64),nn.ReLU(),nn.Dropout(0.2),nn.Linear(64, 32),nn.ReLU(),nn.Dropout(0.2),nn.Linear(32, 2)  # 输出 400℃ 和 600℃ 的碱度值)def forward(self, x):return self.model(x)def predict():try:# 获取用户输入的各项数值substance = entry_substance.get()N = float(entry_N.get())C = float(entry_C.get())C_N = float(entry_CN.get())K = float(entry_K.get())cellulose = float(entry_cellulose.get())hemicellulose = float(entry_hemicellulose.get())lignin = float(entry_lignin.get())except ValueError:messagebox.showerror("输入错误", "请确保所有数值项均正确填写")return# 构造输入字典input_data = {"Substance": substance,"N": N,"C": C,"C/N": C_N,"K": K,"Cellulose": cellulose,"Hemicellulose": hemicellulose,"Lignin": lignin}try:# 加载保存的预处理器encoder = joblib.load('encoder.pkl')scaler_X = joblib.load('scaler_X.pkl')scaler_y = joblib.load('scaler_y.pkl')except Exception as e:messagebox.showerror("加载错误", f"加载预处理器失败：{e}")return# 对物质类别特征进行 one-hot 编码substance_arr = np.array([[input_data["Substance"]]])X_cat = encoder.transform(substance_arr)# 数值特征转换与标准化X_num = np.array([[input_data["N"], input_data["C"], input_data["C/N"], input_data["K"],input_data["Cellulose"], input_data["Hemicellulose"], input_data["Lignin"]]], dtype=np.float32)X_num_scaled = scaler_X.transform(X_num)# 拼接特征X_combined = np.hstack([X_cat, X_num_scaled]).astype(np.float32)X_tensor = torch.from_numpy(X_combined)# 加载模型（注意：模型参数文件和输入预处理器需放在同一目录下）input_dim = X_combined.shape[1]model = AlkalinityNet(input_dim=input_dim)try:model.load_state_dict(torch.load('final_model.pth', map_location=torch.device('cpu'), weights_only=True))except Exception as e:messagebox.showerror("加载模型错误", f"加载模型失败：{e}")returnmodel.eval()with torch.no_grad():y_pred_tensor = model(X_tensor)y_pred_scaled = y_pred_tensor.numpy()# 反标准化得到预测值y_pred = scaler_y.inverse_transform(y_pred_scaled)pred_400 = y_pred[0, 0]pred_600 = y_pred[0, 1]# 在界面上显示预测结果label_pred_400.config(text=str(pred_400))label_pred_600.config(text=str(pred_600))# 创建 GUI 主窗口
root = tk.Tk()
root.title("碱度预测模型")# 设置参考尺寸与基础字体大小（可根据需要调整）
REF_WIDTH = 800
REF_HEIGHT = 600
BASE_FONT_SIZE = 18# 用于存放所有需要动态调整字体的控件
widgets_to_update = []# 创建一个默认字体对象，初始大小 BASE_FONT_SIZE
default_font = tkFont.Font(family="SimSun", size=BASE_FONT_SIZE)# 辅助函数：创建标签并加入更新列表（居中显示）
def create_label(text, row, col):lbl = tk.Label(root, text=text, font=default_font, anchor="center")lbl.grid(row=row, column=col, padx=5, pady=5, sticky="nsew")widgets_to_update.append(lbl)return lbl# 辅助函数：创建输入框并加入更新列表（内容居中）
def create_entry(row, col):ent = tk.Entry(root, font=default_font, justify="center")ent.grid(row=row, column=col, padx=5, pady=5, sticky="nsew")widgets_to_update.append(ent)return ent# 定义行列权重，使控件居中扩展
for i in range(11):root.grid_rowconfigure(i, weight=1)
for j in range(2):root.grid_columnconfigure(j, weight=1)# 创建左侧标签
label_substance = create_label("物质", 0, 0)
label_N = create_label("N", 1, 0)
label_C = create_label("C", 2, 0)
label_CN = create_label("C/N", 3, 0)
label_K = create_label("K", 4, 0)
label_cellulose = create_label("纤维素", 5, 0)
label_hemicellulose = create_label("半纤维素", 6, 0)
label_lignin = create_label("木质素", 7, 0)
label_400 = create_label("400摄氏度碱度", 8, 0)
label_600 = create_label("600摄氏度碱度", 9, 0)# 创建右侧输入框
entry_substance = create_entry(0, 1)
entry_N = create_entry(1, 1)
entry_C = create_entry(2, 1)
entry_CN = create_entry(3, 1)
entry_K = create_entry(4, 1)
entry_cellulose = create_entry(5, 1)
entry_hemicellulose = create_entry(6, 1)
entry_lignin = create_entry(7, 1)# 用于显示预测结果的标签（400℃ 和 600℃）
label_pred_400 = create_label("未预测", 8, 1)
label_pred_600 = create_label("未预测", 9, 1)# 预测按钮（也加入更新列表）
predict_button = tk.Button(root, text="预测", font=default_font, command=predict)
predict_button.grid(row=10, column=0, columnspan=2, pady=10)
widgets_to_update.append(predict_button)# 定义一个函数，在窗口大小变化时更新所有控件的字体大小
def on_resize(event):# 根据窗口当前尺寸与参考尺寸计算缩放比例scale_factor = min(event.width / REF_WIDTH, event.height / REF_HEIGHT)new_font_size = max(int(BASE_FONT_SIZE * scale_factor), 8)  # 设置最小字体为8# 更新所有控件字体new_font = (default_font.actual("family"), new_font_size)for widget in widgets_to_update:widget.config(font=new_font)# 绑定窗口尺寸变化事件
root.bind("<Configure>", on_resize)root.mainloop()

本地运行看看效果

2.在huggingface上创建Space

点击new space

填写相关信息后点击Create

3.上传模型、代码、环境配置文件

上传你的模型和相应代码、以及requirements.txt

requirements.txt中直接写需要用到的库

上传文件中需要有个名为 app.py的文件，huggingface会根据这个文件创建网页端应用
为了能够让hf分享别人可以访问的public链接，在app.py中添加参数share=True

# Launch the app with shareable link
if __name__ == "__main__":iface.launch(share=True)

为了不让模型自动推理运行，而是让它点击运行时才推理，我们需要将app.py中 live=True设置为False

# Create Gradio interface
iface = gr.Interface(fn=predict,inputs=[gr.Textbox(label="Substance", placeholder="Enter substance"),gr.Number(label="N"),gr.Number(label="C"),gr.Number(label="C/N"),gr.Number(label="K"),gr.Number(label="Cellulose"),gr.Number(label="Hemicellulose"),gr.Number(label="Lignin")],outputs=[gr.Number(label="400℃ Alkalinity"),gr.Number(label="600℃ Alkalinity")],live=False,  # Disable live prediction to avoid automatic predictiontitle="Alkalinity Prediction Model",description="Input relevant data and click the 'Predict' button to get predictions."
)

hf会根据环境配置文件下载相关库并根据app.py创建应用

这样就可以在网页端直接使用模型

将左侧输入值填入后，点击submit后模型输出值显示到右侧

将分享链接分享给好兄弟后，他就可以直接在网页端使用我训练好的简单模型了