DLAI-Streamlit-快速原型开发笔记-全-

DLAI Streamlit 快速原型开发笔记（全）

001：课程介绍与核心理念 🚀

在本节课中，我们将要学习如何利用 Streamlit 和生成式 AI 技术，快速构建和迭代软件应用原型。课程由 DeepLearning.AI 与 Snowflake 合作推出，旨在帮助开发者掌握在 AI 时代加速开发的思维框架与实用工具。

课程概述

欢迎来到本课程。在这里，你将学习如何使用 Streamlit 快速原型开发生成式 AI 应用程序。

本课程是 DeepLearning.AI 与 Snowflake 的合作成果，后者负责管理 Streamlit。如今，掌握如何构建生成式 AI 应用的人正以前所未有的速度前进。AI 为你编写代码、解决问题、规划复杂软件应用的能力，正在极大地加速我们所有人构建软件的速度。现在，使用实际可运行的软件原型来验证完整想法，不仅是可行的，而且通常比仅使用纸面文档或手绘线框图更可取。

当你快速构建出某些东西时，你可以利用该软件原型获取反馈，并且是更丰富的反馈，从而更好地决定下一步迭代的方向。你可以取得进展，并获得真实的反馈来推动进展，这比以往任何时候都要快得多。

在本课程中，你将学习一个思维框架，用于思考如何快速构建原型以及如何快速迭代。

与导师的对话

我很高兴能与你的导师陈宁·南塔萨万博士一同在这里。他还创建了 YouTube 频道“数据教授”，帮助了数千名开发者将他们的 AI 想法变为现实。欢迎，陈宁。

谢谢安德鲁的亲切介绍。我知道你经常谈论生成式 AI 如何彻底改变你自己的开发过程。对你个人而言，在软件工作中最大的变化是什么？

我感觉这已经令人兴奋了一段时间，但我感觉自己就像在一艘移动缓慢的船上，我并不感到无聊，这是一艘非常快乐的船。但最近编码方面的变化让我感觉，这艘船现在移动得快多了，这种速度和动力让我感到非常兴奋。

所以这些天，我几乎每个周末都在写代码。我在周六和周日花更多时间，而不是工作日。但我发现，有了一个想法，我可以在周六下午去咖啡店坐下来，在一到四个小时内让某些东西启动并运行。事实证明，我的很多想法都是坏主意，实现后一看，觉得“哦，这行不通”，它永远不会面世，这没关系，因为我只浪费了少量时间。有时我构建了一些东西，觉得“你知道吗，我应该喜欢这个”，然后带给我的团队，看看他们是否有兴趣将其推广到更大规模。

但这种速度以及尝试某事的成本急剧降低，意味着我和我看到世界各地的许多聪明团队现在都愿意进行更多尝试。如果行不通也没关系，只是进行更多尝试，直到找到真正有效的东西，然后我们再将其推广到更大规模。我看到开发者正从“让我规划每一个细节”转向“让我测试这一个想法”。

当原型开发变得快速时，真正的瓶颈就变成了等待反馈。如果你能在第三天而不是第三周获得反馈，你就有更多时间进行有意义的改进。

但是安德鲁，当开发进展如此迅速时，你如何确保从每次迭代中学到有用的东西呢？

我经常使用的一个实践是，当构建原型时，有时在咖啡店只有两个小时，我经常做的是不断削减范围，直到我想要实现的项目可以在两小时内完成。

你可以将范围削减到足够小，以构建一个设想中更大应用程序的一个组件。然后你可以拿这个组件展示给用户，看看他们是否喜欢。例如，如果你设想用户能更好地处理电子邮件，也许你可以削减范围，构建一个最小可行产品，只处理少量电子邮件，也许是从你的邮箱复制粘贴，然后展示一个结果。你可以拿这个给用户测试，甚至自己测试。如果你自己的直觉不差，有时用自己的直觉来预测用户想要什么，我发现这足以做出非常快速的决策，从而使产品决策的速度与现在可能的执行速度相匹配。

你在 Snowflake 工作，同时也在运营你的 YouTube 频道，你是否看到开发者的心态正在转向这种快速原型开发方法？

是的，看到人们意识到他们可以在几天而不是几个月内验证一个想法并获得反馈时，那种顿悟时刻真是令人惊叹。那些快速掌握这一点的开发者，通常是那些以前犯过这个错误的人。他们花了几个月时间构建了某些东西，发布后才发现用户想要完全不同的东西。

当我和 Snowflake 的同事交谈时，一个直接的担忧是：快速原型开发是否会损害最终开发的质量？对此你有什么看法？

我认为有趣的是，通常是快速的迭代帮助你达到质量。因为如果我们一开始并不确切知道用户想要什么，那么构建某些东西、获得反馈、再构建、再获得反馈的过程，能让我们获得更深刻的用户洞察，从而最终得到真正适合用户、更深入考虑他们需求的东西。

话虽如此，这里有一个星号，那就是当你将产品推广到更大规模时，我认为良好的软件工程基础确实很重要。如果你正在构建一个大规模、生产级、安全的应用程序，理解软件基础，比如使用什么数据库、如何构建软件、如何在云端部署和扩展，这套深厚的知识体系仍然非常有价值。

所以，并非生活中的一切都是快速编码、快速完成并发布。但在项目的初始阶段，当要构建什么功能、我们正在构建什么这些问题都不明确时，快速原型开发至关重要。然后，当你决定要推广时，再投入进行更深层次的技术投资，以稳健、可靠和安全的方式进行扩展，这似乎是拼图中非常重要的一块。

我很乐意分享我发现最有用的框架，用于推动这种快速进展。我发现，快速迭代的最佳工具是那些完全消除系统集成的工具。你可以用生成式 AI 快速编写代码，但连接所有前端和后端才是你花费时间的地方。这就是我们构建这门课程的原因。Snowflake 管理数据，Streamlit 创建即时用户界面，因此你可以专注于迭代你的核心想法，而不是花费大量时间调试系统集成。

作为一个后端背景强于前端背景的人，我不是前端专家。我发现使用生成式 AI 编写 Streamlit 代码，为我省去了前端工作，最终我写的前端代码比以前多得多。

课程内容导览

接下来，让我们了解一下本课程中你将看到的内容。

你将为一个名为 Avalanche 的虚构运动装备公司构建一个情感分析仪表板。它基于一个相当常见的真实世界场景：你的数据很混乱，项目不断演变，每个人都需要他们能够理解并使用的洞察。

你将使用生成式 AI 工具来帮助编写、排查故障和迭代你的代码，就像一个真正的代码开发者。然后，你将把你的仪表板应用程序连接到存储在 Snowflake 中的客户评论数据，并设置高效查询所需的机制。

你将通过添加聊天功能、使用提示工程和检索增强生成技术来改进你的仪表板，使其答案基于实际数据。最后，你将部署你的应用程序并练习收集反馈，因为开发并不会在发布时结束，而是从那里开始。

最终，你将创建一个功能性的应用程序，展示如何将数据转化为可以与团队分享的洞察。并且，你将掌握一个有效的工作流程，将你的想法转化为可工作的原型。这确实是本课程的目标：帮助你磨练快速、深思熟虑迭代的技能，这样你就可以利用工具将激动人心的想法变为现实，让这些想法能够被潜在用户接触到，以获得反馈并持续改进。

所以，如果你有一些想法，那很好。如果你还没有想法，也没关系。也许你一直在想“也许我应该在某天构建那个东西”。但如果你不确定从哪里开始，我希望本课程的逐步方法能为你指明一些方向，帮助你从一个模糊或试探性的概念开始，最终得到一个可工作的原型。

希望你发现本课程中学到的技能对你的工作以及有趣的个人项目都有用。接下来，我希望你继续观看下一个视频，陈宁将在那里分享生成式 AI 如何从根本上改变了原型开发，以及这对你构建应用程序的方式意味着什么。

那么，让我们进入下一个视频。

002：生成式AI应用原型设计入门 🚀

在本节课中，我们将要学习如何利用 Python 和 Streamlit 来快速构建生成式 AI 应用的原型。软件开发的方式已经改变，生成式 AI 可以成为你的编程伙伴，帮助你快速将想法转化为可运行的代码。

课程目标与结构 🎯

上一节我们介绍了课程背景，本节中我们来看看本课程的具体目标和结构安排。

本课程的目标不是单纯展示工具，而是帮助你快速构建真正可用的应用。你将从一个简单的命令行脚本开始，最终开发出功能完备的 Web 应用，这些应用将包含图表、数据分析和交互式聊天机器人等功能。

课程结构注重快速上手，通过实践项目来边做边学。在第一个模块结束时，你将拥有一个功能完整的原型，它可以接收用户输入、生成代码、在 Web 界面中实时运行代码并可视化数据。

你将学到什么 📚

以下是本课程的核心学习内容：

学习生成式 AI 工具如何加速你的应用开发流程。
构建能够响应用户输入并实时生成 Python 代码的真实世界应用。
应用诸如最小可行产品和任务受众优先级等设计原则，以专注于重要事项。

第一模块重点 🔧

接下来，我们聚焦于第一模块。该模块将帮助你构建一个基础的生成式 AI 界面来展示你的想法。

以下是第一模块的具体步骤：

提示生成式 AI 模型以生成 Python 代码。
在可共享的 Streamlit 应用中运行生成的代码。

最终，你将获得一个由生成式 AI 驱动、可部署至云端的工作原型，随时可以测试或分享。

所需工具与技能 🛠️

为了顺利完成本课程，你需要准备一些工具并具备相关技能。

以下是课程中可能用到的工具和技术：

大型语言模型：例如 ChatGPT、Claude 或 Gemini。
轻量级应用框架：例如 Streamlit、Gradio 或 Jupyter Notebooks。
提示工程技巧和基本的 Web 设置。

如果你熟悉 Python 编程，了解生成式 AI 和提示的基础知识，那么本课程非常适合你。具备基本的 SQL 知识会有所帮助，但不是必需的。

灵活性与结语 💡

虽然本课程的示例将使用 Streamlit，但你完全可以尝试任何你喜欢的 Web 应用框架和任何你熟悉的生成式 AI 模型。这里的目标不是精通每一个工具，而是学习如何在你熟悉的环境中快速实现功能。

我希望你能享受这门课程，并期待在下一个视频中与你相见。

本节课中我们一起学习了生成式 AI 应用原型设计的入门知识，包括课程目标、你将学到的技能、第一模块的重点内容以及所需的工具和预备知识。核心在于掌握快速将想法转化为可工作原型的流程和方法。

003：原型设计的优势 🚀

在本节课中，我们将要学习为什么原型设计对于生成式 AI 应用开发至关重要。我们将探讨原型如何帮助应对 AI 产品的不确定性，并通过真实案例了解其巨大价值。

当你向 ChatGPT 提出同一个问题两次时，请思考一下。你得到完全相同的答案了吗？通常不会。这就是构建 AI 产品很棘手的原因。在用户真正使用之前，你永远无法知道他们会对你的生成式 AI 应用作何反应。

你无法猜测他们会问什么问题。你也无法预测生成式 AI 何时会给出一个令人困惑的答案。这种不确定性意味着，与常规软件相比，你需要更早、更频繁地测试你的想法。这就是原型设计的关键所在。

什么是原型？🎯

上一节我们提到了不确定性带来的挑战，本节中我们来看看应对挑战的核心工具——原型。

一个原型是一个想法的快速、轻量级且可感知的版本。它并不完美，也无需完美。原型被快速构建出来，以便你能测试某些东西、从中学习并进行迭代。

以下是关于原型的关键点：

原型不是为了打磨完善或功能完整而设计的。
它们用于测试，而非用于生产环境。
原型通常会在后续过程中被丢弃或大幅修改。

在本课程中，你将专注于为生成式 AI 应用进行原型设计。在开发生成式 AI 应用时，用一个原型来展示你的愿景，每一次都胜过仅仅口头描述你的想法。

为什么需要原型？💡

了解了原型的定义后，我们来看看它具体能解决哪些问题。

当你希望在投入数周开发之前尽早获得反馈、在不构建完整产品的情况下测试有风险的想法，以及用真实数据和真实用户验证你的假设时，制作原型是必不可少的。原型非常适合早期阶段的实验。

与其创建容易被误解的详细规格说明，不如快速构建一个原型，它能精确展示你的应用如何工作。这让人们能够体验你的愿景，而不是凭空想象。

《福布斯》将“未能制作原型”列为软件项目失败的十大原因之一。

一个反面案例：Alex 的故事 ⚠️

理论可能有些抽象，让我们通过一个具体的失败案例来加深理解。

我的同事 Alex（为免尴尬，此为化名）就是一个很好的例子。他有一个绝妙的想法：开发一个能检测沮丧客户并自动将其转接给人工客服的 AI 聊天机器人。他非常兴奋，以至于做了许多开发者会做的事：跳过原型设计，直接开始编写规格说明。

Alex 认为他可以通过书面需求和粗略草图来解释他的愿景。毕竟，他已经在脑海中清晰地规划好了：一个对话式界面，AI 能在检测情感线索的同时给予共情回应。

然而，没有原型，Alex 无法清晰地传达他的愿景。当他说“对话式界面”时，他的开发人员构建了下拉菜单和表单。当他提到“情感分析”时，他们构建了一个关键词检测器，将“我需要帮助”这类信息标记为愤怒的客户。

在为期六周的开发周期中，这种脱节越来越严重。Alex 会说“让它更直观一些”，但没有具体的原型作为参考，每个团队成员都用自己的假设填补了空白。最终的产品将他伟大的想法埋没在一个笨拙的界面之下：客户在输入前必须浏览多个下拉菜单，而 AI 的回应感觉非常机械——这与 Alex 的初衷完全相反。

当他向领导层展示时，一位高管说：“这感觉像是从我们当前的支持系统退步了。”经过六周的开发，这个项目被悄悄搁置了。一个本可以改变他们客户体验的、极具创新性的想法就此夭折。如果 Alex 当初花哪怕一周时间构建一个简单的原型，他的团队或许就能建成他所设想的产品。

原型的成功范例 🌟

失败案例令人警醒，但成功的原型更能启发我们。构建原型不仅仅是理论，它是许多成功企业用来推出和增长产品的、经过验证的策略。

原型可以采取多种不同的形式，并且不应该复杂化。一个原型可以简单到只是一个用于收集电子邮件地址的登录页面、一个用于测试核心想法的基本应用，甚至是一个用于解释概念以评估兴趣的视频。

以下是几个著名的例子：

Airbnb：其创始人通过在一次设计会议期间出租自己的公寓来首次测试他们的想法。这个基本原型帮助完善了概念，并在扩展为我们今天所知的全球旅行平台之前，收集了关键的早期反馈。
Uber：始于一个简单的愿景——在旧金山将高端乘客与豪华车司机连接起来。他们的原型是一个基础应用，仅在一个城市连接一种类型的乘客与一种类型的汽车。这种有限的推出让他们能够测试核心功能并在扩展到其他城市和车辆类型之前收集用户反馈。
Instagram：其第一个原型只专注于带有基本滤镜的照片分享。随着平台发展，用户反馈和参与度推动了如今功能（如视频分享、直接消息和故事）的开发。
Spotify：其原型专注于通过庞大的音乐库提供流畅的流媒体服务。用户反馈和市场需求催生了社交分享和播放列表等新功能，这些现在已成为该平台的核心功能。
GPTZero：由一名普林斯顿学生构建，旨在检测文本是由 ChatGPT 还是人类撰写的。它使用 Streamlit 免费的社区云发布，在几天内就爆火了：700 万次浏览、大量媒体报道和全球关注——所有这些都由一个轻量级的 Streamlit 应用驱动，使得构建、部署和即时扩展变得非常容易。

请注意每个例子都遵循相同的模式：从一个想法开始，创建一个专注的原型，然后根据客户反馈进行迭代和改进。所有这些公司都不得不以艰难的方式做事，但你拥有使用生成式 AI 来使原型设计真正快速且简单的优势。

本节课中我们一起学习了原型设计在生成式 AI 应用开发中的核心优势。我们明确了原型的定义，理解了它如何应对 AI 的不确定性，并通过正反案例看到了尽早、快速构建原型对于验证想法、避免资源浪费和确保产品成功的关键作用。在下一个视频中，你将看到生成式 AI 如何彻底改变了原型设计的过程。

004：生成式AI如何革新原型设计 🚀

在本节课中，我们将要学习生成式AI（GenAI）如何从根本上改变和加速应用原型设计的过程，特别是数据应用和AI工具的开发。

概述

在生成式AI出现之前，构建应用原型，尤其是数据应用和AI工具，是一个非常耗时的过程。即使你有一个绝佳的想法，也需要花费数小时甚至数天来构建一个基础可用的版本。开发者需要反复编写相同的设置代码，例如加载库、创建输入表单、格式化页面布局。这些工作并非针对你的核心创意，但在测试任何想法之前，你都必须手动完成它们。

生成式AI移除了这个瓶颈。在测试之前，你不再需要编写每一个函数、连接每一个依赖项，甚至规划整个流程。

传统原型设计流程

上一节我们提到了传统方法的耗时问题，本节中我们来看看一个具体的例子。想象一下，你有一个想法：创建一个用于分析客户产品评论情感倾向的应用。

在没有生成式AI的情况下，你需要遵循以下步骤：

以下是构建该应用所需的主要步骤：

设计界面：设计一个包含文本框（用于粘贴评论）、按钮（用于运行分析）和结果展示区的界面。
编写代码：编写代码来实现上述界面。
连接后端逻辑：将前端输入连接到后端处理逻辑。
导入分析库：导入用于情感分析的库。
处理数据：清理和加载你的数据。
构建逻辑：逐步构建分析逻辑。
展示结果：编写代码来展示结果，可能以图表或表格的形式。
测试与修复：最终进行测试，修复错误，并重构不合理的部分。

即使是一个如此简单的应用，也可能需要数天时间来构建。如果效果不符合预期，你必须手动地、逐块地回去修改代码。

生成式AI驱动的原型设计

现在，让我们尝试用生成式AI来实现同样的想法。你只需在一个生成式AI应用中输入一段提示（Prompt），要求它“创建一个Streamlit应用，让用户可以粘贴评论、运行情感分析，并将结果以饼图展示”。

在几秒钟内，AI就会生成代码。它会导入必要的库、设置界面、运行分析并创建图表。你点击运行，就可以立即开始测试你的想法。

这正是生成式AI的强大之处：它移除了大部分重复的设置工作，让你能专注于测试真正重要的部分。

思维模式的转变

但生成式AI的意义不仅在于编写更少的代码，更在于它改变了你的思维方式。

在传统的软件开发中，你的思维模式是 “先规划，后构建”。你会从架构、数据模型和依赖关系的角度去思考，然后再编写代码。

公式：传统思维 = 规划 -> 构建

而生成式AI将这个过程翻转了。你不再从结构开始，而是从意图开始。你描述你希望发生什么，然后生成式AI模型会给你一个可以交互的成果。

公式：GenAI思维 = 意图 -> 交互式成果

因此，你的思考方式从 “我该如何构建这个？” 转变为 “测试这个想法是否可行最快的方法是什么？”。这是一种完全不同的心态，将你从“解决方案优先”推向“探索优先”。这种转变是革命性的。

生成式AI将软件开发变成了你与大型语言模型（LLM）之间、原型与用户之间、问题与可能性之间的一场对话。

降低开发门槛

生成式AI最令人兴奋的一点是，它向更多人敞开了软件开发的大门。

以前，如果你不会编程，你的想法通常只能停留在脑海中，或者躺在演示文稿里。现在，教师、医生、研究人员和组织者等人士，无需成为全职开发者，也能构建出解决实际问题的可用应用。

当然，如果你已经掌握编程技能，这些技能非但不会受到威胁，反而会成为你的超能力。你可以行动得更快，构建更灵活的工具，并引导AI精确地生成你所需的内容。你的技能依然至关重要，生成式AI只是帮助你跳过重复的部分，专注于最重要的环节。

总结

本节课中，我们一起学习了生成式AI如何革新原型设计。通过生成式AI，你可以在几秒钟内从想法过渡到可运行的代码，所需的设置更少，技术壁垒更低，从而有更多时间专注于构建和测试核心功能。在下一节视频中，你将看到生成式AI如何改变游戏规则，以及它如何移除了过去拖慢一切进度的瓶颈。

005：GenAI 原型开发周期 🚀

在本节课中，我们将要学习生成式 AI 应用的原型开发周期。我们将了解为何传统开发流程不适用于 GenAI 项目，并掌握快速构建、测试和迭代原型的关键步骤与核心组件。

概述

在开始构建之前，有必要从宏观视角了解原型开发在整个流程中的位置。

传统开发与 GenAI 开发的差异

上一节我们介绍了课程背景，本节中我们来看看开发流程的根本区别。

在传统开发周期中，你从一个详细的计划开始。设计完整的系统。编写代码，进行测试，最后部署。这对于需求明确、固定的项目效果很好。但对于 GenAI 应用实验来说，这种方式太慢了。

GenAI 的开发过程是不同的。你并不总是知道输出会是什么。GenAI 模型可能会让你感到意外。你的提示词可能会失效。导致意外的行为、错误或糟糕的结果。用户的行为方式也可能出乎你的预料。

因此，与其遵循严格的计划，你需要快速构建、频繁测试并迅速调整。这就是原型开发发挥作用的地方。

原型开发的核心地位

原型开发在你有了想法之后立即开始。并且在你投入全面开发之前进行。这是你用真实输入、真实输出和真实反馈快速测试想法的地方。尤其是在构建 GenAI 应用时，原型开发不仅仅是可有可无，它是必不可少的。

原型开发帮助你探索模型的行为方式，以及微小的改变如何产生巨大的差异。即使提示词方式的细微变化，也可能导致结果是“真金白银”还是“毫无意义的胡言乱语”。原型开发还让你能够用真实用户测试你的应用，观察他们如何思考、点击，有时甚至会完全忽略显而易见的东西。

你将在早期发现边缘情况，例如当你的模型自信地回答了一个你根本没问的问题时。你也能快速了解你的想法是坚实可靠、令人惊讶，还是需要在投入数周时间之前进行方向调整。

你会多次回到原型开发阶段，每次你都有新功能要测试或新问题要解决。在本课程中，你将把原型开发作为默认的开发模式。这意味着始终在构建一些东西，一些你可以测试、分享或迭代的东西。即使它只是一个非常粗糙的草稿。

生成式 AI 应用的核心组件

每个基础的 GenAI 应用都有四个关键部分。

以下是构成一个可工作原型的四个核心组件：

用户界面：这是人们使用和与你的应用交互的方式。它可以是一个简单的 Streamlit 应用、一个聊天机器人，甚至只是在笔记本中运行的代码。
逻辑：这是你应用的核心。它接收用户的输入、问题或数据，并将其发送给 AI 以获取响应。
数据：从简单的东西开始你的原型，比如一个 CSV 文件或一份 PDF 文档。这为你在测试期间提供了真实的信息，但不需要在复杂的数据集上花费大量精力。
AI 服务连接：需要连接到一个 AI 服务，如 GPT-4 或 Claude。AI 服务负责智能思考，而你的应用处理围绕它的一切其他事务。

可以这样理解：界面让人们与你的应用对话。逻辑负责决定要做什么。数据为你提供了可操作的内容。而 AI 则承担了繁重的计算工作。将这四部分组合在一起，你就有了一个可工作的原型。

GenAI 开发周期示例

以下是你的 GenAI 开发周期将呈现的样子。

构思：首先想出一个创意。
构建：使用 Python 和 Streamlit 快速构建一个原型。
测试：使用一小组真实数据测试原型。
分享：分享原型以获取用户的反馈。
迭代：根据你学到的东西改进提示词、代码或界面，并决定是否值得将其开发成功能完整的应用。

过去需要数周完成的事情，现在可以在几分钟内完成。这就是快速原型开发的力量。

原型与生产应用的对比

了解原型与完整生产应用之间的区别非常重要。这样，你才能设定正确的目标。

原型帮助你探索想法。它帮助你回答问题。而生产应用则需要可靠和安全。

以下是它们的对比：

目的：
- 原型：用于测试和学习。
- 生产应用：用于交付完整、稳定的产品。
优先级：
- 原型：专注于速度。
- 生产应用：专注于架构和可靠性。
代码质量：
- 原型：代码可以有些混乱但功能正常。
- 生产应用：代码应该经过重构、清晰且可维护。
数据：
- 原型：可以使用小型或模拟数据集。
- 生产应用：需要真实、干净且经过验证的数据。

总结

本节课中我们一起学习了 GenAI 应用的原型开发周期。我们认识到，对于 GenAI 项目，构建一个小型可运行的原型，将其置于真实数据或真实用户面前，并观察其表现，是至关重要的。因为对于 GenAI 来说，最快的学习方式就是尽早构建、频繁测试并实时调整。

在下一个视频中，你将了解更多关于开发者在匆忙进行 GenAI 原型开发时常犯的最大错误，以及可以为你节省数小时挫折感的简单技巧。让我们继续深入。

006：避免常见陷阱 🚧

在本节课中，我们将要学习在使用生成式AI进行快速原型开发时，如何识别并避免一些常见的陷阱。生成式AI虽然能加速开发，但也带来了新的挑战。

概述

生成式AI能加快开发速度，但它也带来了一些新的挑战。相同的提示词可能不会每次都产生相同的结果，措辞上的微小变化可能导致意想不到的结果。此外，当你并非亲自编写每一行代码时，调试会变得更加困难。如果不够谨慎，生成式AI在帮助你快速前进的同时，也可能让你陷入混乱。

陷阱一：过度设计原型

上一节我们介绍了生成式AI带来的挑战，本节中我们来看看第一个常见陷阱：过度设计原型。

我们都曾在构建AI应用时犯过这个错误，即过度设计我们的原型。人们很容易对生成式AI的能力感到兴奋，并要求它一次性构建所有东西：用户界面、后端、数据库和分析图表，全部塞进一个巨大的提示词中。这只会迫使模型生成过多的代码，而这些代码片段可能无法很好地协同工作。调试会变成一场噩梦，你将花费数小时来梳理结果，甚至忘记最初想要构建什么。

解决方案相当直接：保持简单，一次只尝试一个想法。与其要求一次性构建完整的应用程序，不如从一个小功能开始，比如一个单一的函数或一个简单的UI组件。这能让你拥有更多控制权，并更容易发现问题所在。当任务被明确定义时，生成式AI才能发挥最佳效果。

陷阱二：在获得反馈前追求完美

另一个常见陷阱是试图在获得任何反馈之前就完善所有细节。你很容易花费过多时间调整提示词、重新设计图表或争论按钮颜色，而实际上还没有人使用过这个应用。

可以尝试另一种方法：先完成80%，然后获取反馈。你的原型不需要很漂亮，它需要的是有用。这意味着要向真实用户展示它，了解哪些部分有效，然后再进行改进。

例如，假设你正在构建一个提供个性化建议的生成式AI应用。你可能会担心令牌限制或缓存问题。但在处理这些之前，首先应该问：人们是否喜欢这些推荐？问一个更简单的问题：用户觉得这个功能有帮助吗？他们是否真的采取了行动？先构建足够的功能来测试这个核心目标，美化工作可以稍后进行。

陷阱三：忽视代码可读性与团队协作

假设你的原型运行良好，现在你的团队很兴奋，准备在此基础上进行构建。这很棒，但这里有一个问题：从AI获得的代码可能不易于理解，尤其是当你并非代码的原作者时。这很正常，因为你当时追求的是速度，而这是正确的选择。现在到了分享工作成果的时候，以下方法可以让你的团队更轻松：

以下是几个让团队协作更顺畅的实践：

添加注释：用注释解释哪些部分是由AI生成的。
保持结构简单：坚持使用简单的文件名和文件夹结构。
使用熟悉的技术栈：使用你的团队已经了解的工具。
利用AI编写测试：使用生成式AI帮助你编写一些快速的测试用例。

现在花一点时间进行清理，将来会省去很多麻烦。

有效测试你的原型

不要只是点击运行然后祈祷一切顺利。通过以下步骤有效地测试你的提示词和原型：

以下是测试原型的关键步骤：

从简单开始：从简单的提示词开始，仔细观察它的返回结果。
迭代提示词：尝试重新措辞提示词，使其更简单，或给出更清晰的指令。微小的调整可以极大地改变结果。
检查输出：运行一些边界情况测试，例如空输入或异常输入。检查AI的输出是否合理，而不是在“幻觉”（即生成无意义或错误内容）。
进行用户测试：请其他人试用。观察他们在哪里感到困惑。
记录与调试：锁定你的输入和输出，以便后续调试。修复发现的问题，然后再次测试。

你并不是在进行全面的质量保证测试，你只是在试图回答一个问题：这个想法值得构建吗？

让原型开发更顺畅的简单习惯

在利用AI进行构建时，养成以下简单习惯可以让原型开发过程更加顺畅：

以下是几个推荐的习惯：

提示词要具体：在你的提示词中尽可能具体。
使用小数据集测试：测试时使用小型数据集。
运行前阅读代码：在运行AI生成的代码之前先阅读它。
使用版本控制：使用版本控制系统，以便可以撤销错误。
接受结果的不一致性：不要期望每次结果都相同，生成式AI并不总是完全一致的。

总结与核心理念

本节课中我们一起学习了如何避免生成式AI原型开发中的常见陷阱。让我用最重要的一点来总结：你的原型注定是一次性的。

你构建它是为了学习：如果它能帮助人们，并且AI能很好地处理任务，那太好了，你可以在此基础上构建更多。如果不行，那也是个好消息，因为你为自己节省了大量时间。

下一节视频将向你介绍课程项目和数据集，以便你了解在本课程剩余部分将要构建的内容。让我们一起来看看吧。

007：课程项目与数据集介绍 🎯

在本节课中，我们将介绍整个课程的核心实践项目。你将扮演一家名为“雪崩”的户外装备公司的数据科学家，使用生成式AI技术，构建一个能自动化分析客户评论情感的原型应用。

项目背景与目标

在接下来的课程中，你将扮演“雪崩”户外装备公司的数据科学家。你的老板交给你一项非常熟悉的任务：分析哪些冬季产品表现良好，哪些产品受到客户差评。你曾多次对同一份“雪崩”客户评论数据集进行情感分析，但这次，你将构建一个AI原型来自动化整个工作流程。

这类现实世界的任务非常适合生成式AI。它具有重复性、有明确的成功指标，并且老板要求快速得到答案。在整个课程中，你将构建一个由生成式AI驱动的真实应用，该应用能够按产品和交付状态计算平均情感得分、分析客户情感，并允许用户用自然语言提问。

你将从一个简单的Streamlit界面开始，逐步升级为一个完整的仪表板和AI助手。课程结束时，你将拥有一个能够回答“生成式AI能否帮助我们团队更快理解客户反馈？”的工作原型。

项目阶段概览

以下是整个课程项目的三个阶段规划：

第一阶段：你将使用Jupyter和OpenAI，配合Pandas加载和清理数据，构建一个简单的交互界面，用图表和过滤器可视化结果，并将你的第一个原型发布到网上。你将使用生成式AI来帮助你编写代码。

第二阶段：你将转移到Snowflake平台，上传原始文本文件，将其摄取并存储为结构化格式，使用Snowflake内置的AI工具进行分析，然后部署一个功能齐全、包含聊天机器人的应用。

第三阶段：你将把你的聊天机器人连接到数据，并通过提示工程和检索增强生成技术来改进其回答。你将学习快速获取反馈的技巧。

这是一个有指导的项目，但你将有充足的空间进行自定义和实验。如果你想尝试LangChain或其他生成式AI API，尽管去尝试。

数据集介绍

你将使用“雪崩”数据集，这是一个专为本课程构建的虚构数据集。

让我们探索一下客户评论文件，其格式为CSV。在这个文件中，每一行代表一条客户评论，包含以下字段：

产品名称
评论日期
评论文本
情感得分：范围在-1（非常负面）到+1（非常正面）之间

课程开始时，你将使用一个名为 customer_reviews.csv 的预清理CSV文件。在课程后期，你将学习如何自己一步步构建和清理“雪崩”客户评论数据。

如果你想更深入，我们还提供了原始评论文件的DOCX版本，以便你可以在第二模块中测试文件摄取功能。

最终应用预览

现在，你将预览最终的Streamlit应用。应用顶部将有两个标签页：

第一个标签页显示按产品划分的情感得分图表，然后是数据表的预览。你可以按产品筛选表格，并查看每个产品按交付状态划分的情感得分。

第二个标签页有一个文本输入框，允许你使用自然语言对数据提问。它使用一个能够访问你的数据并回答相关问题的语言模型。

课程总结

本节课中，我们一起了解了课程的核心项目——为“雪崩”公司构建一个生成式AI驱动的客户情感分析应用。我们明确了项目目标，概述了从简单原型到功能齐全的仪表板与聊天助手的三个阶段开发路径，并介绍了将要使用的数据集结构。

现在你已经了解了最终项目的样子，我们准备开始深入实践。在下一个视频中，你将学习如何应用一个简单的框架来构建原型，这将帮助你确定要构建什么以及哪些功能最重要。让我们开始构建一些智能的东西，让你的工作变得更轻松。

008：确定 MVP 范围 🎯

在本节课中，我们将要学习如何为你的生成式 AI 应用确定最小可行产品（MVP）的范围。这是启动任何项目前最关键的一步，能帮助你避免过度开发，专注于解决核心问题。

概述：什么是 MVP？

在开始构建之前，你需要决定构建什么。答案不是构建全部，而是构建最小可行产品。这是你的想法中，能够解决实际问题的最小版本。许多 AI 开发者在这里会偏离轨道，他们过于兴奋，过度构建，最终导致精力耗尽。我们不应这样做。

最小可行产品（MVP）是一个帮助你更聪明、而非更费力地构建的框架。Eric Ries 在其著作《精益创业》中推广了这一概念，它已被证明对开发团队极具价值，因为它专注于快速学习。我们使用这个框架来帮助你高效地规划和构建原型。

你越快构建出可测试的东西，就能越快获得反馈并进行改进。这就创造了一个“计划、构建、测试、学习、改进、重复”的实用循环。这样想：花一天时间构建一个东西，获得反馈，并重复这个循环10次，远比花10天构建一个东西，只获得一次反馈要有用得多。

如何定义你的 MVP

以下是你可以用来定义 MVP 的简单框架，它被称为 MAP：使命、受众和优先级。

使命：你的最终目标是什么？
受众：你为谁而构建？
优先级：你需要首先做什么？其他一切都可以等待。

明确你的使命 🧭

定义你的使命意味着从一个基本问题开始：你试图解决什么问题？

首先确定你的应用将解决的具体痛点或低效环节。要具体。不要说“我想构建一个 AI 聊天机器人”，而应该说“客服人员每次通话需要花 20 分钟查找产品信息，我想将其减少到 2 分钟”。你的最终目标应该是具体且可衡量的，它将成为你开发过程中每个决策的“北极星”。

你应该问的第二个问题是：你如何知道你的应用解决了问题？

要解决一个真正的问题，你需要一种方法来知道它何时被解决。这就是指标的作用。它们告诉你你的解决方案是否真的有效。例如，如果你的问题是数据科学家花费太多时间重复相同的工作流程，那么你的成功指标可能是将设置时间从 5 小时减少到 30 分钟。

了解你的受众 👥

了解你的受众塑造了一切，从界面的复杂性到你使用的编程语言。你无法为所有人构建，因此要确定你的主要用户群体。

以下是一些帮助你定义目标受众的关键问题：

他们是技术专家还是完全的新手？
他们对现有解决方案最大的不满是什么？
他们目前使用什么变通方法？
他们如何衡量自己角色的成功？

确定你的优先级 ⚡

这是你弄清楚原型中哪些功能绝对必要、哪些可以等待的地方。你试图快速构建出可用的东西，因此要将重点放在一个核心工作流程上。

问自己：如果只能构建一个功能来展示这个应用的价值，那会是什么？

应用到 Avalanche 项目

现在，让我们将所有内容带回 Avalanche 项目。

首先问最重要的问题：你正在解决什么问题？以及你如何知道它被解决了？

目前，你的团队不断重建相同的情感分析工作流程。他们还花费了太多时间手动挖掘客户评论来回答简单问题。所以，你的工作就是解决这个问题。

你的目标是自动化设置流程，这样就不必有人不断重做；并使其易于直接从数据中获取快速答案。

那么，你如何知道它是否有效呢？从小处着手。只需询问用户：“这为你节省时间了吗？”如果答案是肯定的，那你就走对了路。你以后总可以添加更复杂的指标，但现在，简单的反馈足以让你有信心继续前进。

你的 Avalanche 应用有两个主要用户：

你的经理：只想快速获得答案，无需等待。
你的队友：一遍又一遍运行情感分析的数据科学家。

他们目前都面临同样的痛点。每次他们做这项工作时，都必须从头开始重建流程。这意味着收集数据、清理数据、分析情感、构建图表，并一遍又一遍地回答相同的后续问题。如果你了解他们在哪里浪费时间，你就可以设计你的应用来精确修复这些点。这就是你构建人们真正会使用的东西的方法。

从功能到构建计划

这里有一个难题：如果只能构建一个功能，哪个功能对于测试你的想法是否有效最为关键？

这可能很难回答。因此，先从勾勒大图景开始。不需要很花哨，只需在 Google 幻灯片或纸上快速画个布局。

想象一下最终的仪表板有四个标签页：

一个名为“时间”的标签页，让用户查看特定时间段的情感。
一个名为“产品”的标签页，显示选定产品的平均情感得分。
一个名为“数据”的标签页，在交互式表格中显示原始数据集。
最后一个名为“聊天”的标签页，让用户向 AI 询问有关数据的问题。

现在，让我们把这个功能列表变成一个实际的构建计划。

划掉“下一版本”列中的所有内容。你现在还不构建那些。
将你的“必须有”功能按构建顺序排列。这就成了你的开发路线图。
挑选一两个“最好有”的功能，将它们作为延伸目标放在一边。只有在你提前完成或它们很容易添加时才构建它们。

总结

本节课中，我们一起学习了如何设定清晰的目标、了解你的用户、定义成功标准以及确定构建的优先级。在使用生成式 AI 时，这一点尤其重要，因为很容易被那些并不真正解决核心问题的花哨功能分散注意力。通过保持简单并专注于真正重要的事情，你可以更快地构建一个可工作的原型，然后根据真实反馈进行测试和改进。

在下一个视频中，你将看到如何访问核心材料并开始处理课程 GitHub 仓库中的项目文件。

009：课程 GitHub 仓库概览 🗂️

在本节课中，我们将学习如何获取并理解本课程提供的所有代码与资源。我们将概览课程 GitHub 仓库的组织结构，并指导你如何将其克隆到本地，以便跟随视频进行实践。

概述

你已经制定了项目计划，现在准备开始构建。让我们快速浏览一下课程资源，以便你确切地知道在哪里找到所需文件以及它们是如何组织的。

仓库结构与内容

所有你需要的文件都位于课程的 GitHub 仓库中，你可以在屏幕底部显示的链接中找到它。

打开 GitHub 链接后，你会看到多个文件夹。

以下是仓库的主要组成部分：

data 文件夹：用于存储雪崩（avalanche）数据集。
模块文件夹：每个课程模块都有一个对应的文件夹（例如 module1）。在这些文件夹中，你可以找到跟随视频学习所需的所有代码。

模块文件夹内的代码进一步按课程划分。每个课程文件夹包含视频中使用的 Python 文件或 Notebook，以及一个 lab 文件夹（其中包含完成实验所需的所有必要文件）。在需要时，你还会看到一个 requirements.txt 文件。

这个文件将帮助你安装项目特定部分所需的所有依赖项。例如，在 module1 文件夹中有一个 requirements.txt，你可以使用它来安装模块一所需的一切。

此外，你还会发现一些其他文件：

.env.example：这是一个示例环境变量文件。你需要通过将其重命名为 .env 来复制它，并在其中添加你的 OpenAI API 密钥。
README.md：这是一个简短的指南，帮助你快速开始。如果你已经熟悉克隆仓库的操作，可以跳过本视频。

如何获取课程文件

获取所有课程文件最简单的方法是将仓库克隆到你自己的计算机上。这允许你在学习过程中修改代码。

要克隆仓库，请按照以下步骤操作：

使用屏幕顶部的链接进入主仓库页面。
在页面右上角附近找到绿色的 “Code” 按钮。
复制显示的地址（通常以 git@ 或 https:// 开头）。
如果你在计算机上安装了 Git，在命令行中输入 git clone，然后粘贴你刚刚复制的地址。
如果你没有在命令行中安装 Git，可以使用 GitHub 桌面 UI：点击 “File”，然后选择 “Clone repository”。

克隆完成后，请确保你的仓库副本设置为公开（Public）。这将便于后续在 Snowflake 上进行部署。

文件命名与使用

课程 GitHub 仓库为你提供了一个清晰、简单的项目结构，预装了雪崩数据集和你的起始文件。

在仓库中，每个涉及代码操作的视频都对应一系列文件。为了便于定位，这些文件通常被命名为类似 M1_L1_1 的格式，代表模块 1、第 1 课、视频 1。

你可以使用仓库中的文件来跟随学习，也可以在观看视频时从头开始编写自己的代码。通常，视频内容是循序渐进的，因此你可以继续使用已创建的代码，或者打开每个相应仓库文件夹中包含的完整解决方案。

总结

本节课中，我们一起学习了课程 GitHub 仓库的组织结构。你现在已经获得了构建原型所需的代码、数据和工具。该仓库提供了一个清晰、简单的项目结构，预装了雪崩数据集和起始文件。

从这里开始，你将在每个模块文件夹中编辑 streamlit_app.py 文件，逐步为你的生成式 AI 应用构建功能。

在下一课中，你将通过与生成式 AI 共同创建 MVP（最小可行产品）计划，将规划更进一步。你将学习如何使用提示词来帮助你思考范围、逻辑和实施步骤，从而更快地推进并保持专注。让我们让生成式 AI 不仅用于编写代码，也帮助你更智能地进行设计。

010：与GenAI共同制定MVP计划 🧠

在本节课中，我们将学习如何利用生成式AI（GenAI）作为产品策略伙伴，共同规划和定义你的最小可行产品（MVP）。我们将通过一个医疗健康领域开发者的真实案例，了解如何通过结构化提示词引导AI，帮助你从零开始快速制定一个清晰、可行的MVP计划。

概述

上一节我们介绍了使用地图流程来细化你的MVP想法。本节中，我们来看看如何引入GenAI来帮助你构建，而不是独自完成所有规划工作。

你可以请求GenAI模型帮助你进行头脑风暴、确定功能优先级并制定构建计划。当你时间紧迫或不确定下一步该构建什么时，这尤其有用。

案例研究：Priya的MVP规划

让我们看看一位开发者如何利用GenAI，不仅用于编码，还用于思考其MVP。Priya是一家医疗健康初创公司的ML工程师。她最近构建了一个概念验证，使用GenAI从临床试验PDF中提取结构化见解。它虽然能工作，但提示词很脆弱，结果不一致，而她的利益相关者希望快速看到一个精美的演示。

因此，她打开了GenAI应用并输入：“扮演产品经理，帮我为一个从临床试验PDF中提取数据的应用定义一个MVP。”

Priya没有直接跳入编码，而是让GenAI应用帮助她走完MVP规划流程。

目标：减少团队从杂乱的临床试验报告中手动提取数据所花费的时间。
受众：临床运营人员。这些非技术用户目前依赖工程师为他们运行查询。
成功应用的样子：最简单的成功衡量标准是“这为你节省时间了吗？”早期进行粗略估计即可，无需过度设计KPI。
优先级功能：在GenAI的帮助下，她确定了基本工作流程的范围：拖放上传PDF、用于提取和清理数据的LLM管道、可编辑的结果表格、导出到CSV。

这不是一个完整的产品，而是一个精简、清晰的原型，专注于学习和提供价值。

如何获得更好的规划建议

在深入编码之前，Priya从GenAI那里获得了更多提示，以构建更好的第一个原型提示词。

以下是获得更佳规划建议的关键点：

具体化：不要用“帮我构建一个从PDF提取数据的应用”，尝试使用“我正在构建一个GenAI助手，用于自动化从临床试验PDF中提取数据的过程，以从中获取见解。MVP应包含哪些核心功能？”
提供上下文：说明“我是一名正在构建内部工具的ML工程师”与“我是一名正在构建学校演示的学生”会得到非常不同的回应。
明确输出格式：要求GenAI生成特定类型的输出，例如：
- summarize this as bullet points
- generate a step-by-step plan
- create a table of MVP versus stretch goals
设定角色：与其说“帮我确定应用范围”，不如尝试“扮演一个为ML团队构建GenAI原型的产品经理”。

这些微小的改变将GenAI模型的语气和结构从通用建议转变为专注的协作。

你的实践：与GenAI共同创建MVP计划

现在轮到你来与GenAI共同创建你的MVP计划了。

你可以从这个提示词开始：
I‘m new at using GenAI for prototyping. Help me plan an MVP for a Streamlit app that loads a CSV, performs sentiment analysis using OpenAI, shows a bar chart of the results, and lets users filter by product.

根据你的想法调整它。

然后尝试这个更结构化的提示词：
Act as a product manager. Help me define an MVP for a GenAI app. Use these principles: Define the end goal, identify the audience, choose success metrics, prioritize core features. Then walk me through each step. What problem are you solving? Who are you solving it for? What would success look like? What are the must-have features?

GenAI可以像教练一样，帮助你澄清目标、精简功能，并专注于真正重要的事情。你甚至可以反过来，让GenAI向你提问，帮助你进行头脑风暴和规划。

一旦你定义了MVP，可以要求GenAI将功能组织为“必须有”、“最好有”和“下一版本”。

GenAI的擅长与局限

在继续之前，请记住GenAI擅长帮助你处理以下事情：

创建繁琐的设置代码
头脑风暴功能
编写查询
推荐架构
规划和调试

但你仍然需要人类来：

选择正确的问题
做出UI/UX决策
应用业务逻辑
验证AI输出

实验任务

现在轮到你了，完成这个第一个非评分实验：

用一两句话描述你的GenAI应用想法。
使用你喜欢的GenAI工具（如ChatGPT、Claude或Gemini），复制粘贴上面展示的结构化提示词。
请求帮助定义你的MVP。
将你的功能分类为“必须有”、“最好有”或“下一版本/延伸目标”。
要求AI进行快速的竞争分析。
将你的计划记录为一个单页摘要。

总结

本节课中，我们一起学习了开发者如Priya如何利用GenAI不仅用于构建，还用于规划。你学会了如何通过给予GenAI清晰的上下文、结构和角色，将其视为产品策略教练。现在，你已经准备好能在几分钟内从一张白纸转变为坚实的MVP计划。

接下来，你将开始使用Avalanche数据，一步步构建你的原型。🚀

011：选择合适的工具 🛠️

在本节课中，我们将要学习如何为快速构建生成式AI应用原型选择合适的工具。核心在于理解，原型开发追求速度，而非构建一个功能完备的生产级应用。

概述

构建生成式AI原型时，速度至关重要。你不需要一个完整的生产团队，只需要必要的工具来快速测试想法并获得反馈。你可能习惯于在笔记本中工作，运行模型并分析结果，而不是构建前端界面或设置部署流程。但如果你希望用户能与你的模型交互，你仍然需要一个用户界面，并且这个界面必须能快速、轻松地构建。本节课程将介绍如何为快速构建生成式AI原型选择合适的工具。

思维模式的转变

生成式AI开发中一个最大的思维转变是：你不需要仅仅为了测试一个想法，就去启动后端、配置数据库或设置托管服务。

你可以仅用三种“原料”构建一个可工作的原型：Python、一个轻量级的UI库，以及对一个生成式AI模型的访问权限。当你处于“快速构建”模式时，应选择那些不会拖慢你速度的工具。

选择合适的UI工具

以下是几种UI工具的选择：

Streamlit：如果你是一名数据科学家或机器学习工程师，希望有一种简单的方法将Python脚本转换为交互式应用，而无需担心HTML、CSS或JavaScript，那么Streamlit是理想选择。
其他工具：像Gradio和Dash这样的工具也能工作，但它们通常需要更长的设置时间。

对于生成式AI原型开发，Streamlit在速度、灵活性和易用性方面达到了最佳平衡点。

选择合适的生成式AI模型

对于生成式AI，你无需训练自己的模型。可以直接通过API使用预训练模型：

GPT-4：适用于通用代码和文本生成。
Claude：擅长处理长文档或摘要。
Google Gemini：适用于谷歌生态系统内的项目。
开源模型：如果你想离线工作。

只需选择一个对你来说易于访问的模型，然后开始构建。

原型技术栈示例

让我们分解一个可工作的生成式AI原型技术栈可能的样子：

Python：用于处理应用逻辑和API调用。
Streamlit：用于构建用户界面。
CSV或文本文件：作为一个小型、可测试的数据集（例如，产品评论数据）。
生成式AI API：如OpenAI或Anthropic的API。
API密钥管理：使用.env文件或密钥管理器来安全地保存你的API密钥。

就这么简单。你不需要过度设计你的原型或技术栈。

总结

本节课中，我们一起学习了为快速构建生成式AI应用原型选择工具的核心原则。关键在于从简单开始：使用Python、一个生成式AI模型和一个像Streamlit这样的工具来创建交互式应用。这样你能更快地获得真实反馈，并且可以在后续阶段随时进行扩展。

在下一个视频中，你将设置你的开发环境，并准备开始构建。

012：环境配置 🛠️

在本节课中，我们将学习如何为生成式AI应用搭建一个干净、稳定的开发环境。我们将从项目结构、虚拟环境配置，到安全地集成OpenAI API，一步步完成所有准备工作。

项目结构 📁

在开始构建之前，一个清晰的项目结构有助于保持代码的条理性，并方便后续更新。

以下是推荐的项目结构：

GenAI-prototype/：项目根目录。
streamlit_app.py：应用的核心界面与逻辑文件。
data/：用于存储数据文件的文件夹，例如 customer_reviews.csv。
.env：一个隐藏文件，用于安全地存储API密钥等敏感信息。
requirements.txt：列出应用所需的所有Python包。

虚拟环境 🐍

虚拟环境可以将项目所需的工具和依赖隔离在一个独立的空间中，避免不同项目间的依赖冲突。

首先，在项目文件夹中打开终端，运行以下命令创建虚拟环境：

python -m venv .venv

执行后，项目文件夹中会出现一个名为 .venv 的新文件夹，其中包含了虚拟环境的所有文件。

接下来，激活虚拟环境：

macOS/Linux：source .venv/bin/activate
Windows：.venv\Scripts\activate

激活成功后，终端每行开头会显示 (.venv)，表明当前环境已激活。

最后，安装项目依赖：

pip install -r requirements.txt

配置OpenAI API密钥 🔑

要在应用中使用AI功能，需要连接OpenAI的API服务，这需要一个API密钥。

首先，访问 platform.openai.com 创建账户并登录。在账户面板中找到API密钥部分，点击“Create new secret key”并复制生成的密钥。请务必立即妥善保存此密钥，关闭窗口后将无法再次查看。

为了安全地使用密钥，不应将其直接硬编码在代码中。正确做法是在项目根目录下创建一个名为 .env 的隐藏文件，并在其中添加以下内容：

OPENAI_API_KEY=你的实际API密钥

编写初始代码 💻

现在，我们可以开始编写代码来连接OpenAI服务了。你可以从GitHub仓库的 ml_lesson_02 文件夹中打开 ml2_v2_start.py（一个空文件）开始编写，或者直接参考解决方案文件 ml2_v2.py。

如果你选择从头开始，请在脚本中添加以下代码。这段代码使用 load_dotenv 函数从 .env 文件加载环境变量，并初始化OpenAI客户端。

import os
from openai import OpenAI
from dotenv import load_dotenv

# 加载 .env 文件中的环境变量
load_dotenv()

# 初始化 OpenAI 客户端
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

调用AI模型并获取响应 🤖

上一节我们建立了与OpenAI的连接，本节中我们来看看如何发送提示并获取模型的响应。请注意，OpenAI SDK更新频繁，如果以下方法不适用，请查阅最新官方文档。

在脚本末尾添加以下代码。client.chat.completions.create 函数用于向OpenAI模型发送消息并获取其回复。

response = client.chat.completions.create(
    model="gpt-4o",  # 指定使用的模型，通常使用 gpt-4o
    messages=[{"role": "user", "content": "用一句话解释生成式AI。"}],  # 对话历史
    temperature=0.7,  # 控制创造性，范围 0.0（保守）到 1.0（富有创意）
    max_tokens=150    # 限制回复的最大长度
)

参数说明：

model：指定要使用的AI模型。
messages：以列表形式记录对话历史。
temperature：控制回复的随机性。值越低，回复越确定和一致；值越高，回复越多样和富有创意，但也可能产生不准确的回答。
max_tokens：限制回复的长度，有助于控制成本。

最后，添加一行代码来提取并打印出模型的文本回复：

print(response.choices[0].message.content)

测试与调试 🧪

保存文件后，我们可以测试API连接是否正常。在终端中，确保位于项目文件夹下，运行以下命令（如果你的主文件不是 app.py，请替换为对应的文件名）：

python streamlit_app.py

如果一切顺利，你将在终端看到AI模型返回的句子。

如果遇到问题，终端会显示错误信息。生成式AI本身也是调试的好帮手，你可以将错误信息粘贴给ChatGPT等模型，寻求解决方案。

以下是几个常见的排查方向：

API密钥错误：检查 .env 文件中是否有拼写错误或多余空格。
模型名称问题：确保使用的是最新、有效的模型ID。
费用监控：从小规模测试开始，并在OpenAI平台设置支出提醒。
调试AI输出：尝试边界情况，如长输入或空输入，测试模型的稳定性。
版本控制：使用GitHub跟踪代码变更，尤其是在尝试不同提示词或AI服务时。

总结 📝

本节课中，我们一起学习了如何为生成式AI应用搭建开发环境。我们创建了清晰的项目结构，使用虚拟环境隔离依赖，通过 .env 文件安全地管理API密钥，并编写了连接OpenAI API及获取模型响应的基础代码。最后，我们完成了早期测试，确保整个设置可以正常工作。

接下来，我们将利用这个环境，开始构建你的第一个真实可用的应用原型。

013：13_01_03_Streamlit入门 🚀

在本节课中，我们将学习如何将一个生成式AI脚本转化为一个在浏览器中运行的交互式Web应用。我们将使用Streamlit作为连接Python代码和完整Web界面的桥梁，无需编写任何前端代码。课程结束时，你将拥有一个可工作的原型，它能接收用户输入，将其发送给生成式AI模型，并在浏览器中显示响应。

概述

上一节我们完成了生成式AI脚本的编写。本节中，我们来看看如何利用Streamlit将其快速部署为一个Web应用。我们将从验证安装开始，逐步添加必要的代码，最终在浏览器中启动并运行你的第一个AI应用。

验证Streamlit安装

在之前的视频中，你已经在安装requirements.txt文件时安装了Streamlit。为了验证安装是否成功，请在终端中输入以下命令：

streamlit version

如果看到版本号，说明安装成功。如果没有，请检查你的虚拟环境是否已激活，并重试。

改造你的脚本

在本视频中，你可以继续使用上一节创建的文件，或者直接打开解决方案文件。

你的脚本已经能够连接到OpenAI。现在，是时候将其转变为一个完整的应用了。要将上一节的Python脚本变成一个简单的Web应用，你只需要添加几行代码。

首先，导入Streamlit库：

import streamlit as st

这行代码导入了Streamlit包，并为其设置了简称st，以便在应用中轻松使用其功能。

在脚本顶部，添加应用标题：

st.title(“Hello GenAI”)

这为你的应用创建了一个大标题。在标题下方，你可以添加一些描述应用功能的文本：

st.write(“This is your first Streamlit app.”)

st.write是一个灵活的函数，可以显示文本、数字、数据框等多种内容。

接着，将原本使用print函数在终端打印模型响应的代码，替换为使用st.write在应用中显示模型输出：

st.write(response)

就是这样，仅仅四行代码，你的命令行脚本就变成了一个Web应用。保存文件，准备启动。

启动你的应用

现在，进入激动人心的部分——在浏览器中查看你的应用。你需要在终端中运行应用，但这次使用Streamlit命令。

在终端中输入以下命令：

streamlit run app.py

这个命令会启动一个本地Web服务器，并在浏览器中打开你的应用。你会看到类似这样的消息：“You can now view your Streamlit app in your browser.” 如果浏览器没有自动打开，请访问 http://localhost:8501。

恭喜！你的应用已经上线了。是时候在浏览器中查看它了。你会看到应用标题，以及下方由生成式AI模型返回的响应（之前是在命令行中打印的）。调用生成式AI模型并非总是即时的，所以如果响应有延迟，请不要担心。

只要你的终端保持打开，你的应用就是活动的。任何访问该URL的人都可以与之交互。

当你准备停止应用时，只需回到终端，按下 Ctrl+C 即可关闭它。

快速迭代开发

你的应用现在看起来可能很简单，但这是后续所有功能的基础。Streamlit会在你保存脚本时自动刷新应用。只需点击保存，无需重启或重新加载。这种即时反馈循环使得迭代开发变得非常容易。

以下是快速迭代的步骤：

修改代码。
保存文件。
立即在浏览器中查看更新。

总结

本节课中我们一起学习了如何利用Streamlit将生成式AI脚本快速部署为交互式Web应用。你成功创建了一个由生成式AI驱动的Web应用，无需使用Flask、JavaScript或任何复杂的前端框架。Streamlit为你启动了一个微型Web服务器，处理了布局并管理一切，这意味着你可以完全使用Python进行快速原型开发，而用户则能获得实时的结果。

在下一节视频中，我们将为你的应用添加更多交互性、输入框和更高级的功能。让我们继续构建！

014：创建首个交互式Streamlit应用 🚀

在本节课中，我们将学习如何将一个静态的Streamlit应用升级为交互式应用。我们将通过添加文本输入框、滑块和加载动画等组件，让用户能够自定义提示词、调整模型参数并获得更好的使用体验。

概述

在上一个视频中，我们构建了第一个生成式AI驱动的Streamlit应用。它展示了一段文本并打印了模型输出。但该应用缺乏交互性。本节我们将使用Streamlit提供的一系列交互式Python元素——即“小组件”——来增强应用功能，无需接触HTML或JavaScript。

从静态到交互式

Streamlit小组件允许您为应用添加用户控件。以下是一些在生成式AI应用中非常实用的小组件：

st.text_input：用于输入提示词的文本框。
st.button：用于触发操作的按钮。
st.selectbox：用于模型选择的下拉框。
st.slider：用于调整数值（如温度参数）的滑块。
st.checkbox：用于创建开关的复选框。
st.file_uploader：用于上传CSV或文本文件的上传器。
st.spinner：在等待（例如等待模型回复）时显示加载动画。

在本视频中，我们将使用其中三个组件来升级您的应用：一个用于输入提示词的文本框、一个控制模型创造性的温度滑块，以及一个在模型生成文本时显示的加载动画。在本课程后续部分，您将学习使用更多小组件。

您可以继续编辑上一个视频中的文件，或者在代码仓库中找到解决方案文件来跟随操作。

添加提示词输入框

要为应用添加一个让用户输入自定义提示词的文本框，只需增加一行代码：

user_prompt = st.text_input("Enter your prompt", "explain generative AI in one sentence")

st.text_input函数用于创建用户输入框。其第一个参数是提示用户如何与输入框交互的消息（例如“Enter your prompt”）。您还可以设置一个默认提示词，在应用启动时预填充输入框。

现在，只需在调用模型时，将硬编码的提示词替换为user_prompt变量即可。运行应用后，您将看到输入框。输入内容并按回车键后，模型就会运行。

引入温度滑块

您还可以通过添加滑块小组件，让用户尝试调整模型的创造性或确定性程度。在定义用户输入的代码附近添加以下代码：

temperature = st.slider("Temperature", 0.0, 1.0, 0.7, 0.1)

这段代码创建了一个从0.0到1.0的滑块。0.0表示最确定性（输出最可预测），1.0表示最创造性（输出最多样）。value参数设置了默认值，step参数控制了用户移动滑块时数值的增减幅度。

接着，更新您的模型调用代码，以包含这个特定的温度值。这样，您的应用就变得动态了，用户可以调整AI的“风格”。

改善等待体验

大型语言模型可能需要几秒钟来响应，在此期间您的应用可能会显得卡顿。我们可以通过添加一个加载动画来修复这个问题，让用户知道模型正在运行。

您可以通过将API调用代码包裹在with st.spinner()代码块中来实现：

with st.spinner("Generating response..."):
    # 这里是您的模型调用代码
    response = model.generate(prompt=user_prompt, temperature=temperature)

现在，用户无需猜测应用是否出问题，他们会在模型工作时看到一个有帮助的小动画。

使用缓存优化性能

如果您在开发过程中多次使用相同的输入调用模型，可以使用@st.cache_data装饰器来缓存结果。如果您之前没有接触过装饰器，不必担心，它本质上是一个包装器（类似于with语句），您可以将其放在函数周围，以在不修改原函数的情况下改变或增强其功能。

首先，您需要将模型调用逻辑移到一个独立的函数中，例如命名为get_response。应用功能应保持不变，只是将部分逻辑移入了独立函数。

然后，像这样将装饰器放在get_response函数上方：

@st.cache_data
def get_response(prompt, temperature):
    # 模型调用逻辑
    return response

@st.cache_data是一个Streamlit装饰器，它通过缓存先前函数或计算的结果来提高应用速度。它告诉Streamlit：“我之前见过这个输入，直接返回缓存的结果，而不要重新运行代码。”这对于生成式AI应用尤其有用，因为AI调用既耗时又费钱。如果您需要让模型反复分析相同的数据集，可以使用@st.cache_data从缓存中即时获取结果，而无需反复调用API。在雪崩分析项目中，对于任何需要执行的数据转换或情感分析，您都可以考虑使用此功能。

总结

本节课中，我们一起学习了如何将静态的Streamlit演示应用升级为功能完善的交互式应用。我们通过添加提示词输入框、温度滑块和加载动画，显著提升了用户体验。此外，我们还介绍了如何使用@st.cache_data装饰器来缓存结果，优化应用性能和成本。仅仅几行代码，就让您的应用焕然一新。

现在，是时候引入数据了。在下一个视频中，您将学习如何将数据上传到您的应用中，并对其执行生成式AI驱动的操作，同时进一步提升您的Streamlit技能。我们下个视频见。

015：集成GenAI进行数据处理 🚀

在本节课中，我们将学习如何构建一个功能更丰富的生成式AI应用。我们将为应用添加数据加载和清理功能，并学习如何使用Streamlit的会话状态来保持数据在交互间的持久性。

组织应用布局

上一节我们构建了一个简单的提示词与响应应用。本节中，我们来看看如何组织一个包含多个功能的工作流。

你可以使用 st.columns 将按钮并排显示。

import streamlit as st

col1, col2 = st.columns(2)

然后，在每个列中放置一个按钮。运行应用后，你将看到两个并排的按钮，但目前点击它们不会有任何反应。st.columns 还可以调整列间距等，更多信息请参考屏幕底部的链接。

实现第一个按钮的功能

现在，让我们实现第一个按钮的功能。你需要用以下代码替换第一个按钮中的 pass 语句。

if col1.button(‘加载数据集’):
    df = pd.read_csv(‘your_dataset.csv’)
    st.session_state.df = df

这里需要注意一个重要细节：数据框没有被简单地保存到一个普通的 df 变量中，而是保存到了一个叫做 会话状态（session state） 的地方。原因是，每次用户与应用交互时，Streamlit 都会从头到尾重新运行整个脚本。这意味着，如果你点击一个按钮，所有变量都会丢失，除非你将它们存储在两次运行之间持久化的地方。

通过将数据框存储在 st.session_state.df 中，你的应用会记住它，即使脚本再次运行。这允许用户加载数据集，并在之后对其执行操作，而无需重新加载。

显示加载的数据集

接下来，在脚本底部使用以下代码来显示数据集。

if ‘df’ in st.session_state:
    st.dataframe(st.session_state.df)

请注意这段代码的写法：它位于一个 if 代码块中。这个 if 语句用于检查数据是否已被加载并保存到会话状态中。记住，每次应用重新加载时，它都会运行整个脚本。如果没有数据被加载，就无法显示。

现在，重新打开应用并检查它是否正常工作。按下第一个按钮，数据集将被加载并显示在下方。

实现第二个按钮的功能

现在，你需要为另一个按钮添加功能。构建内容很多，我们可以将繁琐的工作委托出去。

假设你的应用需要清理输入的文本。你可以手动编写所有代码，或者提示生成式AI来生成一个草稿。以下是一个示例提示：

“编写一个Python函数来清理文本，去除标点符号，将所有内容转换为小写，并去除空白字符。”

模型可能会返回类似这样的代码：

import string

def clean_text(text):
    # 去除标点
    text = text.translate(str.maketrans(‘’, ‘’, string.punctuation))
    # 转换为小写
    text = text.lower()
    # 去除首尾空白
    text = text.strip()
    return text

这段代码并不复杂，但它清晰、可测试且易于集成到你的应用中。将代码复制并粘贴到应用的顶部。

将清理功能集成到按钮

然后，你需要将该功能添加到你的按钮中。你想要清理已加载的数据集，因此首先需要检查会话状态中是否存在数据集。

以下是实现此功能的代码：

if col2.button(‘清理文本列’):
    if ‘df’ in st.session_state:
        df = st.session_state.df
        df[‘cleaned_review’] = df[‘review’].apply(clean_text)
        st.session_state.df = df

现在你需要做的就是将此操作应用于数据集中的某一列，并将其保存回会话状态。检查你的应用，现在你有了一个用于加载数据集的按钮和另一个用于清理它的按钮。

你可能已经注意到，点击清理按钮时似乎没有任何变化。别担心，这只是因为该数据集的列数超过了屏幕的显示范围。如果你使用滑块滚动，就可以看到新增的 cleaned_review 列。

为应用添加更多交互性

为了让应用更具交互性，你的用户可能只对特定产品的评论感兴趣。你可以添加一个下拉菜单来筛选显示的数据集，仅显示相关列。

为此，你可以在代码中添加 st.selectbox，并将产品列表作为参数传递给它。

product_list = [‘All Products’, ‘Product A’, ‘Product B’, ‘Product C’]
selected_product = st.selectbox(‘选择产品进行筛选:’, product_list)

然后，你需要添加筛选数据的逻辑。你还可以添加一个“所有产品”选项，以防用户想要分析所有产品。

if ‘df’ in st.session_state:
    display_df = st.session_state.df
    if selected_product != ‘All Products’:
        display_df = display_df[display_df[‘product’] == selected_product]
    st.dataframe(display_df)

通过更新筛选逻辑来实现：如果选择了某个产品，则筛选数据框；如果选择了“所有产品”，则使用原始数据框进行显示。保存并刷新你的应用以查看效果。

总结

本节课中，我们一起学习了如何升级你的生成式AI原型应用，赋予它两个核心功能：加载数据和清理数据。这是大多数生成式AI数据应用的支柱——获取数据、准备数据，并为其分析做好准备。你现在已经有了一个可以在此基础上构建的模板，接下来让我们继续学习，用生动的可视化让你的数据“活”起来。

016：数据可视化

在本节课中，我们将要学习如何为你的应用添加图表，使用四种不同的可视化库。数据清理完成后，下一步是帮助人们理解数据。仅仅打印出一列数字或几行数据可能适用于快速测试，但这不是帮助利益相关者设想最终产品的最佳方式。这时就需要数据可视化。

上一节我们介绍了数据处理，本节中我们来看看如何将数据转化为直观的图表。

使用 Streamlit 内置图表 📊

最简单的方式是使用 Streamlit 的内置图表函数。例如，你可以使用 st.bar_chart 将一列情感得分转化为一个整洁的条形图。它可以直接与 pandas 的 DataFrame 或 Series 配合使用。

Streamlit 还提供了其他开箱即用的图表选项：

st.line_chart：折线图
st.area_chart：面积图
st.scatter_chart：散点图

这些图表非常适合快速探索数据，只需传入 DataFrame，Streamlit 会为你处理布局和渲染。

如果你想比较不同产品的情感得分，可以尝试以下方法：

st.bar_chart(df.groupby(‘product’)[‘sentiment’].mean())

这行代码使用 pandas 的 groupby 按类别分解数据，从而构建显示每个产品（而非单条评论）平均情感得分的图表。

现在，让我们看看实际效果。你只需要将以下三行代码添加到上一视频构建的应用中，即可可视化每个产品的平均情感得分：

st.subheader(‘Mean Sentiment by Product’)
mean_sentiment = df.groupby(‘product’)[‘sentiment’].mean()
st.bar_chart(mean_sentiment)

当你运行应用并点击按钮导入数据集后，可以立即看到生成的图表。

集成 Matplotlib 📈

如果你已经习惯使用 Matplotlib，完全可以在这里使用它。这对于直方图、散点图或任何不需要太多交互性的图表来说是完美的选择。

请注意，这里使用了 filtered_df 变量，因此当你在下拉菜单中选择其他选项时，图表会相应改变。

import matplotlib.pyplot as plt
fig, ax = plt.subplots()
ax.hist(filtered_df[‘sentiment’], bins=20)
st.pyplot(fig)

使用 Plotly 实现交互 📉

如果你需要交互功能，如悬停提示或缩放，Plotly 是一个可靠的选择。Plotly 图表外观现代且流畅，用户可以悬停查看数据点、放大或点击获取更多详情，并且你无需编写任何额外的 UI 代码。

要写入 Plotly 图表，使用 st.plotly_chart。将 use_container_width 参数设为 True，可以确保图表拉伸以适应应用的整个宽度。

import plotly.express as px
fig = px.scatter(filtered_df, x=‘review_length’, y=‘sentiment’)
st.plotly_chart(fig, use_container_width=True)

利用 Altair 进行高级可视化 🎨

另一个很好的选择是 Altair。它与 pandas 配合得很好，并且擅长处理分层绘图或任何带有选择、悬停提示或过滤器的图表。

你可以使用 st.altair_chart 来渲染它。

import altair as alt
chart = alt.Chart(filtered_df).mark_circle().encode(
    x=‘review_length’,
    y=‘sentiment’,
    tooltip=[‘product’, ‘review_text’]
)
st.altair_chart(chart, use_container_width=True)

以下是每个工具适用场景的快速总结：

Streamlit 内置图表：超级快速，非常适合快速获取反馈。
Matplotlib：简单经典，适用于静态绘图。
Plotly：具有交互性，非常适合探索数据。
Altair：适用于更高级的可视化。

从你觉得最简单的工具开始，只在确实需要时才切换。

工具对比示例

让我们通过一些快速示例来看看它们的区别。假设我们想构建一个散点图。

以下是使用 Matplotlib 的实现：

fig, ax = plt.subplots()
ax.scatter(filtered_df[‘review_length’], filtered_df[‘sentiment’])
st.pyplot(fig)

使用 Plotly 的实现：

fig = px.scatter(filtered_df, x=‘review_length’, y=‘sentiment’)
st.plotly_chart(fig, use_container_width=True)

使用 Altair 的实现：

chart = alt.Chart(filtered_df).mark_circle().encode(x=‘review_length’, y=‘sentiment’)
st.altair_chart(chart, use_container_width=True)

最后，使用 Streamlit 原生函数：

st.scatter_chart(filtered_df[[‘review_length’, ‘sentiment’]])

这些工具中的每一个都允许你用几行代码创建清晰、有用的可视化图表。以上只是一些例子，你可以通过查看 Streamlit 文档中的“图表元素”部分了解更多可视化技术。

总结

本节课中我们一起学习了数据可视化。回顾一下，你从使用生成式 AI 生成 Python 函数，到使用 pandas 处理真实数据，再到创建多种可视化图表。你亲眼看到了生成式 AI 如何适应你所需的任何工具，以及一切如何与 Streamlit 无缝协作。

到目前为止，你一直在构建独立的模块。现在，是时候将它们全部整合到一个完整的仪表板应用中了，你将从头开始构建它，并使用生成式 AI 作为你的编码伙伴。

017：在线发布应用 🚀

在本节课中，我们将学习如何将你构建的 Streamlit 应用部署到线上，与世界分享。你将了解如何使用 Streamlit Community Cloud 这个免费平台来发布你的应用。

概述

你已经学会了如何构建交互式 Streamlit 应用，使用 GenAI 生成代码、加载数据集、处理数据并在同一个 Web 应用中创建可视化。现在，只剩下最后一步——与世界分享它。本节视频将指导你如何在 Streamlit Community Cloud 上部署你的应用。

Streamlit Community Cloud 是一个免费平台，可以让你轻松地在线上部署和分享应用。在该平台上，你可以获得有限的公开应用配额（代码也将公开），每个账户一个私有应用，集成了 GitHub 仓库以便于部署，当你向 GitHub 推送更改时会自动更新，并内置分析功能以追踪应用使用情况。这是一个快速、零成本地将你的原型展示给用户的方法。

部署步骤

以下是部署你的 Streamlit 应用到社区云的完整流程。

1. 登录 Streamlit Community Cloud

首先，打开浏览器并访问 streamlit.io/cloud。点击“Join Community Cloud”，然后点击“Continue to sign in”选择使用 GitHub 登录。

接下来，你将被重定向到 GitHub。当被询问是否允许 Streamlit 连接你的 GitHub 账户时，点击“Authorize”。如果是第一次操作，GitHub 会向你的邮箱发送一个验证码。请检查收件箱，复制发送的验证码并粘贴以完成登录过程。

随后，Streamlit 会要求填写基本信息，如你的姓名和邮箱地址。填写完毕后，你就可以开始使用了。

2. 准备应用代码

你可以继续使用上一节视频中的应用，或选择任何其他应用进行部署。如果你还没有准备好，请将课程代码仓库克隆到本地机器。

如果你想从一个经过测试的版本开始，可以使用课程 GitHub 仓库中 M1_lesson3 文件夹下的文件。

接下来，为你要部署的应用专门创建一个新的 GitHub 仓库。登录你的 GitHub 账户，点击屏幕右上角的加号按钮，选择“New repository”。

将仓库命名为 avalanche 或类似的名称。将仓库设置为公开以便于分享，然后点击“Create repository”。

这将在 GitHub 上为你创建一个新仓库。在新仓库中，点击“upload an existing file”，然后上传整个 M1_lesson3_deploy 文件夹。你的新仓库现在应包含以下文件：

streamlit_app.py
requirements.txt
customer_reviews.csv

上传完成后，点击“Commit changes”。至此，你的文件已准备就绪，可以部署了。

3. 部署应用到 Streamlit Cloud

要部署你的原型，请从 Snowflake 登录 streamlit.io/cloud。点击右上角的“Create app”或“New app”。

选择“Deploy a public app from GitHub”，然后选择你的 GitHub 用户名和 avalanche 仓库作为代码源。

将分支保留为 main，并确保它指向你的 Streamlit 应用文件 streamlit_app.py。

为你的原型选择一个唯一的自定义名称，或使用自动生成的网址，然后点击“Deploy”。Streamlit 将开始构建你的应用，这可能需要几分钟时间。

4. 监控应用性能

在应用部署期间，让我们看看监控应用性能的一些选项。首先，在加载屏幕的右下角点击“Manage app”，你会看到两个主要部分。

“View build logs”是你查找应用日志文件以进行故障排除的地方。

应用管理功能允许你在应用出现问题时重启它、下载日志文件、完全删除应用或更新访问设置，以及管理你的密钥文件。

5. 测试与访问

当你的应用启动并运行后，你会收到一条成功消息，其中提供了一个可用于访问的网站地址。该网址通常类似于 https://你的应用名.streamlit.app，并附带一些额外的随机字母和数字。

要进行测试，请浏览该 URL 并测试所有交互式开关。在所有标签页之间导航以确保它们正常工作，然后验证数据表和可视化是否显示正确。

恭喜！你的应用现已上线，任何拥有链接的人都可以访问。

6. 查看分析与日志

想了解有多少人在查看你的应用吗？方法如下：进入你的 Streamlit Community Cloud 仪表板，在你的应用旁边，你会看到三个点，点击它们。

选择“Analytics”。这将显示有多少人访问了你的应用以及他们何时访问。

如果你的应用出现问题，可以检查日志。在你已部署的应用页面上点击“Manage app”，然后查看日志面板。这有助于你找出导致应用出现任何问题的原因。

总结

恭喜你！你已成功将你的 Streamlit 原型部署到云端，并使其可供全世界访问。这是一个真正的成就。通过将一个想法转化为一个可实时分享的 Web 应用，你迈出了比大多数人更远的一步。

现在你的原型已经部署，你可以将链接分享给同事、将其添加到你的作品集或在社交媒体上发布。

本节课将以一个实验结束，在那里你将运用所有学到的知识。

018：基于GenAI的雪崩舆情分析仪表板 📊

在本节课中，我们将综合运用所学知识，构建一个基于生成式AI的雪崩产品客户评论舆情分析仪表板。我们将学习如何加载数据、使用GenAI进行情感分析、展示结果并进行可视化。

概述

我们将构建一个Streamlit仪表板应用，用于分析雪崩数据集的客户评论。应用需要加载数据，使用生成式AI模型分析评论的情感倾向，并将结果以数据框和条形图的形式展示出来。

开始构建

你可以在课程Github仓库的“M1 lesson 3 lab to”文件夹中找到构建本实验所需的一切资源。那里有一个空文件供你编写代码，同时也有一个包含完整代码的解决方案文件供你参考。

以下是本实验将要构建的应用示例。视频中使用了Streamlit和本模块学到的功能，但你可以自由添加自己的想法并修改应用。

应用核心功能要求

你的应用应至少包含两个按钮和一个下拉筛选器。

以下是具体功能列表：

加载数据按钮：点击后应加载并展示数据集。
分析情感按钮：点击后应使用GenAI模型判断每条评论的情感是积极、中性还是消极。请注意，结果可能不完全一致，尤其是一些较旧的模型可能会给出意外或不一致的结果。
下拉筛选器：允许用户按产品进行筛选，并展示筛选后的数据，就像我们之前创建的那样。

开发建议与技巧

由于情感分析可能需要一些时间来处理，建议在测试时只加载少量数据行以加快进程。你可以使用Pandas的head()函数将前10或20行数据保存到会话状态中，正如在之前的视频中所见。

同时，不要忘记缓存结果，以避免不必要的重复计算。代码如下所示：

@st.cache_data
def load_data():
    # 你的数据加载逻辑
    pass

数据可视化

接下来，绘制积极、中性和消极评论的分布图。你可以使用任何绘图库，并自由发挥创意设计颜色和样式。示例中使用了Plotly并自定义了颜色，但这一部分请充分发挥你的想象力。

总结

一旦你完成了这个实验，你就完成了模块一的学习，并拥有了一个功能完整的、由GenAI驱动的舆情分析仪表板。这个仪表板能够导入真实世界的数据集，使用OpenAI对情感进行分类，可视化结果，并支持交互式筛选。

现在你已经打下了坚实的基础，准备好进一步深化你的技能，将GenAI数据助手集成到你的Snowflake应用中。我们下次再见！😊

019：19_02_01_Snowflake平台原型构建 🏔️

在本节课中，我们将学习如何将之前构建的本地原型应用迁移到 Snowflake 平台上。我们将利用 Snowflake 作为主要开发平台，以便快速进行原型开发，而无需担心处理大量数据或搭建基础设施的问题。

在上一模块中，我们在本地环境中为“雪崩仪表板”应用创建了一个最小可行产品原型。该应用能够读取客户评论的 CSV 文件，对数据进行清理和情感分析，并通过 Streamlit 将结果可视化，最终生成一个可通过网页浏览器访问的快速用户界面。

然而，在现实世界中，我们很少能遇到像“雪崩客户评论”那样小而整洁的数据集。因此，本模块将把开发工作转移到 Snowflake 平台上。在这里，您将处理更大批量的文件并与数据库交互，以获得更贴近实际操作的体验。

本模块学习目标 🎯

在本模块中，您将完成以下任务：

将一批非结构化的 Word 文档文件加载到 Snowflake 中。
使用 Snowflake 内置的生成式 AI 工具包 Cortex 来解析这批文件，并将其转换为结构化的表格数据。
在本课程的其余部分，您将使用像 ChatGPT 或 Claude 这样的生成式 AI 应用来帮助您快速编写代码和调试问题。

到本模块结束时，您将拥有一个在 Snowflake 上完整运行的生成式 AI Streamlit 应用。

接下来，我们将在下一个视频中一起浏览本课程将使用的 Snowflake 平台。

020：Snowflake 简介 🏔️

在本节课中，我们将要学习 Snowflake 平台如何与 Streamlit 结合，让你能够直接在数据仓库中快速构建和部署应用原型，而无需担心复杂的设置。

概述

Snowflake 允许你的 Streamlit 应用直接在其平台上运行，这带来了更快的原型开发速度。最关键的优势在于，你的应用可以直接连接到 Snowflake 中的数据，并且 Snowflake 支持 Pandas 等熟悉的 Python 工具，因此能无缝融入你的工作流。

Snowflake 与 Streamlit 结合的优势

上一节我们介绍了 Snowflake 的基本概念，本节中我们来看看将 Streamlit 应用部署在 Snowflake 上的具体好处。

以下是使用 Streamlit in Snowflake 的主要优势：

无需移动数据或切换工具：应用直接与 Snowflake 中的数据交互，无需在外部工具间跳转或手动传输文件。
性能与安全：应用具备更好的速度、更低的延迟以及内置的安全保障。
简化部署：只需点击几下，你的应用就可以在 Snowflake 平台上实时发布。

开始使用 Snowflake

现在，让我们开始了解你的 Streamlit 应用如何在 Snowflake 中工作，并熟悉新的 Snowflake 工作环境。

作为本课程的学生，你可以获得 120 天 的 Snowflake 全平台免费访问权限，以便跟随后续视频进行操作。请在此处注册。

上图展示了一个你在模块一中构建的雪崩仪表板的更高级版本。你现在看到的这个原型被部署在 Snowflake 内部，因此可以安全地分享给任何有权访问底层数据表和应用链接的同事。

注册过程如下：

访问 Snowflake 注册页面并填写注册表单。
从下拉菜单中选择注册原因。此处选择任意选项均可，然后点击“继续”。
在注册表单的第二页，输入公司名称和职位标题（可以自行编造），然后找到标有“选择您的 Snowflake 版本”的下拉菜单。保持默认的“企业版”即可，它提供了本课程所需的所有功能。
选择离你最近的区域（例如，我在西海岸，因此选择“美国西部”）。
阅读条款，如果同意，请点击底部的复选框，然后点击“开始使用”。

在后台设置账户时，你会看到一些用于优化账户偏好的可选复选框。至少请选择 Python 作为你的首选语言，其余部分可以填写或跳过。

接下来，检查你的电子邮箱收件箱，找到 Snowflake 发送的验证邮件。点击邮件中的验证链接，即可登录并访问平台。

探索 Snowflake 工作环境

现在你的账户已设置完成，欢迎来到你的新“游乐场”。

请注意：Snowflake 在不断演进，因此你屏幕上的内容可能与此处展示的略有不同。不必担心，整体流程是清晰的，你完全可以跟上。如果遇到困难，Snowflake 的官方文档和教程非常详细且 helpful。

现在，你可能会看到一个弹出窗口，提供对示例数据集的快速导览。这完全取决于你：如果好奇可以参加导览；如果想直接开始，可以点击“跳过”。

在右下角，根据你的工作风格，有几种不同的方式与 Snowflake 交互：

Snowsight 是主要方式，也是你将主要使用的 Web 界面，它快速、简洁且可视化程度高。
如果你是终端爱好者，也有命令行界面。
如果你深度沉浸于编码，Snowflake 甚至提供了 VS Code 扩展，让你可以停留在编码区域。

由于本课程在浏览器中运行，Snowsight 将是你的主阵地。

在 Snowflake 中构建 Streamlit 应用

现在进入有趣的部分。你已经知道 Streamlit 非常适合制作 Web 应用，而 Snowflake 允许你直接在数据仓库中运行 Streamlit 应用。无需额外设置，无需处理 API 或移动文件，只需构建即可。

使用 Streamlit in Snowflake，你可以直接从 Snowflake 数据表创建仪表板，而无需每次都进行数据准备工作。实时探索和可视化你的数据，确保用户始终获得最准确和最新的结果。将你的整个工作流——代码、数据、逻辑和用户界面——都集中在一个平台。

主要有两种方式实现：

Snowflake Notebooks：非常适合快速原型设计和与团队成员协作。
Streamlit in Snowflake Apps：当你准备更广泛地分享应用时，这是完美选择。

大多数人从 Notebooks 开始，然后在原型稳固后转向 Streamlit in Snowflake Apps。在本课程中，你将同时使用这两种方式。

连接已有项目

让我们将此与你已经在模块一中构建的内容联系起来。你为分析雪崩数据中的产品评论创建了一个可工作的 Streamlit 原型。

现在，在模块二中，你将通过 Snowflake 来增强你的原型：在平台内将你的应用连接到 Snowflake 数据表，并添加过滤器、交互式开关和可视化功能。

接下来，是时候逐步了解 Snowflake 开发环境了，以便你熟悉周围的一切。

总结

本节课中我们一起学习了 Snowflake 数据云平台如何与 Streamlit 集成，从而极大地简化生成式 AI 应用的快速原型开发流程。我们了解了其核心优势：直接数据连接、无需复杂设置、提升的性能与安全性，以及一键式部署。我们还完成了 Snowflake 账户的注册，并初步探索了 Snowsight 工作环境。最后，我们明确了在本课程中将使用 Snowflake Notebooks 和 Streamlit in Snowflake Apps 这两种主要工具来构建和增强我们的应用。

021：Snowsight 开发环境 🏔️

在本节课中，我们将学习如何将本地 Streamlit 应用开发体验迁移到 Snowflake 平台，并深入了解其核心的网页界面——Snowsight。我们将探索 Snowflake 的基本概念、Snowsight 的主要功能区域，并了解如何在此环境中组织数据、编写代码和构建应用。

Snowflake 概述

上一节我们在本地机器上构建并启动了 Streamlit 应用。本节中，我们将把这一体验带入 Snowflake，将开发提升到新的水平。

Snowflake 是云端的一体化数据指挥中心。它存储数据、运行查询，并根据需求自动扩展或缩减计算资源，无需管理硬件或进行复杂设置。

在后台，Snowflake 使用虚拟仓库。这些是独立的计算引擎，可以并行处理您的工作，这意味着多个任务可以同时运行而不会相互拖慢。

数据本身存储在 AWS S3 或 Google Cloud Storage 等云存储中。但在 Snowflake 中，数据以优化、压缩的格式存储，以实现快速搜索和轻松扩展。

Snowsight 工作区

在本课程中，您主要交互的部分是 Snowsight。这是一个基于网页的工作空间，将成为您探索数据、运行代码和构建生成式 AI 应用的主要枢纽。

在 Snowsight 中，您将主要在以下几个区域工作：

数据库：数据存储的位置。
Notebook：使用 SQL 或 Python 代码分析数据的地方。
Streamlit：在 Snowsight 内构建和预览应用界面的地方。

Snowsight 提供了强大的工具集供您选择：

SQL：查询数据的标准语言，用于探索和汇总数据。
Snowpark：一个开发者框架，用于直接在 Snowflake 内部使用 Python、Java 或 Scala。它类似于 Pandas，能在数据所在位置安全、大规模地运行代码。
Cortex：一套完全集成在 Snowflake 中的托管生成式 AI 工具。您可以使用内置的 SQL 或 Python 函数调用大语言模型、运行情感分析、生成文本和构建检索增强生成系统。
Snowflake Copilot：用于 SQL 查询的 AI 编码助手。

典型的工作流程是：首先在 Snowsight 中探索数据，然后在 Notebook 中使用 SQL 或 Python（通过 Snowpark）进行分析。当您准备好分享见解（例如通过交互式仪表板）时，您将使用 Streamlit 在 Snowflake 内部或 Streamlit 社区云上构建和部署原型。Cortex 将为您的应用提供情感分析和文本生成等生成式 AI 功能。

由于 Copilot 对 Python 的支持仍在开发中，我们建议在使用 Python 工作时，借助 Cursor 或 ChatGPT 等工具来获得帮助。

登录与导航

要登录 Snowsight，请在浏览器中打开步骤一所示的链接。输入您的账户标识符（格式如 xy12345，可在初始注册的确认邮件中找到），然后使用您的 Snowflake 凭据登录。

欢迎来到 Snowsight！这是您探索数据、构建 Notebook 和创建应用的一体化指挥中心。左侧边栏是您的主要导航工具。

以下是 Snowsight 中关键功能区域的导航方法：

数据浏览
首先点击左侧边栏的 Data，查看所有数据库、表和模式的位置。在 Data 标签页中，您会看到已创建的数据库列表。每个数据库就像一个主项目文件夹，点击一个数据库可以查看其包含的所有模式。在模式内，您可以查看具体的表。
编写与运行代码
接下来，点击左侧导航边栏中的 Worksheets。然后点击右上角的 + Worksheet 创建一个新的工作表。Snowflake 工作表允许您直接在 Snowflake 环境中编写和运行 SQL 与 Python 代码，非常适合测试查询或进行快速分析。
多步骤分析
要进行多步骤分析，请从左侧导航菜单进入 Notebooks。与工作表不同，Notebook 允许您在一个地方（类似于 Snowflake 原生的 Jupyter Notebook）结合文本、SQL 和 Python。要打开新的 Snowflake Notebook，请点击导航边栏中的 Notebooks，然后点击右上角的 + Notebook。
应用管理
最后，点击导航边栏中的 Apps。这是您在 Snowflake 内部部署的 Streamlit 应用的存放位置。当您从 Notebook 发布 Streamlit 应用后，可以在这里找到它。

数据组织方式

了解 Snowflake 如何组织数据至关重要。其层级结构如下：

数据库：顶层的容器。
模式：类似于子文件夹，用于对不同的数据类型进行分组。
表：数据实际存储的位置。

当您点击一个表（例如 customer_reviews）打开它时，会看到几个标签页：

Table Details：包含表的管理设置和权限。
Columns：列出每个列的名称、数据类型和描述。
Data Preview：显示数据样本以及用于运行查询的计算仓库信息。

这为您理解数据结构提供了一切所需，无需编写代码。

总结

本节课中，我们一起学习了 Snowflake 云数据平台的核心概念，并深入探索了其网页界面 Snowsight。我们了解了如何登录和导航，熟悉了数据、工作表、Notebook 和应用等关键区域，也掌握了 Snowflake 中数据库、模式和表的三层数据组织结构。

现在您已经熟悉了 Snowflake 工作空间，这个基础将使学习本课程的其余部分变得更加轻松。接下来，您将开始加载数据并使用 Python 进行探索。让我们保持势头，继续前进。

022：通过Notebook将CSV数据导入云端雪崩数据集 📊

在本节课中，我们将学习如何将本地的CSV数据文件上传到Snowflake云数据平台，并将其转换为一个可供查询的永久数据表。我们将从创建数据库、架构和存储阶段开始，最终在Snowflake Notebook中完成数据加载和建表操作。

课程概述

到目前为止，您一直在使用一个名为 customer_reviews.csv 的已清洗CSV文件。在本视频中，您将把同一个文件上传到Snowflake，并将其转换为一个正式的数据表。在下一节中，您将通过合并一堆杂乱的Word文档来重新创建相同的数据集。但现在，让我们从简单的开始，先加载已清洗的版本，以便您熟悉从开始到结束的完整流程。

首先，回顾一下模块1的MVP构建计划。您已经在模块1中完成了这个流程。但这次，我们将在Snowflake中从头开始，以便您了解在这个环境中完整的文件上传和建表过程是如何工作的。

现在，是时候处理第一步了：将数据导入Snowflake。

数据格式与Snowflake组织架构

如果您从事过数据科学或分析工作，很可能处理过许多表格数据，通常以CSV、Excel文件或其他电子表格格式出现。Snowflake支持所有最常见的格式，包括：

结构化文件：如CSV和TSV。这些是经典的电子表格格式，非常适合清洗和组织好的数据。
半结构化数据：如JSON、Avro、Parquet和XML。这些是更灵活的格式，通常用于日志、事件或嵌套信息。
文本文档：如PDF和Word文件。如果您来自传统的数据科学背景，这可能不太熟悉，但得益于生成式AI，现在分析和从这类数据中提取见解变得容易得多。

在上传任何内容之前，让我们快速回顾一下Snowflake如何组织您的数据。可以将其想象成一个办公室的文件柜：

数据库 就像柜子本身，是项目的顶级容器。
架构是柜子内部的文件夹，用于保持条理。
表、视图和阶段 是您的实际数据和管理工具。表是结构化数据的行和列，视图是看起来像表的保存查询，阶段是在将文件加载到表之前的上传区域。

这种结构使您的数据保持整洁、模块化且易于导航。现在，您将为自己设置它。

设置数据环境：数据库、架构和阶段

根据上述组织方式，您需要创建三样东西：一个用于存储项目的数据库、一个用于组织文件的架构，以及一个用于上传雪崩客户评论CSV文件的阶段。这个设置反映了Snowflake中最典型的项目设置。

第一步：创建数据库

这是您雪崩应用相关所有内容的顶级容器。

在左侧边栏中点击 “数据” 选项卡。这将打开数据库窗口。
点击右上角的 “+ 数据库” 图标。
在数据库窗口中，为您的数据库命名，例如 avalanche_db。
点击 “创建数据库”。

第一步完成。现在，在左侧您有了一个新的 avalanche_db 数据库，您将用它作为顶级容器来存储所有雪崩相关的表和架构。

第二步：创建架构

现在让我们添加一个架构来保持条理。您将在这里存储原始文件和表。

在左侧边栏中点击您新建的 Avalanche_db。
在打开的 Avalanche_db 窗口右上角，点击 “+ 架构”。
为您的架构命名，例如 avalanche_schema。
然后点击 “创建”。

现在您有了一个地方，可以将原始文件与清洗过的文件或您以后添加的任何其他内容分开组织。

第三步：创建阶段

如果您计划在多个Notebook或同一工作空间的不同用户之间重用文件，这将特别有用。这是您的上传区域，是在将文件加载到表之前存放原始文件的地方。

点击现在列在您的 avalanche_db 下的 avalanche_schema。
在屏幕右上角，点击蓝色的 “创建” 按钮。
从下拉菜单中选择 “阶段”，然后选择 “Snowflake管理”（除非您有理由选择外部管理的存储，否则这是最容易配置的选项）。
在创建阶段窗口中，为您的阶段命名，例如 avalanche_co_stage。
如果架构尚未指向 avalanche_db.avalanche_schema，请立即更新。
选择服务器端加密，其他选项可以保留默认设置。
然后点击右下角亮蓝色的 “创建” 按钮。

当您的阶段准备就绪后，就可以将 customer_reviews.csv 文件上传到您刚刚创建的阶段了。

上传文件到阶段

一旦雪崩阶段准备就绪，您将被带到设置窗口。

在屏幕右上角，点击 “+ 文件” 按钮。
拖放或浏览到您克隆课程仓库的位置，并选择 customer_reviews.csv。
点击 “上传” 按钮。

您的文件现已安全存储在 avalanche_stage 中，并准备好在查询和脚本中被引用。

在Snowflake Notebook中操作数据

现在您的数据已经在Snowflake上，其余的工作可以在Snowflake Notebook中完成。Snowflake Notebook类似于Jupyter Notebook，但托管在Snowflake中。您可以编写和运行Python和SQL代码，可视化数据，并直接与您的Snowflake环境交互。

要打开一个新的Notebook：

在左侧边栏中点击 “项目”，然后点击 “Notebooks”。
在屏幕右上角，点击 “+ Notebook” 按钮。
为您的Notebook命名，例如 avalanche_customer_reviews。
选择您的 avalanche 数据库和架构。
将运行时选项保留为 “在仓库上运行”。这是使用Python进行数据分析的最佳选择，因为它预装了大多数数据科学包。
其他选项保留默认设置，然后点击 “创建”。

您的Notebook打开后，将进入主编辑器窗口，这是您编写代码的地方。您的Notebook将打开，其中包含几个Python和SQL的示例代码单元格。要运行一个单元格，请按键盘上的 Shift + Enter 或点击单元格右上角的运行按钮。您现在可以尝试一下，看看它是如何工作的。

第一个单元格是您连接到存储在Snowflake上的任何数据的方式。所以保留它以便获取客户评论数据。现在，您可以继续删除最后两个示例代码块，方法是点击每个块右上角的三点菜单并选择“删除”。

理解数据框：Pandas vs Snowpark

现在您已经设置了数据库、架构和阶段，准备将您的 customer_reviews.csv 文件加载到数据框中。

在Snowflake Notebook中，您主要会使用两种类型的数据框：Pandas数据框 和 Snowpark数据框。它们看起来相似并支持许多相同的操作，但在底层，它们的行为非常不同。

Pandas数据框 在您的本地机器上立即运行所有操作。这对于小型数据集的快速分析非常棒，但当数据量变大时，它们可能会变慢或崩溃。
Snowpark数据框 不会立即执行。相反，它们会构建一个查询计划——一种描述应该发生什么（如过滤、连接或转换数据）的蓝图，但直到您请求结果时才会真正运行任何操作。然后，当您准备好时，整个计划会被发送到Snowflake的云基础设施，并在数据所在的位置一次性执行。这意味着无需下载、没有内存过载，并且速度更快。

那么，您应该使用哪一个呢？下表为您提供了一个很好的概述：

特性	Pandas 数据框	Snowpark 数据框
执行位置	本地机器	Snowflake 云端
最佳用例	快速本地测试和小文件	处理大型数据集或利用Snowflake计算引擎
内存使用	数据加载到本地内存	数据保留在云端
速度	小数据快，大数据慢	大数据集性能更佳

使用Pandas进行快速的本地测试和小文件处理。当您处理较大的数据集或想要利用Snowflake计算引擎的全部功能时，请使用Snowpark数据框。

实践：加载数据到Snowpark数据框

现在您了解了Snowflake如何处理数据框，让我们通过将您的 customer_reviews.csv 文件加载到Snowpark数据框中来实践一下。

第一步：连接到Snowflake环境

第一步是将您的Snowflake Notebook连接到您的项目环境。Snowflake使用称为活动会话的东西自动为您处理。每个Snowflake Notebook开始时都会自动填充这个代码块：

import streamlit as st
import pandas as pd
from snowflake.snowpark.context import get_active_session

session = get_active_session()

让我们通过点击右上角的播放按钮来运行这个代码块。这段代码首先导入核心库 streamlit 和 pandas，就像您以前做的那样。然后，您可以从 snowpark 库调用 get_active_session()。这将创建到您的Snowflake项目的直接连接。一旦该会话处于活动状态，您就完全接入了Snowflake的后端。这意味着您现在可以查询现有表、从阶段加载文件、将数据写入新表，并在Snowflake的云中运行所有操作，而不是在您的本地机器上。

第二步：从阶段加载CSV文件

现在您已连接到Snowflake并准备好会话，是时候加载您的数据了。让我们将 customer_reviews.csv 文件放入一个Snowpark数据框中，以便您可以直接在Notebook中开始处理它。

使用这行代码：

df = session.read.options(infer_schema=True).csv('@avalanche_stage/customer_reviews.csv')
df.show()

这行代码将您的CSV文件直接从Snowflake阶段加载到Snowpark数据框中，以便您可以在Python代码中预览和处理它。

session.read 告诉Snowpark您即将将数据读入一个新的数据框。
.options(infer_schema=True) 是一个有用的快捷方式，让Snowflake根据您的CSV内容自动检测列名及其数据类型。如果不使用此选项，所有内容都将作为纯文本加载。
.csv('@avalanche_stage/customer_reviews.csv') 直接指向您之前上传的文件。@avalanche_stage 是您命名的阶段（您创建的安全上传区域），customer_reviews.csv 是放在其中的文件。
df.show() 让您可以预览数据集的前几行，就像在Pandas中使用 df.head() 一样。

此时，您正在将Snowflake托管的数据读入Notebook，用Python分析它，并预览结果，所有这些都无需离开云端。让我们点击播放按钮运行它。

理解Snowflake中的文件路径

在继续之前，值得理解文件路径在Snowflake中是如何工作的，尤其是在使用阶段时。当您看到像 @avalanche_stage/customer_reviews.csv 这样的文件路径时，以下是每个部分的含义：

@ 符号告诉Snowflake您正在引用一个阶段（您的文件存储区域）。
avalanche_stage 是您之前创建的阶段的名称，是您上传 customer_reviews.csv 文件的地方。
customer_reviews.csv 是您放在该阶段内的文件名。

如果您将文件上传到阶段内的子文件夹，路径可能看起来像这样：@avalanche_stage/raw_files/customer_reviews.csv。Snowflake将阶段视为类似云目录，您可以使用类似文件夹的路径在其中组织文件，即使底层存储是扁平的。在以后的课程中处理多个文件时，了解这些路径如何工作将帮助您保持条理并避免错误。

将数据保存为永久表

现在您已经预览了CSV文件并确认一切看起来都正确，是时候让您的数据永久化了。目前，您的数据只存在于Notebook的内存中，就像一个临时的便签本。要使其真正有用，您需要将其转换为Snowflake数据库中的一个表。

以下是执行此操作的代码：

df.write.mode("overwrite").save_as_table("customer_reviews")

这行代码告诉Snowpark：

"customer_reviews" 是您要在Snowflake数据库中创建的表的名称。
mode="overwrite" 告诉Snowflake，如果已存在同名表，则用这个新表替换它。

一旦您运行此命令，您的数据框就不再是临时的。它成为一个真实的、永久的表，存储在您的项目数据库和架构中。这意味着您可以针对它编写SQL查询，可以将其连接到Streamlit应用，可以将其与其他数据连接，并且可以在您的Snowflake环境中与您的团队或其他工具共享它。这是将原始数据转换为结构化、Snowflake原生资源的关键步骤，准备好被查询、可视化和构建。别忘了运行这个单元格。

课程总结

干得漂亮！在本节课中，您：

创建了一个新的数据库、架构和阶段来组织您的数据。
使用Snowflake Notebook上传了您的 customer_reviews.csv 文件。
直接从阶段将客户评论CSV文件加载到Snowpark数据框中。
预览数据以验证其看起来良好。
并将其保存为Snowflake内部一个可查询的永久表。

您已经正式完成了MVP构建计划的第一步：将数据导入Snowflake。在下一个视频中，您将通过使用Snowflake Cortex的GenAI强大工具，将一堆原始的DocX客户评论转换为干净的结构化数据，从而提升您的技能水平。

023：批量文件上传 📁

在本节课中，我们将学习如何在 Snowflake 中批量上传大量文件。你将从头开始重新创建客户评论表，但这次是通过合并超过 100 个 Word 文档来实现。我们将使用一个名为“阶段”的中间区域来安全地管理和验证文件，然后再将它们加载到最终的数据表中。

为什么需要“阶段”？

在开始加载文件之前，我们先回顾一下为什么“阶段”如此重要。Snowflake 不会直接将文件加载到表中。相反，你需要先将它们上传到一个称为“阶段”的地方。

阶段就像一个安全的文件暂存区。它帮助你在数据摄取前预览和验证文件，保持上传内容的有序性，并允许你在多个工作流中重复使用相同的文件。将文件加载到阶段而不是直接加载到表中也更安全。如果上传过程中出现问题，你的文件不会丢失。

好消息是，我们在上一节课程中已经创建了数据库、模式和阶段，现在我们将再次使用它们。

准备上传环境

上一节我们介绍了数据库和模式的概念，本节中我们来看看如何利用已创建的资源。你的数据库是 avalanche_db，模式是 avalanche_schema，阶段是 avalanche_stage。

现在，是时候上传那 100 个 Word 文档了。

以下是上传文件的步骤：

从课程 GitHub 仓库下载 data_customer_reviews_docs.zip 文件。
在本地解压该 ZIP 文件。解压后，你应该会看到一个包含 100 个 .docx 文件的文件夹。
登录 Snowsight 主页，在左侧边栏点击 Data。
导航到 Databases 并点击你的 avalanche_db 数据库。
选择你的 avalanche_schema 模式。
从侧边栏选择 Stages，然后点击 Stages 并选择你的 avalanche_stage。
点击屏幕右上角的 + Files 按钮。
将存储那 100 个解压后 Word 文件的文件夹拖放进去，或通过浏览选择它们。
选中所有 100 个文件，然后点击 Open。
在弹出的窗口中，确认 avalanche_db 和 avalanche_stage 已正确选中，然后点击 Upload。

即使有 100 个文件，这个过程在 Snowflake 中也会很快完成。

验证上传结果

上一节我们完成了文件上传，本节中我们使用一个新的 Snowflake Notebook 来检查所有文件是否按预期上传成功。

以下是验证步骤：

在 Snowsight 左侧导航栏，点击 Projects，然后点击 Notebooks。
在 Notebooks 窗口，点击右上角亮蓝色的 + Notebook 按钮。
为你的 Notebook 命名，选择 avalanche 数据库和模式，其他选项保持默认，点击 Create。
在新的 Notebook 中，删除底部默认的两个代码单元格。
将鼠标悬停在第一个包含 get_active_session() 的代码块上，从弹出的选项中选择 + SQL。
在新的 SQL 单元格中，粘贴以下语句来列出阶段中的所有文件：
```
LIST @avalanche_stage;
```
按 Shift + Enter 运行。这将返回阶段中所有文件的列表。

你可以手动数一数上传的文件来确认有 100 个，但让我们用一个更简单的方法：使用生成式 AI 助手来编写一个 SQL 命令。

你可以使用类似这样的提示词：

“如何使用 SQL 统计存储在 avalanche_db 数据库、avalanche_schema 模式中名为 avalanche_stage 的内部阶段里当前的文件数量？”

助手可能会返回类似这样的 SQL：

SELECT COUNT(*) FROM @avalanche_stage;

将其复制并粘贴到 Snowflake Notebook 的 SQL 代码块中并运行。如果你像我一样，在上一节上传了一个 CSV 文件但后来删除了它，你可能会得到 101 的计数。一旦你验证文件已成功上传，就可以继续下一步：解析并将它们合并到一个结构化的表中。

总结

本节课中我们一起学习了如何在 Snowflake 中进行批量文件上传。你复用了之前创建的数据库、模式和阶段，下载了 100 个 Word 文档的批次，将它们上传到指定的 Snowflake 阶段，并使用 SQL 验证了上传结果。现在，你已经掌握了 Snowflake 中的批量文件上传技能，可以完全勾选 MVP 构建计划中的第二步。你知道了如何向 Snowflake 上传单个文件以及大批量文件。

024：利用Cortex从暂存区到数据表转换

概述

在本节课中，我们将学习如何利用 Snowflake Cortex 的内置功能，将上传到 Snowflake 暂存区的大量 Word 文档，转换并解析成一个结构化的数据表。整个过程无需复杂的 Python 库，直接在 Snowflake Notebook 中使用 SQL 即可完成。

上一节我们介绍了如何将数据上传到 Snowflake 暂存区，本节中我们来看看如何解析和结构化这些数据。

为什么使用 Snowflake Cortex？

在开始之前，我们先快速回顾一下为何使用 Snowflake Cortex。Cortex 是 Snowflake 内置的一套 AI 工具集，它允许您使用简单的 SQL 来处理和分析数据，无需额外设置。它包含诸如 parse_document 这样的函数，可以直接从文档、PDF 和文本文件中提取内容。这意味着您无需使用 Python 或外部库来提取文本，Cortex 为您处理一切，并且快速、安全，完全在 Snowflake 内部运行。

第一步：验证暂存区文件

首先，我们需要确认文件已成功上传至暂存区。在您的 Snowflake Notebook 中新建一个 SQL 单元格，运行以下命令：

LIST @AVALANCHE_STAGE;

您应该会看到一个 .docx 文件列表，每个文件对应一份客户评价。如果您看到的是 101 个文件而不是 100 个，很可能是因为之前上传的 customer_reviews.zip 文件仍然存在。这没关系，我们稍后会将其过滤掉。

第二步：使用 Cortex 解析文档并创建表

接下来，我们将使用 Cortex 的 parse_document 函数来提取文本并创建结构化表。您可以向您喜欢的生成式 AI 应用寻求帮助来生成 SQL，例如：“请编写使用 Snowflake Cortex 从 AVALANCHE_STAGE 暂存区中的 .docx 文件提取文本，并保存到名为 raw_customer_reviews 的表的 SQL 语句。”

生成的 SQL 语句可能类似于以下代码：

CREATE OR REPLACE TABLE raw_customer_reviews AS
SELECT
    relative_path AS file_name,
    snowflake.cortex.parse_document(build_scoped_file_url(@avalanche_stage, relative_path)) AS extracted_content
FROM
    directory(@avalanche_stage)
WHERE
    relative_path LIKE '%.docx';

以下是这段代码的作用：

directory(@avalanche_stage)：获取您暂存区中每个文件的元数据。
relative_path：是文件名，例如 review_43.docx。
parse_document 函数：接收暂存区名称和文件名，然后从文档中提取文本。
结果将存储在一个包含两列的表中：file_name 和 extracted_content（一个半结构化的 JSON 对象）。

在 Snowflake Notebook 的 SQL 单元格中运行此代码。

第三步：预览结果以确认解析成功

代码运行完成后，运行以下查询以确保一切正常工作：

SELECT * FROM raw_customer_reviews LIMIT 5;

这将显示每个文档的前几行内容，方便您检查解析是否按预期进行。如果您在这里看到了结果，那就太好了！这意味着您的 100 个 Word 文档现在已经整齐地组织好，并准备进行下一步的清理工作。

总结

本节课中我们一起学习了一项相当高级的操作：直接在 Snowflake 内部处理超过 100 个 Word 文档，全程仅使用 SQL 和 Cortex。我们从一堆压缩的、非结构化的文件开始，现在得到了一个干净、可查询的名为 raw_customer_reviews 的数据表，为后续的分析工作做好了准备。干得漂亮！

025：从内容中提取信息

在本节课中，我们将学习如何从上一节创建的原始内容表格中，提取出产品名称、评论日期和评论内容等具体信息，并将其整理成一个名为“customer reviews”的新表格。我们将使用 SQL 和正则表达式来完成这项任务。

上一节我们介绍了如何从上传的 docx 文件中提取原始内容并创建表格。本节中，我们来看看如何清理这些数据，提取出有价值的结构化信息。

你可以使用 Snowflake Notebook，通过 Python 或 SQL 来解析这些数据。由于所有 docx 文件的文本格式一致，这使得正则表达式特别有用。我们将使用 SQL 代码进行演示，因为它通常比 Python 处理得更快。你可以定义一个模式，然后将其应用到每一行数据。

以下是提取各项信息的具体步骤：

首先，提取产品名称。我们将使用正则表达式函数 REGEXP_SUBSTR 来搜索“product”这个词，然后捕获其后直到下一个换行符的所有内容。这样就能得到干净的产品名称。

接下来，提取评论日期。同样使用 REGEXP_SUBSTR 函数，但这次我们寻找一个特定的日期模式，例如 yyyymmdd 格式（如 20231013）。

然后，提取评论内容本身。这里我们将使用一个 CASE 语句来检查内容中是否存在“customer review”字样。如果存在，则提取其后的文本；如果不存在，则留空。

现在，进行一点创造性的处理。每个文件名中都包含一个三位数的编号。由于这些文件来自“batch2”，我们将通过在每个文件编号前加上数字“2”来创建一个唯一的 ID。这个 ID 将有助于后续将评论与发货记录关联起来。例如，如果文件编号是 045，那么唯一 ID 就变成 2045。

编写完整的 SQL 查询后，你可以在原始客户评论表上运行它，将数据整理成清晰的列，为分析做好准备。

现在到了最重要的部分：将结果保存为 Snowflake 上的一个表，以便后续使用。为此，你可以简单地添加一个 CREATE TABLE 语句。运行这个单元后，你将得到一个清理后的客户评论表，可以在下游任务中使用。

做得很好！在上一节中，你从一堆压缩的非结构化文件开始。现在，你已经有了一个名为“customer reviews”的、干净且可查询的表格，随时可以进行分析了。在下一节中，我们将切换数据集，开始探索可用的发货日志，为情感分析增加更多深度。

本节课中我们一起学习了如何使用 SQL 和正则表达式从原始文本中提取结构化信息，并创建了一个清晰、可查询的数据表，为后续的数据分析工作奠定了基础。

026：雪崩运输分析系统 🚚

概述

在本节课中，我们将学习如何将雪崩公司的运输日志数据上传至 Snowflake 平台，并进行数据验证、加载和清洗，为后续与客户评论数据结合分析做准备。

欢迎来到雪崩运输实验。在之前的视频中，你已经学习了如何上传单个文件以及在 Snowflake 中暂存批量数据。现在，是时候将这些技能整合到一个真实场景中了。本次实验，你将处理雪崩公司的运输日志。客户评论帮助你了解用户对销售商品的看法，而运输数据则帮助你理解配送如何影响用户情绪。将两者结合，你将获得强大的跨职能洞察力，帮助团队做出更明智的决策。

在本实验中，你将处理一个结构化的 CSV 文件，其中包含雪崩公司的运输操作日志。每一行代表一次货运，其中一些可能存在配送问题，这些问题可能与差评相关联。

让我们开始吧。

实验准备与数据上传

上一节我们介绍了实验的目标和数据背景，本节中我们来看看如何准备环境并上传数据。

你已获得一个名为 shippinglogs.csv 的 CSV 文件，其中包含雪崩公司的运输操作日志。你的任务是将该文件上传到雪崩公司的 avalanche_stage 暂存区，验证内容，将其加载到 Snowflake 表中，并准备清洗数据，以便在下一个实验中与客户评论结合。你可以在课程 GitHub 仓库中找到本实验所需的一切资源。

本实验假设你已经创建了 avalanche_db 数据库、avalanche 模式和 avalanche_stage 暂存区。如果尚未创建，请返回之前的视频，完成这些步骤后再继续。

回到 Snowsight 主页，首先将运输日志 CSV 文件从本地计算机上传到你的 Snowflake 账户，方法与上传客户评论 CSV 文件时相同。这次会更容易，因为你已经创建了数据库、模式和暂存区。

在 Snowsight 主页屏幕，点击左侧导航菜单的加号按钮，选择最后一个选项“添加数据”。在弹出的窗口中，你会看到一个将文件加载到暂存区的选项。在将数据集转换为表之前，你需要先清理数据。

接下来，将 shippinglogs.csv 文件拖放或浏览到你计算机上的下载位置。选择 avalanche 数据库、模式和暂存区，然后点击上传。

验证数据与加载到 Snowpark DataFrame

文件上传完成后，通过运行一个快速 SQL 语句来确认其存在。点击右上角的“项目”，然后点击“笔记本”。点击“+ 笔记本”打开一个新的 Snowflake 笔记本。为笔记本命名，选择 avalanche 数据库和模式，其他选项保持默认。为其命名，例如“testing”，然后点击“+SQL”添加一个新的 SQL 单元格。复制并运行以下命令：

LIST @avalanche_stage;

这将列出当前存储在暂存区中的所有文件。如果你看到 shippinglogs.csv，说明上传成功。

接下来，在你的 Snowflake 笔记本中，添加一个 Python 单元格并粘贴以下代码：

# 从暂存区读取数据到 Snowpark DataFrame
df = session.read.options({"field_delimiter": ",", "skip_header": 1}).csv('@avalanche_stage/shippinglogs.csv')
df.show()

session 是激活的会话，它将你的笔记本连接到 Snowflake 计算会话。field_delimiter 指定字段分隔符为逗号。skip_header: 1 告诉 Snowpark 文件的第一行是列名，不是数据。df.show() 为你提供数据预览，类似于 pandas 中的 df.head() 函数。

点击运行。干得漂亮！现在，运输数据已经加载到 Snowpark DataFrame 中。你可以使用 Python 和 Snowpark 来清洗和探索 DataFrame 中的数据。

数据清洗与探索

在数据预览中，你可以看到列名周围有引号。你可以通过使用别名重命名列来轻松修复这个问题，如下所示：

# 清洗列名：去除引号
df_cleaned = df.selectExpr(
    "`\"shipment_id\"` as shipment_id",
    "`\"carrier\"` as carrier",
    "`\"ship_date\"` as ship_date",
    "`\"delivery_status\"` as delivery_status",
    "`\"delivery_days\"` as delivery_days"
)
df_cleaned.show()

Snowpark 会完全按照文件中的样子加载列名，包括引号、大写字母和空格。通过使用 selectExpr 和别名，你正在使用 Snowflake 的 SQL 方言直接编辑列名。

列名清洗完毕后，你可以进行一些操作，例如统计每个承运商处理的货运数量，或者切换到 pandas 进行快速原型设计。通常，在本地处理较小数据集时使用 pandas，当你希望进行可扩展的平台分析时使用 Snowpark，这是一个好主意。

利用这段时间清洗数据，检查空值，确保度量单位合理，并执行你通常为准备数据所做的任何其他操作。如果你需要帮助，可以与你喜欢的 AI 助手协作。

保存清洗后的数据到表

当你的 DataFrame 看起来没问题后，使用 df.write.save_as_table 函数将其保存到一个新表中。

# 将清洗后的 DataFrame 保存为 Snowflake 表
df_cleaned.write.mode("overwrite").save_as_table("cleaned_shipping_logs")

这将永久地将你清洗后的运输日志 DataFrame 注册为 avalanche 数据库内的一个表。之后，它可以使用 SQL 进行查询、与其他表连接、流入应用程序或发送到 Cortex 进行生成式 AI 分析。

恭喜！你现在已经能够向 Snowflake 读写数据了。本实验将使你为 MVP 构建计划的下一步做好准备：进行最终的数据准备和情感分析。

如果你遇到困难，解决方案在课程 GitHub 仓库的 M2_lab_1 中。祝你好运，我们下个视频见。

总结

本节课中我们一起学习了如何将 CSV 格式的运输日志数据上传到 Snowflake 暂存区，使用 Snowpark DataFrame 加载和预览数据，清洗数据（如重命名列），以及最终将清洗后的数据保存为 Snowflake 中的永久表。这些步骤为后续结合客户评论数据进行跨职能分析奠定了坚实的基础。

027：统一数据表架构 🧩

在本节课中，我们将学习如何将客户评论和物流日志两个数据集合并，并进行清理，为后续的情感分析做好准备。这是构建MVP路线图中的第三步。

上一节我们完成了数据的上传和初步清理。本节中，我们将使用SQL和Snowflake Cortex工具，将两个表格合并成一个统一的数据集，并对文本数据进行标准化处理。

准备工作与数据预览

在开始合并数据之前，我们需要先了解现有表格的结构。以下是查看表格预览的步骤。

打开一个Snowflake笔记本，并运行SQL来预览customer_reviews和shipping_logs表。你可以使用类似以下的提示词向你的生成式AI助手寻求帮助：

-- 预览客户评论表
SELECT * FROM customer_reviews LIMIT 5;
-- 预览物流日志表
SELECT * FROM shipping_logs LIMIT 5;

运行这些代码可以帮你回忆每个表中的列名和其他有用细节，类似于Pandas的describe方法。

合并客户评论与物流日志

现在，我们将通过order_id这个共同字段，把两个表格连接起来。以下是实现这一目标的方法。

向你的AI助手请求帮助，生成合并表格的SQL代码。一个有效的提示词示例如下：

-- 合并两个表格的SQL示例
SELECT 
    cr.review_text,
    sl.shipping_date,
    sl.carrier,
    sl.status
FROM customer_reviews cr
JOIN shipping_logs sl ON cr.order_id = sl.order_id;

如果首次尝试不成功，请将错误信息复制给你的AI助手，它将帮助你进行故障排查。合并后，你可以使用SELECT * FROM merged_review LIMIT 10;来检查前10行数据，确保合并操作正确无误。

清理与标准化评论文本

虽然生成式AI模型能处理各种数据，但输入数据的质量直接影响分析结果的准确性。因此，在进行分析前，对文本数据进行清理至关重要。以下是清理步骤。

首先，将合并后的表格转换为Snowpark DataFrame。然后，应用lower函数将review_text列中的所有文本转换为小写，以确保后续文本搜索和匹配的一致性。

# 将文本转换为小写
df_cleaned = merged_df.withColumn(‘review_text_lower’, lower(col(‘review_text’)))

接下来，使用trim函数去除每条评论开头和结尾可能存在的多余空格。这一步很重要，能避免因格式不一致导致的错误分析。

# 去除首尾空格
df_cleaned = df_cleaned.withColumn(‘review_text_trimmed’, trim(col(‘review_text_lower’)))

保存清理后的数据集

完成清理后，我们需要将处理好的数据保存下来，供后续分析使用。以下是保存数据的步骤。

以下代码行将在Snowflake中创建一个名为cleaned_reviews的新表来存储清理后的数据。mode=‘overwrite’参数意味着如果存在同名表，它将被覆盖。请谨慎使用此参数，以免意外覆盖需要保留的数据表。

# 将清理后的DataFrame保存为新表
df_cleaned.write.mode(‘overwrite’).saveAsTable(‘cleaned_reviews’)

运行此代码块后，你就拥有了一个干净、规整的数据集，可以随时用于任何分析任务。

总结

本节课中，我们一起学习了数据准备流程的关键一步：统一数据架构。我们回顾了如何预览表格结构，使用SQL通过order_id合并customer_reviews和shipping_logs表，并对评论文本进行了小写转换和空格修剪的标准化清理。最后，我们将清理后的数据集保存为cleaned_reviews表。现在，你的数据已经准备就绪，为下一步引入生成式AI进行情感分析奠定了坚实的基础。

028：基于Cortex的舆情分析 📊

在本节课中，我们将学习如何利用 Snowflake Cortex 函数对客户评论进行情感分析，从而避免手动编写复杂的分析代码。我们将借助生成式 AI 工具来加速工作流程，并回顾我们的 MVP 计划进度。

概述

本节视频将引导我们完成数据分析的第四步。由于数据已经过清洗和预处理，本项目将进展得很快。我们将使用 Snowflake Notebook 和 Cortex 函数来高效地计算情感得分。

开始分析

首先，我们需要在 Snowsight 中打开一个新的 Snowflake Notebook。请确保已选择 Avalanche DB 数据库和 avalanche 模式，其他设置保持默认即可。

运行第一个代码块以实例化您的 Snowflake 会话。

# 实例化 Snowflake 会话
session = snowflake.snowpark.Session.builder.configs(connection_parameters).create()

接着，删除 Notebook 中默认的两个代码块，准备工作就完成了。

借助生成式 AI 选择 Cortex 函数

现在，是时候请您的生成式 AI 助手来帮助选择用于情感评分的 Cortex 函数了。

首先，通过如下声明设定 AI 的角色：
“你是一位精通 Python 和 SQL 集成的 Snowflake 数据平台专家。你的职责是通过提供最直接、对初学者友好的解决方案，来教授如何使用 Snowflake 进行数据分析。”

然后，使用如下提示词来获取情感评分：
“请编写 Snowflake SQL，对 customer_review 表中的 review_text 列使用 snowflake.cortex.sentiment 函数，以返回情感标签和得分。”

您将获得一个类似以下的查询：

SELECT
    REVIEW_TEXT,
    SNOWFLAKE.CORTEX.SENTIMENT(REVIEW_TEXT) as SENTIMENT_SCORE
FROM CUSTOMER_REVIEWS;

这是为您的数据框获取情感得分最直接的方法。此处，Cortex 的 sentiment 函数处理 review_text 列，并为每条评论返回一个情感得分。

执行查询并查看结果

您可以在 Notebook 中使用一行代码运行此查询，并将结果加载到 Pandas 数据框中。

# 将 SQL 查询结果加载到 Pandas DataFrame
sentiment_df = session.sql("""
    SELECT
        REVIEW_TEXT,
        SNOWFLAKE.CORTEX.SENTIMENT(REVIEW_TEXT) as SENTIMENT_SCORE
    FROM CUSTOMER_REVIEWS
""").to_pandas()

然后，您可以使用 Pandas 的 head() 函数查看结果。

# 查看前几行结果
print(sentiment_df.head())

生成的数据框包含原始评论文本以及每条评论的情感得分。此操作非常快速，因为 Cortex 在 Snowflake 内部进行了大规模并行处理。

可视化得分分布

获得情感得分后，我们可以轻松地使用 Matplotlib 的直方图来可视化得分分布。

import matplotlib.pyplot as plt

# 绘制情感得分直方图
plt.hist(sentiment_df[‘SENTIMENT_SCORE‘], bins=20, edgecolor=‘black‘)
plt.title(‘Distribution of Sentiment Scores‘)
plt.xlabel(‘Sentiment Score‘)
plt.ylabel(‘Frequency‘)
plt.show()

如果遇到 “Module not found error”，我们需要安装 Matplotlib 包。

以下是安装步骤：

点击 Notebook 右上角的 “Packages”。
在弹出的下拉菜单中，保持选择为 “Anaconda packages only”。（仅当需要手动安装某些内容，而不是使用 Pip 或 Conda 时，才使用 “Stage packages”）
在搜索栏中搜索您想安装的包，例如 matplotlib。
找到包后，它会显示在待安装列表中，点击 “Save” 即可。

安装完成后，返回并重新运行上述代码块。

保存工作成果

现在，是时候保存您的工作了。以下代码行将在 Snowflake 中创建一个新表来存储结果。

# 将带有情感得分的结果保存回 Snowflake 表
session.write_pandas(sentiment_df, ‘CUSTOMER_REVIEWS_WITH_SENTIMENT‘, auto_create_table=True)

生成式 AI 的辅助作用

在整个过程中，生成式 AI 可以在以下方面为您提供帮助：

探索功能：询问 Cortex 中有哪些可用的函数。
编写与调试：协助编写和调试 Python 代码。
数据解析：从复杂字段中解析和提取数据。
结果可视化：在 Matplotlib 或 Seaborn 中可视化输出。
问题处理：建议错误处理或模型替代方案。

总结

在本节课中，我们使用生成式 AI 来生成代码，利用 Cortex 的 sentiment 函数为评论评分，并使用 Matplotlib 将结果可视化。接下来，我们将继续与生成式 AI 协作，为您的 Avalanche 应用添加更多可视化和交互功能。

029：29_02_03_Snowflake数据可视化 📊

在本节课中，我们将学习如何利用AI大规模分析情感数据，以发现人工难以察觉的趋势。通过将原始情感数据转化为可视化的洞察，为团队提供可操作的决策依据。

概述

上一节我们完成了数据分析，现在进入第五步：数据可视化探索。本节的目标是将数字化的洞察转化为易于理解和行动的故事。

从构思到实现

首先，我们可以向生成式AI助手提问，以获取可视化图表构思。例如，可以询问：“我可以从Avalanche客户评论和物流日志中创建哪些类型的图表？”

以下是可能得到的建议：

创建情感标签数量的条形图。
制作随时间变化的平均情感得分折线图。
绘制物流时间与情感得分的散点图。
按承运商或地区制作分组条形图。

为了保持原型简洁，建议从一两个图表开始。

按产品分组情感得分

打开一个新的笔记本，初始化你的Snowflake会话，并使用以下查询来获取带有情感得分的评论数据。

# 示例查询代码
query = “SELECT product_id, sentiment_score FROM merged_reviews_table”

由于在之前的视频中我们已经用直方图可视化过情感得分，这次让我们按产品来细分情感得分。为了快速获得代码，可以向AI助手提问：“如何按产品分组情感得分？”

现在，你可以使用生成的代码来比较客户对不同产品的感受。

可视化物流模式与异常

接下来，请AI助手帮助你使用时序图来可视化物流模式和异常情况。你应该能得到类似以下的代码。

# 示例：绘制物流量的时序图
import matplotlib.pyplot as plt
plt.figure(figsize=(12, 6))
plt.plot(shipping_data[‘date’], shipping_data[‘volume’], marker=‘o’)
plt.title(‘Shipping Volume Over Time’)
plt.xlabel(‘Date’)
plt.ylabel(‘Volume’)
plt.grid(True)
plt.show()

现在，与其用传统方式搜索异常，不如请AI助手帮你更深入地挖掘。可以使用这样的提示：“如何识别物流量低的日期？”

然后，你可以利用这个洞察来添加更多图表。例如，这个按承运商分组的图表。

探索物流对客户情感的影响

现在，我们可以利用合并后的评论和物流数据，来查看物流是否影响客户情感。

让我们提示AI助手创建一个条形图，展示不同物流状态下的平均情感得分。AI助手可能会建议使用以下代码，该代码使用late列按物流状态对数据集进行分组，然后计算每个组的平均情感得分。

# 示例：按物流状态计算平均情感得分并绘图
import pandas as pd
import matplotlib.pyplot as plt

# 假设 df 是包含 ‘shipping_status’ 和 ‘sentiment_score’ 的 DataFrame
grouped_data = df.groupby(‘shipping_status’)[‘sentiment_score’].mean().sort_values()

plt.figure(figsize=(10, 6))
grouped_data.plot(kind=‘barh’)
plt.title(‘Average Sentiment Score by Shipping Status’)
plt.xlabel(‘Average Sentiment Score’)
plt.show()

为了对数据框进行排序，结果使用Matplotlib的水平条形图绘制，显示了按物流状态划分的平均情感得分。这使得我们很容易看出物流延迟如何影响情感得分。

总结

本节课中，我们一起学习了如何利用生成式AI助手快速构思并创建数据可视化图表。我们探索了按产品分析情感、识别物流异常，并揭示了物流状态与客户情感之间的关联。

接下来，你将把在本模块中学到的所有知识整合到一个Streamlit应用中，并可以在Snowflake内部运行和部署。

030：在 Snowflake 内构建 AI 驱动的 Streamlit 应用 🚀

概述

在本节课中，我们将综合运用模块二所学的全部知识，构建一个功能完整的 Streamlit 应用。这个应用将包含交互式筛选、数据可视化、情感分析以及一个基于数据的动态问答助手。

上一节我们通过 GenAI 对数据集进行了深入的可视化分析。本节中，我们将把所有组件整合起来，构建一个可交互的仪表盘。

创建应用环境

你已经快速推进了 MVP 构建计划，现在来到了第 6 步：创建仪表盘。这一步将最终整合你的原型，并准备将其发布以获取反馈。最困难的部分——数据摄取、清洗、分析和可视化——已经完成。现在是将原型变为现实的时候了。

你将在 Snowflake Notebook 中直接构建 Avalanche Streamlit 应用，也就是你一直工作的同一个环境。

创建一个新的 Notebook，并将其命名为类似 Avalanche_app 的名称。确保将其连接到现有的 Avalanche 数据库和模式，并指向合并了客户评论和运输数据的表。

构建基础应用框架

激动人心的部分来了。你将在一个 Notebook 单元格中编写整个 Streamlit 应用代码，运行后，一个完全交互式的 Web 应用将作为单元格输出出现。这就像魔法，但这个魔法技巧将变成一个可供人们使用的真实工具。

为了让事情变得简单，我们先创建一个基础的 Streamlit 外壳。你可以从之前的视频中复制粘贴代码，或者直接让 GenAI 帮助你。以下是你可以使用的提示词示例：

# 提示词示例
write a streamlit app that loads a table on snowflake for sentiment analysis, show some basic stats, and add a title and sidebar.

你的 GenAI 应用将生成一个基础 Streamlit 应用的 Python 代码。将代码复制粘贴到你的 Notebook 中并运行单元格。如果出现问题，可以使用 GenAI 来调试或修改代码。你可以询问类似“help me fix this error”或“can you rewrite this function to avoid this error”的问题。持续测试和迭代，直到你的应用运行流畅。

集成可视化图表

接下来，你可以集成在之前课程中创建的图表。这些图表应包括每日运输量的折线图、情感分布的条形图，以及一些产品级别的统计数据或顶级产品细分图。

你可以让 GenAI 制作一个 Streamlit 折线图来显示运输量。将代码添加到你的应用中，图表看起来会类似下面的样子。你也可以让 GenAI 帮助处理坐标轴标签、图例，并使图表具有交互性。

添加交互式筛选器

现在，你可以使用 Streamlit 小组件来添加筛选器，使你的应用更具交互性和实用性。向 GenAI 提出以下提示：

# 提示词示例
add a date and sentiment filter to my streamlit app.

它应该会返回类似下面的代码。现在，是时候通过使用 Cortex 来添加一个可以回答数据相关问题的聊天机器人，让你的应用变得更高级了。

集成 AI 问答助手

你可以让 GenAI 在 Streamlit 中编写一个聊天机器人，该机器人使用 Snowflake Cortex 来回答关于清理后的评论表的问题。你的 GenAI 应用很可能会返回类似下面的代码和调用。

为了在 Python 中使用 Cortex，你需要从 Notebook 的下拉菜单中安装一个 Snowflake ML Python 包。所以别忘了这一步。这将为你的用户提供一个友好的界面来提问，例如“product A 的平均情感得分是多少？”或“为什么在这个特定日期运输量减少了？”。

运行 Notebook，现在你的 GenAI 原型中就拥有了一个实时聊天机器人。

如果你在任何地方遇到困难，不用担心，你可以通过此链接在课程模块中找到代码。

总结

干得漂亮！你已经将情感分析变成了一个可工作的 Streamlit 原型。在下一个模块中，你将学习如何部署、分享你的应用，并根据用户反馈进行改进。你还将学习如何使用高级的 GenAI 提示技术来提升结果质量。

实验室见。😊

031：GenAI舆情分析系统概览 🚀

概述

在本节课中，我们将综合运用模块二所学的全部知识，构建一个全新的产品智能仪表盘。我们将为 Avalanche 产品团队开发一个工具，用于探索跨时间和地区的客户舆情、可视化运输延迟趋势，并支持自然语言提问。

实验任务概览

欢迎来到模块二的最终实验。这是您将所有学习成果融会贯通的地方。

您已经探索了如何使用 GenAI 分析数据，使用 Cortex 进行了情感分析，构建了可视化图表，甚至添加了聊天机器人。现在，您将以一种全新的方式应用这些技能。

您的任务是：为 Avalanche 的产品团队构建一个产品智能仪表盘。这个工具将帮助他们探索跨时间和地区的客户情感，可视化运输延迟和交付绩效的趋势，并提出自然语言问题。

与上节课的区别

与上一课不同，您不仅仅是重复已做过的内容。这次您将：

结合情感和运输数据，构建新的可视化图表。
构建一个按地理区域显示产品问题的筛选表格。
添加一个聊天机器人助手。
在整个过程中，您将重度依赖 GenAI。

实验步骤详解

以下是构建仪表盘的核心步骤。

第一步：连接数据源并加载数据

首先，连接 Snowflake 并加载数据。使用您现有的、结合了客户评论的数据集。

您可以向 GenAI 提问，例如：

请编写 Python 代码来连接 Snowflake，并将包含情感分析的评论表加载到 Pandas DataFrame 中。

第二步：创建 Streamlit 应用框架

现在，您可以创建一个新的 Streamlit 应用。启动一个新的 Notebook，并请求 GenAI 创建一个基础的 Streamlit 应用，该应用能够加载数据并包含一个带有产品筛选器的侧边栏。

为您的应用添加标题、侧边栏筛选器和数据预览。

第三步：添加可视化图表

接着，添加图表以按区域可视化情感。您可以提示 GenAI：

使用 Matplotlib 和 Streamlit，绘制按区域划分的平均情感得分图。

您的图表应有助于回答“哪些区域的负面反馈最多？”这个问题。

第四步：突出显示交付问题

您还应该突出显示交付问题。创建一个类似下图的表格。

然后，请求 GenAI：

筛选出具有负面情感和交付问题的评论。按区域和产品分组显示一个表格。

第五步：集成智能聊天助手

别忘了添加一个由自定义语言模型驱动的聊天机器人。您可以提示 GenAI：

使用 Cortex Complete，为我的 Streamlit 应用添加一个聊天机器人。

第六步：部署与分享应用

最后但同样重要的是，部署或分享您的应用。您可以询问 GenAI：

如何在 Snowflake 中部署这个 Streamlit 应用？

按照 GenAI 提供的步骤，在 Snowsight 内部共享应用，或将其导出以供在 Snowflake 外部使用。

高效构建 GenAI 原型的建议

为了最大限度地发挥创建 GenAI 原型的价值，请遵循以下建议：

全程使用 GenAI：从创建应用基础设施到调试可视化，每个步骤都尝试使用 GenAI。
保持简洁专注：您的应用不需要包含所有功能，只需展示一个强大的最小可行产品。
为代码添加注释：为您自己或未来的评审者添加注释，以便理解您的逻辑。

所有起始代码、连接设置和提示示例都在 GitHub 仓库的以下路径中。

总结

本节课中，我们一起学习了如何综合运用 GenAI、Streamlit 和数据可视化技能，构建一个功能完整的产品智能仪表盘。这个实验不仅仅是一个总结，更是一个发射台。您正在以一种现实的、高影响力的方式测试您的技能。

一旦完成，您将拥有一个可以展示的成果：一个结合了真实数据和交互式洞察的、由 GenAI 驱动的仪表盘。

032：选择部署策略

在本节课中，我们将学习如何为你的 Streamlit 应用选择合适的部署策略。核心在于理解你的目标用户，并根据他们的需求在可访问性、安全性和性能之间找到最佳平衡点。

理解部署策略的关键

上一节我们介绍了 MVP 构建计划的步骤，现在来到了最后一步：部署。部署意味着将你的应用发布出去，让其他人能够实际使用并提供反馈。

选择部署策略的关键是理解你的受众。你需要明确应用是为谁构建的：是内部团队成员、外部合作伙伴，还是普通公众？一旦明确了用户群体，你就能选择在可访问性、安全性和性能之间达到最佳平衡的部署选项。

两种主要的部署选择

当你使用 Snowflake 构建 Streamlit 应用时，主要有两种部署选择。以下是这两种选项的详细介绍。

选项一：Streamlit Community Cloud

你已经在模块一中使用过此选项。它的优势在于可以直接连接到 Snowflake。当你希望公开分享应用时，可以选择 Streamlit Community Cloud。

适用场景：构建作品集或演示网站。
核心优势：可以获得一个任何人都可以访问的公共 URL。

选项二：Streamlit in Snowflake

当你的应用需要保持私密性时，应选择 Streamlit in Snowflake。这在你处理敏感数据或需要控制访问权限时非常理想。

适用场景：处理敏感数据或需要严格控制访问权限的内部应用。
核心优势：应用在你的 Snowflake 账户内安全运行，让你能完全控制访问权限。

其他部署方式与推荐

当然，也存在其他部署 Streamlit 应用的方式，例如 Replit 和 Vercel 是创建免费网络应用的好工具。但出于安全性和易用性的考虑，我们推荐坚持使用 Streamlit Community Cloud 或 Streamlit in Snowflake。

在 Snowflake 中，你可以获得对 Python 应用的原生支持，并且安全选项是专门为 Snowflake 集成而构建的。这意味着你可以通过用户角色来保护敏感数据并控制访问权限。

因此，虽然有很多其他工具可以实现部署，但当你构建一个连接到实时数据的生成式 AI 原型时，Snowflake 和 Streamlit Cloud 的组合是更明智的选择。

关于应用隐私设置的说明

当你将应用部署在 Streamlit Community Cloud 上时，你的代码可以保持私有，但应用本身的工作方式略有不同。应用设置菜单中，你可以选择应用是私有还是公开。

你将在后续视频中了解这两种选项，但现在需要知道一个重要信息：每个账户只能拥有一个私有应用。因此，如果你选择私有路线，请谨慎决定。

总结

本节课中，我们一起学习了在 Snowflake 上部署 Streamlit 应用的不同方式。你了解了何时应保持应用内部化和安全，以及何时适合公开分享。现在你已经了解了整体情况，可以根据应用的目标用户和使用方式来选择正确的选项。现在，你可以继续前进，专注于构建一个既强大又易于分享的应用。

033：在 Snowflake 内部部署原型 🚀

在本节课中，我们将学习如何将已完成的雪崩（Avalanche）原型应用部署到 Snowflake 平台内部。通过本次学习，你将能够创建一个可供同事安全访问并提供反馈的内部应用。

概述

上一节我们完成了应用的开发，本节我们将专注于部署。我们将把完整的情绪分析仪表板部署到 Snowflake 中，使其成为一个内部应用，同事可以根据他们的数据行权限进行访问。

部署已完成的应用程序

以下是部署步骤：

首先，你需要获取应用代码。你已经在 Snowflake Notebook 中创建了一个可直接运行的 Streamlit 应用。该应用的代码可以在以下链接的 GitHub 仓库中找到。请下载包含情绪分析仪表板代码的 streamlit_app.py 文件。

接下来，登录你的 Snowflake 账户，使用 Snowsight 在内部部署应用。在左侧导航栏中选择“Projects”，然后选择“Streamlit”。在右上角，点击蓝色的“+ Streamlit App”按钮。

“创建 Streamlit 应用”窗口将会打开。在弹出窗口中，为你的应用命名。在“App location”下拉菜单中，选择你在之前视频中创建的 avalanche_db 数据库和 avalanche 模式。选择默认的计算仓库。点击“Create”来初始化新的 Streamlit 应用。

配置与运行应用

创建后，你将进入 Streamlit 编辑器，其中代码和应用并排显示。在编辑器中，你会看到一些默认的“Hello World”代码。删除编辑器中的所有现有代码。复制你下载的 streamlit_app.py 文件中的所有代码，并将其粘贴到编辑器中。

在运行应用之前，你需要添加必要的包。这个脚本使用了 matplotlib 和 snowflake-ml-python。因此，在左上角选择“Packages”，输入 matplotlib 和 snowflake-ml-python 并选中它们。点击编辑器中的“Run”按钮来部署你的应用。

应用预览将出现在编辑器的右侧窗格中。应用加载完成后，它将在 Snowflake 内部实时运行。并排的编辑器和预览屏幕允许你在修改代码时实时查看变化。

当在 Snowflake 中运行 Streamlit 应用时，你对代码的更改会立即出现在预览窗格中。你的应用运行起来应该类似这样。

理解 Snowflake 的集成优势

你的应用使用了 Snowflake 内置的连接方法。这自动处理了以下事项：通过你当前的 Snowflake 会话进行身份验证、基于行的访问控制（RBAC）以确保数据安全，以及为其 SQL 查询提供自动会话管理和连接池。

如果你不熟悉这些术语，不用担心，我们稍后会进行更详细的解释。但既然你在 Snowflake 中工作，它会为你处理好这些事情。你的应用现在已在内部部署，并准备好与同事分享。

分享与安全控制

要分享你的应用，请点击 Streamlit 应用右上角的“Share”按钮。你将获得一个 Web 链接，Snowflake 平台上的同事可以使用它来访问你的应用。

通过基于行的访问控制（RBAC）与其他 Snowflake 账户用户分享你的应用。这意味着访问权限由现有的 Snowflake 权限和角色控制。用户需要访问底层数据库和模式才能查看数据。该应用在你的 Snowflake 环境中保持安全。

对于雪崩应用，这意味着有权访问 avalanche_db 和 avalanche 模式的用户可以查看该应用。任何具有管理员权限的人都可以修改应用设置和权限，数据访问将遵循现有的 Snowflake 安全策略。

监控性能与成本

当你在 Snowflake 中部署 Streamlit 应用时，它会通过虚拟仓库消耗计算资源。你的应用需要一个仓库来对数据执行 SQL 查询。当用户活跃使用你的应用时，仓库保持活动状态，每个用户会话都可能通过数据加载、过滤、聚合等操作触发多个查询。

因此，你的仓库大小直接影响性能和成本。为了监控性能，有几个关键指标需要关注，例如：你的仓库容量使用了多少、单个查询完成需要多长时间、运行仓库随时间产生的成本、同时使用你的应用的人数。

Snowflake 提供了多种工具来从 Snowsight 内部跟踪你的应用性能。要检查查询历史记录，请转到“Activity”，然后选择“Query History”。这将显示你的 Streamlit 应用执行的每个 SQL 查询，并可以帮助你监控查询持续时间、执行时间、使用的仓库和计算量、消耗的积分以及执行计划。

要从 Snowsight 检查仓库使用情况，请转到“Admin”，然后选择“Warehouses”。“Warehouses”工具显示实时和历史仓库性能，帮助你更好地了解空闲时间、队列深度、平均执行时间和随时间变化的积分使用情况。

“Admin”面板还有一个名为“Resource Monitors”的工具，它将显示成本控制和使用情况警报。这可以帮助你为仓库设置支出限制、在达到阈值时收到警报，并自动暂停仓库以控制成本。

建立定期审查流程

如果你的原型最终成为我们都希望的那种绝妙想法，那么建立一个每周审查流程来监控你的应用使用情况是个好主意。

以下是建议的每周检查事项：

检查查询历史记录：识别缓慢或昂贵的查询。
分析模式：寻找可以缓存以提高效率的重复操作。
审查仓库使用情况：确保仓库大小与实际负载相匹配。
测试优化：通过实施小的更改并测量其影响。
监控结果：跟踪性能指标的改进。

这种监控方法有助于你维护一个经济高效、高性能的 Streamlit 应用，同时确保访问内部仪表板的同事获得良好的用户体验。

提升用户体验的技巧

以下是部署原型时提升用户体验的一些技巧：

提供清晰的导航和说明。
包含有用的工具提示和描述。
确保响应式设计以适应不同的屏幕尺寸。
在推出前使用不同的用户角色和权限进行测试。

总结

至此，你的应用已在 Snowflake 上成功运行。恭喜你！你已成功使用 Streamlit 在 Snowflake 上部署了情绪分析仪表板。你在 Snowflake 的内部部署为完善仪表板提供了完美的测试环境，并确保其已准备好进行更广泛的公开访问。

034：部署至 Streamlit 社区云 🚀

在本节课中，我们将学习如何将你在 Snowflake 上构建的雪崩数据仪表板原型，部署到 Streamlit 社区云。这将使你能够通过分享一个链接，轻松地与其他人共享你的项目。

概述

上一节我们完成了应用的本地开发。本节中，我们将把应用部署到云端，使其成为一个可公开访问的网页应用。整个过程主要涉及将代码上传至 GitHub，并在 Streamlit 社区云上进行配置。

准备工作

在开始部署之前，你需要完成几项准备工作。

以下是部署前的必要步骤：

创建 Streamlit 社区云账户：如果你还没有账户，请前往 Streamlit 社区云网站注册，并使用你的 GitHub 账户登录。
创建新的 GitHub 仓库：与模块 1 的做法类似，为你要部署的应用创建一个全新的 GitHub 仓库。请为仓库选择一个独特的名称。
上传项目文件：在你的新 GitHub 仓库中，点击“上传现有文件”，然后将整个课程文件夹（包含 streamlit_app.py 和 requirements.txt）上传至此。上传完成后，点击“提交更改”。

你的文件现已准备就绪，可以开始部署。

部署应用到 Streamlit 社区云

接下来，我们将把 GitHub 仓库中的应用部署到 Streamlit 社区云。

以下是部署的具体操作步骤：

登录 Streamlit 社区云。
点击右上角的“创建应用”或“新建应用”按钮。
选择“从 GitHub 部署一个公共应用”。
在表单中，选择你的 GitHub 用户名以及对应的仓库名称。
分支保持为 main，并确保主文件路径指向你的 Streamlit 应用文件（通常是 streamlit_app.py）。
为你的应用选择一个唯一的子域名，或使用自动生成的网址。
点击“部署”按钮。

Streamlit 将开始构建你的应用，这个过程可能需要几分钟。

配置 Snowflake 数据库连接

由于你的应用需要从 Snowflake 数据库拉取实时数据，因此必须在云端配置访问权限。

以下是配置数据库连接的步骤：

在部署的应用页面，点击右下角的“管理应用”。
点击右上角的“三个点”图标，然后选择“设置”。
在左侧边栏中，点击“Secrets”。
在出现的“Secrets”文本框中，添加你的 Snowflake 凭据，格式如下：

[snowflake]
user = "你的用户名"
password = "你的密码"
account = "你的账户标识符"
warehouse = "你的仓库名"
database = "你的数据库名"
schema = "你的模式名"

注意：请务必将所有信息替换为你自己的凭据。你的账户标识符是你登录 Snowflake 时在浏览器地址栏看到的部分。如果找不到，请查阅 Snowflake 官方文档。

保存更改后，应用将自动刷新，并开始使用来自 Snowflake 数据库的实时数据。

常见问题排查

如果你的应用没有按预期工作，可以尝试以下常见的修复方法。

以下是问题排查清单：

应用无法启动：检查所有文件是否已正确上传到 GitHub，并确保 requirements.txt 文件中没有拼写错误。
无法连接 Snowflake：在“Secrets”部分仔细核对你的账户标识符、用户名和密码。同时，确认仓库名和数据库名的拼写完全正确。

总结

本节课中，我们一起学习了如何将 Streamlit 应用从本地原型部署到 Streamlit 社区云。我们完成了从准备 GitHub 仓库、执行部署到配置云端数据库连接的全过程。现在，你的数据仪表板已经成为一个可以通过链接分享的在线应用了。接下来，请亲自尝试部署你的应用吧。

035：原型部署实践 🚀

在本节课程中，我们将学习如何将之前学到的提示工程、数据连接、UI设计和生成式AI知识结合起来，完成应用的部署。你将学会如何在Snowflake内部安全地部署应用，以及如何在Streamlit社区云上公开部署。我们还将涉及如何监控应用状态、控制访问权限，以及利用生成式AI工具来促进团队协作。

在 Snowflake 内部安全部署

上一节我们介绍了应用开发的核心概念，本节中我们来看看如何将完整的“雪崩”原型部署到Snowflake环境中。

首先，打开Snowflake并导航到“项目”下的“Streamlit应用”部分。

点击右上角的蓝色“+ Streamlit应用”按钮。

为你的应用命名，例如“Avalanche prototype”。选择你的“avalanche”数据库和“avalanche”模式。

点击“创建”进入编辑器。删除默认的“Hello World”示例代码。

然后，从你的本地streamlit_app.py文件中复制所有代码，并粘贴到编辑器中。请确保你的代码使用st.connection()或st.get_active_session()来建立连接。记住，当你在Snowflake内部部署时，这些函数会自动处理身份验证和访问权限。

点击“运行”来启动你的原型。

你的应用现已上线，并可在Snowflake内部查看。

接下来，点击“分享”获取一个链接，你可以将此链接分享给团队成员。

监控与优化应用性能

部署完成后，确保应用运行顺畅至关重要。以下是监控和优化应用性能的几个关键步骤：

首先，检查查询历史记录，查看查询耗时以及正在运行的操作。

其次，监控仓库使用情况，以跟踪成本、负载和空闲时间。

然后，设置资源监视器以获取警报并管理支出。

专业建议：每周进行一次审查，查找运行缓慢的查询、可以缓存的冗余操作以及高成本的计算峰值。

如果你想进一步提升，可以使用生成式AI应用来帮助你起草文档、建议代码改进、生成入门指南并修复性能问题。

在 Streamlit 社区云公开部署

现在，让我们将你的应用公开给全世界。

首先，创建一个新的公开GitHub仓库，并上传以下文件：

streamlit_app.py
requirements.txt
streamlit_config.toml
以及任何相关的数据文件夹或文件。

通过终端，首先登录到 streamlit.io/cloud，并选择使用GitHub登录的选项。

然后，点击“创建应用”。选择你想要部署的仓库，并指向streamlit_app.py文件。

现在，你可以点击“部署”。应用启动并运行后，你可以通过点击应用右上角的三个点来访问应用管理菜单。

从应用管理菜单的下拉列表中，选择“管理应用”。在出现的侧边栏上，点击“设置”。这将打开你的应用设置面板。

现在，点击“Secrets”来添加你的Snowflake登录凭据，以便Streamlit可以始终访问你的数据。粘贴以下代码块，但请务必将其更新为你自己的登录信息。

# .streamlit/secrets.toml
snowflake_account = "your_account"
snowflake_user = "your_username"
snowflake_password = "your_password"
snowflake_warehouse = "your_warehouse"
snowflake_database = "avalanche"
snowflake_schema = "avalanche"

完成后，点击“保存”。你的应用将自动重新加载并使用新的凭据。

测试与最终检查

为了在Streamlit社区云上测试和监控你的应用，请访问你部署的应用URL。这通常类似于 https://your-app-name.streamlit.app。

在将原型发送给其他人之前，自己测试应用总是一个好主意。快速检查以确保每个标签页和小部件都能正常工作。

然后，进入你的设置菜单，点击“管理应用”->“日志”以检查是否存在任何问题。在同一个菜单下的“分析”部分，你稍后可以查看使用情况统计信息。

现在你的应用已经部署完成，你将能够快速迭代并使其变得更好。

总结

本节课中我们一起学习了如何将你的“雪崩”原型安全地部署在Snowflake内部，并公开部署到Streamlit社区云上。你现在可以将链接分享给你的团队，将其添加到你的作品集，发布到LinkedIn或X上。最重要的是，开始收集反馈以便在下一个实验中进行迭代。在下一课中，你将学习如何收集和优先处理反馈，以使你的应用变得更好。但现在，请享受这个胜利的时刻。你已经将你的想法变成了现实。

036：快速迭代方法论 🚀

在本节课中，我们将学习一种适用于生成式AI应用开发的快速迭代方法论。这种方法强调快速构建、快速测试和快速改进，而非追求初始的完美。

概述

在迭代改进原型时，开发者投入大量精力来构建和部署初始版本。拥抱快速实验的精神对此大有裨益。人工智能技术使得构建应用的速度变得极快。开发者可以在几天甚至几小时内编写一个提示词并完成部署。这意味着可以尝试大量想法，摒弃不佳的，保留优秀的。

核心原则：速度至上

以下是关于AI开发的惊人事实：开发者可以比以往任何时候都更快地构建应用。

如果开发者只有一个小时，那么就将范围缩小到能在一小时内完成的事情上。即使在短时间内，所能实现的可能性也会令人惊讶。让某个功能运行起来，即使它很粗糙，也总比什么都没有要好。不要花费数周时间进行规划，直接构建一个能工作的东西，然后观察它在哪里出现问题。

与传统方法的区别

这种方法可能与传统的编程最佳实践相悖，但对于生成式AI而言，它能帮助开发者更快地进入市场。因为开发者是通过实践而非空想来发现问题。

例如，在构建客户服务聊天机器人时，客户不会花费数月时间来设计完美的对话流程。只需构建一个能回答公司收到的五个常见问题的基本版本，然后观察用户在何处感到困惑或沮丧。

构建最小可行产品

可以将其类比为烹饪：边做边尝。不要等到整餐饭都做完才判断是否需要加盐。开发者此刻构建的并非最终产品，而是一个用于测试想法的简单版本。这就是最小可行产品——能让开发者了解所需知识的最简版本。

这引出了一个关键问题：原型何时才算足够好？

“完成优于完美”的理念

原型只需要足够好地运行，以测试核心想法并获得反馈。专注于高效地交付80%的核心功能，然后让反馈来指导剩余的部分。

与用户闭环

与用户形成闭环至关重要，但这一点常被忽视。告诉用户你根据他们的反馈做出了哪些更改。向他们发送更新、撰写发布说明或在应用中展示。这能建立信任，并让他们愿意继续提供帮助。

团队协作与知识共享

确保整个团队都知道你发现了什么。将信息放在每个人都能访问的地方，以避免重复犯错。可以将其发布在社交媒体平台、代码托管网站等任何能获得关注和额外见解的地方。

持续改进

开发不是一蹴而就的事情。成功者正是那些持续倾听并持续改进的人。竞争对手也在不断进步，因此开发者需要保持领先。当今时代，成功的关键在于速度：快速构建、快速获得反馈、快速改进，而不是追求完美。

总结

本节课中，我们一起学习了生成式AI应用的快速迭代开发方法论。其核心在于快速构建 → 获取反馈 → 快速改进的循环，而非追求初始的完美。每一次反馈和改进的循环都让开发者更接近用户真正想要的产品。掌握这个循环的开发者将会取得成功。因此，请从小处着手，快速行动，并始终将用户置于所做一切的中心。

037：即时反馈机制 🚀

在本节课中，我们将要学习如何为你的应用快速获取用户反馈。完成比完美更重要，而实现这一点的最佳方式之一就是快速获得反馈。当你能够快速构建出产品时，等待数天才能获得反馈会显得极其缓慢。你获取反馈并据此行动的速度越快，你就能越快构建出人们真正想要使用的东西。

概述

现在，是时候快速行动并学习了。最重要的部分是获取真实的用户反馈。早期获取反馈的策略通常更侧重于定性反馈，这对于激发新想法和理解用户痛点非常有价值。然而，并非所有反馈都同等重要。因此，让我们来看看一些简单而高效、有策略地收集反馈的方法。

高效收集反馈的策略

上一节我们介绍了快速获取反馈的重要性，本节中我们来看看具体如何操作。以下是几种有效的反馈收集方法：

1. 从目标用户群开始

首先，找一小群人，最好是你的目标用户群体。你可以通过社交媒体、专业网络，甚至从现有客户群中寻找测试者。

2. 进行“5秒测试”

在你解释应用功能之前，先向他们展示界面5秒钟。然后问他们：“你记住了什么？你认为这个应用是用来做什么的？”这可以检验你最重要的功能是否突出且令人难忘。

3. 在关键时刻收集反馈

在用户刚刚使用完你的功能时抓住他们，例如他们刚刚完成购买、结束教程或尝试了新功能。此时他们的体验记忆犹新，因此反馈会更具体、更有用。

4. 聚焦核心用户旅程

识别出你应用中最重要的用户旅程，并只测试那条路径。例如，在你的雪崩分析原型中，应用需要做的最重要的事情就是对输入数据进行情感分析。因此，请你的测试者选择一个日期范围并设置产品，然后查看结果。就这么简单。在核心工作流程完善之前，忽略其他一切。

5. 提出具体问题

不要问宽泛的问题，如“你觉得怎么样？”，试着问能给你提供具体功能信息的问题，例如：“这个按钮容易找到吗？”或“这个功能如何帮助你解决问题？”开放式问题鼓励测试者提供详细的见解，但也可以加入一些评分量表以便于分析。

6. 观察用户自然行为

观察用户在其自然状态下如何使用你的应用。注意他们做事的顺序、在哪里卡住、是否需要为了使用应用而在应用外做很多事情。这是一个重要的发现点。例如，如果用户在上传文件到你的应用之前需要进行大量编辑，这就是一个需要改进的信号。

7. 进行“出声思考”测试

当人们试用你的应用时，试着请他们大声说出自己的想法。这是发现诸如“我在找提交按钮，但它不在我以为的地方”这类问题的好方法。如果你能记住所有反馈当然好，但也可以询问他们你是否可以做笔记。

8. 尝试“咖啡店测试”捷径

如果传统方法耗时太长，可以使用这个捷径。方法很简单：带上你的笔记本电脑，找到同事、朋友，甚至咖啡店里的陌生人，然后问：“嘿，你能花30秒看看这个，然后告诉我你的想法吗？”如果做得好，这种非正式的方法可以成为有价值的、可操作的反馈来源。

总结

本节课中，我们一起学习了多种快速获取用户反馈的策略。记住，持续构建、持续迭代、持续获取宝贵的反馈是产品成功的关键。请跟随我到下一个视频，学习如何根据反馈采取行动。

038：反馈响应策略 📝

在本节课中，我们将学习如何有效地收集、分析和响应原型开发过程中获得的用户反馈。我们将探讨如何区分反馈的优先级，并采取快速行动来改进你的应用。

有许多快速且简单的方法可以为原型有效收集反馈。但并非所有反馈都有用，例如有人不喜欢你的配色方案，或者希望添加对更广泛受众无用的功能。本视频将介绍如何对反馈进行优先级排序并采取行动的策略。

首先，将反馈分类到不同的类别中，例如错误报告、功能请求或可用性问题。这不仅能帮助你了解用户的要求，还能理解他们提出这些要求的原因。

当用户说你的应用“很慢”或“某个功能不工作”时，不要只是猜测问题所在。要像侦探一样思考，系统地调查以找到真正的问题。不要惊慌失措地试图一次性修复所有问题，而要变得有条理。将问题分解成更小的部分。问问自己：是只对新用户慢，还是对回访用户也慢？是移动端用户比桌面端用户更受影响吗？通过这种方式分解问题，你可以精确定位导致问题的根源。

对于快速原型开发，你的测量方法应该和你的构建速度一样快。尝试以下快速验证方法：

观察少量用户测试你更新后的原型。即使是五个用户也能发现主要问题。
向近期用户发送一个简短的调查，询问一个关于你所做更改的具体问题。
检查你的基本分析数据，看看用户行为是否朝着你期望的方向转变。
设置简单的A/B测试，让一半用户看到旧版本，另一半看到新版本，然后比较他们的行为。

目标不是统计上的完美，而是获得一个清晰的信号，判断你是否在朝着正确的方向前进。

现在，我们已经到了反馈不一定只来自人类用户的阶段。让AI帮助你编码。像 Github Copilot 和 Cursor 这样的工具可以为你编写代码，帮助你调试问题，并自动化枯燥的任务。要擅长“提示”。你越能清楚地告诉AI你想要什么，你得到的帮助就越好。这是一项值得培养的技能，因为它可以极大地加快你的工作速度。在下一个视频中，你将了解更多相关内容。

对于复杂问题，尝试智能体工作流。将问题分解为步骤，并让AI处理每个部分。这种方法比试图一次性解决所有问题能带来更好的结果。

系统地跟踪反馈。使用能帮助你自动收集和组织用户反馈的工具。这为你提供了快速做出明智决策所需的数据。

现在，让我们看看你从“雪崩”公司的同事那里得到的一些反馈：

“我询问了关于数据的问题，但它给了我错误的答案。”
“它似乎不太了解我们公司的产品线。”
“如果我们可以选择其他数据集来分析就好了，我甚至没看到上传按钮。”

你如何决定在推出原型之前，需要对这些评论中的哪些（如果有的话）采取行动？关键在于找到易于实现、可以快速添加的功能。记住你在构建MVP时使用的“必须有”与“最好有”决策框架。你可以使用类似的过程来优先处理反馈，使用一个影响度 vs. 实施难度矩阵。

这个框架帮助你首先关注高影响、低难度的更改，这些是你的“速赢”机会。你可以使用影响度-难度矩阵来优先处理“雪崩”的反馈。例如：

提供关于数据的正确答案：对于你的原型来说，这是高影响、低难度的“速赢”。
添加选择其他数据集的能力：对于一个原型来说，可能是低影响，并且需要更多努力，因此目前可以跳过。

你刚刚经历的反馈 -> 优先级排序 -> 构建 -> 验证的循环，是驱动成功产品的引擎。你转动这个轮子的速度越快，你就能越快创造出真正能引起受众共鸣的东西。

请记住，每一条反馈都是一份礼物，但并非每份礼物都需要立即拆开。保持专注，保持快速，并持续构建。

本节课中，我们一起学习了如何系统化地处理原型反馈。我们介绍了将反馈分类、像侦探一样调查问题根源、采用快速验证方法，以及利用AI工具和影响度-难度矩阵来优先处理高价值任务。掌握这个快速迭代的循环，将帮助你高效地改进产品，使其更符合用户需求。

039：雪崩应用的迭代优化循环 🔄

在本节课中，我们将学习如何将用户反馈转化为有意义的改进，从而避免原型被废弃。我们将掌握一套系统的方法，从用户视角测试应用、快速收集可操作的反馈、根据影响力和工作量确定改进优先级，并利用AI工具加速迭代过程。

你的原型已经上线。用户正在试用，反馈也随之而来。

现在该怎么办？大多数原型失败，并非因为它们本身有问题，而是因为开发者不知道如何将用户反馈转化为有意义的改进。他们要么完全忽略反馈，要么试图一次性修复所有问题，结果什么都没改好。

从用户视角测试应用 👀

上一节我们讨论了原型上线后的反馈现状，本节中我们来看看如何从用户视角进行测试。

首先，打开你已部署的雪崩应用。你可以通过 Snowflake 的 Streamlit 界面或 Streamlit Cloud 访问它。假设你是雪崩公司的品牌经理，你的业务目标是回答这个问题：客户对我们的冬季产品线有何看法？

以全新的眼光浏览你的应用并进行评估：

你能否快速找到情感分析功能？
结果是否以易于理解的格式呈现？
不熟悉你数据的人是否知道下一步该点击什么？

这种视角转换有助于你在真实用户遇到问题之前，就发现可用性问题。

评估第一印象与核心用户旅程 🧭

在明确了用户视角的重要性后，接下来我们具体评估应用的第一印象和核心使用流程。

向某人展示你的应用五秒钟，然后立即询问他们：

你认为这个应用是做什么的？
什么最吸引你的注意？
你能弄清楚下一步该做什么吗？

这个测试评估的是第一印象。你的核心功能应该一目了然，而不是隐藏或令人困惑。如果你独自工作，可以截取应用截图，通过短信或 Slack 发送给朋友，请他们只看五秒钟并回答同样的问题。

确定你应用中最重要的单一用户旅程。对于雪崩应用，这可能是：加载仪表板 -> 运行情感分析 -> 解读结果。计时走一遍这个流程，注意你在哪里会放慢速度或犹豫。问自己：这个流程中有什么令人困惑或别扭的地方吗？说明文字是否清晰且可操作？布局是否有效地支持了这个主要任务？

请记住，你不是在测试所有功能，而是专注于这一个关键工作流程，以保持测试的快速和集中。

收集与分类反馈 📋

测试完成后，我们会得到大量信息。以下是整理这些反馈的有效方法。

打开一个笔记应用或拿一张纸，创建以下三个分类：

Bug（错误）：任何损坏或无法工作的部分。
可用性问题：功能可以工作，但感觉笨拙或令人困惑。
功能创意：未来开发中值得添加的“锦上添花”的功能。

对于你识别的每个项目，问自己：什么是高影响力但低工作量就能修复的？我现在能在30分钟内改进什么？ 这些就是你的“快速胜利点”。专注于立即解决其中的一两个。

利用AI工具加速迭代 ⚡

识别出需要改进的问题后，我们可以借助强大的AI工具来加速修复过程。

如果你识别出需要修复的问题，可以利用AI工具来提供帮助：

针对内容问题：使用 GitHub Copilot、ChatGPT 或 Claude 来重新措辞令人困惑的标签或工具提示。可以请求AI重写提示模板以提高清晰度，或请求帮助清理代码块。
针对用户体验：使用 Snowflake 中的 Jupyter 助手选项卡来测试回答用户问题的新方法。可以请求AI建议替代的图表类型或数据可视化方式。

你并不是在构建一个新应用，而是在打磨和完善你已经创建的东西。

闭环反馈与持续改进 🔄

完成初步优化后，迭代循环的最后一步是关闭反馈环，这能培养用户忠诚度。

如果在测试过程中有人提供了反馈，请告诉他们你做了哪些更改。一条简单的信息，例如：“嘿，根据你的反馈，我让那个图表更容易阅读了。再次感谢你的建议！”这种方法可以将临时的测试者转变为你的应用的长期用户和倡导者。

一个被持续使用的原型和一个被遗忘的原型之间的区别，往往取决于上线后发生的事情。让我们确保你的原型属于前者。

在下一节视频中，我们将探讨如何通过更好的提示设计技术，更快地改进你的生成式AI结果。

本节课中我们一起学习了如何系统化地处理用户反馈以优化应用原型。我们掌握了从用户视角测试、评估第一印象、梳理核心流程、分类反馈优先级，并利用AI工具高效实施改进的方法。关键在于快速识别并实施“高影响力、低工作量”的改进，形成持续的迭代优化循环，从而确保你的原型能够持续吸引用户并创造价值。

040：提示词优化技巧 🚀

在本节课中，我们将要学习如何通过优化提示词来加速生成式AI应用的开发流程。我们将深入探讨提示词工程的核心技巧，这些技巧能将数小时的编码工作转化为几分钟的智能提示，从而帮助你快速构建、测试并迭代你的应用原型。

在现代开发周期中，速度至关重要。你需要尽快从想法过渡到可测试的原型，然后收集用户反馈，并根据所学进行迭代。本节视频将深入探讨AI驱动的开发，并展示如何设计提示词，以加速你的原型开发速度。

为什么提示词工程对快速原型开发至关重要

在快速原型开发中，你是在与时间赛跑。你需要快速构建一个可工作的原型，用真实用户进行测试，收集反馈，快速实施更改，并重复这个循环。糟糕的提示词会在每一步造成瓶颈。

一个模糊的提示词可能给你80%正确的代码，但修复最后20%可能需要数小时。一个精心设计的提示词能让你完成95%的工作，让你专注于用户反馈，而不是调试。

当用户给你诸如“图表令人困惑”或“我找不到导出按钮”的反馈时，你需要迅速将这些反馈转化为代码更改。有效的提示词让你能够直接将用户反馈转化为给AI助手的具体技术指令。

例如，与其纠结于“让它更直观”这样的用户反馈，你可以设计一个提示词：“你是一位专注于用户体验的Python开发者。用户说图表令人困惑。请重写这段图表代码，使其包含：清晰的坐标轴标签、解释每条线代表什么的图例、显示精确数值的悬停提示，以及解释图表内容的标题。”这能在几分钟内将模糊的反馈转化为可执行的代码更改。

构建高效提示词的四大核心组件

每个强大的提示词最多包含四个构建模块。理解这些组件对于快速原型开发至关重要，每个组件在帮助你从想法快速过渡到工作代码方面都有特定作用。

具体指令
模糊的指令会浪费时间。你会得到无法解决具体问题的通用代码，迫使你花费数小时修改它。例如，与其说“制作一个应用”，不如尝试“构建一个Streamlit应用，用于分析PDF研究论文并回答相关问题”。当需要整合用户反馈时，同样要具体，例如“为分析结果添加一个下载按钮”，而不是“让它更有用”。
上下文
上下文能防止AI做出减慢你速度的假设。没有适当的上下文，你可能得到React代码，而你需要的却是Streamlit；或者得到Python 2语法，而你使用的是Python 3。上下文包括两个关键要素：
- 角色设定：赋予AI一个专业的身份和专长水平。例如，“你是一位有丰富Streamlit应用开发经验的Python开发者”。这消除了基础解释，并为你提供生产就绪的代码。
- 约束与要求：帮助定义项目的规则。指定Python版本、部署平台或技术限制，并包含公司指南或合规要求，例如“你的应用必须在移动设备上运行”或“仅使用Python 3.9”。这样，当用户在特定平台上报告问题时，你可以快速将这些约束添加到提示词中。
具体输入数据
提供具体的输入数据能让你立即获得可工作的代码。与其得到通用示例，不如获得适用于你实际数据的代码。你可以通过以下方式实现：
- 提供AI将处理的具体内容，如你想要修改或扩展的特定代码片段。
- 提供示例的数据格式，添加样本文件或数据集。如果用户报告你的应用在处理某些文件类型时崩溃，你可以在提示词中包含有问题的文件格式，以获得正确处理它的解决方案。
  可以将其理解为给别人烹饪指令与同时给他们指令和具体食材之间的区别。
输出指示器
输出指示器对速度至关重要。没有它们，你会在需要代码时浪费时间解析解释，或者在需要即时解决方案时得到教程。明确说明你希望响应如何结构化。例如，“仅返回可工作的Python代码”、“格式化为JSON”或“提供一个单独的Python文件”。当你需要快速整合用户反馈时，你可以精确指定所需内容，例如“仅返回修改后的函数，而不是整个文件”或“仅显示所需的CSS更改”。

加速原型开发的策略

以下是专门设计用于加速原型开发和反馈整合过程的策略。

上一节我们介绍了高效提示词的组件，本节中我们来看看如何运用策略来组织它们。

从简单开始，然后迭代
这反映了快速原型开发的理念：先快速做出能工作的东西，然后根据用户反馈进行改进。不要试图一次性构建所有功能。首先创建一个基本版本，然后逐步完善。这种方法让你能更好地控制开发过程，获得更可靠、可迭代的结果，以及更快的反馈循环。

将复杂任务分解为更小的提示
当用户给出反馈时，你通常需要更改应用的多个部分。更小、更聚焦的提示让你能够快速且安全地进行这些更改。因此，与其使用一个庞大的提示词，不如创建一系列聚焦的请求：

你的第一个提示词应描述基本的应用结构。
第二个提示词可用于添加特定功能。
第三个提示词是实现错误处理的好地方。
第四个提示词可用于优化性能。

例如，如果用户报告应用运行缓慢且图表令人困惑，你可以用单独的提示词来处理这些问题：

提示词1：优化此数据加载代码以提高性能。
提示词2：改进这些图表可视化以提高清晰度。
你不必完全遵循此布局，但按照你通常编码的逻辑顺序进行提示，有助于获得你想要的结果。

设置防护栏以保持代码一致性
在基于反馈进行迭代时，防护栏能保持你的代码一致且可维护。使用这些防护栏让AI的回答保持在正轨上：

告诉AI要避免什么：这可以防止AI引入可能破坏你现有原型的不必要的复杂性或依赖项。
在需要时要求推理：帮助你理解为何进行更改，这在快速迭代且需要保持控制时至关重要。
使用一致的术语：确保在你根据不同的反馈进行多次更改时，你的代码库保持连贯。
维护你的编码标准：即使在进行快速更改时，也有助于保持代码的可读性和可维护性。
这些防护栏在快速原型开发中尤为重要，因为你正在快速进行更改，需要确保每次迭代都建立在前一次的基础上，而不会引入不一致或技术债务。

一个高效提示词的实例分析

让我们分析一个结构良好的提示词，看看它为何如此有效。

提示词示例：

你是一位经验丰富的Python开发者，专注于构建Streamlit应用。请创建一个Streamlit应用，实现以下功能：
1.  从用户上传的PDF文件中提取文本。
2.  使用OpenAI API总结提取的文本。
3.  在Streamlit界面中显示原始文本和摘要。
4.  允许用户下载摘要为文本文件。
约束条件：
- 摘要长度限制在300字以内。
- 假设所需的包（streamlit, PyPDF2, openai）已安装。
- 仅使用Python 3.9+兼容的语法。
请将输出作为单个可运行的Python文件返回。

分析：

角色设定（“经验丰富的Python开发者”）设定了技术专长水平，有助于将响应集中在Streamlit特定解决方案上，并消除了更基础的编程说明。
具体指令以详细的逐步说明形式列出，每个要点都成为一个特定的功能。
约束条件明确指定了300字的限制，并告知AI应假设所需包已安装，这防止了它包含安装说明，使响应专注于实现而非设置。它还通过指定使用Python 3.9+语法来确保AI使用正确的库。
输出指示器（“作为单个可运行的Python文件返回”）让你获得可运行的代码，而不是教程或解释。

这个结构化的提示词生成了一个完整的、可工作的Streamlit应用，所有四个功能都已实现并准备运行。相比之下，一个模糊的提示词如“帮我构建一个PDF应用”，你只会得到通用建议，而不是功能代码。

将用户反馈转化为快速代码更新

提示词工程在快速原型开发中变得极其强大的地方在于，它不仅帮助你构建初始应用，还改变了你整合用户反馈的速度。

通过有效的提示词，你可以在几分钟内将用户反馈转化为可工作的代码更新。当你得到诸如“仪表板太杂乱”和“我找不到导出按钮”的模糊反馈时，你可以使用类似以下的提示词来获得直接解决用户反馈的特定代码更新，这些更新可以在几分钟内部署。

反馈转化提示词示例：

用户反馈指出当前仪表板过于杂乱，且难以找到导出按钮。你是一位UI/UX专家。请修改以下Streamlit仪表板代码：
1.  将主要指标卡片重新组织为两列网格布局，以节省垂直空间。
2.  将“导出数据”按钮从侧边栏移至主区域顶部的醒目工具栏中。
3.  为所有交互元素添加工具提示说明。
4.  确保所有更改保持响应式设计。
这是当前的代码：[在此处粘贴当前代码]
请仅返回修改后的代码部分。

一旦掌握了将反馈快速转化为提示词的技巧，你可以使用系统化的方法来持续改进你的原型：

以下是系统化改进原型的四个方向：

快速代码审查：要求你的生成式AI审查你的原型代码，并根据用户反馈建议增强功能。
性能优化：快速识别并修复用户报告的性能问题。
功能扩展：为用户请求的新功能生成多种解决方案。
用户体验改进：将主观反馈转化为具体的UI和UX增强，将“感觉笨拙”等评论转化为具体的界面修改。

这种系统化的方法创建了一个强大的加速开发循环：原型 -> 反馈 -> 改进 -> 重复。

总结

本节课中，我们一起学习了如何通过优化提示词来加速生成式AI应用的原型开发。我们了解到，精心设计的提示词能为你节省数小时的开发时间，让你可以将这些时间用于用户研究、测试和迭代。即使有了完美结构的提示词，有时你仍需要为AI提供额外的上下文，以帮助应对复杂的原型开发挑战。在下一课中，我们将探索提示词增强技术，以进一步扩展你的AI能力。

041：通过数据增强升级原型 🚀

在本节课中，我们将学习如何通过“提示增强”技术，让您的AI应用原型能够基于特定数据集回答问题，而无需更换或重新训练模型。

概述

上一节我们构建了一个基础的聊天机器人原型。本节中，我们将解决用户反馈中提到的问题：“我询问了关于数据集的问题，它给出了错误的答案，而且似乎对我们的产品线知之甚少。” 核心解决方案并非更换更强大的模型，而是通过提示增强，将您的数据直接“喂”给AI，使其能够基于这些信息进行回答。

从通用到具体：提示增强的核心思想

想象一下，要求某人猜测您冰箱里有什么，与直接打开冰箱门让他查看的区别。您当前的AI聊天机器人原型就像那个猜测者，它对“雪崩数据”一无所知。当被问及数据中的产品时，它只能给出通用回答，例如“我无法访问特定的产品信息”。这就像要求某人评论一部他们从未看过的电影。

提示增强就是为您的原型提供一张“小抄”。您不再要求AI仅凭通用知识回答问题，而是将关于您数据的特定信息直接嵌入到每次提问的提示中。

升级您的聊天机器人代码

以下是升级步骤，我们将从上一模块已部署的应用代码开始。

注意：您可以在课程资源库的指定文件路径中找到本视频的起始代码笔记本。代码被分为两个单元格以便于理解。

第一步：导入与数据加载

第一个单元格导入必要的库并加载数据集，这与之前的操作一致。

import streamlit as st
import pandas as pd
# ... 其他必要的导入

# 加载数据集
df = pd.read_csv('avalanche_data.csv')

第二步：改造数据为AI可读格式

因为大型语言模型无法直接读取电子表格或数据库，您需要将数据框转换为AI能理解的格式。您可以使用 df.to_string() 方法，将pandas数据框转换为一个类似格式化表格的字符串。

data_string = df.to_string()

现在，您可以使用这个字符串，将其直接传递到聊天机器人的提示上下文中，帮助AI理解您的数据。

第三步：创建增强提示函数

在这里，您将升级基础聊天机器人。目标是每次用户输入问题时，都包含“雪崩数据”。

此前，您的聊天机器人提示仅仅是用户的文本输入。现在，您将创建一个函数，将该文本输入与一个提示模板以及您刚创建的数据文本版本结合起来。

将 create_avalanche_prompt 函数想象成AI的“简报室”。每次有人提问，您都在给您的生成式AI聊天机器人提供：其工作描述、所需的所有相关信息以及需要回答的具体问题。

工作描述：设定AI作为雪崩数据专家的角色。这使聊天机器人专注于提供与数据相关的答案。
数据上下文：在这里，模板中的占位符（如“雪崩数据”）被替换为您实际的文本格式数据 (data_string)。
问题部分：被替换为用户刚刚输入的问题。

以下是该函数的一个示例：

def create_avalanche_prompt(user_question, data_context):
    prompt_template = f"""
    你是一个雪崩数据集专家。请根据以下数据回答问题。
    数据：
    {data_context}
    问题：{user_question}
    答案：
    """
    return prompt_template

第四步：整合到Streamlit应用

在第二个单元格中，您拥有Streamlit应用的骨架（标题、文本、表格、图表），最后是聊天机器人。现在，您需要修改聊天机器人的部分，使用新的增强提示函数。

您需要将此完整提示传递给模型。这样，每次调用时，提示中都包含完整的数据框内容，因此AI将知道您拥有什么数据，并能够回答相关问题。

# 在Streamlit聊天界面中
if user_input:
    augmented_prompt = create_avalanche_prompt(user_input, data_string)
    # 将 augmented_prompt 发送给您的AI模型（例如通过OpenAI API）
    response = get_ai_response(augmented_prompt)
    st.write(response)

测试与效果

现在您可以运行单元格并测试其工作原理。您刚刚将您的原型从一个为没有答案而道歉的东西，转变为一个能够自信回答关于您雪崩数据问题的工具。

总结

本节课中，我们一起学习了提示增强技术。通过将数据集转换为文本并动态嵌入到每个用户提问的提示中，我们成功升级了AI应用原型，使其能够基于特定数据提供准确答案，而无需改动底层模型。这种方法简单高效，是快速提升原型能力的关键步骤。

在下一视频中，我们将探讨当数据量过大而无法全部放入提示时该怎么办，并学习如何使用RAG（检索增强生成） 技术来解决这一问题。

042：使用RAG提升模型性能 🚀

在本节课中，我们将要学习检索增强生成（RAG）技术。这是一种让大型语言模型（LLM）在回答问题时，能够从外部知识库中查找最新、最相关事实的方法。通过RAG，你的模型将从一个仅依赖训练数据的“知识库”转变为一个懂得实时查阅资料的“研究助手”。

什么是RAG？🔍

上一节我们介绍了LLM应用可能面临的挑战，本节中我们来看看RAG如何解决这些问题。

RAG是一种帮助LLM提供更佳答案的技术。它在生成回复前，先从外部来源检索相关信息。这就像给你的模型配备了一个能为你查找有用事实的助手。

RAG包含两个主要步骤：

检索：它在你的知识库（如一组文档或数据库）中搜索，以找到最相关的信息。这可以包括基于关键词的词汇搜索，或使用向量嵌入的语义搜索。
生成：它将找到的信息注入到大型语言模型中，以生成更准确的回复。

这种组合使你的模型回答更具事实性、相关性，并减少了“幻觉”（即编造信息）的可能性。

为什么需要RAG？🤔

LLM虽然强大，但它们并非无所不知。它们尤其不了解你的最新产品数据、内部政策或医学、法律等专业领域的信息。

使用RAG，你无需重新训练模型来让它变“聪明”。相反，你让它在运行时查找事实。这在准确性、透明度和可信度至关重要的场景中非常理想，例如医学研究或合同法。此外，通过减少提示词长度和避免不必要的模型重训练，它还能让你的应用更便宜、更快。

以下是需要使用RAG的几种情况：

你的知识库太大，无法全部放入提示词中。
你的内容频繁变化，并且你需要实时答案。
你需要为合规性或可信度提供来源引用。
你在医疗保健等准确性至关重要的专业领域工作。
你想使用用户特定数据来提供个性化答案。
你想优化令牌使用以节省成本。

RAG实战：雪崩数据集示例 📊

回到雪崩数据集的例子，假设用户提问：“本月我们的客户对我们的退货政策有何评价？”

如果仅使用提示词，模型将根据其通用训练进行猜测。而使用RAG，它会搜索你最近的雪崩评论，找到最相关的几条，并基于真实的客户反馈给出答案。

以下是其幕后的工作原理：

模型收到用户问题。
你的系统将评论分解成小块，以便它们能放入提示词中。
检索引擎找到最相关的小块。
LLM将该上下文与问题结合，生成一个有根据的答案。

在Snowflake中，这整个过程可以使用Cortex Search来处理，它会为你完成向量搜索、重新排序和检索。你可以在Snowflake文档中阅读更多相关信息。

RAG vs. 微调 ⚖️

RAG在查询时获取新的上下文，而微调则将特定行为内化到模型本身。

微调最适合以下情况：

你需要特定的写作风格或语调。
反复执行相同的任务，例如合同摘要。
需要一致的逻辑或推理。
不想管理外部文档或存储。

然而，微调设置速度较慢，需要带标签的训练数据，并且如果你的数据发生变化，则更难适应。

以下是许多顶级团队使用的成功公式：

使用提示工程来逐步指导模型。
使用RAG来注入相关的事实性上下文。
使用微调来锁定重复性任务的风格、行为或推理。

总结 🎯

本节课中我们一起学习了RAG技术。你现在理解了为什么RAG已成为生产级LLM应用的支柱。它是一个聪明的演示与团队真正信任的应用之间的关键区别。

核心洞见是：不要让你的LLM记住所有东西，而是教会它如何研究。

接下来，我们将使用Snowflake和Streamlit实现一个RAG系统，该系统能够回答关于你的雪崩数据集的问题，并提供引用和置信度。是时候看看RAG的实际应用了。

043：基于Cortex Search构建RAG管道 🚀

在本节课中，我们将学习如何利用 Snowflake 的 Cortex Search 服务来构建一个检索增强生成（RAG）管道。我们将从数据分块开始，到创建搜索服务，最后进行查询测试，完成应用原型的最后一块拼图。

上一节我们介绍了RAG如何提升信息检索的效果。本节中，我们来看看如何将这些理论付诸实践。

理解 Cortex Search

Cortex Search 是 Snowflake 为 AI 应用提供的托管搜索服务。它能自动从你的数据中创建索引和嵌入向量，并提供简单的 API，让你无需自行管理复杂的基础设施，即可构建 RAG 应用。

准备数据

首先，在 Snowflake 中打开一个新的 Notebook，或者按照屏幕上显示的文件路径在 GitHub 仓库中找到代码。在开始新操作之前，先预览 parsed_reviews 表的内容，以检查现有的数据结构和内容。

创建分块数据表

接下来，你将创建一个名为 chunked_content 的新表。以下是创建表的 SQL 语句：

CREATE OR REPLACE TABLE chunked_content (...);

创建表之后，使用 INSERT 语句配合 snowflake.cortex.split_text_recursive 函数。这是一个强大的文本分析函数，能将客户评论文本分割成多个块，以便于后续处理。

INSERT INTO chunked_content
SELECT 
    ...,
    snowflake.cortex.split_text_recursive(review_text, ...) AS chunk
FROM parsed_reviews;

至此，你的数据已完成分块并加载到 chunked_content 表中。通过选择前几行数据快速查看新表，确保分块过程正确执行，数据已为后续分析做好准备。

设置 Cortex Search 服务

现在，是时候使用 CREATE OR REPLACE CORTEX SEARCH SERVICE 来设置搜索服务了。添加以下代码块：

CREATE OR REPLACE CORTEX SEARCH SERVICE my_search_service
ON chunked_content
COLUMNS chunk;

这段代码创建了一个基于你分块数据的搜索引擎，使你可以快速查询文本中存储的特定信息，例如产品评论。

测试搜索功能

最有趣的部分来了：测试你的搜索。在 chunked_content 表上运行一个 SQL 查询，以查找特定内容，例如“所有关于护目镜的评论”。你可以通过将搜索词传递给 SEARCH_PREVIEW 函数来获取匹配结果，如下所示：

SELECT *
FROM TABLE(SEARCH_PREVIEW('my_search_service', 'goggles'));

更好的是，你也可以使用 Python 进行搜索。以下是你需要使用新建的搜索引擎来搜索“护目镜”评论的代码：

首先，一如既往，你需要设置一个 Snowflake 会话连接。

import snowflake.connector

ctx = snowflake.connector.connect(
    user='<user>',
    password='<password>',
    account='<account>'
)

然后，你可以编写一个简单的提示词，创建查询服务，并使用你的提示词并指定要搜索的列来进行搜索。

prompt = "Find reviews about goggles"
query_service = ctx.cortex.search_service('my_search_service')
results = query_service.search(prompt, columns=['chunk'])

你可以将结果格式化为 JSON 并从中提取信息。

import json
formatted_results = json.dumps(results, indent=2)

最后，只需在你的 Streamlit 应用中展示它。

import streamlit as st
st.json(formatted_results)

本节课中，我们一起学习了如何利用 Snowflake Cortex Search 服务构建 RAG 管道。我们从数据分块开始，创建了搜索服务，并最终通过 SQL 和 Python 两种方式测试了检索功能，为生成式 AI 应用原型完成了关键的数据检索部分。

044：集成RAG的聊天机器人 🚀

在本节课中，我们将学习如何将之前分别掌握的 Snowflake 数据分析和 RAG 搜索功能整合到一个强大的应用程序中。这个应用将能够分析客户数据，并即时搜索客户评论。我们将构建一个功能全面的分析工具，并为其聊天机器人注入 RAG 的强大能力。

概述

你已经分别掌握了 Snowflake 数据分析和 RAG 搜索。现在，你将把它们结合到一个强大的应用程序中，该程序能够分析客户数据并即时搜索评论。让我们构建一个出色的应用。你的应用已经可以完成很多工作：一键加载数据、筛选客户信息、显示有意义的图表以及与你的数据对话。你已经创建了一个真正的分析工具。你学习了 RAG 并构建了完整的流程。现在，进入激动人心的部分。

为聊天机器人添加 RAG 功能

上一节我们介绍了数据分析工具的基础功能，本节中我们来看看如何增强其智能对话能力。

想象一下，你的用户可以询问特定产品，并立即从真实的客户评论中获得准确答案。现在是最后的关键一步：将你上节课笔记本中的 RAG 代码添加到你的 Streamlit 应用程序中。你的聊天机器人即将变得非常智能。

实际上，你上节课笔记本中的最后一个单元格已经是一个使用 RAG 服务的可运行 Streamlit 应用。

它唯一缺少的是一个输入窗口，以便你可以输入任何想要的提示，而不是使用应用中硬编码的提示。你已经知道如何使其具有交互性。

整合代码与界面优化

以下是整合和优化应用的步骤。

首先，你可以将此代码添加到现有应用的底部，添加一些标题和标签，或按照你偏好方式进行调整。

随着应用规模扩大，你可能需要进一步组织代码。还记得你如何使用列来并排放置按钮吗？创建选项卡几乎完全相同。你首先创建选项卡，然后使用 with 语句指定每个选项卡中要放置的内容。

一如既往，你可以完全自由地按照自己的方式实现它。

如果你需要任何帮助，可以在 M3/lesson3/lab_two 文件夹中找到一些辅助文件和完整的应用解决方案代码。你可以将这些部分组合起来构建最终的应用。

进阶挑战：添加对话记忆

目前，你的聊天机器人只有金鱼般的记忆，它在每个问题之后会忘记一切。尝试使用会话状态变量添加聊天历史记录，以便用户可以进行真实的对话。

一种方法是修改提示，使其不仅接收数据和问题，还接收聊天历史记录。你需要通过将其存储为会话状态变量来跟踪此聊天历史记录，就像你保存数据集的位置一样。如果你遇到困难，解决方案在同一个文件夹中。

总结

本节课中我们一起学习了如何从基础的 Streamlit 应用进阶到集成 RAG 的高级应用。你已经掌握了全栈技能。现在，你可以快速原型化任何数据应用想法，添加 AI 功能，并将概念转化为可行的解决方案。

在我们的最后一个视频中，我们将讨论你构建了什么、学到了什么，以及最重要的是，接下来可以着手哪些令人兴奋的项目。

045：后续发展路径 🚀

在本节课中，我们将回顾整个课程的学习成果，并探讨在掌握了快速原型开发技能之后，如何规划下一步的发展路径。我们将从已完成的成就出发，展望几个可以深入探索的创意方向。

课程回顾与成就

恭喜你成功抵达终点线。这不仅是本课程的终点，更是你决定接下来要开发任何原型的起点。

让我们花点时间回顾一下你所完成的成就。你从一个想法开始，将其转变为一个完整的原型，涵盖了从数据摄取、分析到用户体验的每一步，并且全程使用了真实世界的数据。你使用 Streamlit 快速构建了精美的前端界面，使用 Snowflake 进行强大的数据处理，并利用 Cortex 通过生成式 AI 为整个应用赋能。

你实践了敏捷开发，将 AI 作为你的编程伙伴，以前所未有的速度编写、调试和改进你的应用。你不仅仅是观察生成式 AI 的运行，更将其融入了你的工作流程。

后续发展路径

现在，你已经成为一名生成式 AI 原型开发能手。接下来该做什么呢？以下是一些启发你思考的想法。

创意一：构建多模态应用

目前，大型语言模型可以接受文本、图像，甚至音频作为输入，有些还支持视频。想象一下这个场景：你录制一段应用使用过程的屏幕录像，然后将其输入给一个模型，并自动请求获取用户体验反馈、文档或下一步功能建议。

创意二：探索 AI 智能体

我们现已进入智能体生成式 AI 的时代。你可以创建行为类似初级开发者的自定义智能体。赋予它们一个角色、一些目标和一种开发风格，然后让它们去开发功能、测试代码或评估应用性能。凭借你在这里建立的 MVP（最小可行产品）优先 的思维方式，你已具备了在这一领域开始工作的绝佳条件。

创意三：将原型转化为产品

无论你构建的是工作项目、副业项目，还是仅仅为了乐趣，你已经学会了如何将一个想法变成一个可运行的生成式 AI 应用。若想从原型走向产品，可以按以下步骤进行：

添加身份验证和权限，以支持真实用户。
集成外部 API，以获取实时数据或触发现实世界的操作。
将洞察转化为功能，基于你的分析开发仪表板、警报或自定义工具。
部署并实现应用盈利，收集用户反馈，并开始对访问权限或洞察分析收费。

凭借你在此构建的基础，你已经成功了一半。下一步就是：让它变得有用，让它变得真实，让它成为你的作品。

总结与展望

AI 将持续快速发展，工具会变，界面会变，模型也会变。但你的思维方式——你所建立的 “构建、评估、迭代、改进、重复” 的原型开发循环——才是让你保持领先的关键。这正是现代软件，尤其是生成式 AI 应用的开发方式，现在也成为了你的开发方式。

那么，接下来做什么？这取决于你。你已经掌握了更快构建更智能应用的技能。所以，请继续开发原型，继续实验，继续让生成式 AI 放大你所能带来的价值。

这仅仅是第一个版本。现在，去让它变得更好吧。

再次恭喜你，你正式成为了一名生成式 AI 原型开发者！🎉

posted @ 2026-03-26 08:12 绝不原创的飞龙阅读(9) 评论(0) 收藏举报

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

DLAI-Streamlit-快速原型开发笔记-全-

DLAI Streamlit 快速原型开发笔记（全）

001：课程介绍与核心理念 🚀

课程概述

与导师的对话

课程内容导览

002：生成式AI应用原型设计入门 🚀

课程目标与结构 🎯

你将学到什么 📚

第一模块重点 🔧

所需工具与技能 🛠️

灵活性与结语 💡

003：原型设计的优势 🚀

什么是原型？🎯

为什么需要原型？💡

一个反面案例：Alex 的故事 ⚠️

原型的成功范例 🌟

004：生成式AI如何革新原型设计 🚀

概述

传统原型设计流程

生成式AI驱动的原型设计

思维模式的转变

降低开发门槛

总结

005：GenAI 原型开发周期 🚀

概述

传统开发与 GenAI 开发的差异

原型开发的核心地位

生成式 AI 应用的核心组件

GenAI 开发周期示例

原型与生产应用的对比

总结

006：避免常见陷阱 🚧

概述

陷阱一：过度设计原型

陷阱二：在获得反馈前追求完美

陷阱三：忽视代码可读性与团队协作

有效测试你的原型

让原型开发更顺畅的简单习惯

总结与核心理念

007：课程项目与数据集介绍 🎯

项目背景与目标

项目阶段概览

数据集介绍

最终应用预览

课程总结

008：确定 MVP 范围 🎯

概述：什么是 MVP？

如何定义你的 MVP

明确你的使命 🧭

了解你的受众 👥

确定你的优先级 ⚡

应用到 Avalanche 项目

从功能到构建计划

总结

009：课程 GitHub 仓库概览 🗂️

概述

仓库结构与内容

如何获取课程文件

文件命名与使用

总结

010：与GenAI共同制定MVP计划 🧠

概述

案例研究：Priya的MVP规划

如何获得更好的规划建议

你的实践：与GenAI共同创建MVP计划

GenAI的擅长与局限

实验任务

总结

011：选择合适的工具 🛠️

概述

思维模式的转变

选择合适的UI工具

选择合适的生成式AI模型

原型技术栈示例

总结

012：环境配置 🛠️

项目结构 📁