颜值爆表投诉却居全国榜首 云南的旅游业怎么了？

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
本脚本用于将大众点评格式的CSV数据（如train_dianping.csv）转换为FastText训练所需的格式。
输入: train_dianping.csv（第1列为文本内容，第2列为情感标签：0=负面，1=正面）
输出: fasttext_data_dianping.txt（每行为: __label__negative/positive + 空格 + 文本内容）
"""

import csv  # 导入csv模块用于处理CSV文件
import os   # 导入os模块用于文件路径和存在性判断


def process_dianping_to_fasttext(input_file, output_file):
    """
    读取大众点评格式的CSV文件，转换为FastText格式并写入输出文件。
    参数：
        input_file (str): 输入的CSV文件路径
        output_file (str): 输出的FastText格式文件路径
    返回：
        bool: 处理是否成功
    """
    processed_count = 0  # 统计已处理的样本数
    
    try:
        # 以utf-8编码分别打开输入和输出文件，准备读写
        with open(input_file, 'r', encoding='utf-8') as infile, \
             open(output_file, 'w', encoding='utf-8') as outfile:
            
            csv_reader = csv.reader(infile)  # 创建CSV读取器
            
            # 跳过表头（如果有表头可取消注释）
            # next(csv_reader, None)
            
            for row in csv_reader:
                # 确保每行至少有两列（文本和标签）
                if len(row) >= 2:
                    text = row[0].strip()  # 获取文本内容并去除首尾空白
                    sentiment = row[1].strip()  # 获取情感标签并去除首尾空白
                    
                    # 跳过空文本
                    if not text:
                        continue
                    
                    # 将情感标签转换为FastText格式的label
                    if sentiment == '0':
                        label = '__label__negative'
                    elif sentiment == '1':
                        label = '__label__positive'
                    else:
                        # 遇到未知标签时警告并跳过
                        print(f"Warning: Unknown sentiment value '{sentiment}' in row {processed_count + 1}")
                        continue
                    
                    # 清理文本内容：去除多余空格和换行
                    text = ' '.join(text.split())
                    
                    # 按FastText要求写入：标签+空格+文本
                    outfile.write(f"{label} {text}\n")
                    processed_count += 1
                    
                    # 每处理10000条输出一次进度
                    if processed_count % 10000 == 0:
                        print(f"Processed {processed_count} records...")
    
    except FileNotFoundError:
        # 输入文件不存在时的异常处理
        print(f"Error: Input file '{input_file}' not found.")
        return False
    except Exception as e:
        # 其他异常处理
        print(f"Error processing file: {e}")
        return False
    
    # 输出处理结果
    print(f"Successfully processed {processed_count} records.")
    print(f"Output saved to: {output_file}")
    return True

def main():
    """
    主程序入口：指定输入输出文件路径，检查输入文件是否存在，调用处理函数，输出处理进度和部分结果。
    """
    # 指定输入和输出文件名
    input_file = "train_dianping.csv"
    output_file = "fasttext_data_dianping.txt"
    
    # 检查输入文件是否存在，避免后续出错
    if not os.path.exists(input_file):
        print(f"Error: Input file '{input_file}' not found in current directory.")
        print("Please make sure the file exists and run the script from the correct directory.")
        return
    
    print(f"Processing {input_file}...")
    print(f"Output will be saved to {output_file}")
    
    # 调用处理函数进行格式转换
    success = process_dianping_to_fasttext(input_file, output_file)
    
    if success:
        print("\nProcessing completed successfully!")
        
        # 成功后展示输出文件的前5行，方便用户快速查看结果格式
        try:
            with open(output_file, 'r', encoding='utf-8') as f:
                print("\nFirst 5 lines of output:")
                for i, line in enumerate(f):
                    if i >= 5:
                        break
                    print(f"{i+1}: {line.strip()}")
        except Exception as e:
            print(f"Error reading output file: {e}")
    else:
        print("Processing failed!")

# 脚本入口判断，支持直接运行
if __name__ == "__main__":
    main()

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import fasttext
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
import os
import time

def prepare_data():
    """
    准备中文意图分类的训练数据
    返回: 
        train_file (str): 训练数据文件路径
        test_file (str): 测试数据文件路径
    """
    # 从文件读取数据
    data = []
    with open('fasttext_data_dianping.txt', 'r', encoding='utf-8') as f:
        for line in f:
            line = line.strip()
            if line:  # 确保不是空行
                # 分割标签和文本，只分割第一个空格
                if ' ' in line:
                    label, text = line.split(' ', 1)
                    data.append((label.strip(), text.strip()))

    print(f"原始数据集大小: {len(data)}")
    
    # 创建DataFrame
    df = pd.DataFrame(data, columns=["label", "text"])
    # 统计各个类别的数据量
    label_counts = df['label'].value_counts()
    print("\n各类别数据量统计:")
    for label, count in label_counts.items():
        print(f"  {label}: {count}条")
    
    # 对于超过1000条数据的分类，只选择1000条
    balanced_data = []
    for label in label_counts.index:
        label_data = df[df['label'] == label]
        if len(label_data) > 100000:
            print(f"  将{label}类别数据从{len(label_data)}条减少到100000条")
            label_data = label_data.sample(100000, random_state=1)
        balanced_data.append(label_data)
    
    # 合并平衡后的数据
    balanced_df = pd.concat(balanced_data)
    print(f"平衡后的数据集大小: {len(balanced_df)}")
    
    # 分割训练集和测试集
    train_df, test_df = train_test_split(balanced_df, test_size=0.1, random_state=42)
    
    # 保存为FastText格式的临时文件
    train_file = "fasttext_train.txt"
    test_file = "fasttext_test.txt"
    
    # 写入训练数据
    with open(train_file, 'w', encoding='utf-8') as f:
        for _, row in train_df.iterrows():
            f.write(f"{row['label']} {row['text']}\n")
    
    # 写入测试数据
    with open(test_file, 'w', encoding='utf-8') as f:
        for _, row in test_df.iterrows():
            f.write(f"{row['label']} {row['text']}\n")
    
    return train_file, test_file

def train_model(train_file, model_path="fasttext_model.bin"):
    """
    训练FastText分类器
    参数:
        train_file (str): 训练数据文件路径
        model_path (str): 模型保存路径
    返回:
        model: 训练好的FastText模型
    """
    start_time = time.time()
    
    model = fasttext.train_supervised(
        input=train_file,
        lr=0.05,            # 学习率
        epoch=100,           # 训练轮数
        wordNgrams=2,       # n-gram特征的最大长度
        dim=128,            # 词向量维度
        loss='softmax',      # 损失函数
        bucket=200000,       # 词典大小
        lrUpdateRate=50,    # 学习率更新频率
        minCount=3,         # 最小词频
        verbose=2,           # 输出详细信息
        thread=8,            # 使用的线程数
        ws=5,                # 窗口大小
        minn=3, maxn=6       # n-gram特征的最小和最大长度
    )

    # 保存模型
    model.save_model(model_path)
    training_time = time.time() - start_time
    print(f"模型训练完成，耗时: {training_time:.2f}秒")
    print(f"模型已保存至 {model_path}")
    
    return model

def evaluate_model(model, test_file):
    """
    在测试数据上评估模型
    参数:
        model: 训练好的FastText模型
        test_file (str): 测试数据文件路径
    """
    # 评估模型
    result = model.test(test_file)
    print(f"\n测试样本数量: {result[0]}")
    print(f"精确率: {result[1]:.4f}")
    print(f"召回率: {result[2]:.4f}")
    print(f"F1分数: {2 * result[1] * result[2] / (result[1] + result[2]):.4f}")
    
    # 获取测试数据的预测结果
    y_true = []
    y_pred = []
    with open(test_file, 'r', encoding='utf-8') as f:
        for line in f:
            label = line.split(' ')[0]
            text = ' '.join(line.split(' ')[1:]).strip()
            y_true.append(label)
            pred_label = model.predict(text)[0][0]
            y_pred.append(pred_label)
    
    # 打印分类报告
    print("\n详细分类报告:")
    print(classification_report(y_true, y_pred))

def predict_example(model, text):
    """
    对单个示例进行预测
    参数:
        model: 训练好的FastText模型
        text (str): 待分类的文本
    """
    labels, probs = model.predict(text)
    print(f"\n文本: {text}")
    for label, prob in zip(labels, probs):
        print(f"预测标签: {label.replace('__label__', '')}")
        print(f"置信度: {prob:.4f}")

def main():
    # 准备数据
    print("准备数据中...")
    train_file, test_file = prepare_data()
    
    # 训练模型
    print("\n训练模型中...")
    model = train_model(train_file)
    
    # 评估模型
    print("\n评估模型中...")
    evaluate_model(model, test_file)
    
    # 示例预测
    print("\n进行示例预测...")
    examples = [
        "您好，请问有什么可以帮您的？",
        "我考试考砸了，我妈妈骂了我",
        "播放一首周杰伦的七里香",
        "太感谢了!!!!",
        "我可以用中文和你对话吗?",
        "请帮我预定明天上午10点飞往北京的机票",
        "这个产品有什么优惠活动吗？"
    ]
    for example in examples:
        predict_example(model, example)
    
    print("\n训练和评估完成！")

if __name__ == "__main__":
    main()

# 数据平衡处理
balanced_data = []
for label in label_counts.index:
    label_data = df[df['label'] == label]
    if len(label_data) > 100000:
        print(f"  将{label}类别数据从{len(label_data)}条减少到100000条")
        label_data = label_data.sample(100000, random_state=1)
    balanced_data.append(label_data)

    model = fasttext.train_supervised(
        input=train_file,
        lr=0.05,            # 学习率
        epoch=100,           # 训练轮数
        wordNgrams=2,       # n-gram特征的最大长度
        dim=128,            # 词向量维度
        loss='softmax',      # 损失函数
        bucket=200000,       # 词典大小
        lrUpdateRate=50,    # 学习率更新频率
        minCount=3,         # 最小词频
        verbose=2,           # 输出详细信息
        thread=8,            # 使用的线程数
        ws=5,                # 窗口大小
        minn=3, maxn=6       # n-gram特征的最小和最大长度
    )

print(classification_report(y_true, y_pred))

    model = fasttext.train_supervised(
        input=train_file,
    )

    model = fasttext.train_supervised(
        input=train_file,
        lr=0.01,            # 学习率
        epoch=50,           # 训练轮数
        wordNgrams=2,       # n-gram特征的最大长度
        dim=128,            # 词向量维度
        loss='softmax',      # 损失函数
    )

    model = fasttext.train_supervised(
        input=train_file,
        lr=0.01,            # 学习率
        epoch=50,           # 训练轮数
        wordNgrams=2,       # n-gram特征的最大长度
        dim=128,            # 词向量维度
        loss='softmax',      # 损失函数
        bucket=200000,       # 词典大小
        lrUpdateRate=100,    # 学习率更新频率
        verbose=2,           # 输出详细信息
        thread=4,            # 使用的线程数
        minn=3, maxn=5       # n-gram特征的最小和最大长度
    )

    model = fasttext.train_supervised(
        input=train_file,
        lr=0.05,            # 学习率
        epoch=100,           # 训练轮数
        wordNgrams=2,       # n-gram特征的最大长度
        dim=128,            # 词向量维度
        loss='softmax',      # 损失函数
        bucket=200000,       # 词典大小
        lrUpdateRate=50,    # 学习率更新频率
        minCount=3,         # 最小词频
        verbose=2,           # 输出详细信息
        thread=8,            # 使用的线程数
        ws=5,                # 窗口大小
        minn=3, maxn=6       # n-gram特征的最小和最大长度
    )