Tag: Python

  • 如何使用Python快速去除图片背景并保存

    如何使用Python快速去除图片背景并保存

    你是否曾经遇到过这样的问题:你有一张图片,但是你只想保留其中的某些物体或图案,而将其他部分的背景删除?这可能是因为你需要将物体或图案添加到其他图片中,或者只是为了更好地突出显示这些物体。在这个教程中,我们将向你展示如何使用Python和PIL库快速去除图片的背景,并保存你想要的部分。

    开篇故事

    假设你是一名设计师,正在为一本儿童教育书籍制作插图。你已经有了一些美丽的插图,但它们都带有白色背景。为了使插图更好地融入书籍,你希望将背景去掉,只保留插图中的内容。手动去除每张图片的背景将非常耗时,所以你希望找到一种快速而有效的方法。

    在这个背景下,你决定使用Python编写一个脚本,自动去除图片的背景,并将结果保存为具有透明背景的PNG图像。这将帮助你节省大量的时间,同时确保插图看起来更加专业。

    准备工作

    在开始之前,确保你已经安装了以下必要的库和工具:

    • Python(建议使用3.x版本)
    • Pillow(Python Imaging Library,用于处理图像)
    • 一些包含带背景的图片

    步骤 1:导入必要的库

    首先,让我们导入所需的Python库。我们将使用Pillow库来处理图像。

    from PIL import Image

    步骤 2:编写背景去除函数

    接下来,我们将编写一个函数,该函数将负责去除图片的背景并返回结果。我们将使用Pillow库中的convert方法来实现这一点。

    def remove_background(image_path, save_path):
        img = Image.open(image_path)
        img = img.convert('RGBA')
    
        width, height = img.size
    
        for x in range(width):
            for y in range(height):
                r, g, b, a = img.getpixel((x, y))
                # 判断像素是否属于背景,这里假设背景是白色
                if r > 100 or g > 100 or b > 100:
                    img.putpixel((x, y), (0, 0, 0, 0))
                else:
                    img.putpixel((x, y), (r, g, b, 255))
    
        img.save(save_path)

    这个函数接受输入图片的路径(image_path)和保存结果图片的路径(save_path)。它将图像转换为RGBA模式,然后遍历每个像素,将背景像素的Alpha通道设置为0,从而使其变为透明。我们假设背景是白色,但你可以根据需要修改这个条件。

    步骤 3:使用函数去除背景

    现在,我们可以使用刚刚编写的remove_background函数去除图片的背景。你可以将下面的代码添加到你的脚本中,用于处理单个图片:

    input_image_path = 'input_image.png'  # 输入图片路径
    output_image_path = 'output_image.png'  # 输出图片路径
    
    remove_background(input_image_path, output_image_path)

    步骤 4:批量处理多张图片

    如果你有多张图片需要处理,你可以使用一个循环来批量处理它们。首先,将所有需要处理的图片放入一个文件夹中,然后使用以下代码来批量处理它们:

    import os
    
    input_folder = 'input_images'  # 包含输入图片的文件夹路径
    output_folder = 'output_images'  # 包含输出图片的文件夹路径
    
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)
    
    # 遍历文件夹中的所有图片文件
    for filename in os.listdir(input_folder):
        if filename.endswith('.png') or filename.endswith('.jpg'):
            input_image_path = os.path.join(input_folder, filename)
            output_image_path = os.path.join(output_folder, filename)
            remove_background(input_image_path, output_image_path)

    这段代码将遍历指定文件夹中的所有图片文件,并将它们的背景去除后保存到另一个文件夹中。

    步骤 5:查看处理结果

    你现在已经成功地去除了图片的背景,并保存了处理后的图片。你可以打开这些图片,查看它们的背景是否已经被成功去除,并且只剩下了前景物体或图案。

    结语

    通过使用Python和Pillow库,你可以轻松地去除图片的背景,并创建具有透明背景的PNG图像。这个技巧在许多情况下都非常有用,无论是用于设计、图像编辑还是其他创意项目。

    无论你是一名设计师、开发者还是对图像处理感兴趣的人,都可以受益于这个简单而强大的背景去除技巧。现在,你可以将它应用到自己的项目中,创造出令人印象深刻的图像!

  • 使用FastAPI和Edge TTS创建自定义文本转语音应用

    使用FastAPI和Edge TTS创建自定义文本转语音应用

    有时候,你可能需要一个自定义的文本转语音(TTS)应用,以将文字转化为声音。这可以用于语音助手、有声书、自动化通知等各种应用场景。在这篇教程中,我们将介绍如何使用FastAPI和Edge TTS创建一个简单但功能强大的自定义TTS应用。

    开篇故事

    假设你是一名开发者,正在为一个在线教育平台开发新功能。你的用户希望能够将课程文本内容转化为音频,以便在不方便阅读的情况下仍然能够学习。然而,你发现市面上的现成TTS工具并不能满足你的需求,因为你需要更多的自定义选项。

    在这个背景下,你决定创建一个自己的TTS应用,以满足用户的需求。你选择使用FastAPI作为Web框架,结合Edge TTS来实现文本到语音的转换。这个教程将帮助你一步步构建这个应用。

    准备工作

    在开始之前,确保你已经安装了以下必要的库和工具:

    • Python(建议使用3.7或更高版本)
    • FastAPI
    • Edge TTS
    • Pygame(用于播放生成的音频)

    步骤 1:创建FastAPI应用

    首先,让我们创建一个FastAPI应用。你可以使用以下代码来创建一个基本的FastAPI应用:

    from fastapi import FastAPI
    
    app = FastAPI()
    
    @app.get("/")
    async def read_root():
        return {"message": "Welcome to your TTS app!"}

    这个应用会在根路径返回一则欢迎消息。

    步骤 2:集成Edge TTS

    接下来,我们需要集成Edge TTS,这是一个用于文本到语音转换的库。你可以按照以下步骤来进行集成:

    1. 安装Edge TTS库:

      pip install edge-tts
    2. 导入Edge TTS库:

      import edge_tts
    3. 创建一个异步函数来处理TTS:

      import asyncio
      
      async def tts(text, output, voice, rate):
         volume = '+0%'
         tts = edge_tts.Communicate(text=text, voice=voice, rate=rate, volume=volume)
         await tts.save(output)

    现在,我们已经准备好使用Edge TTS来进行文本到语音的转换。

    步骤 3:创建TTS接口

    接下来,我们将创建一个接口,允许用户输入文本,并选择声音、速度等参数来生成语音。以下是创建TTS接口的代码:

    from fastapi import Form, File
    
    @app.post("/synthesize")
    async def synthesize(text: str = Form(...), voice: str = Form(...), rate: int = Form(...)):
        # 在这里处理TTS的逻辑
        # 构造文件名并生成音频文件
        # 返回包含下载链接的响应

    在这个接口中,我们接收用户输入的文本、声音和速度参数。然后,我们可以使用上一步中定义的tts函数来生成语音,将生成的音频文件保存到指定的目录,并返回包含下载链接的响应。

    步骤 4:下载生成的音频文件

    最后,我们创建一个接口,允许用户下载生成的音频文件。以下是下载接口的代码:

    from fastapi.responses import FileResponse
    import os
    
    @app.get("/download")
    async def download(filename: str):
        file_path = os.path.join("mp3", filename)
        return FileResponse(path=file_path, filename=filename, media_type="application/octet-stream")

    这个接口将根据用户提供的文件名在指定目录中查找音频文件,并返回给用户。

    运行应用

    现在,你已经创建了一个简单的TTS应用。你可以使用以下命令来运行应用:

    uvicorn main:app --host 0.0.0.0 --port 8000 --reload

    然后,你可以通过浏览器访问http://localhost:8000/来查看你的应用。

    结语

    通过使用FastAPI和Edge TTS,你可以轻松创建一个自定义的文本转语音应用。这个应用可以满足各种需求,包括在线教育、语音助手和自动化通知等。希望这个教程能够帮助你入门FastAPI和Edge TTS,并启发你创建更多有趣的应用。

    无论你是一名新手开发者还是经验丰富的工程师,这个教程都可以帮助你构建自己的TTS应用。开始创建吧,让你的创意变成现实!

  • 黑盒交易:用Python进行数据分析和人工智能交易的秘诀

    黑盒交易:用Python进行数据分析和人工智能交易的秘诀

    走进黑盒交易的世界

    每天,全球金融市场都在进行着数以亿计的交易。这些交易由各种各样的参与者执行,包括机构投资者、个人交易员以及高频交易公司。但在这个快节奏、高度竞争的环境中,有一群特殊的交易者采用了一种独特的方式来执行交易,他们被称为“黑盒交易者”。

    黑盒交易,也被称为算法交易或自动化交易,是一种交易方式,其中交易决策是由计算机程序而不是人类交易员进行的。这些程序使用数据分析、大数据和人工智能技术来识别交易机会、制定买卖策略,并执行交易。与传统的人工交易相比,黑盒交易具有更高的速度和效率,可以在瞬间做出多个交易决策,从而获得更好的交易结果。

    黑盒交易的优势

    为什么越来越多的交易者转向黑盒交易呢?这是因为黑盒交易具有一些明显的优势,包括:

    1. 无情执行

    黑盒交易程序执行交易决策时没有情感干扰。它们只会根据预定的规则和算法执行操作,不受恐惧、贪婪或情绪的影响。这有助于消除了许多人为错误,提高了交易的一致性。

    2. 高速度

    黑盒交易系统可以在毫秒级别内执行交易,远远快于人类交易员。这使得高频交易成为可能,可以在极短的时间内进行大量交易。

    3. 数据分析

    黑盒交易程序可以分析大量的市场数据,并根据这些数据制定决策。这使得它们能够识别出微小的价格差异和趋势,从而找到交易机会。

    4. 自动化

    一旦设置好,黑盒交易系统可以自动执行交易,无需人工干预。这使得交易者可以在不间断地监控市场的情况下进行交易。

    如何入门黑盒交易?

    如果你对黑盒交易感兴趣,并希望探索这个领域,下面是一些入门步骤:

    步骤1:学习Python编程

    Python是数据科学和算法交易的首选编程语言。它易于学习,拥有丰富的数据分析库和机器学习工具。你可以从在线教程和课程中学习Python编程,或者阅读相关的书籍。

    步骤2:理解数据分析

    数据分析是黑盒交易的核心。你需要学习如何收集、清洗和分析金融数据。这包括学习如何使用Python库如Pandas和NumPy来处理数据,以及如何使用数据可视化工具如Matplotlib和Seaborn来呈现数据。

    步骤3:熟悉大数据技术

    在黑盒交易中,你可能会处理大量的金融数据。了解大数据技术如Hadoop和Spark可以帮助你更有效地处理和分析数据。

    步骤4:深入学习机器学习

    机器学习是人工智能交易的关键。你需要学习如何使用机器学习算法来构建预测模型,以便识别交易机会。有许多在线课程和教材可以帮助你入门机器学习。

    步骤5:选择合适的交易平台

    选择一个适合你的交易平台,它应该能够执行你的交易策略并提供必要的数据。一些常用的交易平台包括Interactive Brokers、MetaTrader和QuantConnect。

    使用Python进行黑盒交易的示例

    以下是一个简单的示例,展示如何使用Python进行黑盒交易。

    import pandas as pd
    from sklearn.model_selection import train_test_split
    from sklearn.ensemble import RandomForestClassifier
    from sklearn.metrics import accuracy_score
    import yfinance as yf
    
    # 收集金融数据
    data = yf.download('AAPL', start='2020-01-01', end='2021-01-01')
    
    # 创建特征和目标变量
    data['Price_Up'] = (data['Close'] - data['Close'].shift(1)) > 0
    X = data[['Open', 'High', 'Low', 'Volume']]
    y = data['Price_Up']
    
    # 划分训练集和测试集
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
    
    # 构建随机森林模型
    model = RandomForestClassifier()
    model.fit(X_train, y_train)
    
    # 预测价格上涨
    y_pred = model.predict(X_test)
    
    # 计算准确率
    accuracy = accuracy_score(y_test, y_pred)
    print(f'模型准确率:{accuracy}')

    在这个示例中,我们使用了Python库来下载苹果股票(AAPL)的历史数据,并构建了一个随机森林分类模型来预测股价是否上涨。这只是一个简单的示例,黑盒交易的实际应用要复杂得多,

    但它展示了你可以使用Python进行数据分析和人工智能交易的可能性。

    结语

    黑盒交易是一个激动人心的领域,它结合了数据分析、大数据和人工智能技术,可以帮助你在金融市场中取得更好的交易结果。虽然入门可能需要一些学习和练习,但一旦掌握了必要的技能,你将能够利用Python进行数据分析和人工智能交易,为你的投资策略增加一份强大的助力。

    无论你是一名初学者还是已经有一些经验的交易员,学习黑盒交易都值得一试。开始你的黑盒交易之旅吧,探索数据的奥秘,挖掘潜在的交易机会!

  • 评估自动文摘质量的终极指南

    评估自动文摘质量的终极指南

    你是否曾经尝试过创建自动文摘系统,但却不知道如何准确评估其质量?本文将为您提供关于如何评估抽象文摘质量的详细指南。我们将介绍传统的评估方法,如ROUGE和BERTScore,以及一种创新的方法,利用大型语言模型(LLM)作为评估器。

    1. 开篇故事

    在探讨自动文摘质量评估之前,让我们来看一个生动有趣的故事。假设你是一名AI研究员,正在开发一款自动文摘系统,这个系统可以将长篇文章精炼成简短的摘要。你花费了数月时间不断改进算法,优化性能,但你开始面临一个棘手的问题:如何准确地评估你的文摘质量?这个问题在自然语言处理领域一直备受关注,因为它涉及到了如何衡量文本的准确性、连贯性和相关性。

    在这个教程中,我们将为你揭示评估自动文摘质量的关键方法,让你的工作更具实际应用性和可衡量性。

    2. 引言

    自动文摘质量评估是一个耗时的过程,因为它涉及到不同的质量指标,如连贯性、简洁性、可读性和内容。传统的自动评估指标,如ROUGE和BERTScore等,虽然具体可靠,但可能与实际文摘质量的相关性不高。特别是对于开放性生成任务,它们与人类评价的相关性相对较低。因此,在评估文摘质量时,越来越需要依赖人类评估、用户反馈或基于模型的指标,同时需要警惕潜在的偏见。虽然人类判断提供了宝贵的见解,但通常不具备可扩展性,并且成本较高。

    除了传统的评估指标,我们还展示了一种使用大型语言模型(LLM)的方法(G-Eval),用作评估抽象性摘要的新型、无参考度量。在这种情况下,我们使用gpt-4来评分候选输出。gpt-4已经有效地学习了语言质量的内部模型,使其能够区分流畅、连贯的文本和低质量的文本。利用这种内部评分机制,可以自动评估LLM生成的新候选输出。

    3. 安装必要的软件包

    在进行评估之前,我们需要安装一些必要的软件包,以便进行评估。这些包包括ROUGE、BERTScore和OpenAI的API。

    !pip install rouge --quiet
    !pip install bert_score --quiet
    !pip install openai --quiet
    import openai
    import os
    import re
    import pandas as pd
    
    # 这里放置Python实现ROUGE指标的代码
    from rouge import Rouge
    
    # BERTScore利用BERT的上下文嵌入并通过余弦相似度匹配候选和参考句子中的单词。
    from bert_score import BERTScorer
    
    openai.api_key = os.environ.get("OPENAI_API_KEY")

    4. 示例任务

    为了本教程的目的,我们将使用以下示例文摘任务。请注意,我们提供了两个生成的摘要供比较,以及一个参考的人工撰写摘要,这是ROUGE和BERTScore等评估指标所需的。

    摘录 (excerpt):

    OpenAI的使命是确保人工通用智能(AGI)造福全人类。OpenAI将直接构建安全和有益的AGI,但如果其工作有助于其他人实现这一目标,它也将认为使命已达成。OpenAI遵循几个关键原则。首先,广泛分布的利益 – 对AGI部署的任何影响都将用于全人类的利益,以避免有害的使用或权力过度集中。其次,长期安全 – OpenAI致力于进行研究,使AGI安全,并促进这些研究在AI社区中的采纳。第三,技术领导 – OpenAI旨在处于AI能力的前沿。第四,合作导向 – OpenAI积极与其他研究和政策机构合作,并寻求创建一个共同工作的全球社区,共同解决AGI的全球挑战。

    摘要 (Summaries):

    • 参考摘要 /ref_summary(人工生成):
      OpenAI的目标是确保人工通用智能(AGI)造福所有人,避免有害用途或权力过度集中。它致力于研究AGI的安全性,并在AI社区中促进这些研究。OpenAI旨在领导AI能力的发展,与全球研究和政策机构合作,解决AGI的挑战。

    • 评估摘要1 / eval_summary_1(系统生成):
      OpenAI旨在使AGI造福全人类,避免有

    害用途和权力集中。它引领安全和有益的AGI研究,并在全球促进采用。OpenAI在AI领域保持技术领导地位,与全球机构合作,解决AGI的挑战。它力求领导一个协作的全球努力,为集体利益开发AGI。

    • 评估摘要2 / eval_summary_2(系统生成):
      OpenAI旨在确保AGI供所有人使用,完全避免有害内容或权力过度集中。致力于研究AGI的安全性,并在AI社区中促进这些研究。OpenAI希望在AI领域处于领先地位,并与全球研究和政策团体合作,探讨AGI的相关问题。

    5. 使用ROUGE进行评估

    ROUGE是Recall-Oriented Understudy for Gisting Evaluation的缩写,主要用于衡量生成的输出与参考文本之间的词语重叠。这是评估自动文摘任务的一种流行指标。在其各种变体中,ROUGE-L提供了系统生成和参考摘要之间最长连续匹配的信息,衡量系统保留原始摘要要点的程度。

    # 计算ROUGE分数的函数
    def get_rouge_scores(text1, text2):
        rouge = Rouge()
        return rouge.get_scores(text1, text2)
    
    # 计算两个摘要与参考摘要之间的ROUGE分数
    eval_1_rouge = get_rouge_scores(eval_summary_1, ref_summary)
    eval_2_rouge = get_rouge_scores(eval_summary_2, ref_summary)
    
    rouge_scores_out = []
    
    for metric in ["rouge-1", "rouge-2", "rouge-l"]:
        for label in ["F-Score"]:
            eval_1_score = eval_1_rouge[0][metric][label[0].lower()]
            eval_2_score = eval_2_rouge[0][metric][label[0].lower()]
    
            row = {
                "Metric": f"{metric} ({label})",
                "Summary 1": eval_1_score,
                "Summary 2": eval_2_score,
            }
            rouge_scores_out.append(row)
    
    # 展示ROUGE分数
    rouge_scores_out_df = (
        pd.DataFrame(rouge_scores_out)
        .set_index("Metric")
    )
    
    rouge_scores_out_df

    上述代码计算了两个不同摘要与参考文本之间的ROUGE分数。在rouge-1方面,摘要2优于摘要1,表示单词重叠较多。而在rouge-l方面,摘要2得分较高,意味着最长公共子序列匹配较好,因此可能更好地捕捉了原始文本的主要内容和顺序。由于摘要2直接提取了摘录中的许多词汇和短语,因此与参考摘要的重叠可能较高,从而导致较高的ROUGE分数。

    然而,需要注意的是,尽管ROUGE和类似的指标(如BLEU和METEOR)提供了定量的度量,但它们通常无法捕捉良好生成摘要的真正本质。它们与人类评分的相关性也较差。鉴于LLM的进展,它们擅长生成流畅和连贯的摘要,传统的指标如ROUGE可能会误判这些模型,特别是如果摘要的表达方式不同但仍然准确地包括核心信息。

    6. 使用BERTScore进行评估

    ROUGE依赖于候选文本和参考文本中单词的精确匹配,无法解释底层语义。这就是BERTScore的作用,它利用BERT模型的上下文嵌入,旨在评估在机器生成的文本背景下,预测文本和参考句子之间的相似性。通过比较两者的嵌入,BERTScore捕获了传统n-gram指标可能忽略的语义相似性。

    # 实例化英语语言的BERTScorer对象
    scorer = BERTScorer(lang="en")
    
    # 计算摘要1与摘录的BERTScore
    P1, R1, F1_1 = scorer.score([eval_summary_1], [ref_summary])
    
    # 计算摘要2与摘录的BERTScore
    P2, R2, F2_2 = scorer.score([eval_summary_2], [ref_summary])
    
    print("摘要1 F1分数:", F1_1.tolist()[0])
    print("摘要2 F1分数:", F2_2.tolist()[0])

    上述代码计算了两个摘要与摘录之间的BERTScore分数。F1分数接近表明它们在捕获关键信息方面表现相似。然而,这种小差异应谨慎解释。由于BERTScore可能无法完全理解人类评估员可能理解的微妙和高级概念,仅依赖于这一指标可能会导致对摘要的实际质量和细微差别进行错误解读。将BERTScore与人工评估和其他指标结合使用可以提供更可靠的评估。

    7. 使用GPT-4进行评估

    在这里,我们实现了一个使用gpt-4的示例无参考文本评估器,受到G-Eval框架的启发,该框架使用大型语言模型评估生成文本的质量。与ROUGE或BERTScore等依赖于与

    参考摘要的比较的指标不同,基于gpt-4的评估器仅基于输入提示和文本评估生成内容的质量,而无需任何基准参考。这使其适用于新数据集和任务,其中人类参考文献稀缺或不可用。

    以下是此方法的概述:

    • 我们定义了四个不同的标准:

      • 相关性:评估摘要是否仅包含重要信息并排除多余信息。
      • 连贯性:评估摘要的逻辑流程和组织结构。
      • 一致性:检查摘要是否与源文档中的事实一致。
      • 流畅性:评估摘要的语法、拼写、标点、词汇选择和句子结构。
    • 我们为每个标准创建提示,以原始文档和摘要作为输入,并利用思维链生成和引导模型以输出每个标准的1-5之间的数值评分。

    • 我们使用定义的提示从gpt-4生成分数,然后比较它们在不同摘要之间。

    # 评估提示模板基于G-Eval
    EVALUATION_PROMPT_TEMPLATE = """
    您将获得一份为一篇文章写的摘要。您的任务是根据一个度量标准对摘要进行评分。
    请确保您非常仔细地阅读和理解这些说明。
    请在审阅时保持这个文档打开,并根据需要参考它。
    
    评估标准:
    
    {criteria}
    
    评估步骤:
    
    {steps}
    
    示例:
    
    源文本:
    
    {document}
    
    摘要:
    
    {summary}
    
    评估表单(仅分数):
    
    - {metric_name}
    """
    
    # 标准1:相关性
    RELEVANCY_SCORE_CRITERIA = """
    相关性(1-5) - 从源文本中选择重要内容。 \
    摘要应仅包含源文档中的重要信息。 \
    评估员被要求惩罚包含冗余和多余信息的摘要。
    """
    
    RELEVANCY_SCORE_STEPS = """
    1. 仔细阅读摘要和源文档。
    2. 比较摘要与源文档,并确定文章的主要要点。
    3. 评估摘要多好地涵盖了文章的主要要点,以及它包含了多少无关或多余的信息。
    4. 指定一个从1到5的相关性评分。
    """
    
    # 标准2:连贯性
    COHERENCE_SCORE_CRITERIA = """
    连贯性(1-5) - 所有句子的综合质量。 \
    我们将此维度与DUC质量问题中的结构和连贯性一致,即“摘要应该具有良好的结构和组织。 \
    摘要不应仅仅是一堆相关信息,而应该从句子到一\
    个关于一个主题的连贯信息体中逐渐构建起来。”
    """
    
    COHERENCE_SCORE_STEPS = """
    1. 仔细阅读文章,确定主要主题和要点。
    2. 仔细阅读摘要,并将其与文章进行比较。检查摘要是否涵盖了文章的主要主题和要点,
       并且是否以清晰且逻辑的顺序呈现它们。
    3. 根据评估标准,为连贯性评分,评分范围从1到5,其中1是最低的,5是最高的。
    """
    
    # 标准3:一致性
    CONSISTENCY_SCORE_CRITERIA = """
    一致性(1-5) - 摘要与被总结源文之间的事实一致性。 \
    一个事实一致的摘要仅包含源文档支持的陈述。 \
    评估员还被要求惩罚包含虚构事实的摘要。
    """
    
    CONSISTENCY_SCORE_STEPS = """
    1. 仔细阅读文章,确定它呈现的主要事实和细节。
    2. 仔细阅读摘要,并将其与文章进行比较。检查摘要是否包含文章不支持的任何事实错误。
    3. 根据评估标准,为一致性评分。
    """
    
    # 标准4:流畅性
    FLUENCY_SCORE_CRITERIA = """
    流畅性(1-3): 摘要的质量,涉及语法、拼写、标点、词汇选择和句子结构。
    1: 差。摘要有许多错误,使其难以理解或听起来不自然。
    2: 一般。摘要有一些错误,影响了文本的清晰度或流畅性,但主要要点仍然可以理解。
    3: 良好。摘要几乎没有错误,阅读和理解起来很容易。
    """
    
    FLUENCY_SCORE_STEPS = """
    阅读摘要并根据给定的标准评估其流畅性。指定一个从1到3的流畅性评分。
    """
    
    # 为不同标准准备数据
    evaluation_metrics = {
        "相关性": (RELEVANCY_SCORE_CRITERIA, RELEVANCY_SCORE_STEPS),
        "连贯性": (COHERENCE_SCORE_CRITERIA, COHERENCE_SCORE_STEPS),
        "一致性": (CONSISTENCY_SCORE_CRITERIA, CONSISTENCY_SCORE_STEPS),
        "流畅性": (FLUENCY_SCORE_CRITERIA, FLUENCY_SCORE_STEPS),
    }
    
    summaries = {"摘要1": eval_summary_1, "摘要2": eval_summary_2}
    
    data = {"评估
    
    标准": [], "摘要": [], "评分": []}
    
    for metric, (criteria, steps) in evaluation_metrics.items():
        for summary_name, summary_text in summaries.items():
            prompt = EVALUATION_PROMPT_TEMPLATE.format(
                criteria=criteria, steps=steps, document=excerpt, summary=summary_text, metric_name=metric
            )
            response = openai.Completion.create(
                engine="text-davinci-003", prompt=prompt, max_tokens=100
            )
            rating = int(re.search(r"\d", response.choices[0].text).group())
            data["评估标准"].append(metric)
            data["摘要"].append(summary_name)
            data["评分"].append(rating)
    
    # 将数据转换为DataFrame以进行比较
    evaluation_df = pd.DataFrame(data)
    
    # 输出评估结果
    evaluation_df

    上述代码使用gpt-4基于定义的四个标准为两个摘要生成了1-5之间的分数。这些标准包括相关性、连贯性、一致性和流畅性。根据每个标准的提示,gpt-4生成了评分,然后将这些评分与不同摘要进行比较。根据评估结果,您可以看到每个摘要在不同标准下的表现如何。

    8. 总结

    自动文摘质量评估是一个复杂的任务,涉及多个方面,包括文本的相关性、连贯性、一致性和流畅性。传统的评估指标如ROUGE和BERTScore提供了一种方式来量化自动生成的文本与参考文本之间的相似性,但它们不能全面捕捉文本质量的各个方面。因此,将它们与基于大型语言模型的评估器结合使用可能会更全面地评估文本质量。

    在这个教程中,我们展示了如何使用ROUGE、BERTScore和基于gpt-4的评估器来评估自动生成的文本的质量。请记住,这些指标和方法只是评估文本质量的一部分,最终的评估可能需要人工评估和用户反馈来全面评估文本生成系统的性能。希望这个指南能帮助您更好地了解如何评估自动文摘质量,从而改进和优化您的自动生成文本的系统。

  • 如何使用Chat模型进行微调:一个食谱命名实体识别教程

    如何使用Chat模型进行微调:一个食谱命名实体识别教程

    在数字时代,人工智能技术正不断演进,为我们的生活和工作带来了革命性的变化。开放AI(OpenAI)的GPT-3.5-turbo模型是一项重要的技术,它可以用于各种自然语言处理任务,包括聊天和命名实体识别(NER)。本教程将向您展示如何使用GPT-3.5-turbo进行微调,以执行食谱命名实体识别任务。

    1. 引子:解锁人工智能的潜力

    在当今的数字世界中,人工智能技术正日益成熟和普及。无论是自动化客户支持,还是从大规模数据中提取有用信息,AI都发挥着关键作用。而GPT-3.5-turbo模型是一种强大的AI工具,可以用于许多自然语言处理任务,使您能够创建智能聊天机器人,或者像本教程一样执行命名实体识别任务。

    2. 准备工作:设置环境

    在开始微调之前,确保您已经安装了最新版本的OpenAI Python包,并已获取了OpenAI API密钥。这个密钥将用于与GPT-3.5-turbo模型进行通信。

    # 安装最新版本的OpenAI Python包
    !pip install --upgrade openai
    
    import json
    import openai
    import os
    import pandas as pd
    from pprint import pprint
    
    # 添加您的OpenAI API密钥
    OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")

    3. 数据准备:准备数据进行微调

    在进行微调之前,您需要准备训练数据。在本教程中,我们将使用食谱数据集,并从中提取通用的食材名称作为命名实体。以下是数据准备的步骤:

    3.1 数据集加载和筛选

    为了进行微调,我们需要一个特定领域的数据集。数据集应该足够专注,以便模型可以学习,但也要足够通用,以便不会错过未见过的示例。在本教程中,我们从RecipesNLG数据集中提取了一个子集,该子集只包含来自www.cookbooks.com的文档。

    # 读取我们将在此任务中使用的数据集
    recipe_df = pd.read_csv("data/cookbook_recipes_nlg_10k.csv")
    
    # 显示数据集的前几行
    recipe_df.head()

    3.2 数据格式转换

    在微调时,我们需要将数据转换为适用于ChatCompletion格式的训练示例。每个训练示例都是一个包含多个消息的对话列表。以下是数据转换的示例代码:

    training_data = []
    
    system_message = "You are a helpful recipe assistant. You are to extract the generic ingredients from each of the recipes provided."
    
    def create_user_message(row):
        return f"""Title: {row['title']}\n\nIngredients: {row['ingredients']}\n\nGeneric ingredients: """
    
    def prepare_example_conversation(row):
        messages = []
        messages.append({"role": "system", "content": system_message})
    
        user_message = create_user_message(row)
        messages.append({"role": "user", "content": user_message})
    
        messages.append({"role": "assistant", "content": row["NER"]})
    
        return {"messages": messages}
    
    # 对数据集的每一行应用数据转换函数
    training_data = recipe_df.apply(prepare_example_conversation, axis=1).tolist()

    3.3 上传文件

    将转换后的数据保存为.jsonl文件,然后上传到OpenAI的Files端点,以供微调使用。

    def write_jsonl(data_list: list, filename: str) -> None:
        with open(filename, "w") as out:
            for ddict in data_list:
                jout = json.dumps(ddict) + "\n"
                out.write(jout)
    
    # 保存训练数据和验证数据为.jsonl文件
    training_file_name = "tmp_recipe_finetune_training.jsonl"
    write_jsonl(training_data, training_file_name)
    
    validation_file_name = "tmp_recipe_finetune_validation.jsonl"
    write_jsonl(validation_data, validation_file_name)
    
    # 使用OpenAI的Files端点上传文件
    training_response = openai.File.create(
        file=open(training_file_name, "rb"), purpose="fine-tune"
    )
    training_file_id = training_response["id"]
    
    validation_response = openai.File.create(
        file=open(validation_file_name, "rb"), purpose="fine-tune"
    )
    validation_file_id = validation_response["id"]

    4. 微调模型

    现在,我们可以使用准备好的文件创建微调任务。在创建任务时,我们需要指定训练文件、验证文件、模型名称和可选的后缀来标识模型。以下是微调模型的示例代码:

    response = openai.FineTuningJob.create(
        training_file=training_file_id,
        validation_file=validation_file_id,
        model="gpt-3.5-turbo",
        suffix="recipe-ner",
    )
    
    job_id = response["id"]

    您可以使用以下代码检查微调任务的状态:

    response = openai.FineTuningJob.retrieve(job_id)
    
    print("Job ID:", response["id"])
    print("Status:", response["status"])

    5. 跟踪微调进度

    微调任务可能需要一些时间来完成。您可以使用以下代码跟踪微调进度:

    response = openai.FineTuningJob.list_events(id=job_id, limit=50)
    
    events = response["data"]
    events.reverse()
    
    for event in events:
        print(event["message"])

    6. 微调成功!

    一旦微调任务完成,您将获得一个微调模型的ID。以下是

    如何获取微调模型的示例代码:

    response = openai.FineTuningJob.retrieve(job_id)
    fine_tuned_model_id = response["fine_tuned_model"]
    
    print("Fine-tuned model ID:", fine_tuned_model_id)

    7. 使用微调模型进行推理

    最后,您可以使用微调的模型来执行推理。只需调用ChatCompletions并指定微调模型的名称和消息列表。以下是如何使用微调模型进行推理的示例代码:

    test_df = recipe_df.loc[201:300]
    test_row = test_df.iloc[0]
    test_messages = []
    test_messages.append({"role": "system", "content": system_message})
    user_message = create_user_message(test_row)
    test_messages.append({"role": "user", "content": create_user_message(test_row)})
    
    response = openai.ChatCompletion.create(
        model=fine_tuned_model_id, messages=test_messages, temperature=0, max_tokens=500
    )
    print(response["choices"][0]["message"]["content"])

    8. 结论

    通过本教程,您已经学会了如何使用GPT-3.5-turbo模型进行微调,以执行食谱命名实体识别任务。这个过程涵盖了数据准备、模型微调和推理的所有关键步骤。希望这个教程对您在自然语言处理领域的工作和项目中有所帮助。

  • 如何使用Python优化爬虫和数据可视化

    如何使用Python优化爬虫和数据可视化

    你是否曾经想过如何从Bilibili网站上获取有关UP主的信息,并将其可视化呈现出来?本教程将向你展示如何使用Python、Selenium、Pandas和Matplotlib优化你的爬虫和数据可视化流程,以更轻松地收集和分析数据。

    前言

    在这个信息爆炸的时代,我们有许多方法来获取数据。而对于喜欢Bilibili的用户来说,UP主的粉丝数量和内容质量是非常关键的信息。我们将使用Python编程语言来自动抓取Bilibili上UP主的信息,并通过数据可视化来更好地理解这些数据。

    准备工作

    在开始之前,确保你已经安装了以下Python库:

    • Pandas:用于数据处理和分析。
    • Matplotlib:用于数据可视化。
    • Selenium:用于网页自动化操作。

    你还需要下载Microsoft Edge浏览器驱动,确保与你的浏览器版本相匹配。现在,让我们开始吧!

    第一步:设置环境

    首先,让我们设置Python环境并导入必要的库:

    import pandas as pd
    import matplotlib.pyplot as plt
    from selenium import webdriver
    from selenium.webdriver.common.by import By
    import pinyin

    在这里,我们导入了所需的库,包括Pandas用于数据处理、Matplotlib用于可视化、Selenium用于网页自动化操作以及pinyin用于处理拼音。

    第二步:设置中文显示

    由于我们将处理中文字符,我们需要设置Matplotlib以正确显示中文字符:

    plt.rcParams["font.sans-serif"] = ["SimHei"]
    plt.rcParams["axes.unicode_minus"] = False

    这将确保你的可视化图表中可以正确显示中文。

    第三步:编写辅助函数

    在进行爬取和数据处理之前,我们将编写一些辅助函数来处理文字数据:

    def getStrAllAlpha(string):
        return pinyin.get_initial(string, delimiter="").upper()
    
    def getStrFirstAlpha(string):
        string = getStrAllAlpha(string)
        string = string[0:1]
        return string.upper()

    这两个函数将用于将UP主的名字转换为拼音,并提取首字母,以便后续的数据整理。

    第四步:爬取UP主信息

    现在,让我们开始爬取Bilibili上UP主的信息。我们将使用Selenium来自动化这个过程。首先,设置Bilibili的搜索页面URL:

    url = "https://search.bilibili.com/upuser?keyword=mc&from_source=webtop_search&spm_id_from=333.1007&order=fans"

    接下来,设置浏览器的User-Agent,以模拟用户操作:

    header = {'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2227.1 Safari/537.36'}
    opt = webdriver.EdgeOptions()
    opt.add_argument('--user-agent=%s' % header)
    edge = webdriver.Edge(options=opt)

    然后,让浏览器打开Bilibili的搜索页面:

    edge.get(url)

    现在,我们准备开始爬取UP主信息。我们将循环爬取100个UP主的名字和粉丝数量,并将它们存储在两个列表中:

    name_list = []
    people_list = []
    
    for i in range(1, 101):
        try:
            # 使用XPath定位UP主信息
            li = edge.find_element(by=By.XPATH, value='//*[@id="user-list"]/div[1]/ul/li[' + str(i) + ']')
            txt = li.text
            name = txt.split("\n")[0].split("+")[0]
            people = txt.split("\n")[2].split(":")[1].split("万")[0]
            name_list.append(name)
            people_list.append(float(people))
            print(name, people)
        except:
            print("切页")
            # 点击下一页按钮
            button = edge.find_element(by=By.XPATH, value='//*[@id="user-list"]/div[1]/div[2]/div/ul/li[' + str(page) + ']/button').click()
            page += 1

    这个循环将遍历100个UP主的信息,并将它们存储在两个列表中。如果需要翻页,它还会自动点击下一页按钮。

    第五步:数据整理

    现在,我们已经成功爬取了UP主的信息,接下来让我们对数据进行整理。首先,我们将按照首字母对UP主进行分类:

    abc_name = []
    abc_name2 = []
    abc_people = []
    abc_people2 = []
    abc = "A"
    
    for i in range(26):
        for j in name_list:
            if getStrFirstAlpha(j) == abc:
                abc_name.append(j)
                tt = name_list.index(j)
        abc = chr(ord(abc) + 1)
    
    for id in abc_name:
        if id not in abc_name2:
            abc_name2.append(id)
    
    for i in abc_name2:
        abc_people2.append(people_list[name_list.index(i)])

    这段代码会将UP主按照首字母进行分类,并创建两个新的列表,分别存储UP主的名字和粉丝数量。

    第六步:数据保存

    我们将整理好的数据保存为CSV文件,以备后续分析和可视化使用:

    data = pd.DataFrame({"UP主名字": name_list, "粉丝数量/万": people_list})
    data.to_csv("up主信息.csv")
    
    data = pd.DataFrame({"UP主名字": abc_name2, "粉丝数量/万": abc_people2})
    data.to_csv("按首字母分类.csv")

    这将创建两个CSV文件

    ,分别存储UP主的详细信息和按首字母分类的信息。

    第七步:数据可视化

    现在,我们已经成功获取和整理了UP主的信息,接下来让我们使用Matplotlib进行数据可视化。我们将创建两个柱状图,一个显示所有UP主的粉丝数量,另一个按首字母分类显示:

    plt.subplot(1, 2, 1)
    bar1 = plt.bar(name_list, people_list, color=['r', 'r', 'r', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b'])
    plt.xticks(rotation=90, fontsize=13)
    plt.bar_label(bar1, label_type='edge')
    
    plt.subplot(1, 2, 2)
    bar2 = plt.bar(abc_name2, abc_people2, color=['r', 'r', 'r', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b'])
    plt.bar_label(bar2, label_type='edge')
    plt.xticks(rotation=90, fontsize=13)
    
    plt.show()

    这段代码会创建两个子图,一个显示所有UP主的粉丝数量,另一个按首字母分类显示。最后,通过plt.show()将图表显示出来。

    总结

    通过这个教程,你学会了如何使用Python、Selenium、Pandas和Matplotlib来爬取Bilibili上UP主的信息,并将其进行数据整理和可视化。这对于分析UP主的粉丝数量和分类是非常有用的。

    现在,你可以探索更多的数据分析和可视化方法,或者将这些数据用于其他有趣的项目。希望这个教程对你有所帮助!

  • 如何创建一个自动化按键和鼠标点击工具

    如何创建一个自动化按键和鼠标点击工具

    在日常计算机使用中,我们常常需要进行重复性的操作,例如定时按下某个键盘按键或模拟鼠标点击。这可能涉及到玩游戏、自动化测试、数据录入等各种场景。为了实现这些功能,你可以创建一个自动化按键和鼠标点击工具。本教程将介绍如何使用Python和一些库来创建这样的工具。

    1. 开场故事

    想象一下,你正在玩一个需要不断点击鼠标的游戏,或者你需要在浏览器上定期执行某项任务。每次都手动点击或按下键盘按键是多么繁琐和乏味!那么,有没有一种方法可以自动化这些操作,让计算机来代劳呢?答案是肯定的,本文将向你展示如何创建一个自动化按键和鼠标点击的工具,让你告别重复性操作的困扰。

    2. 准备工作

    在开始之前,我们需要准备一些工具和库。首先,你需要安装Python,如果你还没有安装,可以从官方网站下载并安装。接下来,我们将使用以下库:

    • PyQt5:用于创建图形用户界面。
    • pynput:用于监听键盘和鼠标事件。
    • pygetwindow:用于获取当前活动窗口的信息。
    • pyautogui:用于模拟键盘按键和鼠标点击事件。

    你可以使用以下命令安装这些库:

    pip install PyQt5 pynput pygetwindow pyautogui

    3. 创建图形用户界面

    首先,我们将创建一个图形用户界面(GUI),以便用户可以轻松地控制自动化工具。我们将使用PyQt5库来构建GUI。以下是一个示例GUI的代码:

    from PyQt5 import QtWidgets, uic
    from PyQt5.QtGui import QPainter, QColor, QCursor
    from PyQt5.QtCore import Qt, QRectF
    from pynput.mouse import Button, Controller
    import pyautogui
    import threading
    import time
    import os
    
    # ... 其他代码 ...
    
    class Ui(QtWidgets.QMainWindow):
        def __init__(self):
            super(Ui, self).__init__()
            uic.loadUi(ui_path, self)
    
            # ... 创建GUI元素 ...
    
            self.show()
    
    # ... 其他代码 ...

    在这个GUI中,我们可以添加按键、设置时间间隔、监控按键状态等功能。

    4. 监听键盘和鼠标事件

    接下来,我们将创建一个用于监听键盘和鼠标事件的类。我们使用pynput库来实现这一功能。以下是一个示例代码片段:

    from pynput import keyboard, mouse
    import pygetwindow as gw
    
    class Controller:
        def __init__(self):
            self.mouse_controller = mouse.Controller()
            self.mouse_pressed = False
            self.keyboard_stop_flag = True
            self.mouse_auto_stop_flag = True
    
        def on_press(self, key):
            try:
                # 检查游戏是否运行并且是当前活动窗口
                # game_windows = gw.getWindowsWithTitle(self.game_title)
                # if game_windows and gw.getActiveWindow() in game_windows:
                if key == keyboard.Key.f1:
                    if self.keyboard_stop_flag:
                        self.keyboard_stop_flag = False
                        window.statusButton.setChecked(True)
                        self.start_keyboard_press_key()
                    else:
                        self.keyboard_stop_flag = True
                        window.statusButton.setChecked(False)
                elif key == keyboard.Key.f2:
                    # 鼠标连点
                    if self.mouse_auto_stop_flag:
                        self.mouse_auto_stop_flag = False
                        window.mouseStatusButton.setChecked(True)
                        self.start_mouse_auto_click_key(self.MOUSE_STATUS_CLICK)
                    else:
                        self.mouse_auto_stop_flag = True
                        window.mouseStatusButton.setChecked(False)
                elif key == keyboard.Key.f3:
                    # 鼠标长按
                    if self.mouse_auto_stop_flag:
                        self.mouse_auto_stop_flag = False
                        window.mouseStatusButton.setChecked(True)
                        self.start_mouse_auto_click_key(self.MOUSE_STATUS_PRESS)
                    else:
                        self.mouse_auto_stop_flag = True
                        window.mouseStatusButton.setChecked(False)
                elif key == keyboard.Key.f4:
                    # 按键映射
                    pass
                elif key == keyboard.Key.f12:
                    mouse_pos = QCursor.pos()
                    global mouseX, mouseY
                    mouseX = mouse_pos.x()
                    mouseY = mouse_pos.y()
                    window.xPos.setText(str(mouseX))
                    window.yPos.setText(str(mouseY))
                else:
                    print(f"{key} pressed")
            except Exception as e:
                import traceback
                traceback.print_exc()
    
        # ... 其他代码 ...

    在这个类中,我们定义了一个Controller类,用于监听键盘和鼠标事件。根据按键的不同,我们可以执行不同的操作,例如启动键盘按键模拟、鼠标点击等。

    5. 创建自动化操作

    现在,我们可以创建自动化的操作,例如模拟键盘按键和鼠标点击。以下是示例代码:

    class Controller:
        # ... 其他代码 ...
    
        def start_keyboard_press_key(self):
            for key, interval in key_time_dict.items():
                if key in pyautogui.KEYBOARD_KEYS:
                    print("启动线程, 按键: ", key, " 间隔: ", interval)
                    t = threading.Thread(target=self.press_key, args=(key, interval))
                    t.daemon = True
                    t.start()
                else:
                    print(f"Key: {key} is not a valid key")
    
        def press_key(self, key, interval):
            print("按键: ", key, " 间隔: ", interval)
            while True:
                if self.keyboard_stop_flag:
                    break
                pyautogui.press(key)
                time.sleep(interval)
    
        def start_mouse_auto_click_key(self, status):
            print("启动鼠标自动点击线程... ")
            if status == self.MOUSE_STATUS_CLICK:
                print(f"鼠标自动点击... delay:{window.mouseDelay.value()}")
                delay = window.mouseDelay
    
    .value()
                t = threading.Thread(target=self.mouse_click, args=(delay,))
                t.daemon = True
                t.start()
            elif status == self.MOUSE_STATUS_PRESS:
                print("鼠标长按... ")
                mouseC = mouse.Controller()
                pyautogui.mouseDown()
                t = threading.Thread(target=self.mouse_press)
                t.daemon = True
                t.start()
    
        def mouse_click(self, interval):
            print("鼠标自动点击, 间隔: ", interval)
            while True:
                if self.mouse_auto_stop_flag:
                    break
                # 获取鼠标当前位置
                print("指定的坐标... {}, {}".format(mouseX, mouseY))
                if mouseX == 0 and mouseY == 0:
                    mouseXx, mouseYy = pyautogui.position()
                else:
                    mouseXx = mouseX
                    mouseYy = mouseY
                pyautogui.click(int(mouseXx), int(mouseYy))
                time.sleep(interval)
    
        def mouse_press(self):
            print("开启鼠标长按... ")
            while True:
                if self.mouse_auto_stop_flag:
                    # 释放鼠标左键并退出循环
                    pyautogui.mouseUp()
                    print("鼠标长按结束")
                    break
                print("鼠标长按中... ")
                time.sleep(0.3)

    这个部分的代码用于启动键盘按键模拟和鼠标点击操作。根据用户的设置,它可以实现自动点击、长按和模拟按键等功能。

    6. 启动监听器

    最后,我们需要启动监听器来监控键盘和鼠标事件。我们在主程序中创建了一个start_listener函数,该函数启动了监听键盘和鼠标事件的线程。以下是示例代码:

    def start_listener():
        game_title = "Your Game Title"  # 替换为你的游戏窗口标题
        global controller
        controller = Controller()
        # 启动一个守护线程
        print("启动线程监听...")
        daemon = threading.Thread(target=keyboard_listener, args=(controller,))
        daemon.daemon = True
        daemon.start()
        daemon = threading.Thread(target=mouse_listener, args=(controller,))
        daemon.daemon = True
        daemon.start()
    
    def keyboard_listener(args):
        print("启动线程监听键盘...")
        controller = args
        with keyboard.Listener(
                on_press=controller.on_press,
                on_release=controller.on_release) as listener:
            listener.join()
    
    def mouse_listener(args):
        print("启动线程监听鼠标...")
        controller = args
        with mouse.Listener(
                on_click=controller.on_mouse_press,
                on_release=controller.on_mouse_release) as listener:
            listener.join()

    通过这些代码,我们可以启动监听器来监控键盘和鼠标事件,然后根据用户的设置执行相应的自动化操作。

    7. 总结

    通过创建一个自动化按键和鼠标点击工具,你可以轻松地执行重复性的操作,提高工作效率。这个工具可以用于各种应用场景,包括游戏、自动化测试、数据录入等。希望本教程对你有所帮助,让你更好地掌握自动化操作的技巧。

  • 让语言模型在你的计算机上运行代码:Open Interpreter

    让语言模型在你的计算机上运行代码:Open Interpreter

    你是否曾经梦想过拥有一个能够运行代码的助手,能够执行各种任务,从编辑照片、视频、PDF文件,到控制浏览器进行研究,再到绘制、清理和分析大型数据集?现在,这个梦想成真了!Open Interpreter是OpenAI的Code Interpreter的本地开源实现,它可以让语言模型在你的计算机上运行代码,为你提供一个自然语言界面,让你可以通过终端与它进行交互。在本文中,我们将探讨Open Interpreter的功能、用法以及与OpenAI的Code Interpreter的比较。

    开篇故事

    想象一下,你正在处理一个庞大的数据集,需要进行数据清理和分析。你不想编写大量的代码,也不想手动进行这些任务,因为这既费时又繁琐。然后,你听说了一种神奇的工具,可以让你用自然语言命令来完成这些任务。你迫不及待地想要尝试一下,看看它是否能够让你的工作事半功倍。这个神奇的工具就是Open Interpreter!

    什么是Open Interpreter?

    Open Interpreter是OpenAI的Code Interpreter的本地开源实现,它让你可以在你的计算机上运行代码。你可以使用自然语言与Open Interpreter进行交互,就像与ChatGPT一样,只需在安装后运行 $ interpreter 即可。Open Interpreter支持多种编程语言,包括Python、JavaScript、Shell等,这意味着你可以使用它执行各种任务,无需编写繁琐的代码。

    如何开始

    使用Open Interpreter非常简单。首先,你需要安装它,只需运行以下命令:

    pip install open-interpreter

    安装完成后,你可以在终端中运行以下命令来启动Open Interpreter:

    interpreter

    这将打开一个ChatGPT-like的界面,你可以在其中使用自然语言命令来与Open Interpreter进行交互。例如,你可以输入以下命令来执行一个任务:

    import interpreter
    
    interpreter.chat("绘制AAPL和META的归一化股价图")

    除了执行单个命令外,你还可以启动交互式对话,与Open Interpreter进行多轮交流。

    Open Interpreter与ChatGPT的Code Interpreter的比较

    尽管OpenAI发布的GPT-4搭载了Code Interpreter,但它有一些限制,例如无法访问互联网、预装的包有限、上传文件大小限制等。而Open Interpreter通过在你的本地环境上运行来克服这些限制。它可以访问互联网,没有时间或文件大小限制,并且可以使用任何包或库。这将GPT-4的Code Interpreter的强大功能与本地开发环境的灵活性相结合,为你提供了更广泛的应用可能性。

    高级用法

    除了基本的使用方法之外,Open Interpreter还提供了一些高级用法,以增强你的控制能力。以下是一些高级用法示例:

    • 保存和恢复对话: 你可以保存Open Interpreter的对话历史,然后在需要时恢复它。这对于长期项目或任务非常有用。
    # 保存对话
    messages = interpreter.chat("我的名字是小明。", return_messages=True)
    # 重置对话
    interpreter.reset()
    # 恢复对话
    interpreter.load(messages)
    • 自定义系统消息: 你可以自定义Open Interpreter的系统消息,以扩展其功能、修改权限或提供更多上下文信息。
    interpreter.system_message += """
    使用-y参数运行shell命令,以免用户确认。
    """
    • 切换模型: 如果需要,你可以切换Open Interpreter使用的模型。
    interpreter --fast

    以上只是一些高级用法的示例,Open Interpreter提供了丰富的配置选项,以满足不同场景下的需求。

    安全注意事项

    需要注意的是,由于生成的代码在你的本地环境中执行,它可以与你的文件和系统设置进行交互,潜在地导致意外的结果,如数据丢失或安全风险。因此,Open Interpreter在执行代码之前会要求你确认。你可以使用 interpreter -y 或设置 interpreter.auto_run = True 来跳过此确认,但在这种情况下,你需要格外谨慎,确保不会请求修改文件或系统设置的命令。

    结语

    Open Interpreter为开发者提供了一个强大的工具,让你可以使用自然语言来运行代码,执行各种任务,无需编写大量的代码。它的本地运行方式克服了许多云服务的限制,为你提供了更大的自由度和灵活性。无论是进行数据分析、自动化任务还是进行实验性编程,Open Interpreter都能够帮助你更轻松地实现目标。

    现在,你可以尝试安装Open Interpreter,并开始探索其强大的功能,看看它如何为你的项目带来便利和效率提升!

  • 如何使用DALL·E API:创建惊艳图像的秘诀

    如何使用DALL·E API:创建惊艳图像的秘诀

    注意:本文将教你如何使用OpenAI的DALL·E图像API,但请确保你已经获得了相应的API访问权限。

    你是否曾经想过能够通过简单的文字描述生成令人惊艳的图像?OpenAI的DALL·E图像API为你提供了这个机会。本文将向你展示如何使用DALL·E API的三个关键端点:生成、编辑和变化,以及一些有用的提示和技巧。

    开场故事

    想象一下,你是一名创意设计师,你的任务是为一家时尚杂志创建独特的封面图像。你需要一种方法来将你的创意快速转化为视觉艺术,而不需要繁琐的图像编辑工作。幸运的是,有一种新颖的技术可以帮助你实现这一目标,那就是使用DALL·E API。在本文中,我们将探讨如何使用这个API来生成、编辑和变换图像,让你的创意得以充分展示。

    准备工作

    在开始之前,你需要完成一些准备工作。

    导入必要的库

    首先,导入你需要的Python库。这些库将帮助你与DALL·E API进行交互,并进行图像处理。

    import openai  # OpenAI Python库,用于进行API调用
    import requests  # 用于下载图像
    import os  # 用于访问文件路径
    from PIL import Image  # 用于显示和编辑图像

    设置API密钥

    在继续之前,确保你已经获取了OpenAI的API密钥,并将其设置为环境变量。你可以在终端中运行以下命令来设置API密钥:

    export OPENAI_API_KEY="你的API密钥"

    设置保存图像的目录

    为了保存生成的图像,创建一个目录,以便后续使用。你可以使用以下代码来创建目录:

    # 设置保存DALL·E图像的目录
    image_dir_name = "images"
    image_dir = os.path.join(os.curdir, image_dir_name)
    
    # 如果目录不存在,则创建它
    if not os.path.isdir(image_dir):
        os.mkdir(image_dir)

    使用DALL·E API

    现在,让我们深入了解如何使用DALL·E API的不同端点来生成、编辑和变换图像。

    生成图像

    生成端点用于根据文本描述生成图像。你只需提供一个文本描述,DALL·E就会尝试创建相应的图像。

    必要输入:

    • prompt(str):对所需图像的文本描述。最大长度为1000个字符。

    可选输入:

    • n(int):要生成的图像数量。必须介于1和10之间,默认为1。
    • size(str):生成图像的尺寸。必须是以下尺寸之一:”256×256″、”512×512″或”1024×1024″。较小的图像生成速度更快,默认为”1024×1024″。
    • response_format(str):生成的图像返回格式。必须是”url”或”b64_json”之一,默认为”url”。
    • user(str):代表你的最终用户的唯一标识符,有助于OpenAI监测和检测滥用。了解更多信息。

    让我们看看如何使用DALL·E API生成图像的示例:

    # 设置文本描述
    prompt = "一个赛博朋克的猴子黑客,梦想着一堆美味的香蕉,数字艺术"
    
    # 调用OpenAI API
    generation_response = openai.Image.create(
        prompt=prompt,
        n=1,
        size="1024x1024",
        response_format="url",
    )
    
    # 打印响应
    print(generation_response)

    上述代码将返回生成的图像的URL。你可以将这个URL用于下载图像,如下所示:

    # 保存图像
    generated_image_name = "生成的图像.png"  # 任何你喜欢的名称,文件类型应为.png
    generated_image_filepath = os.path.join(image_dir, generated_image_name)
    generated_image_url = generation_response["data"][0]["url"]  # 从响应中提取图像URL
    generated_image = requests.get(generated_image_url).content  # 下载图像
    
    with open(generated_image_filepath, "wb") as image_file:
        image_file.write(generated_image)  # 将图像写入文件

    接下来,我们可以使用PIL库来显示生成的图像:

    # 显示生成的图像
    print(generated_image_filepath)
    Image.open(generated_image_filepath)

    变换图像

    变换端点用于生成与输入图像相似的新图像(变体)。

    必要输入:

    • image(str):要用作变体基础的图像。必须是有效的PNG文件,小于4MB,并且是正方形。

    可选输入:

    • n(int):要生成的图像数量。必须介于1和10之间,默认为1。
    • size(str):生成图像的尺寸。必须是以下尺寸之一:”256×256″、”512×512″或”1024×1024″。较小的图像生成速度更快,默认为”1024×1024″。
    • response_format(str):生成的图像返回格式。必须是”url”或”b64_json”之一,默认为”url”。
    • user(str):代表你的最终用户的唯一标识符,

    有助于OpenAI监测和检测滥用。了解更多信息。

    以下是如何生成图像变体的示例:

    # 调用OpenAI API,使用`create_variation`而不是`create`
    variation_response = openai.Image.create_variation(
        image=generated_image,  # 从上面生成的图像获取
        n=2,
        size="1024x1024",
        response_format="url",
    )
    
    # 打印响应
    print(variation_response)

    类似于生成图像,我们可以将变体的URL用于下载图像,如下所示:

    # 保存变体图像
    variation_urls = [datum["url"] for datum in variation_response["data"]]  # 提取URL
    variation_images = [requests.get(url).content for url in variation_urls]  # 下载图像
    variation_image_names = [f"变体图像_{i}.png" for i in range(len(variation_images))]  # 创建名称
    variation_image_filepaths = [os.path.join(image_dir, name) for name in variation_image_names]  # 创建文件路径
    for image, filepath in zip(variation_images, variation_image_filepaths):  # 遍历变体
        with open(filepath, "wb") as image_file:  # 打开文件
            image_file.write(image)  # 将图像写入文件

    接下来,我们可以使用PIL库来显示生成的原始图像和变体图像:

    # 显示原始图像
    print(generated_image_filepath)
    Image.open(generated_image_filepath)
    
    # 显示新的变体图像
    for variation_image_filepaths in variation_image_filepaths:
        print(variation_image_filepaths)
        Image.open(variation_image_filepaths)

    编辑图像

    编辑端点使用DALL·E生成现有图像的指定部分。编辑需要三个输入:要编辑的图像、指定要重新生成的部分的蒙版和描述所需图像的提示。

    必要输入:

    • image(str):要编辑的图像。必须是有效的PNG文件,小于4MB,并且是正方形。
    • mask(str):另一个图像,其完全透明区域(例如,alpha为零的区域)指示图像应该进行编辑。必须是有效的PNG文件,小于4MB,并且与图像具有相同的尺寸。
    • prompt(str):对所需图像的文本描述。最大长度为1000个字符。

    可选输入:

    • n(int):要生成的图像数量。必须介于1和10之间,默认为1。
    • size(str):生成图像的尺寸。必须是以下尺寸之一:”256×256″、”512×512″或”1024×1024″。较小的图像生成速度更快,默认为”1024×1024″。
    • response_format(str):生成的图像返回格式。必须是”url”或”b64_json”之一,默认为”url”。
    • user(str):代表你的最终用户的唯一标识符,有助于OpenAI监测和检测滥用。了解更多信息。

    编辑需要一个“蒙版”,以指定图像的哪个部分需要重新生成。蒙版是一个图像,其中alpha值为0(透明)的任何像素都将重新生成。下面的代码创建一个1024×1024的蒙版,其中底半部分是透明的:

    # 创建一个蒙版
    width = 1024
    height = 1024
    mask = Image.new("RGBA", (width, height), (0, 0, 0, 1))  # 创建一个不透明的图像蒙版
    
    # 将底半部分设置为透明
    for x in range(width):
        for y in range(height // 2, height):  # 仅循环遍历蒙版的底半部分
            # 将alpha(A)设置为零以使像素变为透明
            alpha = 0
            mask.putpixel((x, y), (0, 0, 0, alpha))
    
    # 保存蒙版
    mask_name = "底半部分蒙版.png"
    mask_filepath = os.path.join(image_dir, mask_name)
    mask.save(mask_filepath)

    现在,我们可以使用这个蒙版来编辑图像,生成一些编辑的示例:

    # 编辑图像
    
    # 调用OpenAI API
    edit_response = openai.Image.create_edit(
        image=open(generated_image_filepath, "rb"),  # 来自生成部分的图像
        mask=open(mask_filepath, "rb"),  # 来自上面的蒙版
        prompt=prompt,  # 来自生成部分的文本描述
        n=1,
        size="1024x1024",
        response_format="url",
    )
    
    # 打印响应
    print(edit_response)

    与前面的示例一样,我们可以将编辑的图像的URL用于下载图像,如下所示:

    # 保存图像
    edited_image_name = "编辑后的图像.png"  # 任何你喜欢的名称,文件类型应为.png
    edited_image_filepath = os.path.join(image_dir, edited_image_name)
    edited_image_url = edit_response["data"][0]["url"]  # 从响应中提取图像URL
    edited_image = requests.get(edited_image_url).content  # 下载图像
    
    with open(edited_image_filepath, "wb") as image_file:
        image_file.write(edited_image)  # 将图像写入文件

    现在,我们可以使用PIL库来显示原始图像和编辑后的图像:

    # 显示原始图像
    print(generated_image_filepath)
    Image.open(generated_image_filepath)
    
    # 显示编辑后的图像
    print(edited_image_filepath)
    Image.open(edited_image_filepath)

    小贴士

    在使用DALL·E API时,以下是一些有用的小贴士:

    • 尝试不同的文本描述:通过尝试不同的文本描述来获得不同风格和主题的图像。
    • **实验编辑

    **:尝试使用不同的蒙版和文本描述来编辑图像,以获得不同的效果。

    • 注意图像尺寸:选择适合你项目需要的图像尺寸,较小的图像生成速度更快。
    • 保留API密钥安全:确保不分享你的API密钥,以防止滥用。

    现在,你已经了解如何使用DALL·E API生成、编辑和变换图像,你可以尝试将这些技巧应用到你的创意项目中,为你的设计工作增添一些魔法。

    结论

    DALL·E API为创意设计师和艺术家提供了一个令人兴奋的机会,可以通过简单的文本描述来生成、编辑和变换惊艳的图像。无论你是在制作杂志封面、广告宣传、艺术作品还是任何其他创意项目,DALL·E API都可以成为你的得力助手。

    现在,赶快尝试一下这个令人着迷的技术,看看它如何为你的创意世界带来新的可能性!

  • 创建自动化试卷生成工具:使用Python和OpenPyXL

    创建自动化试卷生成工具:使用Python和OpenPyXL

    你是否曾经需要为学生创建大量的试卷,但又不想手动编写每一份试卷?在这个教程中,我们将使用Python编写一个自动化试卷生成工具,可以根据题库随机生成试卷,并保存为Word文档。无需编程经验,我们将一步步引导你完成整个过程。

    开场故事

    假设你是一名教师,每学期都需要为你的学生创建多份试卷。但是,手动编写每一份试卷非常耗时且容易出错。你希望有一种自动化工具,可以根据题库随机生成试卷,以节省时间并降低错误率。现在,让我向你介绍如何使用Python创建这样一个自动化试卷生成工具。

    准备工作

    在开始之前,确保你的计算机上已经安装了以下工具和库:

    • Python:确保你已经安装了Python。如果没有,你可以从Python官方网站下载并安装。

    • OpenPyXL:OpenPyXL是一个用于操作Excel文件的Python库。你可以使用以下命令安装它:

      pip install openpyxl

    创建自动化试卷生成工具

    现在,让我们开始创建自动化试卷生成工具。

    导入必要的库

    首先,我们需要导入必要的Python库和模块。这些库包括random(用于生成随机数)和openpyxl(用于操作Excel文件)。

    import random
    from openpyxl import load_workbook

    创建随机数生成函数

    我们将创建一个函数,用于生成不重复的随机整数。这个函数将接受两个参数,分别是最大数和需要生成的随机数的个数。

    def Random_num(num_max, num_qty):
        num_list = []
        while len(num_list) < num_qty:
            num = random.randint(2, num_max)
            if num in num_list:
                continue
            else:
                num_list.append(num)
        return num_list

    创建题目抽取函数

    接下来,我们将创建一个函数,用于根据随机生成的题目编号从题库中抽取题目。这个函数将接受两个参数,分别是试题类型和需要抽取的试题编号。

    def Question(que_type, numbers):
        questions = []
        wb = load_workbook("题库.xlsx")
        ws = wb[que_type]
    
        for i in numbers:
            question = ws["B" + str(i)].value
            if que_type == "多选题" and ws["G" + str(i)].value:
                answerE = "E:\t" + str(ws["G" + str(i)].value)
                single_question = [question, answerE]
            else:
                single_question = [question]
            questions.append(single_question)
    
        return questions

    创建试卷生成函数

    现在,我们将创建一个函数,用于将抽取的试题写入Word文档中。

    from docx import Document
    from docx.shared import Pt
    from docx.oxml.ns import qn
    
    def To_word(number, questions_data):
        doc = Document("试题-模板.docx")
    
        title1 = "一、单项选择题(共40题,每题1分)"
        p = doc.add_paragraph()
        r = p.add_run(title1)
        r.bold = True
        r.font.size = Pt(12)
    
        for index, i in enumerate(questions_data["单选题"], start=1):
            doc.add_paragraph(f"{index}. {i[0]}")
    
        title2 = "二、多项选择题(共20题,每题2分)"
        p = doc.add_paragraph()
        r = p.add_run(title2)
        r.bold = True
        r.font.size = Pt(12)
    
        for index, i in enumerate(questions_data["多选题"], start=1):
            doc.add_paragraph(f"{index}. {i[0]}")
    
            if len(i) == 2:  # 判断是否有E选项
                doc.add_paragraph(f"{i[1]}")
    
        title3 = "三、判断题(共10题,每题1分)"
        p = doc.add_paragraph()
        r = p.add_run(title3)
        r.bold = True
        r.font.size = Pt(12)
    
        for index, i in enumerate(questions_data["判断题"], start=1):
            doc.add_paragraph(f"{index}. {i[0]}")
    
        title4 = "四、填空题(共10题,每题1分)"
        p = doc.add_paragraph()
        r = p.add_run(title4)
        r.bold = True
        r.font.size = Pt(12)
    
        for index, i in enumerate(questions_data["填空题"], start=1):
            doc.add_paragraph(f"{index}. {i[0]}")
    
        doc.save(f"试卷及答案\\考试题{number}.docx")

    创建答案生成函数

    接下来,我们将创建一个函数,用于生成试题答案,并将答案写入Word文档中。

    def Answer(number, questions_data):
        doc = Document()
    
        title = "计算机系2020第二学期期末考试题(答案)"
        p = doc.add_paragraph()
        r = p.add_run(title)
        r.bold = True
        r.font.size = Pt(20)
    
        title1 = "一、单项选择题答案(共40题,每题1分)"
        p = doc.add_paragraph()
        r = p.add_run(title1)
        r.bold = True
        r.font.size = Pt(12)
    
        p = doc.add_paragraph()
        for index, i in enumerate(questions_data["单选题"], start=1):
            p.add_run(f"{index}. {i[0]} {i[1]}\t")
            if index % 10 == 0:
                p = doc.add_paragraph()
    
        title2 = "二、多项选择题答案(
    
    共20题,每题2分)"
        p = doc.add_paragraph()
        r = p.add_run(title2)
        r.bold = True
        r.font.size = Pt(12)
    
        p = doc.add_paragraph()
        for index, i in enumerate(questions_data["多选题"], start=1):
            p.add_run(f"{index}. {i[0]} {i[1]}\t")
            if index % 3 == 0:
                p = doc.add_paragraph()
    
        title3 = "三、判断题答案(共10题,每题1分)"
        p = doc.add_paragraph()
        r = p.add_run(title3)
        r.bold = True
        r.font.size = Pt(12)
    
        p = doc.add_paragraph()
        for index, i in enumerate(questions_data["判断题"], start=1):
            p.add_run(f"{index}. {i[0]} {i[1]}\t")
            if index % 5 == 0:
                p = doc.add_paragraph()
    
        title4 = "四、填空题答案(共10题,每题1分)"
        p = doc.add_paragraph()
        r = p.add_run(title4)
        r.bold = True
        r.font.size = Pt(12)
    
        p = doc.add_paragraph()
        for index, i in enumerate(questions_data["填空题"], start=1):
            p.add_run(f"{index}. {i[0]} {i[1]}\t\t")
            if index % 2 == 0:
                p = doc.add_paragraph()
    
        doc.save(f"试卷及答案\\考试题{number}答案.docx")

    主函数

    最后,我们创建了主函数来运行整个试卷生成过程。

    if __name__ == '__main__':
        for number in range(1, 21):  # 生成20套试卷
            num_single_choice = Random_num(566, 40)
            num_mult_choice = Random_num(196, 20)
            num_judgment = Random_num(418, 10)
            num_completion = Random_num(190, 10)
    
            question_num = {
                "单选题号": num_single_choice,
                "多选题号": num_mult_choice,
                "判断题号": num_judgment,
                "填空题号": num_completion
            }
    
            questions_data = {
                "单选题": Question("单选题", question_num["单选题号"]),
                "多选题": Question("多选题", question_num["多选题号"]),
                "判断题": Question("判断题", question_num["判断题号"]),
                "填空题": Question("填空题", question_num["填空题号"])
            }
    
            To_word(number, questions_data)
            Answer(number, questions_data)
            print(f"试卷{number}及答案生成完成!")

    运行试卷生成工具

    现在,你已经创建了一个自动化试卷生成工具,可以根据题库随机生成试卷,并将试卷和答案保存为Word文档。要运行工具,只需运行上述代码。生成的试卷和答案将保存在指定的文件夹中。

    总结

    通过本教程,你学会了如何使用Python和OpenPyXL创建一个自动化试卷生成工具。这个工具可以大大节省教师编写试卷的时间,同时降低了人为错误的风险。你可以根据自己的需求进一步扩展这个工具,添加更多功能,如生成不同类型的试题或自定义试题模板。

    希望这个教程对你有所帮助,让你更轻松地处理大量试卷生成工作!