如何建立一个超级简单的手写数字识别器
余弦相似度的初学者友好使用
当你开始机器学习时，有几个众所周知的数据集(例如🥀的虹膜数据集)。其中有一个简单、流行和有趣的图像数据集，即由大量手写数字组成的 MNIST 数据集📝 [1].
在这里，我们将使用一个令人难以置信的简单想法来从这些图像中获取信息:两个向量之间角度的余弦。因此，这对 ML 或 DS 领域的新手来说尤其有利😉。你可能熟悉矢量的点积。在这种情况下，你可能知道它可以通过两种方式获得，分量乘积之和，幅度与角度余弦的乘积，即。对于三维空间中称为 A 和 B 的两个向量，我们有:
这被扩展到多个(有限)维度，并将所谓的相似度定义为角度[2]的余弦:
以这种方式，指向相同方向的两个向量，因此是“相似的”，具有接近 1 的相似度，并且当它们更不相似时，它会变得更低值(低至-1)。
到目前为止还不错，但现在让我们转向手写数字图像，以及如何使用这个概念来识别其中哪些数字是相似的。
一些 MNIST 数字。图片作者。
使用 Scikit-learn，可以轻松访问 MNIST 数据集[3]:
这里 X 包含了向量形式的每一位的数据信息。每个图像是 28×28 像素的矩阵，因此 X 向量有 784 个条目。这些向量就是我们想要比较的。为了尽可能简单起见，我将重点放在与零图像相对应的 X[1] 数字上，如下图所示:
对应于 X[1]的数字的绘图。图片作者。
任务是找到类似于*X【1】*的向量，并且假设它们也是零。下面的代码解决了这个问题，假设您已经导入了 numpy:
这里 j=1 (所以*X【j】*是我们想要的零) i 遍历前 5000 个元素。在第 6 行，我们用 pp 代表 X[i] 和 X[j] 之间的点积。然后，在第 9 行，它除以给出角度余弦的向量范数的乘积(相似度)。请记住，我们希望这些值接近 1，所以从第 10 行到第 14 行，我们使用高斯函数来过滤接近 1 的值。sigma 的值可以考虑到最大的 sigma 来调整，我们将接受更多可能不太相似的向量。在第 13 行中，有一个条件，只取大于 0.3 的高斯函数的高度值，以确保所有向量对应于与所选向量相似的零。以下是这些值的结果:
检测到的零类似于第一次遇到的零。图片作者。
太神奇了！！它工作得很好，🥂.这里需要注意的是，这些不是所有的零，只是那些与我们选择的第一个更相似的零。但是，肯定有其他书写零的方式，让位于相同数字的不同形状。你可以用其他数字试试，只要这个数字有“好的形状”，就能得到好的结果。我的意思是，有些数字非常特殊，即使是人类也很难识别😅。
我在一个与基因组学相关的黑客马拉松中使用了同样的想法来识别肾脏疾病中表达的基因，并且工作得足够好以至于赢得了一个荣誉提名🔥。作为我的第二次黑客马拉松还不错！因此，除了简单之外，不要低估这项技术。
如果您想使用上面显示的代码，这里有 Colab 笔记本的链接:
https://github.com/napoles-uach/MediumPost/blob/main/CosineSimilarity.ipynb
感谢阅读！！
参考资料:
https://en.wikipedia.org/wiki/MNIST_database。
https://en.wikipedia.org/wiki/Cosine_similarity。
https://scikit-learn.org/stable/modules/generated
/sk learn . datasets . load _ digits . html
查看我最近写的其他帖子:
如何使用 Streamlit 为 2021 年的模型构建 UI
Streamlit 是一个开源的 Python 库，可以为各种目的构建 UI，它不局限于数据应用/机器学习。它简单易学，几行代码就可以创建一个漂亮的 web 应用程序。
查尔斯·德鲁维奥在 Unsplash 上拍摄的照片
目录
- 先决条件
- 安装所需的库
- 逻辑回归模型
- 简化用户界面
- 结论
为什么应该使用 Streamlit？
Streamlit 是一个 Python 库，它帮助我们在没有 HTML/CSS/JS 的情况下为我们的模型开发 ui。大多数模特死在 Jupyter 笔记本里，没有吸引力。但是，使用 Streamlit，您可以为您的模型创建一个干净的 UI，并向其他人展示它。构建 UI 可以让用户以更友好的格式使用您的模型。
- 你不需要处理 HTML/CSS/JSS。
- 它支持降价。
- 它提供了许多预构建的小部件，进一步减少了构建 UI 所花费的时间。
- 构建响应性用户界面。
- 使用 Streamlit 共享轻松部署 Streamlit 应用程序。
- 它是开源的，如果需要，你可以创建自己的小部件。
本教程将建立一个逻辑回归模型来预测一个人是否会在泰坦尼克号灾难中幸存。在构建模型之后，我们将使用 Streamlit 为我们的模型构建一个 web 应用程序和一个 UI。web 应用程序将让用户输入值并获得预测的结果。
先决条件
本教程的重点是 Streamlit，所以应该熟悉使用 scikit-learn 构建 ML 模型。
- 很好的理解 Python。
- 对数据清理和标准技术有基本的了解，如数字编码、一键编码。
- 熟悉 scikit-learn 库。
- 熟悉逻辑回归有所帮助，但不是必需的。
- 熟悉熊猫图书馆。
- 对 Matplotlib 库的基本了解。
安装所需的库
python -m venv venv
venv/Scripts/activate
pip install streamlit,scikit-learn, pandas, matplotlib
首先，我们需要创建一个虚拟环境来管理我们的包并安装所需的包:streamlit、scikit-learn、pandas 和 matplotlib。安装完成后，键入以下命令以确保 streamlit 已按预期安装。
streamlit hello
这将启动一个样例 Streamlit 应用程序。你可以在命令行上按 ctrl+C 来停止应用程序。
导入必要的库
我们需要导入所有已安装的库。
import streamlit as st
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import confusion_matrix
import matplotlib.pyplot as plt
逻辑回归模型
首先，我们将加载 Titanic 数据集，并操作我们的数据集以满足我们的要求。你可以从 Kaggle 下载数据集。
加载数据帧
我们导入数据集并创建数据帧。
train_df = pd.read_csv("train.csv")
print(train_df.head())
您可以打印数据帧来检查其中的列。
在逻辑回归模型使用数据之前，我们需要对数据执行以下操作。
- 给特征“性别”分配一个数值
- 对功能“Pclass”使用一键编码
- 填写年龄栏中缺少的值。
- 仅选择所需的功能。
我们将定义一个函数来转换我们的数据，使其可用于我们的逻辑回归模型。
操纵数据
def manipulate_df(df):
# Update sex column to numerical
df['Sex'] = df['Sex'].map(lambda x: 0 if x == 'male' else 1)
# Fill the nan values in the age column
df['Age'].fillna(value = df['Age'].mean() , inplace = True)
# Create a first class column
df['FirstClass'] = df['Pclass'].map(lambda x: 1 if x == 1 else 0)
# Create a second class column
df['SecondClass'] = df['Pclass'].map(lambda x: 1 if x == 2 else 0)
# Create a second class column
df['ThirdClass'] = df['Pclass'].map(lambda x: 1 if x == 3 else 0)
# Select the desired features
df= df[['Sex' , 'Age' , 'FirstClass', 'SecondClass' ,'ThirdClass' 'Survived']]
return df
- 对于
sex列，如果乘客是男性，我们设置值为 0，如果乘客是女性，我们设置值为 1。 - 我们使用平均值来填充年龄列中缺失的数据。
- 我们对
Pclass.使用一次热编码。 - 由于我们不专注于构建模型，我们将只从数据框架中选择 6 个特征。
列车测试分离
train_df = manipulate_df(train_df)
features= train_df[['Sex' , 'Age' , 'FirstClass', 'SecondClass','ThirdClass']]
survival = train_df['Survived']
X_train , X_test , y_train , y_test = train_test_split(features , survival ,test_size = 0.3)
我们将使用 70–30 的比例来分割数据集。
缩放要素数据
scaler = StandardScaler()
train_features = scaler.fit_transform(X_train)
test_features = scaler.transform(X_test)
我们需要对数据进行缩放，因此均值= 0，标准差= 1。
建立模型
# Create and train the model
model = LogisticRegression()
model.fit(train_features , y_train)
train_score = model.score(train_features,y_train)
test_score = model.score(test_features,y_test)
y_predict = model.predict(test_features)
在训练我们的模型之后，我们存储我们的模型的准确度分数。
我们已经成功建造了我们的模型。现在我们将继续简化它。
细流
要运行 streamlit 应用程序，请键入以下命令。
streamlit run app.py
您应该会看到一个空白屏幕，因为我们现在没有显示任何组件。在右上角，选择“总是重新运行”。这告诉 Streamlit 在我们每次修改代码时重新加载。
标题和输入数据帧
Webapp 截图
我们将在 web 应用程序的这一部分使用以下功能:
- title( str ) :这个方法就像一个< h1 >标签。它接受一个字符串作为参数，并将文本显示为标题。
- subheader( str) :类似于 title 方法，但是显示的文字字体比标题显示的字体要小。
- table(dataframe):table()方法将一个 data frame 作为参数，并显示出来。您也可以使用。dataframe()方法，而。table()方法显示了一个更好看的表格。
代码如下:
st.title("Would you have survived the Titanic Disaster?")
st.subheader("This model will predict if a passenger would survive the Titanic Disaster or not")
st.table(train_df.head(5))
st.table()的替代方法是 st.dataframe()。它们都支持 dataframe 并可以显示它，但是我更喜欢 st.table()，因为它看起来更好。
模型性能
web 应用的屏幕截图
首先，我们需要形成混淆矩阵并计算值。
confusion = confusion_matrix(y_test, y_predict)
FN = confusion[1][0]
TN = confusion[0][0]
TP = confusion[1][1]
FP = confusion[0][1]
我们可以使用 subheader()方法来显示训练和测试分数。
st.subheader("Train Set Score: {}".format ( round(train_score,3)))
st.subheader("Test Set Score: {}".format(round(test_score,3)))
现在，我们将使用上述数据创建一个条形图。
plt.bar(['False Negative' , 'True Negative' , 'True Positive' , 'False Positive'],[FN,TN,TP,FP])
为了显示图表，我们将使用 Streamlit 的 pyplot()方法。
st.pyplot()
您可以将 st.pyplot()视为 plt.show()的等价物。
接受用户的输入
web 应用的屏幕截图
接下来，我们允许用户输入数据并显示预测。
我们将使用以下方法:
- text_input(str) :该方法将一个字符串作为参数，并以输入参数作为标签创建一个文本输入字段。
- st.selectbox(str，options = ) :这个方法创建一个下拉菜单。它接受两个参数，用作标签的字符串和选项列表。选项需要以字符串值列表的形式传递。
- st.slider(str，start，end，step) :用给定的参数创建一个滑块。
代码显示如下:
name = st.text_input("Name of Passenger ")
sex = st.selectbox("Sex",options=['Male' , 'Female'])
age = st.slider("Age", 1, 100,1)
p_class = st.selectbox("Passenger Class",options=['First Class' , 'Second Class' , 'Third Class'])
每次用户输入时，脚本都会重新运行，相应的变量会存储输入值。
在我们使用这些值进行预测之前，我们需要对它们进行缩放和修改。
sex = 0 if sex == 'Male' else 1
f_class , s_class , t_class = 0,0,0
if p_class == 'First Class':
f_class = 1
elif p_class == 'Second Class':
s_class = 1
else:
t_class = 1
input_data = scaler.transform([[sex , age, f_class , s_class, t_class]])
prediction = model.predict(input_data)
predict_probability = model.predict_proba(input_data)
- 首先，我们将 sex 的值设置为 0 或 1。
- 然后，我们对乘客类使用一键编码。
- 最后，我们缩放输入并计算预测和概率。
展示我们的预测
if prediction[0] == 1:
st.subheader('Passenger {} would have survived with a probability of {}%'.format(name , round(predict_probability[0][1]*100 , 3)))
else:
st.subheader('Passenger {} would not have survived with a probability of {}%'.format(name, round(predict_probability[0][0]*100 , 3)))
基于预测，我们显示一条文本消息。
我们现在已经为我们的模型构建了一个用户界面
结论
只需几行额外的代码，我们就可以将一个简单而枯燥的脚本转换成一个具有整洁 UI 的 web 应用程序。许多人可能已经建立了一个模型来预测泰坦尼克号灾难中乘客的生存，但是为它建立一个 web 应用程序将使你脱颖而出。
我最近用 WordPress 创建了一个博客，如果你能看看的话，我会很高兴的😃
在 LinkedIn 上与我联系
https://www.linkedin.com/in/rahulbanerjee2699/
最初发表于 版块 。木卫一 2021 年 1 月 6 日
不追独角兽如何打造独角兽 AI 团队
一个优秀人工智能团队的 7 个技能角色
GIF by giphy
文章原载于 VentureBeat
你如何开始组建一个人工智能团队？好吧，雇用能够理解业务问题、能够将其转化为“正确的”人工智能构建模块、能够交付实施和生产部署的独角兽。听起来很容易！只不过这种独角兽的出现极为罕见。即使你找到了独角兽，你也很可能买不起它！
在我过去二十年领导数据+人工智能产品和平台的经验中，一个更有效的策略是专注于招募可靠的执行者，他们在团队中累计支持七个特定技能角色。
独角兽人工智能团队的 7 个技能角色
独角兽人工智能团队的七个技能角色(图片由作者提供)
数据集解释器角色
人工智能项目的生命线是数据。找到正确的数据集、准备数据并持续确保高质量是一项关键技能。有很多关于数据集的部落知识，所以你需要有人专门跟踪数据属性的含义和不同数据集的来源。与数据相关的一个挑战是处理组织内对业务指标的多种定义。在我的一个项目中，我们正在处理销售、财务和市场营销中“每月新客户”的八种定义。对于这种技能角色，一个很好的起点是一个传统的数据仓库工程师，他具有很强的数据建模技能，并且天生好奇如何将数据属性的含义与应用程序和业务操作相关联。
管道建造者角色
从多个来源获取数据到 AI 模型需要数据管道。在管道中，数据被清理、准备、转换并转化为 ML 特征。这些数据管道(传统数据仓库中称为提取-转换-加载或 ETL)会变得非常复杂。组织通常拥有管道丛林，其中有数千条使用异构大数据技术构建的管道，如 Spark 、 Hive 和 Presto 。管道建造者角色侧重于以适当的健壮性和性能大规模地建造和运行管道。寻找这种角色的最佳地点是拥有多年批处理和实时事件管道开发经验的数据工程师。
AI 全栈角色
AI 从设计、训练、部署、再训练，本质上都是迭代的。构建 ML 模型需要对代码、特性、数据集和模型配置的不同排列进行数百次实验。这个角色是人工智能领域知识和强大的系统构建技能的结合。他们专注于现有的 AI 平台，如 Tensorflow 、 Pytorch ，或基于云的解决方案，如 AWS 、 Google 和 Azure 。随着这些人工智能平台的民主化和广泛的在线课程，这种角色不再稀缺。根据我的经验，强大的软件工程背景加上他们对掌握人工智能的好奇心是一个极其有效的组合。在为这种角色招聘时，很容易遇到喜欢单飞而不是团队合作的天才——保持警惕，尽早淘汰他们。
人工智能算法角色
大多数人工智能项目很少需要从头开始或实现新的算法。这个角色的作用是在问题的背景下，在人工智能算法和技术的搜索空间上指导团队。它们有助于减少路线修正的死角，并有助于平衡解决方案的准确性和复杂性。鉴于专注于人工智能算法创新的地方的高需求，这种角色不容易获得。如果你负担不起找一个全职的人来掌握这项技能，可以考虑找一个专家做顾问或者创业顾问。另一个选择是投资培训全栈团队，给他们时间学习研究进展和算法内部。
数据+人工智能运营角色
AI 解决方案在生产中部署后，需要持续监控以确保其正常工作。生产中可能会出现很多问题:数据管道故障、质量差的数据、供应不足的模型推断端点、模型预测正确性的漂移、业务度量定义中不协调的变化，等等。该角色侧重于构建正确的监控和自动化，以确保无缝运营。与软件产品的传统开发运维相比，考虑到移动部分的数量，数据+人工智能运维要复杂得多。谷歌的研究人员将这种复杂性正确地总结为 CACE 原则:改变任何事情都会改变一切。寻找这种角色的一个很好的起点是有经验的数据运营工程师，他们渴望学习数据+人工智能领域。
假设规划者角色
人工智能项目充满惊喜！从原始数据到可用的人工智能的旅程不是一条直线。您需要灵活的项目规划——根据对数据集、功能、模型准确性、客户体验的假设的证明或否定进行调整。找到这种技能角色的一个好地方是传统的数据分析师，他们有在紧迫的期限内处理多个并发项目的经验。鉴于他们跟踪和平行假设的本能，他们可以成为优秀的项目经理。
影响所有者角色
影响所有者非常熟悉如何部署人工智能产品来实现价值的细节。例如，当使用人工智能解决与提高客户保持率相关的问题时，这个角色将完全理解与客户获取、保持和流失相关的旅程图。他们将负责定义支持团队专家如何实施人工智能解决方案中的客户流失预测，以减少流失。找到这种角色的最佳地方是在现有的业务团队中——理想情况下，是一个具有强烈产品直觉和实用主义的工程师。没有这个角色，团队最终会构建技术上可行的东西，而不是在端到端工作流中实际需要什么来产生价值。
总结一下，这七个技能人物角色是每个 AI 团队必备的。这些人物角色的重要性根据数据的成熟度、人工智能问题的类型以及更广泛的数据和应用程序团队可用的技能而有所不同。例如，与拥有少量大表的组织相比，拥有大量小表的组织中的数据解释者角色更加重要。在为 AI 团队中的每个技能角色确定正确的资历和基数时，应该考虑这些因素。希望，你现在可以开始建立你的人工智能团队，而不是等待独角兽出现！
如何使用 Python 和 AssemblyAI 构建一个转录音频的 Web 应用程序
我们将使用 Streamlit 建立一个 web 应用程序，让用户上传他们的音频。AssemblyAI 的 API 将用于转录这个音频。我们也将建立一些很酷的动画
Web 应用程序的屏幕截图
你可以在这里找到部署的应用
转录是将音频转换为文本的过程。虽然你可以实现一个机器学习模型来从音频中获取文本，但这很麻烦。
- 从音频信号中提取特征需要丰富的音频信号处理知识。
- 必须从各种来源挖掘/搜集大量数据。
- 需要具备 PyTorch 或 TensorFlow 等机器学习库的知识。
幸运的是，AssemblyAI 有一个免费的版本，让我们通过几个请求就可以转录音频。
在本文中，我们将构建一个 web 应用程序，它可以使用 AssemblyAI 和 Streamlit 转录音频，Streamlit 是一个 Python 库，用于构建机器学习模型的 ui。
你可以在这里找到带有完整源代码的回购协议。
要求
- 一个 AssemblyAI 账户(免费注册这里
- 一个 AssemblyAI API 密钥(你可以在这里找到它
- Python 3.5+的基础知识(注意:本教程我将使用 Python 3.9)
- 虽然不是必需的，但是熟悉请求库会有所帮助
我们将使用的库
AssemblyAI
AssemblyAI 用于将音频转换为文本。它提供了一个 REST API，可以在任何调用 REST API 的语言中使用，比如 JavaScript、PHP、Python 等。我们将使用 Python 向 API 发出请求。
细流
Streamlit 是一个开源的应用框架，用于构建机器学习模型的 UI，无需了解 HTML、CSS 或 JavaScript。它有一个广泛的预建组件库，可以用来在几分钟内构建一个简单的 UI。
要求
我们将使用请求库向 AssemblyAI 的 REST API 发出请求。
Python-dotenv
我们将使用 Python-dotenv 库来读取变量。环境文件。
设置项目目录
使用命令行创建新的文件夹/目录
mkdir ASSEMBLYAI
为了保持秘密凭证的秘密性，将凭证存储在. env 文件中是一个很好的做法。然后，我们可以使用 Python-dotenv 库从。环境文件。如果愿意，我们也可以将它们存储在环境变量中。
在您创建的新目录 ASSEMBLYAI 中，创建两个新的 Python 文件和一个. env 文件
如果使用 Windows:
New-Item main.py, transcribe.py, .env
如果使用 macOS 或 Linux:
touch touch main.py && transcribe.py && touch .env
文件 main.py 将包含与 Streamlit UI 相关的所有代码，而文件 transcribe.py 将包含帮助器函数和与 AssemblyAI 的 API 交互的代码。
你可以从这里下载一个样本 MP3 文件。将文件命名为“testData ”,并将其保存在 ASSEMBLYAI 目录中。
设置项目环境
确保你在 ASSEMBLYAI 目录下，如果你不只是使用 cd 命令来改变目录。
cd ASSEMBLYAI
如果这是你第一次使用虚拟环境，你必须安装 virtualenv
如果使用 Windows:
python -m pip install — user virtualenv
如果使用 macOS 或 Linux:
python3 -m pip install — user virtualenv
首先，我们需要通过在命令行上输入以下代码来创建一个虚拟环境:
如果使用 Windows:
python -m venv venv
如果使用 macOS 或 Linux:
Python3 -m venv venv
然后，我们需要在命令行中使用以下命令来激活本地虚拟环境:
如果使用 Windows:
venv/Scripts/activate
如果使用 macOS 或 Linux:
source venv/bin/activate
有关如何设置虚拟环境的更多详细信息，请参考本网站。
要分别安装 Requests、Steamlit 和 Python-dotenv 库，我们可以在命令行上输入这一行:
pip install streamlit, requests, python-dotenv
这将安装所需的最新库。
作者图片
这是你的文件结构应该看起来的样子。
将 API 密钥添加到。环境文件
- 打开。您在“设置项目环境”一节中创建的 env 文件。
- 添加以下内容:
API_TOKEN = “Your API Key”
- 将字符串“Your API Key”替换为 Assembly AI 给你的 API Key。
如何克隆回购并运行它
- 去 GitHub repo 下载。
- 启动命令行，将目录更改为下载的文件夹。
- 按照上一节设置虚拟环境。
- 激活虚拟环境。
- 在下载的文件夹中创建一个. env 文件，并添加 API 密钥。(参考上一节。)
- 要安装所需的库，您可以手动键入名称并安装它们，或者使用提供的 requirements.txt 文件。
如果使用 Windows:
pip install streamlit, requests, python-dotenv
如果使用 macOS 或 Linux:
pip install streamlit requests python-dotenv
或者
pip install -r requirements.txt
- 一旦成功安装了所有要求，请键入以下命令
streamlit run main.py
这应该会运行 webapp。您可以尝试上传文件。
转录 mp3 文件
在构建 UI 之前，我们需要几个助手函数，我们可以用它们将文件上传到 AssemblyAI 的服务器，供模型处理并返回转录的文本。
助手函数的代码应该写在transcripte . py文件中
导入所需的模块
这段代码应该出现在转录. py 文件的开头
import os
from dotenv import load_dotenv
import requests
助手功能 1:将本地音频文件上传到 AssemblyAI
我们需要编写的第一个函数是上传存储在本地机器上的音频文件的方法。这个函数应该存在于转录. py 文件中
AssemblyAI 模型期望文件可以通过 URL 访问。因此，我们需要将音频文件上传到 blob 存储，以便通过 URL 访问。幸运的是，AssemblyAI 提供了一种快速简单的方法来实现这一点。
我们需要向以下 AssemblyAI API 端点发出 POST 请求:
[https://api.assemblyai.com/v2/upload](https://api.assemblyai.com/v2/upload)
该响应将包含一个指向该文件的临时 URL，我们可以将该 URL 传递回 AssemblyAI ’ transcript` API 端点。该 URL 是仅可由 AssemblyAI 服务器访问的私有 URL。
所有上传的内容转录后会立即删除，永远不会保存。
我们将使用之前安装的 Python 请求库来发出 POST 请求
def get_url(token,data):
‘’’
Parameter:
token: The API key
data : The File Object to upload
Return Value:
url : Url to uploaded file
‘’’
headers = {‘authorization’: token}
response = requests.post(‘https://api.assemblyai.com/v2/upload',
headers=headers,
data=data)
url = response.json()[“upload_url”]
print(“Uploaded File and got temporary URL to file”)
return url
- 该函数接受两个参数:API 令牌和要上传的文件对象
- 我们向上述 AssemblyAI Upload API 端点发出 POST 请求，并将 API 令牌和文件对象作为请求体的一部分。
- 响应对象包含上传文件的 URL。该 URL 由函数返回。
助手功能 2:上传文件进行转录
现在我们有了一个函数来获取音频文件的 URL，我们将使用这个 URL 并向端点发出请求，端点将实际转录文件。这个函数也应该存在于 transcribe.py 文件中
最初，当我们请求转录时，音频文件具有“排队”状态。我们将在最后一个帮助函数中更多地讨论文件是如何从“排队”到“完成”的。现在，我们只需要向转录端点以及文件的 URL 发出请求。我们需要向以下 AssemblyAI API 端点发出请求:
[https://api.assemblyai.com/v2/transcript](https://api.assemblyai.com/v2/transcript)
这个函数与前面的函数非常相似。
def get_transcribe_id(token,url):
‘’’
Parameter:
token: The API key
url : Url to uploaded file
Return Value:
id : The transcribe id of the file
‘’’
endpoint = “https://api.assemblyai.com/v2/transcript"
json = {
“audio_url”: url
}
headers = {
“authorization”: token,
“content-type”: “application/json”
}
response = requests.post(endpoint, json=json, headers=headers)
id = response.json()[‘id’]
print(“Made request and file is currently queued”)
return id
- 该函数接受两个参数:API 令牌和来自前面函数的音频文件 URL。
- 我们向 AssemblyAI“抄本”API 端点发出 POST 请求…如果音频文件当前未在处理中，则新文件会立即被处理。如果有正在进行的转录，则新的音频文件将排队，直到前一个作业完成。
如果您希望能够同时运行多个作业，您将需要升级到高级计划
- 响应对象将包含转录的 ID。这个 ID 和一个单独的端点将用于获取转录的状态。
- 该函数将返回这个 ID
助手功能 3:下载音频转录
一旦我们有了音频文件的转录 ID，我们就可以向以下 AssemblyAI API 端点发出 GET 请求，以检查转录的状态:
[https://api.assemblyai.com/v2/transcript/{transcribe_id}](https://api.assemblyai.com/v2/transcript/{transcribe_id})
只要没有遇到错误，转录的状态就从“排队”变为“处理中”再变为“完成”。
我们将需要轮询这个端点，直到我们得到一个状态为“completed”的响应对象。
我们可以利用一个 while 循环 不断向端点发出请求。在循环的每次迭代中，我们将检查转录的状态。循环将继续运行，直到状态为“完成”。发出请求并等待状态完成的过程称为轮询。我们将在“构建 Streamlit UI”一节中实现这个轮询特性。
下面的函数将简单地获取处方的当前状态。这个函数应该存在于转录. py 文件中
def get_text(token,transcribe_id):
‘’’
Parameter:
token: The API key
transcribe_id: The ID of the file which is being
Return Value:
result : The response object
‘’’
endpoint= f”https://api.assemblyai.com/v2/transcript/{transcribe_id}"
headers = {
“authorization”: token
}
result = requests.get(endpoint, headers=headers).json()
return result
助手功能 4:从 UI 请求转录
我们的第三个函数将连续调用前面的两个函数。
该功能也将连接到我们的 Streamlit UI 中的“上传”按钮。该函数只有一个参数:file 对象。该函数将执行以下操作
- 它将从我们的。环境文件。
- 它将使用令牌来调用先前定义的函数
- 它将返回转录 ID
下面是该函数的代码片段。这个函数应该存在于transcripte . py文件中:
def upload_file(fileObj):
‘’’
Parameter:
fileObj: The File Object to transcribe
Return Value:
token : The API key
transcribe_id: The ID of the file which is being transcribed
‘’’
load_dotenv()
token = os.getenv(“API_TOKEN”)
file_url = get_url(token,fileObj)
transcribe_id = get_transcribe_id(token,file_url)
return token,transcribe_id
- 我们将使用 load_dotenv() 函数来加载我们的。环境文件。然后我们将使用操作系统库中的 get() 函数，从。环境文件。
- 调用 get_url() 函数，将文件对象和令牌作为参数。
- 用 get_url() 函数返回的令牌和 file_url 调用**get _ transcripte _ id()**函数。
- 返回令牌和转录 ID。
构建 Streamlit UI
现在我们已经有了所有需要的助手函数，我们可以开始在 Streamlit UI 上工作了。
然而，在进入 Streamlit UI 的实际代码之前，让我们看一下我们将使用的 Streamlit 组件。
- header(string)、subheader(string)、text(string) —这些组件在我们的 UI 上显示各种大小的文本。 header() 可以认为是< h1 >标签， subheader() 是< h2 >而 text() 是< p >
- file_uploader(label) —创建一个上传文件的按钮。参数标签是显示在按钮上方的字符串。它返回一个文件对象。我们将使用它来接受来自用户的文件
- 进度(整数) —创建一个进度条。整数必须介于 0 和 100 之间。它表示指定任务完成的百分比。如果我们创建一个每次迭代睡眠时间为 0.1 s b/w 的 for 循环，我们就可以创建一个很酷的进度条动画。
- spinner(label) —只要我们在标签的代码块中，标签就会显示。
- 气球() —这是展示气球的，是啊，真酷🎈
构建用户界面的组件
下面的代码应该写在 main.py 文件中。main.py 文件将是我们的 web 应用程序的入口点。
首先，我们需要导入所有需要的模块和库
import streamlit as st
from transcribe import *
import time
转录是的名字这个文件带有我们的帮助函数。
为了确保您当前已经导入了库，您可以尝试在命令行中运行以下命令。在运行该命令之前，确保您的虚拟环境已激活，并且您当前位于根文件夹(ASSEMBLYAI)中:
streamlit run main.py
您应该会看到一个空白的 web 应用程序。要重新运行应用程序，您可以单击汉堡菜单，然后单击重新运行，或者您可以打开 web 应用程序，然后按“Ctrl + R”或“Cmnd + R”
让我们首先创建一个标题和上传按钮。
在 main.py 文件中输入以下代码:
st.header(“Transcribe Audio”)
fileObject = st.file_uploader(label = “Please upload your file” )
重新运行应用程序后，您应该会看到以下内容
作者图片
最初，变量是“None”，一旦文件被上传，变量的值就是文件对象。
if fileObject:
token, t_id = upload_file(fileObject)
result = {}
#polling
sleep_duration = 1
percent_complete = 0
progress_bar = st.progress(percent_complete)
st.text(“Currently in queue”)
while result.get(“status”) != “processing”:
percent_complete += sleep_duration
time.sleep(sleep_duration)
progress_bar.progress(percent_complete/10)
result = get_text(token,t_id)
sleep_duration = 0.01
for percent in range(percent_complete,101):
time.sleep(sleep_duration)
progress_bar.progress(percent)
- 本质上，如果变量 fileObject 不为“None”，我们调用 upload_file 函数。
- 我们使用 while 循环来轮询端点。
- 创建一个进度条，在 while 循环的每一次迭代中，程序会休眠一秒钟，并将进度条的百分比递增 1
- 一旦状态变为“处理中”，睡眠时间将减少到 0.01 秒。这导致了一个非常酷的动画，开始时，进度条进展缓慢，一旦文件被处理，它的进展真的很快
作者 GIF
- 进度条显示为 100%时，我们再次轮询端点。这一次检查状态是否为“已完成”。我们使用 spinner() 函数在投票时在屏幕上显示文本:
st.balloons()
st.header(“Transcribed Text”)
st.subheader(result[‘text’])
- 一旦状态为“完成”，我们退出 while，并使用 balloons() 函数在屏幕上循环显示气球。
- 最后，我们在屏幕上显示转录的文本。
作者图片
结论
恭喜你！👏您已经成功构建了一个可以转录音频的 web 应用程序。您可以在 web 应用程序的基础上构建一些附加功能
- AssemblyAI 允许用户指定声学模型和/或语言模型。您可以使用 Streamli 的选择框构建一个类似的下拉功能。
- 添加一个功能，让用户记录他们的声音，并转录它。这可能有点复杂，因为 Streamlit 没有任何内置组件来录制语音。但是，您可以使用 HTML 和 JavaScript 来构建这样一个特性。查看这个答案供参考。
我最近开始了一个修改版的#100daysofcode 挑战。我的目标是写与 Python、数据科学或编程相关的内容。关注我在媒体上的进度
如何为 BERT 构建一个词块标记器
实践教程
从头开始构建 BertTokenizer 的简单指南
作者图片
对于许多更具体的用例来说，从头构建一个转换器模型通常是唯一的选择。尽管 BERT 和其他 transformer 模型已经针对许多语言和领域进行了预训练，但它们并没有涵盖所有内容。
通常，这些不太常见的用例会从有人来构建特定的 transformer 模型中获益最多。它可能是一种不常用的语言或者一个不太懂技术的领域。
BERT 是一系列基于语言的机器学习中最受欢迎的转换器——从情感分析到问答。BERT 已经实现了跨越许多边界和行业的多样化创新。
对于许多人来说，设计新的 BERT 模型的第一步是记号赋予器。在这篇文章中，我们将看看 BERT 使用的 WordPiece tokenizer 看看我们如何从头开始构建自己的 WordPiece tokenizer。
文字片
BERT 使用所谓的单词块记号赋予器。它的工作原理是将单词拆分成完整的形式(例如，一个单词成为一个标记)，或者拆分成单词片段——其中一个单词可以拆分成多个标记。
一个有用的例子是我们有多种形式的单词。例如:
通过将单词拆分成单词块，我们已经识别出单词"surfboard"和"snowboard"通过单词块"##board"共享含义，我们甚至没有对我们的令牌进行编码，也没有通过 BERT 以任何方式对它们进行处理。
使用单词片段允许 BERT 轻松识别相关单词，因为它们通常共享一些相同的输入标记，然后这些标记被输入到 BERT 的第一层。
作为旁注，还有许多其他的 transformer 记号赋予器——比如 SentencePiece 或者流行的 字节级字节对编码(BPE)记号赋予器 。它们各有利弊，但是最初的 BERT 使用的是单词块标记器。
构建标记器
当构建一个新的标记器时，我们需要大量的非结构化语言数据。我的首选是 OSCAR 语料库——一个巨大的多语言数据集，涵盖了 166 种不同的语言。
然而，那里有许多数据集。HuggingFace 的datasets库也提供了对其中大部分内容的便捷访问。我们可以看到使用 Python 有多少:
一个很酷的 1306 数据集。其中许多也非常庞大——OSCAR 本身被分成 166 种语言，OSCAR 的许多“部分”包含万亿字节的数据。
我们可以用 HF 的datasets下载奥斯卡意大利语语料库。但是，我们应该小心，因为完整的数据集包含 11.3 亿个样本。总共约 69GB 的数据。HF 允许我们使用split参数指定我们只想要完整数据集的部分。
在我们的split参数中，我们已经指定我们想要来自train数据集的第一个2000000样本(大多数数据集被组织成train、validation和test集合)。尽管这仍然会下载完整的train集——它将被缓存在本地以备将来使用。
我们可以通过将streaming=True参数添加到load_dataset来避免下载和缓存整个数据集——在这种情况下split必须设置为"train"(没有[:2000000])。
数据格式编排
下载完数据后，我们必须将其重新格式化为简单的明文文件，每个样本之间用一个换行符隔开。将每个样本存储在一个文件中会创建一个巨大的文本文件。所以，我们把它们分成许多份。
培养
一旦我们保存了所有简单的、换行符分隔的明文文件——我们继续训练我们的记号赋予器！
我们首先使用pathlib创建一个包含所有明文文件的列表。
然后，我们初始化并训练分词器。
这里有几个重要的参数需要注意，在初始化期间，我们有:
clean_text—通过删除控制字符并用空格替换所有空白来清除文本。handle_chinese_chars—标记器是否包括汉字周围的空格(如果在数据集中找到)。stripe_accents—我们是否删除重音，何时True这会使é → e、ⅳ→o 等。lowercase—如果True标记器将大写和小写字符视为相等；A == a，B == b，等等。
在培训期间，我们使用:
vocab_size—我们的记号赋予器中记号的数量。在稍后的文本标记化过程中，未知单词将被分配一个不理想的[UNK]标记。我们应该尽可能减少这种情况。min_frequency—一对令牌被合并的最小频率。special_tokens—BERT 使用的特殊令牌列表。limit_alphabet—不同字符的最大数量。workpieces_prefix—添加到单词的片段的前缀(就像我们前面例子中的**##**board)。
在我们完成训练后，剩下的就是保存我们闪亮的新标记器。我们使用save_model方法来实现这一点——指定一个目录来保存我们的标记器和标记器名称:
就这样，我们构建并保存了我们的 BERT tokenizer。在我们的记号赋予器目录中应该找到一个文件— vocab.txt。
vocab.txt 文件的屏幕截图——我们新的令牌化器文本到令牌 ID 的映射。
在标记化过程中,vocab.txt用于将文本映射到标记，然后根据vocab.txt中标记的行号将标记映射到标记 id——这些 id 然后被输入到 BERT 中！
vocab.txt 的一小部分，显示令牌及其令牌 id(如行号)。
符号化
现在我们有了记号赋予器；我们可以继续使用from_pretrained加载它，就像我们使用任何其他标记器一样，我们必须指定保存标记器的本地目录。
我们也像往常一样标记:
这里我们返回大多数 BERT 任务需要的三个张量，input_ids、token_type_ids和attention_mask。我们可以看到由2代表的初始[CLS]令牌和由3代表的最终[SEP]令牌。
由于我们的vocab.txt文件包含我们的令牌和令牌 id 的映射(例如，行号)——我们可以通过将我们的input_ids令牌 id 与vocab.txt中的行对齐来访问令牌:
让我们试试另一个——如果你在意大利，这是一个不错的选择:
最后，让我们对将要拆分成多个单词片段的内容进行标记:
这就是我们构建和应用意大利 Bert tokenizer 所需的一切！
这就是本文的全部内容，涵盖了为 BERT 定制的单词块标记器的构建过程。
我希望你喜欢它！如果你有任何问题，请通过 Twitter 或在下面的评论中告诉我。如果你想要更多这样的内容，我也会在 YouTube 上发布。
感谢阅读！
参考
如何用 Python 构建 YouTube 转录 App
由eleven creative从 envato elements 使用图像创建(经许可)。
使用 AssemblyAI 和 Streamlit 的分步教程
背景
或许，在你的学习之旅中，你想看一个小时的 YouTube 视频，或者你有一个 YouTube 视频播放列表要看，但你时间不够？
有两个可能的选择:
- 找时间看视频
- 转录视频(你可以浏览视频以获取关键观点)
如果您选择第二个选项，您将在本文中了解如何利用自动语音识别将 YouTube 视频中的音频转录为书面形式。简而言之，我们将用 Python 实现一个语音到文本的 Streamlit 应用程序，使用 AssemblyAI API 来执行 YouTube 视频的转录。
在我们继续之前，值得注意的是，我还为本文制作了一个补充视频，除了构建 Streamlit 应用程序，我们还构建了一个具有相同功能的命令行工具(即一个可以从命令行运行的简单 Python 脚本)。
如何使用 AssemblyAI 和 Streamlit 在 Python 中构建自己的语音到文本转换应用
构建转录器应用程序的概念框架
也许，提供一个关于我们将要构建的转录器应用程序的高级概述会很好。
构建转录应用程序的概念框架。由作者绘制。
现在让我们开始构建应用程序吧！
建立工作环境
首先要做的是安装conda，我们将使用它来管理我们的工作环境。
现在，让我们用 Python 版创建一个新的 conda 环境。在这里，我们将环境命名为transcriber。
conda create -n transcriber python=3.9
当提示安装 Python 库依赖项时，只需输入Y，字面意思是“是”。
现在已经创建了环境，当您打开终端时，您可以键入以下内容来激活 conda 环境:
conda activate transcriber
完成后，您可以通过键入以下命令退出 conda 环境:
conda deactivate
下载 GitHub repo
我们现在将通过以下命令从 GitHub repo transcriber-app下载运行 transcriber 应用程序所需的所有文件:
git clone [https://github.com/dataprofessor/transcriber-app](https://github.com/dataprofessor/transcriber-app)
这将显示以下文件夹内容:
transcriber-app/
├─ .streamlit/
│ ├─ secrets.toml
├─ api.txt
├─ app.py
├─ requirements.txt
├─ transcriber.py
├─ README.md
接下来，安装必备库，本质上是streamlit和pytube库。
您可以通过以下方式实现这一点(仅选择并执行以下一项):
pip install requirements.txt
或者通过以下方式手动安装库:
pip install -U streamlit
pip install pytube
-U选项有助于将streamlit库更新到最新版本，以确保您可以访问最新版本。
从 AssemblyAI 获取 API 密钥
在运行 Streamlit transcriber 应用程序之前，我们需要从 AssemblyAI 获取 API 密钥。
这超级简单，只要做到以下几点:
- 转到装配 AI
- 注册并登录
- 复制在右侧找到的 API 密钥。
演示如何获取 AssemblyAI API 的截屏。
运行命令行工具
需要注意的是，api.txt和transcriber.py是作为命令行工具运行转录器 app，可以通过以下命令执行:
python transcriber.py -i "[https://youtu.be/mkVjrB8g6mM](https://youtu.be/mkVjrB8g6mM)"
确保打开api.txt文件，并用 AssemblyAI 中的 API 键替换填充文本。
(注意:请随意用您选择的 YouTube 视频替换该 URL)
在命令行中运行转录器的截屏。
运行 Streamlit 应用
如果您在本地运行 Streamlit 应用程序，请确保打开.streamlit/secrets.toml文件，并用 AssemblyAI 中的 API 密钥替换填充文本。
要启动应用程序，请在终端中输入以下内容:
streamlit run app.py
运行 Transcriber Streamlit 应用程序的截屏。
将 Streamlit 应用部署到云
如果您正在部署到云，最简单的方法是使用 Streamlit Cloud 进行部署，这需要一个到 GitHub repo 的链接。重要的是不要上传.streamlit/secrets.toml到你的 GitHub repo，而是你可以从 Streamlit 云管理界面输入 API 密钥。
为此，您可以进入应用仪表板，在应用的下拉菜单下，点击编辑机密。从secrets.toml文件中复制内容并粘贴到文本框中。
代码的解释
第 1–7 行
导入必备库。
第 9 行
打印出应用程序的标题。
第 10 行
使用st.progress()函数实例化进度条，并将初始值设置为0。
第 12–111 行
定义自定义的实用函数，执行所有的任务来转录 YouTube 视频。这由 8 个任务组成，如各种注释行所述，如下:
1)从 YouTube 视频检索音频文件
2。将 YouTube 音频文件上传到 AssemblyAI
3)转录上传的音频文件
4)提取转录 ID
5)检索转录结果
6)检查转录是否完成
7)打印转录文本
8)将转录文本保存到文件
在本文的补充视频中提供了深入的解释: 如何使用 AssemblyAI 和 Streamlit 在 Python 中构建自己的语音到文本转录 App。
第 113–141 行
实际应用从这里开始。简而言之，该应用程序接受 YouTube 视频的用户输入 URL，并将该信息转发给第 12-111 行中提到的自定义实用程序函数，以执行上述 8 项任务。
结论
恭喜你！现在，您已经构建了自己的转录器应用程序，用于将 YouTube 视频转换为转录文本。只需稍加调整，你就可以定制应用程序来转录任何视频或音频文件。
接下来读这些
- 如何掌握数据科学所需的 Python
下面是数据科学所需的必备 Python - 如何掌握数据科学的熊猫
下面是数据科学需要的必备熊猫 - 如何用 Python 构建 AutoML App
使用 Streamlit 库的分步教程 - 学习数据科学的策略
闯入数据科学的实用建议 - 如何免费搭建一个简单的作品集网站
不到 10 分钟从零开始的分步教程
✉️ 订阅我的邮件列表，获取我在数据科学方面的最佳更新(偶尔还有免费赠品)!
关于我
目前，我是 Streamlit 的全职开发人员。此前，我是泰国一所研究型大学的生物信息学副教授，数据挖掘和生物医学信息学负责人。在我下班后的时间里，我是一名 YouTuber(又名数据教授)制作关于数据科学的在线视频。在我制作的所有教程视频中，我也在 GitHub 上分享 Jupyter 笔记本(数据教授 GitHub 页面)。
https://www.youtube.com/dataprofessor
在社交网络上与我联系
✅YouTube:http://youtube.com/dataprofessor/
♇网站:http://dataprofessor.org/(在建)
♇LinkedIn:https://www.linkedin.com/company/dataprofessor/
♇Twitter:https://twitter.com/thedataprof
♇Facebook:http://facebook.com/dataprofessor/
♇github:https://github.com/dataprofessor/
♇insta gram:
如何使用 GPT-3 在 10 分钟内构建令人惊叹的人工智能用例？
人工智能的未来
照片由 Unsplash 上的 h heyerlein 拍摄
你是否认为构建一个基于自然语言处理的人工智能应用程序，比如聊天机器人或翻译器，需要大量的数据科学技能，并且会花费大量的时间？它不总是正确的，这篇文章将帮助你更好地理解。我将展示如何使用 GPT-3 以最少的开发工作构建一些令人惊叹的基于自然语言处理的人工智能应用程序。在开始建造之前，让我们先了解一下 GPT 3 号是什么，GPT 3 号的所有特点是什么让它如此特别。
什么是 GPT-3？
GPT-3 是预训练的生成式 Transformer 3，它是一种在互联网上的大量数据集上训练的语言模型，由一家名为 OpenAI 的公司开发。GPT-3 是通过 API 提供的，目前，该 API 处于受控测试阶段，有一个等待名单，可以获得这个惊人的 API。
以下是为什么 GPT-3 模型被谈论得最多的一些原因
- GPT-3 模型由 1750 亿个参数组成，以前的版本，GPT-2 模型只有 15 亿个参数。参数是将输入转换为输出的神经网络模型中的权重
- 它是一个生成模型，这意味着它有能力生成一个连贯的长单词序列作为输出
- 这种最先进的语言模型可以回答几乎任何传递给它的问题，而且以一种更人性化的方式
- 因此，模型训练中使用的数十亿个单词、文本和代码片段使它能够用多种编程语言自动编码
- 它的多语言文本处理也有助于处理英语以外的语言
- 最好的部分是 GPT-3 模型可以执行特定的任务，如成为一名翻译或聊天机器人或代码生成器，无需任何定制或任何特殊调整，它需要的只是一些训练示例
要了解更多关于这个神奇模型的技术细节，请点击这里。在这篇文章中，我将向你展示如何使用这个神奇的 API 来解决不同的基于 NLP 的人工智能用例。
获取 GPT-3 测试版 API
要构建本文中涵盖的用例，您需要访问 GPT-3 测试版 API。它目前只能通过邀请获得，您可以使用下面的链接申请访问。它将带您进入一个表格，其中会询问一些关于您的组织和您计划实施的项目的问题。
实施背景
为了与 GPT-3 API 接口，我将使用来自下面的gp t3-沙箱仓库的脚本。我在这个库中使用的脚本是 API 文件夹中的 gpt.py，它使我能够访问 GPT-3 API，从而可以显示可以解决的不同用例。本文使用的脚本可以在这里找到
用例 1 —聊天机器人
在这里，我们不会传递任何训练示例，而只是直接访问 API 并将其用作聊天机器人。
在下面的例子中，我正在导入所需的包以及我们从“gpt3-sandbox”存储库中下载的脚本。我们将向模型传递三个参数，
- 发动机——有四个选项供我们选择，分别是达芬奇、阿达、巴贝奇、居里。我们将使用达芬奇，因为它是使用 1750 亿个参数训练的最强大的引擎
- 温度-通常介于 0 和 1 之间，用于控制生成输出的随机性。值为 0 使模型具有确定性，也就是说，每次执行时输出都是相同的，而另一方面，值为 1 时，生成的输出具有很高的随机性。
- max _ tokens 最大完成长度
在下面的脚本中，需要询问的问题被传递给变量“prompt1 ”,然后使用 submit_request 函数传递给模型。结果存储在“output1”变量中，如下所示，
在上面的例子中，正如你所看到的，这个模型可以对所提的问题给出一个非常好的回答，而不需要调整。由于这里我们不提供任何训练示例，模型输出不需要总是响应，它可以提出一组类似的问题或与传递的输入相关的内容。通过提供一些训练样本，可以提高性能
用例 2 — LaTex —文本到等式
在下面的例子中，我们将看到文本到等式转换的实现，只需要很少的训练，这是其他预训练模型所不可能的。
在下面的示例中，温度值已经增加，以使响应具有一定的随机性，我们还将一些预定义的示例作为训练数据集传递给模型。只需 5 个例子，我们就可以训练模型将文本转换成方程。在使用已知示例训练模型之后，我们将以下内容作为输入“x 的平方加上 2 倍”,模型将其转换为一个等式。
用例 3—翻译(英语到法语)
就像上面的几个例子一样，我们可以训练模型像一个翻译一样工作。下面是翻译器模块的代码，我们在这里训练模型将英语文本翻译成法语，只有三个例子。
该模型能够以非常少的开发工作量执行特定的任务，如“外语翻译器”或“文本到等式转换器”,这使得它非常特别。
下面是一个教程视频，我提供了一个用例实现的演练。
一些使用 GPT-3 创建的酷应用程序
要了解更多使用 GPT3 构建的有趣应用程序，请查看本页这里。
关于我
我是一名拥有超过 10 年经验的数据科学专家，并且已经撰写了 2 本数据科学方面的书籍。我写数据科学相关的内容是为了让它简单易懂。跟我上 中 **。**我也有一个 YouTube 频道，在那里我教授和谈论各种数据科学概念。如果有兴趣，可以订阅我下面的频道。
https://www.youtube.com/c/DataSciencewithSharan
如何在你的组织中建立一个人工智能道德团队？
Javier Allegue Barros 在 Unsplash 上拍摄的照片
所以你在研究人工智能系统，并且对负责任的人工智能感兴趣？在实现这一目标的过程中，你遇到过挑战吗？许多文章提到了从原则到实践的转变，但是当你试图在实践中实现它们时，却以失败告终。那么少了什么呢？这里有一些想法，我认为会帮助你迈出实现它的第一步。
获得领导认同
是的，这很重要！为什么？嗯，在你的组织中，不同的单位有不同的激励和目标。在实践中实现负责任的人工智能需要不同单位之间的协调。领导团队可以帮助提供一个统一的命令，将不同的单位聚集在一起实现这一目标。
更重要的是，他们可以作为在你的组织中追求负责任的人工智能背后的“为什么”的中心传播点。他们有权制定政策，推动整体变革*，让基层工作变得更轻松、更有效。尤其是在你面临同事不情愿的情况下，来自领导层的明确信息为每个人提供了一颗北极星。*
最后，当我们(研究和从业者社区)为人工智能伦理领域的一些非常复杂的挑战找出切实可行的解决方案时，领导在为你提供必要的资源和“空中掩护”以试验工具和技术方面发挥着重要作用。
建立反馈机制
作为对上述建议的补充，我们还应该使现场的实践者能够很容易地提供关于工作良好和不良好的工具、技术和过程的反馈。当您有一个大型组织，有许多团队在开发非常不同的产品和服务时，这一点非常重要。自上而下的指导方针和任务可能会因缺乏背景和细微差别而受到影响，而这种情况只会在接近行动地点时变得更加清晰。
有效的反馈机制有两个特点:它们易于归档，并且对哪些反馈被采纳具有透明度。许多地方在第二个方面失败了，没有这一点，整个征求反馈的工作就变得毫无结果。这也从一开始就阻碍了员工分享反馈，使他们对这个过程失去信任。分享已采取行动的反馈结果(通常可以通过工具、技术和流程的变化看到)，更重要的是，分享未采取行动的反馈结果以及未采取行动的原因，这将唤起组织中员工的更高信任度。
授权给人们做决定
通常，那些最接近问题和构建解决这些问题的解决方案的人具有高度的背景洞察力。我们可以通过授权这些人做出决策来利用这些见解。这种授权很重要，因为它确保人们对他们正在构建的解决方案有更大的主人翁感。他们变得更有能力解决对他们的用户和客户真正重要的问题。
一个分层的组织可以帮助不同的团队朝着一个共同的愿景团结起来。尽管如此，当辅以自下而上的方法来生成解决方案并授权员工执行这些解决方案时，我们增加了实现我们负责任的人工智能目标的可能性。
建立这种授权的实际方法是开始分配少量的直接责任来修改产品和服务提供，并随着时间的推移，随着人们表现出对 it 的能力和技能，增加这种责任的范围。更重要的是，用促进负责任人工智能决策的培训项目积极补充这种在职体验将使这种方法取得成功。
与组织价值观保持一致
当人工智能伦理被框定在与组织的使命和价值观一致的环境中时，其中一个核心的不协调之处就出现了。在它们之间建立明确的联系有助于促进理解和利用组织内的其他评估工具(如绩效评估)和政策。
它还有助于将负责任的人工智能作为组织中每个人的工作角色的关键功能进行渗透，这有助于将这些责任有机整合到现有的工作角色中，并使在组织中创建新的工作角色变得容易，这些新的工作角色的任务是在组织中实施人工智能道德。
让 RAI 成为常态而不是例外
正如微软在工具和流程方面投入了多年的努力，以使可访问性成为他们产品和服务的一等公民一样，让负责任的人工智能成为规范而不是例外应该是我们的北极星。
如果通过投资，我们可以使这些想法的实现成为一个默认的动作和简单的动作，那么我们不仅会获得更高的牵引力，而且还会阻止开发人员做除了“正确的”事情之外的任何事情。是的，最后一部分有点令人向往，但并非不切实际！
我很想听听您的意见，看看这些想法中是否有您感兴趣的，以及您是否在您的组织中尝试过这些想法。
请订阅来自蒙特利尔人工智能伦理研究所的人工智能伦理简报了解更多类似内容。
如何建立一个令人惊艳的音乐推荐系统？
利用 Spotify 的数据生成音乐推荐。
马塞拉·拉斯科斯基在 Unsplash 上的照片
你有没有想过 Spotify 是如何根据你的收听历史推荐歌曲和播放列表的？你想知道 Spotify 是如何找到与你已经听过的歌曲相似的歌曲的吗？
有趣的是，Spotify 有一个 web API，开发者可以用它来检索歌曲的音频特征和元数据，如歌曲的流行度、节奏、音量、音调和发行年份。我们可以使用这些数据来构建音乐推荐系统，根据用户所听歌曲的音频特征和元数据向用户推荐歌曲。
在本文中，我将演示如何使用 Spotify 歌曲数据集和 Spotify 的 Python 客户端 Spotipy 来构建基于内容的音乐推荐系统。
安装 Spotipy
Spotipy 是 Spotify Web API 的 Python 客户端，开发者可以轻松获取数据并查询 Spotify 的歌曲目录。在这个项目中，我使用 Spotipy 来获取数据，这些数据在我从 Kaggle 访问的原始 Spotify 歌曲数据集中并不存在。您可以使用下面的命令安装 Spotipy 和 pip。
pip install spotipy
安装 Spotipy 后，您需要在 Spotify 开发者页面上创建一个应用，并保存您的客户端 ID 和密钥。
导入库
在下面的代码中，我导入了 Spotipy 和其他一些用于数据操作和可视化的基本库。你可以在 GitHub 上找到该项目的完整代码。
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import spotipy
import os
%matplotlib inline
读取数据
为了建立一个音乐推荐系统，我使用了 Spotify 数据集，它在 Kaggle 上公开，包含超过 170，000 首不同歌曲的元数据和音频特征。我使用了这个数据集中的三个数据文件。第一个文件包含单首歌曲的数据，而接下来的两个文件包含按流派和歌曲发行年份分组的数据。
spotify_data = pd.read_csv('./data/data.csv.zip')
genre_data = pd.read_csv('./data/data_by_genres.csv')
data_by_year = pd.read_csv('./data/data_by_year.csv')
我在下面加入了列元数据，它是通过为每个数据帧调用熊猫 info 函数生成的。
spotify_data
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 170653 entries, 0 to 170652
Data columns (total 19 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 valence 170653 non-null float64
1 year 170653 non-null int64
2 acousticness 170653 non-null float64
3 artists 170653 non-null object
4 danceability 170653 non-null float64
5 duration_ms 170653 non-null int64
6 energy 170653 non-null float64
7 explicit 170653 non-null int64
8 id 170653 non-null object
9 instrumentalness 170653 non-null float64
10 key 170653 non-null int64
11 liveness 170653 non-null float64
12 loudness 170653 non-null float64
13 mode 170653 non-null int64
14 name 170653 non-null object
15 popularity 170653 non-null int64
16 release_date 170653 non-null object
17 speechiness 170653 non-null float64
18 tempo 170653 non-null float64
dtypes: float64(9), int64(6), object(4)
memory usage: 24.7+ MB
流派 _ 数据
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 2973 entries, 0 to 2972
Data columns (total 14 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 mode 2973 non-null int64
1 genres 2973 non-null object
2 acousticness 2973 non-null float64
3 danceability 2973 non-null float64
4 duration_ms 2973 non-null float64
5 energy 2973 non-null float64
6 instrumentalness 2973 non-null float64
7 liveness 2973 non-null float64
8 loudness 2973 non-null float64
9 speechiness 2973 non-null float64
10 tempo 2973 non-null float64
11 valence 2973 non-null float64
12 popularity 2973 non-null float64
13 key 2973 non-null int64
dtypes: float64(11), int64(2), object(1)
memory usage: 325.3+ KB
逐年数据
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 2973 entries, 0 to 2972
Data columns (total 14 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 mode 2973 non-null int64
1 genres 2973 non-null object
2 acousticness 2973 non-null float64
3 danceability 2973 non-null float64
4 duration_ms 2973 non-null float64
5 energy 2973 non-null float64
6 instrumentalness 2973 non-null float64
7 liveness 2973 non-null float64
8 loudness 2973 non-null float64
9 speechiness 2973 non-null float64
10 tempo 2973 non-null float64
11 valence 2973 non-null float64
12 popularity 2973 non-null float64
13 key 2973 non-null int64
dtypes: float64(11), int64(2), object(1)
memory usage: 325.3+ KBExploratory Data Analysis
基于上面的列描述，我们可以看到每个数据帧具有关于音频特征的信息，例如不同歌曲的可跳舞性和响度，这些信息也已经跨流派和特定年份进行了汇总。
探索性数据分析
该数据集非常有用，可用于多种任务。在建立推荐系统之前，我决定创建一些可视化工具，以便更好地理解数据和过去 100 年来音乐的趋势。
随着时间推移的音乐
使用按年份分组的数据，我们可以了解音乐的整体声音从 1921 年到 2020 年是如何变化的。在下面的代码中，我使用 Plotly 来可视化过去 100 年来歌曲的不同音频特征的值。
import plotly.express as px sound_features = ['acousticness', 'danceability', 'energy', 'instrumentalness', 'liveness', 'valence']
fig = px.line(data_by_year, x='year', y=sound_features)fig.show()
根据上面的情节，我们可以看到，音乐已经从 20 世纪初更多的声学和器乐声音过渡到 21 世纪初更多的舞曲和活力的声音。20 世纪 20 年代的大部分曲目很可能是古典和爵士风格的器乐作品。由于计算机和先进的音频工程技术的出现，2000 年代的音乐听起来非常不同，这些技术允许我们创建具有各种效果和节拍的电子音乐。
我们还可以看看音乐的平均节奏或速度在这些年里是如何变化的。下面的代码生成的图表也支持声音向电子音乐的急剧转变。
fig = px.line(data_by_year, x='year', y='tempo')fig.show()
根据上面的图表，我们可以清楚地看到，在过去的一个世纪里，音乐的发展速度明显加快了。这一趋势不仅是 20 世纪 60 年代迷幻摇滚等新流派的结果，也是音频工程技术进步的结果。
不同体裁的特点
该数据集包含不同歌曲的音频特征以及不同流派的音频特征。我们可以利用这些信息来比较不同的流派，了解它们在声音上的独特差异。在下面的代码中，我从数据集中选择了 10 个最流行的流派，并可视化了每个流派的音频特征。
top10_genres = genre_data.nlargest(10, 'popularity')
fig = px.bar(top10_genres, x='genres', y=['valence', 'energy', 'danceability', 'acousticness'], barmode='group')fig.show()
上述许多流派，如中国电穿孔是非常具体的，很可能属于一个或多个广泛的流派，如流行音乐或电子音乐。我们可以将这些高度特定的流派进行分类，并根据它们的音频特征来理解它们与其他流派的相似程度。
用 K-均值聚类流派
在下面的代码中，我使用了著名而简单的 K-means 聚类算法，根据每个流派的数字音频特征，将该数据集中的 2，900 多种流派分成 10 个聚类。
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipelinecluster_pipeline = Pipeline([('scaler', StandardScaler()), ('kmeans', KMeans(n_clusters=10, n_jobs=-1))])X = genre_data.select_dtypes(np.number)
cluster_pipeline.fit(X)
genre_data['cluster'] = cluster_pipeline.predict(X)
既然流派已经被分配到聚类中，我们可以通过在二维空间中可视化聚类来进一步进行分析。
用 t-SNE 可视化体裁聚类
每个流派都有许多音频特征，很难在高维空间中可视化聚类。但是，我们可以使用一种称为t-分布式随机邻居嵌入的降维技术，将数据压缩到一个二维空间中，如下面的代码所示。
from sklearn.manifold import TSNEtsne_pipeline = Pipeline([('scaler', StandardScaler()), ('tsne', TSNE(n_components=2, verbose=2))])
genre_embedding = tsne_pipeline.fit_transform(X)projection = pd.DataFrame(columns=['x', 'y'], data=genre_embedding)
projection['genres'] = genre_data['genres']
projection['cluster'] = genre_data['cluster']
现在，通过使用 Plotly 的散射函数，我们可以很容易地在二维坐标平面中可视化流派簇。
import plotly.express as pxfig = px.scatter(
projection, x='x', y='y', color='cluster', hover_data=['x', 'y', 'genres'])
fig.show()
二维空间中的流派簇。
用 K-Means 聚类歌曲
为了理解如何建立一个更好的推荐系统，我们还可以使用 K-means 对歌曲进行聚类，如下所示。
song_cluster_pipeline = Pipeline([('scaler', StandardScaler()),
('kmeans', KMeans(n_clusters=20,
verbose=2, n_jobs=4))],verbose=True)X = spotify_data.select_dtypes(np.number)
number_cols = list(X.columns)
song_cluster_pipeline.fit(X)
song_cluster_labels = song_cluster_pipeline.predict(X)
spotify_data['cluster_label'] = song_cluster_labels
基于主成分分析的歌曲聚类可视化
歌曲数据帧比流派数据帧大得多，所以我决定使用 PCA 而不是 t-SNE 进行降维，因为它的运行速度明显更快。
from sklearn.decomposition import PCApca_pipeline = Pipeline([('scaler', StandardScaler()), ('PCA', PCA(n_components=2))])
song_embedding = pca_pipeline.fit_transform(X)projection = pd.DataFrame(columns=['x', 'y'], data=song_embedding)
projection['title'] = spotify_data['name']
projection['cluster'] = spotify_data['cluster_label']
现在，我们可以使用下面的代码在二维空间中可视化歌曲集群。
import plotly.express as pxfig = px.scatter(projection, x='x', y='y', color='cluster', hover_data=['x', 'y', 'title'])
fig.show()
二维空间中的歌曲集群。
上面的情节是交互式的，所以当你悬停在点上时，你可以看到每首歌的标题。如果你花一些时间探索上面的情节，你会发现相似的歌曲往往位于彼此附近，集群内的歌曲往往至少有些相似。这个观察是我在下一节中创建的基于内容的推荐系统背后的关键思想。
构建基于内容的推荐系统
根据上一节的分析和可视化，很明显，相似的流派往往具有彼此靠近的数据点，而相似类型的歌曲也聚集在一起。
在实践层面上，这一观察非常有意义。相似的风格听起来相似，并且来自相似的时间段，而这些风格中的歌曲也是如此。我们可以利用这种想法，通过获取用户听过的歌曲的数据点，并推荐与附近数据点对应的歌曲，来构建推荐系统。
查找不在数据集中的歌曲
在我们建立这个推荐系统之前，我们需要能够容纳原始 Spotify 歌曲数据集中不存在的歌曲。我在下面定义的 find_song 函数从 Spotify 的目录中获取任何歌曲的数据，给出歌曲的名称和发行年份。结果以熊猫数据帧的形式返回，数据字段出现在我从 Kaggle 下载的原始数据集中。
有关如何使用 Spotipy 的详细示例，请参考此处的文档页面。
生成歌曲推荐
现在终于可以搭建音乐推荐系统了！我使用的推荐算法非常简单，遵循三个步骤:
- 计算用户听过的每首歌曲的音频和元数据特征的平均向量。
- 在数据集中找到 n 个最接近这个平均向量的数据点(不包括用户收听历史中歌曲的点)。
- 拿这 n 点，推荐对应的歌曲
该算法遵循在基于内容的推荐系统中使用的通用方法，并且是可推广的，因为我们可以用从经典欧几里德距离到余弦距离的大范围距离度量来数学地定义术语最近。为了这个项目的目的，我使用了余弦距离，这是为两个向量 u 和 v 定义的。
余弦距离公式。
换句话说，余弦距离是 1 减去余弦相似度，余弦是两个向量之间的夹角。余弦距离通常用在推荐系统中，并且即使当所使用的向量具有不同的量值时也能很好地工作。如果两首歌曲的向量是平行的，它们之间的角度将是零，这意味着它们之间的余弦距离也将是零，因为零的余弦是 1。
我在下面定义的函数在 Scipy 的 cdist 函数的帮助下实现了这个简单的算法，用于查找两对点集合之间的距离。
该算法背后的逻辑听起来令人信服，但这个推荐系统真的有效吗？找到答案的唯一方法是用实际例子来测试它。
比方说，我们想为听 90 年代垃圾音乐的人推荐音乐，特别是涅槃乐队的歌曲。我们可以使用 recommend_songs 函数来指定他们的收听历史并生成推荐，如下所示。
recommend_songs([{'name': 'Come As You Are', 'year':1991},
{'name': 'Smells Like Teen Spirit', 'year': 1991},
{'name': 'Lithium', 'year': 1992},
{'name': 'All Apologies', 'year': 1993},
{'name': 'Stay Away', 'year': 1993}], spotify_data)
运行此功能会产生下面的歌曲列表。
[{'name': 'Life is a Highway - From "Cars"',
'year': 2009,
'artists': "['Rascal Flatts']"},
{'name': 'Of Wolf And Man', 'year': 1991, 'artists': "['Metallica']"},
{'name': 'Somebody Like You', 'year': 2002, 'artists': "['Keith Urban']"},
{'name': 'Kayleigh', 'year': 1992, 'artists': "['Marillion']"},
{'name': 'Little Secrets', 'year': 2009, 'artists': "['Passion Pit']"},
{'name': 'No Excuses', 'year': 1994, 'artists': "['Alice In Chains']"},
{'name': 'Corazón Mágico', 'year': 1995, 'artists': "['Los Fugitivos']"},
{'name': 'If Today Was Your Last Day',
'year': 2008,
'artists': "['Nickelback']"},
{'name': "Let's Get Rocked", 'year': 1992, 'artists': "['Def Leppard']"},
{'name': "Breakfast At Tiffany's",
'year': 1995,
'artists': "['Deep Blue Something']"}]
从上面的列表中我们可以看到，推荐算法产生了一个 90 年代和 2000 年代的摇滚歌曲列表。名单中的乐队如 Metallica，Alice in Chains 和 Nickelback 与 Nirvana 相似。排行榜上的第一首歌，“生活是一条高速公路”不是一首垃圾歌曲，但如果你仔细听，吉他即兴重复的节奏实际上听起来类似于涅槃乐队的“闻起来像青少年精神”。
如果我们想为听迈克尔·杰克逊歌曲的人做同样的事情呢？
recommend_songs([{'name':'Beat It', 'year': 1982},
{'name': 'Billie Jean', 'year': 1988},
{'name': 'Thriller', 'year': 1982}], spotify_data)
推荐函数给出了下面的输出。
[{'name': 'Hot Legs', 'year': 1977, 'artists': "['Rod Stewart']"},
{'name': 'Thriller - 2003 Edit',
'year': 2003,
'artists': "['Michael Jackson']"},
{'name': "I Didn't Mean To Turn You On",
'year': 1984,
'artists': "['Cherrelle']"},
{'name': 'Stars On 45 - Original Single Version',
'year': 1981,
'artists': "['Stars On 45']"},
{'name': "Stars On '89 Remix - Radio Version",
'year': 1984,
'artists': "['Stars On 45']"},
{'name': 'Take Me to the River - Live',
'year': 1984,
'artists': "['Talking Heads']"},
{'name': 'Nothing Can Stop Us', 'year': 1992, 'artists': "['Saint Etienne']"}]
排行榜首是洛德·斯蒂沃特的歌曲，他和迈克尔·杰克逊一样，在 20 世纪 80 年代成名。该列表还包含迈克尔·杰克逊的《颤栗者》的 2003 年版本，这是有意义的，因为用户已经听过这首歌的 1982 年版本。该榜单还包括 20 世纪 80 年代乐队的流行和摇滚歌曲，如《45 岁的星星》和《会说话的脑袋》。
我们可以使用更多的例子，但是这些例子应该足以展示推荐系统如何产生歌曲推荐。要获得更完整的示例，请查看该项目的 GitHub 库。用这段代码随意创建你自己的播放列表！
摘要
Spotify 跟踪歌曲的元数据和音频特征，我们可以用它们来建立音乐推荐系统。在本文中，我演示了如何使用这些数据构建一个简单的基于内容的音乐推荐系统，该系统采用余弦距离度量。像往常一样，你可以在 GitHub 上找到这个项目的完整代码。
如果你喜欢这篇文章，并且想了解更多关于推荐系统的知识，可以看看下面列出的我以前的一些文章。
加入我的邮件列表
你想在数据科学和机器学习方面变得更好吗？您想了解数据科学和机器学习社区的最新图书馆、开发和研究吗？
加入我的邮件列表，获取我的数据科学内容的更新。当你注册的时候，你还会得到我免费的解决机器学习问题的逐步指南！
来源
- Y.E. Ay， Spotify 数据集 1921–2020，160k+曲目【T7，】，(2020)，Kaggle。
- 长度范德马滕和 g .辛顿，使用 t-SNE 可视化数据，(2008)，《机器学习研究杂志》。
- 页（page 的缩写）维尔塔宁等人。al，SciPy 1.0:Python 中科学计算的基本算法，(2020)，自然方法。
如何构建自动化开发管道
行业笔记
用最小的挫折开发软件的剧本
在 Unsplash 上 Manouchehr Hejazi 拍摄的照片
在过去的几年里，我领导过许多开发团队。我发现其中的一个共同点是**需要建立一个自动化开发管道。你不一定需要复杂的开发管道。我发现即使是一个基本的管道也可以防止你日常开发中的许多挫折。如果你想开发一个软件产品，即使是一个小玩意，开发管道对你来说也是必不可少的。自动化开发管道帮助您持续评估产品的健全性。对于开发团队来说，没有什么比破软件更伤人的了。你必须尽你所能去阻止它。我来分享两个你发自内心感受到这种需求的场景。**
- **场景 1(当您想要保护主分支免于意外错误时)——**您在团队中工作，并且使用 git 存储库来管理开发。每天都有几个拉取请求要合并到主分支。每个人都尽最大努力编写高质量的功能代码，但不时会有错误注入主分支。结果，代码库停止运行，因此，团队变得沮丧。进度变得非常缓慢，最后期限一个接一个地错过。你希望有办法阻止这种事情发生。
- **场景 2(当您想要加快开发速度时)——**您正在开发一个 web scraper，为一个数据科学项目收集数据。数据科学团队每天都需要大量的数据。在解析机器学习管道中的数据时，您不能承受任何延迟。尽管如此，目标网站中的 HTML 结构不时会发生变化，导致 scraper 停止运行。您希望有一种方法可以自动测试刮刀，并尽快识别错误。
在本文中，我用简单的语言描述了开发管道。我还描述了构建自动化开发管道的最重要的步骤:
- 如何构建和启动服务器
- 如何构建容器化解决方案
- 如何自动构建容器化的解决方案
我希望这有助于你更好地构建开发管道，远离不必要的挫折。
什么是“开发管道”？
开发管道是自动连续执行的一系列命令，用于测试、构建或部署软件产品。这些命令在不同的级别上运行，并使用不同的工具。例如，需要一个服务器来构建开发管道。一个问题是“**如何配置这个服务器？”**您可以手动配置，但最佳实践是使用 Docker 技术。
使用 Docker 技术有很多优势，比如能够在需要时以最少的麻烦从一个服务迁移到另一个*。当您开始构建真实世界的产品时，您会发现能够从一个服务迁移到另一个服务是多么重要。几个月前我也遇到过这种情况。我们被要求从 GCloud 迁移到 OVH ，因为该公司在 OVH 基础设施上有一些其他服务。我们只需不到几天的时间就可以将所有内容从 GCloud 迁移到 OVH。想象一下，如果我们手动配置，会发生什么！*
开发管道是自动连续执行的一系列命令，用于测试、构建或部署软件产品。
如何构建自动化开发管道
构建自动化开发管道需要三个步骤:(a)构建并启动服务器，(b)构建容器化的解决方案，©连续设置一系列命令。
—如何构建和启动服务器
启动服务器需要三个步骤:(1) 构建 docker 映像，(2) 存储 docker 映像，(3) 运行 docker 映像。如果你不想有一个自动化的开发管道，你不需要采取这一步。基本上可以在自己的机器上运行。但是，如果您想要设置 CI/CD 工具，您必须为此启动服务器。
1。构建 Docker 映像— 您需要启动服务器来构建自动化开发管道。有很多方法可以做到这一点。我的建议是构建一个基于 Linux 的 Docker 镜像并安装所有需要的库。你可以通过编写一个 Dockerfile **来构建一个 Docker 镜像。**docker file 是一个文本文档，包含了所有用于安装所有必需的库和软件包的命令。您可以使用下面的代码基于 Docker 文件构建 Docker 映像。
docker **build** —f Dockerfile -t REPOSITORY_NAME/IMAGE_NAME:TAG .
要了解如何为服务器编写 Dockerfile，可以阅读本文:如何创建 Ubuntu 服务器使用 Docker 构建 AI 产品。
2。存储一个 Docker 映像— 然后，你必须在 Docker 注册表中存储Docker 映像T21。Docker 注册表基本上是一个存储 Docker 图像的地方，仅此而已。可以选择包括 DockerHub 或者亚马逊 ECR 在内的任何服务。如果你不知道，我推荐使用 DockerHub，因为它是 Docker 命令行界面的原生版本，与其他服务相比，它让你的生活更轻松。在选择注册中心的过程中，会有一些关于安全性和效率的问题，这些问题在现阶段并不重要。例如，如果您有一个复杂的管道，最好使用位于正在使用的其他云服务旁边的注册服务。这使得命令如docker pull或docker push执行得更快。您可以使用下面的代码将 Docker 映像推送到远程 Docker 存储库。
docker **push** REPOSITORY_NAME/IMAGE_NAME:TAG
3。运行 Docker 镜像— 你可以在许多服务上运行 Docker 镜像来启动服务器。最后两步是关于如何构建和存储一个 Docker 映像作为服务器使用。这一步是关于如何启动服务器。如果你不想有一个“自动化”的开发管道，你就不需要服务器。
让我分享一个在 CircleCI 上用于启动服务器的代码片段，circle CI 是目前使用的一个著名的 CI/CD 工具。下面的代码是定义要在服务器上运行的测试作业的一部分，该服务器使用 Docker 映像启动。这是 CircleCI 使用的语法，因此其他 CI/CD 工具可能不同，但概念是相同的。启动后，可以运行其他步骤，如checkout。checkout是 CircleCI 用来在服务器上克隆一个代码库的特殊代码，该代码库是在之前的一个步骤中启动的。如果你想了解更多关于 CircleCI 的内容，我推荐你阅读这篇文章:如何用简单的话学习 circle ci。
jobs:
test:
docker:
- image: REPOSITORY_NAME/DOCKERIMAGE_NAME:TAG
auth:
username: $USERNAME
password: $PASSWORD
steps:
- checkout
- run:
...
照片由奥拉夫·阿伦斯·罗特内在 Unsplash 拍摄
—如何构建容器化的解决方案
构建软件最重要的一步是确保它能工作。你可以把它看作是一个“集成测试”,将单个的模块组合在一起，作为一个组进行测试。因此，如果您正在开发一个数据科学项目，您可能希望构建一个集成测试，如果您正在开发一个 web 应用程序，您可能希望使用 Docker 构建一个容器化的解决方案。
使用 Docker 技术，您可以为服务器构建一个 Docker 映像，并为您的解决方案构建一个 Docker 映像。您在为服务器和解决方案构建 Docker 映像时面临的挑战是相似的；然而，他们有不同的目的。正如你在上面读到的，你必须有一个 docker 文件作为“如何做”的处方来构建你的解决方案。当你有了一个功能 Dockerfile 文件，你就可以进入下一步了。请注意，这些是下一节将解释的开发管道的构建块。
—如何自动构建容器化解决方案
*开发管道是一系列连续执行的命令。您可以通过两种方式自动执行一系列命令:Bash 脚本或 CI/CD 工具。*后者给你更多的选项去配置；但是，前一种可以自己解决很多问题。让我们深入了解这些工具是什么。
**1。Bash 脚本(当你想要构建一个管道时)——**Bash 脚本是一个文本文件，包含一系列命令，当你运行脚本时，这些命令会连续运行。Bash 脚本中的每一行都是您先前在终端中执行的一个命令，以完成特定的任务。Bash 脚本中编写的命令的顺序与您在终端中运行它们的顺序完全相同。下面的代码提示了什么是 bash 脚本。请注意，Bash 脚本在 Windows 和 macOS 上略有不同，这不是本文的重点。您可以使用下面用 Bash 脚本编写的代码来build 和pushDocker 图像。
#!/bin/bash
export IMAGE_NAME=XXX
export USERNAME=XXX
export PASSWORD=XXXdocker login -u $USERNAME -p $PASSWORD
docker build -f Dockerfile -t $IMAGE_NAME .
docker push $IMAGE_NAMEE
**2。CI/CD(当你想要建立一个“自动化”的管道时)——**CI/CD(即持续集成/持续部署)工具是一个专门的软件，主要运行在云上，当它们被触发时，以特定的顺序自动执行一系列命令。它们通常使用 YAML 文件进行配置，您可以在其中定义许多“作业”和“工作流”。“作业”是在单个单元中执行的步骤的集合，类似于上面解释的 Bash 脚本。“工作流”是一组规则，用于根据需要按特定顺序运行一组作业。
我强烈建议首先编写一个 Bash 脚本，然后开始配置您选择的 CI/CD 工具。你可能会问为什么？首先，您很可能需要 Bash 脚本中编写的所有代码来配置 CI/CD 工具。其次，如果你不是专家，设置 CI/CD 工具可能会有点困难。下面的代码是要在 CircleCI 上运行的作业的一部分。正如你所看到的，这些命令与上面的 Bash 脚本完全相同*，但是采用了 CircleCI 可以解析的 YAML 形式*。
...
- run:
name: Authentication
command: docker login -u $USERNAME -p $PASSWORD
- run:
name: Build
command: docker build -f Dockerfile -t $IMAGE_NAME .
- run:
name: Store
command: docker push $IMAGE_NAME
...
—遗言
自动化开发管道是一个复杂的概念，可以以多种形式实现。在这篇文章中，我试图与你分享主要的概念。你肯定需要学习更多来为你的软件产品建立一个有用的管道。然而，你需要从这篇文章中学到的是，即使是一个小的自动化管道也能帮你很多。所以，我建议你今天就建立一个自动化的管道。你永远不会后悔！
感谢阅读！
如果你喜欢这个帖子，想支持我…
https://pedram-ataee.medium.com/membership
如何构建 AutoML API
构建可重用 ML 类的简单指南
最近人们对汽车很感兴趣。从开源项目到云中的可扩展算法，让非技术用户更容易使用 ML 的项目越来越多。云中 AutoML 的例子包括 SageMaker Canvas 和 Azure AutoML 等等。在本文中，我们将不会在云上工作，而是向您展示如何构建一个简单的 Python API 来自动解决回归问题。有许多开源项目正在解决 AutoML 问题。
我将带您完成构建您自己的 AutoML 类的过程。即使您最终没有创建自己的包，构建可重用的类也是很好的编程实践。您还可以构建 API 来自动化 ML 中的许多冗余任务。一个例子是为 NLP 项目构建预处理类，你可以为基于文本的项目重用你的 API。要阅读这篇文章，你应该对 Python 和面向对象编程有很好的理解。
目录
- 设置
- 构建您的 API
- 测试 API
- 后续步骤和结论
1.设置
在我们开始构建 API 之前，您需要安装以下库:pandas、numpy 和 sklearn。下面的代码块将包含我们正在处理的导入。
进口
既然已经安装了所有必需的库，下一步就是设置我们要处理的类。我们的简单 API 有四个主要参数:数据集、目标列、模型类型和度量类型。对于数据集，我们将提供 CSV 数据集的路径。对于目标列，我们需要选择我们试图预测的列，因为它是在数据集中声明的。对于模型类型，我们在线性和随机森林回归中有两个选项可供选择。最后，对于公制类型，有平均绝对误差(MAE)和均方根误差(RMSE)。
AutoML 类已创建
我们还会用类方法填充一些参数。
现在我们已经准备好为预处理、模型训练和评估构建我们的方法。
2.构建您的 API
构建 AutoML API 的第一步是预处理函数。我们将读入数据，然后将其分成训练集和测试集。我们还检查我们的目标列参数是否存在于已经提供的数据集中。
预处理方法
既然我们已经有了我们训练和测试数据，我们可以把注意力集中在我们的模型构建/训练方法上。
训练方法
目前只有两种模型提供:线性 _ 回归和随机 _ 森林。我们检查以确保您输入了这两个模型中的一个，然后根据您的选择创建并训练所选的模型。
线性和随机森林回归
现在我们可以返回一个基于 metric_type 参数的度量。为此，我们可以创建一个 evaluate 方法，根据该参数的输入返回 MAE 或 RMSE。
评估方法
首先，我们检查以确保输入是受支持的指标之一，然后我们返回用户选择。如果我们想要完整的信息，我们可以使用 logModelInfo 方法，该方法具有模型类型和两个度量。一般来说，随着 API 变得越来越复杂，您将需要一个日志记录方法来跟踪您的查询。
日志信息
3.测试 API
现在我们可以用一些样本输入来测试我们的样本 API。
样本值输入
在这里，我们要求一个线性回归模型与 MAE 指标。
示例输出(作者截图)
我们可以使用随机森林模型和 RMSE 度量来尝试另一个样本。
样本 RF 输入
示例输出(作者截图)
4.后续步骤和结论
要访问示例的完整代码，请查看这个链接。如您所见，为 ML 构建 Python 类是一个非常简单的过程。要构建复杂的真实世界级别的包，只需要几个额外的步骤和一个可重复的设置，查看这个资源就可以开始了。有大量的 AutoML 开源项目你可以开始参与。即使作为数据科学家，熟悉构建类、包，并在更深层次上理解您正在使用的开源工具或 AutoML 服务也是至关重要的。
如果你喜欢这篇文章，请在LinkedIn上联系我，订阅我的媒体 简讯 。如果你是新手，使用我的 会员推荐 报名。
如何用 Python 构建 AutoML 应用程序
使用来自 envato elements 的 koctia 的图像创建(经许可)。
数据科学 | 机器学习
使用 Streamlit 库的分步教程
自动化机器学习(AutoML)通过简化流程来帮助降低机器学习模型构建的门槛，从而允许非技术用户利用机器学习的力量。另一方面，AutoML 的可用性也有助于解放数据科学家的时间(否则他们会花在冗余和重复的预处理任务或模型构建任务上)，允许他们探索数据分析管道的其他领域。
简而言之，用户可以向 AutoML 系统提供输入数据集，用于模型构建(特征转换、特征选择、超参数优化等)。)最后，它将预测作为输出返回。
如果你可以构建自己的 AutoML 应用程序，并根据自己的喜好进行定制，这不是很好吗？该 AutoML 应用程序的开发分为两部分:(1)模型部署有助于完成数据生命周期，以及(2) AutoML 有助于非技术用户访问 ML。
在本文中，我们将使用 Streamlit 和 Scikit-learn 库用 Python 构建一个 AutoML 应用程序。这个 web 应用程序将允许用户上传他们自己的 CSV 文件，并且 web 应用程序将通过执行网格超参数搜索来自动构建随机森林模型。
需要注意的是，这篇文章的灵感来自于我前段时间在我的 YouTube 频道上做的一个视频( 如何搭建一个机器学习超参数优化 App)(数据教授 )。
1.AutoML 应用程序概述
我们今天构建的 AutoML 应用程序不到 200 行代码，确切地说是 171 行。
1.1.技术堆栈
web 应用程序将使用以下库在 Python 中构建:
streamlit—网络框架pandas—处理数据帧numpy—数值数据处理base64—对要下载的数据进行编码scikit-learn—进行超参数优化，建立机器学习模型
1.2.用户界面
web 应用程序有一个简单的界面，由两个面板组成:(1)左侧面板接受输入 CSV 数据和参数设置，而(2)主面板显示输出，包括打印出输入数据集的数据帧、模型的性能指标、超参数调整的最佳参数以及调整后的超参数的 3D 等值线图。
AutoML 应用程序的屏幕截图。
1.3.AutoML 应用程序演示
让我们看一下下面 2 个截图中的 web 应用程序，这样你就可以对你将要构建的应用程序有个大概的了解。
1.3.1。AutoML 应用程序使用示例数据集
试用 web 应用程序的最简单方法是使用提供的示例数据集，方法是单击主面板中的Press to use Example Dataset按钮，这将加载糖尿病数据集作为示例数据集。
使用示例数据集的 AutoML 应用程序的屏幕截图。
1 . 3 . 2。AutoML 应用程序使用上传的 CSV 数据**
或者，您也可以上传自己的 CSV 数据集，方法是将文件直接拖放到上传框中(如下图所示)，或者点击Browse files按钮并选择要上传的输入文件。
使用输入 CSV 数据集的 AutoML 应用程序的屏幕截图。
在上面的两个屏幕截图中，在提供示例数据集或上传的 CSV 数据集后，应用程序打印出数据集的数据帧，通过使用提供的输入学习参数自动构建几个机器学习模型，以执行超参数优化，然后打印出模型性能指标。最后，在主面板的底部提供了调整后的超参数的交互式 3D 等高线图。
您也可以点击以下链接试用该应用程序:
2.代码
现在让我们深入了解一下 AutoML 应用程序的内部工作原理。如你所见，整个应用程序只用了 171 行代码。
应该注意的是，代码中提供的所有注释(由包含散列标签符号#的行表示)通过记录每个代码块正在做什么来使代码更可读。
第 1–10 行
导入必要的库，包括streamlit、pandas、numpy、base64、plotly和scikit-learn。
第 15–16 行
set_page_config()功能允许我们将网页标题指定为page_title=‘The Machine Learning Hyperparameter Optimization App’，并将页面布局设置为全幅模式，如layout=’wide’输入参数所指定。
第 19–25 行
在这里，我们使用 st.write()函数和 markdown 语法，通过在标题文本The Machine Learning Hyperparameter Optimization App前面使用#标签来编写第 20 行的网页标题文本。在随后的几行中，我们编写了 web 应用程序的描述。
第 29–58 行
这些代码块属于左侧面板中的输入小部件，它接受用户输入的 CSV 数据和模型参数。
- 第 29–33 行—第 29 行通过
st.sidebar.header()函数打印左侧边栏面板的标题文本，其中函数中的 sidebar 指示输入小部件应该放置在左侧边栏面板中的位置。线 30 通过st.sidebar.file_uploader()功能接受用户输入的 CSV 数据。正如我们所看到的，有 2 个输入参数，其中第一个是文本标签Upload your input CSV file，而第二个输入参数type=[“csv”]限制只接受 CSV 文件。第 31–33 行通过st.sidebar.markdown()函数以 Markdown 语法打印到示例数据集的链接。 - 第 36 行—通过
st.sidebar.header()功能打印标题文本Set Parameters。 - 第 37 行通过
st.sidebar.slider()功能显示一个滑动条，允许用户通过简单调整滑动条来指定数据分割比率。第一个输入参数打印小部件标签文本Data split ratio (% for Training Set)，其中接下来的 4 个值代表最小值、最大值、默认值和增量步长。最后，将指定值赋给split_size变量。 - 第 39–47 行显示学习参数的输入部件，而第 49–54 行显示一般参数的输入部件。类似于对第 37 行的解释，这些代码行也利用
st.sidebar.slider()作为输入小部件，接受用户指定的模型参数值。第 56–58 行将滑块输入的用户指定值组合成一个聚合形式，然后作为负责超参数调整的GridSearchCV()函数的输入。
第 64 行
通过st.subheader()功能在输入数据帧上方添加一个副标题文本Dataset。
第 69–73 行
这段代码将通过base64库对模型性能结果进行编码和解码，作为一个可下载的 CSV 文件。
第 75–153 行
在高层次上，这个代码块是build_model()自定义函数，它将接受输入数据集和用户指定的参数，然后执行模型构建和超参数调整。
- 第 76–77 行——输入数据帧分为
X(删除最后一列 Y 变量)和Y(特别选择最后一列)变量。 - 第 79 行——这里我们通过
st.markdown()函数通知用户模型正在构建中。然后在第 80 行，Y 变量的列名通过st.info()函数打印在一个信息框中。 - 第 83 行——使用
X和Y变量作为输入数据，通过train_test_split()功能执行数据分割，而用户指定的分割比率值由split_size变量指定，该变量从第 37 行描述的滑动条中取值。 - 第 87–95 行—通过分配给
rf变量的RandomForestRegressor()函数实例化随机森林模型。如您所见，RandomForestRegressor()函数中定义的所有模型参数都从用户指定的输入小部件中获取参数值，如上文第 29–58 行所述。 - 第 97–98 行—执行超参数调整。
→第 97 行——在rf变量中指定的上述随机森林模型被指定为GridSearchCV()函数中的estimator参数的输入变量，它将执行超参数调整。在超参数调整中探索的超参数值范围在param_grid变量中指定，该变量直接从用户指定值中取值，该值从滑动条(第 40-43 行)获得，并作为param_grid变量(第 56-58 行)进行预处理。
→第 98 行——超参数调整过程从输入X_train和Y_train作为输入数据开始。 - 第 100 行—通过
st.subheader()功能打印型号性能副标题文本。接下来的行将打印模型性能指标。 - 第 102 行——存储在
grid变量中的超参数调整过程的最佳模型被用于对X_test数据进行预测。 - 第 103–104 行—通过使用
Y_test和Y_pred_test作为输入参数的r2_score()函数打印 R2 分数。 - 第 106–107 行—通过使用
Y_test和Y_pred_test作为输入参数的mean_squared_error()函数打印 MSE 分数。 - 第 109–110 行—打印最佳参数，并四舍五入到小数点后两位。最佳参数值从
grid.best_params_和grid.best_score_变量中获得。 - 第 112–113 行—第 112 行通过
st.subheader()功能打印副标题Model Parameters。第 113 行通过st.write()功能打印存储在grid.get_params()中的模型参数。 - 第 116-125 行——从
grid.cv_results_获得模型性能指标，并重新调整为x、y和z。
→第 116 行——我们将有选择地从grid.cv_results_中提取一些数据，这些数据将用于创建一个包含 2 个超参数组合及其相应性能指标的数据框架，在本例中是 R2 分数。特别是，pd.concat()功能将用于组合 2 个超参数(params)和性能指标(mean_test_score)。
→第 118 行——现在将进行数据整形，以将数据准备成适合创建等高线图的格式。特别是，pandas库中的groupby()函数将用于根据两列(max_features和n_estimators)对数据帧进行分组，从而合并第一列(max_features)的内容。 - 第 120–122 行—数据现在将被旋转到一个 m ⨯ n 矩阵中，其中的行和列分别对应于
max_features和n_estimators。 - 第 123-125 行——最后，各
x、y和z变量的整形数据将用于绘制等高线图。 - 第 128-146 行——这些代码块现在将通过
plotly库使用x、y和z变量创建 3D 等高线图。 - 第 149-152 行——然后将
x、y和z变量组合成一个df数据帧。 - 第 153 行——存储在 grid_results 变量中的模型性能结果现在可以通过
filedownload()自定义函数下载(第 69–73 行)。
第 156–171 行
在高层次上，这些代码块将执行应用程序的逻辑。这由 2 个代码块组成。第一个是if代码块(第 156-159 行)，第二个是else代码块(第 160-171 行)。每次 web 应用程序加载时，它将默认运行else代码块，而if代码块将在输入 CSV 文件上传时被激活。
对于两个代码块，逻辑是相同的，唯一的区别是df数据 dataframe 的内容(无论它是来自输入 CSV 数据还是来自示例数据)。接下来，通过st.write()功能显示df数据框的内容。最后，通过build_model()自定义函数启动模型构建过程。
3.运行 AutoML 应用程序
现在我们已经编写了应用程序，让我们继续启动它。
3.1.创造康达环境
让我们首先创建一个新的conda环境(为了确保代码的可再现性)。
首先，在终端命令行中创建一个名为automl的新conda环境，如下所示:
conda create -n automl python=3.7.9
其次，我们将登录到automl环境
conda activate automl
3.2.安装必备库
首先，下载requirements.txt文件
wget [https://raw.githubusercontent.com/dataprofessor/](https://raw.githubusercontent.com/dataprofessor/ml-auto-app/main/requirements.txt)[ml-opt-app](https://github.com/dataprofessor/ml-opt-app)[/main/requirements.txt](https://raw.githubusercontent.com/dataprofessor/ml-auto-app/main/requirements.txt)
其次，安装如下所示的库
pip install -r requirements.txt
3.3.下载应用程序文件
您可以下载数据教授的 GitHub repo 上托管的 web 应用程序文件，也可以使用上面找到的 171 行代码。
wget [https://github.com/dataprofessor/](https://github.com/dataprofessor/ml-app/archive/main.zip)[ml-opt-app](https://github.com/dataprofessor/ml-opt-app)[/archive/main.zip](https://github.com/dataprofessor/ml-app/archive/main.zip)
接下来，解压缩文件内容
unzip main.zip
现在通过cd命令进入main目录
cd main
现在你在main目录中，你应该能够看到ml-opt-app.py文件。
3.4.启动 web 应用程序
要启动应用程序，请在终端提示符下键入以下命令(即确保ml-opt-app.py文件位于当前工作目录中):
streamlit run ml-opt-app.py
几秒钟后，终端提示中出现以下消息。
> streamlit run ml-opt-app.pyYou can now view your Streamlit app in your browser.Local URL: [http://localhost:8501](http://localhost:8501)
Network URL: [http://10.0.0.11:8501](http://10.0.0.11:8501)
最后，应该会弹出一个浏览器和应用程序。
本地启动的 AutoML App 截图。
您也可以通过以下链接测试 AutoML 应用程序:
4.结论
现在您已经按照本文中的描述创建了 AutoML 应用程序，接下来呢？你或许可以将这款应用调整为另一种机器学习算法。附加功能，如功能重要性图也可以添加到应用程序中。可能性是无穷的，并享受定制应用程序的乐趣！请随时发表评论，说明您是如何为自己的项目修改应用程序的。
订阅我的邮件列表，获取我在数据科学方面的最佳更新(偶尔还有免费赠品)!
关于我
我是泰国一所研究型大学的生物信息学副教授和数据挖掘和生物医学信息学负责人。在我下班后的时间里，我是一名 YouTuber(又名数据教授)制作关于数据科学的在线视频。在我制作的所有教程视频中，我也在 GitHub 上分享 Jupyter 笔记本(数据教授 GitHub page )。
https://www.youtube.com/dataprofessor
在社交网络上与我联系
✅YouTube:http://youtube.com/dataprofessor/
♇网站:http://dataprofessor.org/(在建)
♇LinkedIn:https://www.linkedin.com/company/dataprofessor/
♇Twitter:https://twitter.com/thedataprof/
♇Facebook:http://facebook.com/dataprofessor/
♇github:https://github.com/dataprofessor/
♇Instagram:)
如何用 Python 构建 EDA 应用程序
使用来自 envato elements 的 hoangpts 的图像创建(经许可)。
数据科学 | 机器学习
用 50 行代码从头开始一步一步的教程
探索性数据分析(EDA)是探索和总结数据集主要特征的基本和初步的第一步。EDA 提供了帮助我们更好地理解变量及其关系的方法。这是通过非图形(描述性统计)和图形(数据可视化)技术实现的。
在本文中，我们将创建一个 EDA web 应用程序，您可以使用它来加速 EDA 分析，或者让您的同事无需使用 Python 编写代码就可以执行 EDA。执行 EDA 分析只需简单上传输入 CSV 文件。
也可以参考我 YouTube 频道(数据教授)的我的 YouTube 视频 如何利用熊猫建档 构建探索性数据分析 app 作为本文的补充。
1.EDA 工具(Pandas Profiling)
一个简单直观的 EDA 工具是 Python 中的pandas-profiling库。它允许通过df.profile_report()功能为df数据帧生成一份分析报告。
生成的配置文件是一个交互式 HTML 报告，显示每个变量的以下统计数据(更多详情，请参见文档):
- 类型推断:识别数据帧中各列的数据类型。
- 要领:类型、唯一值、缺失值。
- 分位数统计:最小值、最大值、Q1、中位数、Q3、极差和四分位差。
- 描述性统计:均值、众数、标准差、总和、中位数绝对偏差、变异系数、峰度、偏度。
- 最频繁值
- 直方图:数值范围分布。
- 相关性:突出显示高度相关的变量、Spearman、Pearson 和 Kendall 矩阵。
- 缺失值:缺失值的矩阵、计数、热图和树状图。
- 重复行:列出出现次数最多的重复行。
- 文本分析:了解文本数据的类别(大写、空格)、脚本(拉丁文、西里尔文)和块(ASCII)。
2.关于我们今天正在构建的 EDA 应用程序
我们今天将要构建的 EDA 应用程序将允许我们将自己的 CSV 数据集上传到应用程序，然后应用程序将自动生成一个*(一个便于 EDA 分析的交互式 HTML 报告)。*
你可以在这里自己试试: EDA App 演示
3.EDA 应用程序的代码
这段代码有 50 多行代码，准确地说是 52 行。
让我们来看看应用程序背后的技术。它基于由以下内容组成的 5 个 Python 库:
numpy—用于生成由 5 列(变量)组成的合成数据集，该数据集用作示例数据集(注意 web 应用程序页面标题下主面板中的Press to use Example Dataset按钮)。pandas—用于存放数据帧形式的数据。streamlit—使构建简单 web 应用成为可能的 web 框架。pandas_profiling—为执行 EDA 生成交互式 HTML 报告的库。streamlit_pandas_profiling—允许在 Streamlit web 应用程序中使用pandas_profiling库的库。
4.对代码的逐行解释
第 1–5 行
- 导入由
numpy、pandas、streamlit、pandas_profiling和streamlit_pandas_profiling组成的必备库
第 7–13 行
- 第 7 行 —注释文本，表示后续代码块与 web 应用程序的标题相关。
- 第 8–13 行—
st.markdown()功能打印 web 应用程序的标题。输入参数采用 Markdown 语法。
第 15–20 行
- 第 15 行 —注释文本，描述第 16–20 行负责 CSV 上传功能。
- 第 16 行 —
with用于构建属于代码块的后续代码行。st.sidebar.header()指定使用header()功能在左侧面板显示标题文本1\. Upload your CSV data。 - 第 17 行—
st.sidebar.file_uploader()功能允许创建上传框。需要注意的是st.sidebar指定了上传框在侧边栏中的位置(可折叠的左侧面板)。在file_uploader()函数中找到的输入参数type=["csv"]指定上传框只接受csv文件类型。 - 第 18 行—
st.sidebar.markdown()函数指定使用markdown()函数在左侧面板中显示一个指向示例 CSV 文件的链接。
第 22–52 行
- 第 22 行 —注释文本，描述后续代码块负责创建 Pandas Profiling 报告。这里需要注意的是，这个部分由一个
if-else语句组成，每次 web 应用程序加载时，默认情况下都会运行else代码块(第 35–52 行)。上传输入 CSV 文件后，if代码块(第 23-34 行)将被激活并运行。 - 第 23–34 行 —该代码块代表
if语句。如前所述，该代码块将在输入 CSV 文件上传后运行。
— 第 23 行 —设置if条件，检测uploaded_file is not None指示文件上传。
— 第 24 行—@st.cache装饰器允许应用程序跳过后续代码行中定义的高成本且重复的函数。
— 第 25–27 行 —一个名为load_csv的自定义函数，通过uploaded_file变量从上传框读入输入 CSV 文件。
— 第 28 行 —从load_csv自定义函数读取的 CSV 文件内容被分配给df变量。
— 第 29 行—ProfileReport()功能被分配给pr变量。
— 第 30–31 行—**Input DataFrame**的标题通过st.header()功能打印为标题文本(第 30 行)。存储在df变量中的数据帧内容被打印出来(第 31 行)。
— 第 32 行 —"- — -”打印一个水平条。
— 第 33–34 行—**Pandas Profiling Report**的标题通过st.header()功能打印为标题文本(第 33 行)。存储ProfileReport()功能输出的pr变量的内容被打印出来。特别是，这是允许 EDA 功能的交互式 HTML 配置文件报告。 - 第 35–52 行 —该代码块代表
else语句。
— 第 35 行—else条件设置为默认状态，每次加载 web 应用程序时运行。
— 第 36 行 —通过st.info()功能在信息框中打印一段文字Awaiting for CSV file to be uploaded.。
— 第 37–52 行—if条件用于指定点击Press to use Example Dataset按钮的结果(其下的语句将被运行),这将使用示例数据集生成配置文件报告。
— 第 38 行 —注释文本，表示以下代码行与示例数据相关。
— 第 39 行——如前面第 24 行所述，@st.cache装饰器允许应用跳过后续代码行的潜在高成本运行(即，否则应用将在每次重新加载时重新生成合成数据集)。
— 第 40–45 行 —定义了一个自定义函数，使用NumPy库创建一个由 5 列组成的合成数据集。
— 第 46 行 —第 40–45 行自定义函数定义的合成数据集被分配给df变量。
5.运行 EDA 应用程序
现在是运行应用程序的时候了。
5.1.创造康达环境
让我们假设您是从零开始，因此您将不得不创建一个新的conda环境(这是一个好主意，以确保代码的可再现性)。
首先，在终端命令行中创建一个名为eda的新conda环境，如下所示:
*conda create -n eda python=3.7.9*
其次，我们将登录到eda环境
*conda activate eda*
5.2.安装必备库
首先，下载 requirements.txt 文件
*wget [https://raw.githubusercontent.com/dataprofessor/eda-app/main/requirements.txt](https://raw.githubusercontent.com/dataprofessor/ml-auto-app/main/requirements.txt)*
其次，安装如下所示的库
*pip install -r requirements.txt*
5.3.下载 EDA 应用文件
您可以下载数据教授的 GitHub repo 上托管的 web 应用程序文件，也可以使用上面找到的 52 行代码。
*wget [https://github.com/dataprofessor/eda-app/archive/main.zip](https://github.com/dataprofessor/ml-app/archive/main.zip)*
接下来，解压缩文件内容
*unzip main.zip*
现在通过cd命令进入main目录
*cd main*
现在你在main目录中，你应该能够看到app.py文件。
5.4.启动 web 应用程序
可以通过在终端提示符下键入以下命令来启动应用程序(即确保app.py文件在当前工作目录下):
*streamlit run app.py*
之后，您将在终端提示符下看到以下消息。
*> streamlit run app.pyYou can now view your Streamlit app in your browser.Local URL: [http://localhost:8501](http://localhost:8501)
Network URL: [http://10.0.0.11:8501](http://10.0.0.11:8501)*
最后，应该会弹出一个浏览器和应用程序。
EDA App 截图。试用 app 请参考EDA App demo。****
****EDA 应用在运行中的截图。我们可以在这里看到相关图。请参考上面第 2 节中的动画示例。
恭喜你！
现在，您已经创建了一个 EDA 应用程序，可以让您在旅途中轻松执行 EDA 分析，只需上传一个输入 CSV 文件，即可开始执行 EDA 分析。
将 EDA 应用部署到互联网
如果您希望向全世界公开您的 web 应用程序，您可以将其部署到互联网上。我在 YouTube 上制作了视频，展示如何在 Heroku、Streamlit 和 Streamlit 上做到这一点。
通过 Streamlit 共享平台在互联网上部署的 EDA 应用示例可在此处访问: EDA 应用演示
订阅我的邮件列表，获取我在数据科学方面的最佳更新(偶尔还有免费赠品)!
关于我
我是泰国一所研究型大学的生物信息学副教授和数据挖掘和生物医学信息学负责人。在我下班后的时间里，我是一名 YouTuber(又名数据教授)制作关于数据科学的在线视频。在我做的所有教程视频中，我也在 GitHub 上分享 Jupyter 笔记本(数据教授 GitHub page )。
***https://www.youtube.com/dataprofessor
在社交网络上与我联系
✅YouTube:http://youtube.com/dataprofessor/
♇网站:http://dataprofessor.org/(在建)
♇LinkedIn:https://www.linkedin.com/company/dataprofessor/
♇Twitter:https://twitter.com/thedataprof
♇Facebook:http://facebook.com/dataprofessor/
♇github:https://github.com/dataprofessor/
♇insta gram:https://www.instagram.com/data.professor/【t19***
如何建立一个高效的现代化数据平台
为什么您应该将数据湖、数据仓库和数据集市集成在一起，而不是将它们孤立起来
乔尔·沃戴尔在 Unsplash 上拍摄的照片
它们应该自由地相互集成，而不是独立地构建和理解数据湖、数据仓库和数据集市。这避免了数据孤岛并简化了数据供应。
什么是什么？
数据仓库和数据湖代表了一个中央数据库系统，可用于公司的分析目的。该系统从各种异构数据源提取、收集和保存相关数据，并提供给下游系统。
数据仓库可以分为四个子过程:
- 数据获取:从各种数据仓库中获取和提取数据。
- 数据存储:在数据仓库中存储数据，包括长期存档。
- 数据供应:为下游系统提供所需的数据，提供数据集市。
- 数据评估:对数据库的分析和评估。
虽然数据仓库将经典的 ETL 过程与关系数据库中的结构化数据结合使用，但数据湖使用 ELT 和模式等范例读取非结构化数据[1]。
差异数据仓库与湖
在上图中，您可以看到主要的区别。你使用的技术也很不同。对于数据仓库，您将使用 SQL 和关系数据库，而对于数据湖，您可能会使用 NoSQL 或两者的混合。
可以说，数据集市是面向特定业务部门的数据仓库的子集[2]。数据集市包含收集的汇总数据的存储库，用于对组织内的特定部门或单位(例如销售部门)进行分析。
将所有这些结合在一个混合数据湖中
那么如何将这些概念结合起来呢？在下图中，您可以从高层次的角度看到一个架构。该过程是将非结构化和未转换的数据加载到数据湖中。从这里，一方面，数据可以用于 ML 和数据科学任务。另一方面，数据也可以以结构化的形式被转换和加载到数据仓库中。从这里开始，可以通过数据集市和(自助式)BI 工具实现传统的数据仓库分布。
混合数据湖概念—图片来自作者
您可以为这个架构使用的主要技术可以是例如:[3][4]
- ELT/ETL 流程通过——talend、Google 数据流、AWS 数据管道
- 数据湖 via — HDFS、AWS 雅典娜和 S3、谷歌云存储
- 数据仓库/数据集市通过——Google big query、AWS Redshift、雪花
注意:像 Google 的 BiqQuery 或 AWS Redshift 这样的技术通常被认为是数据仓库和数据湖技术的混合体，因为它们通常已经实现了 NoSQL 的一些特征。
大多数技术可以从单一来源获得的事实使得建立这样的数据平台更加容易。这对小公司来说是一个优势。例如，一旦数据被加载到数据仓库中，就可以通过现有的接口相对容易地对其进行进一步的处理，用于 ETL 和数据集市过程，通常只需要很少的编程工作。
结论
本文解释了如何使用混合数据湖。数据湖使您的公司能够灵活地以数据形式捕获业务运营的各个方面，同时保持传统数据仓库的活力。从那里，数据可以依次转移到数据集市。好处是一切都建立在相同的数据源和技术上，因此可以更容易地进行更改。大型云提供商通常从一个来源提供所有必要的工具，因此这导致了更容易的处理和可能的成本优势。我帮助构建的一个解决方案包括 Google Storage 和 BigQuery 作为数据湖和暂存区，talend 作为 ETL/ELT 工具，Big Query 作为数据仓库和数据集市层。从那里，数据可以很容易地用于 ML 服务或 BI 工具 Data Studio。
资料来源和进一步阅读
[1] IBM，绘制数据湖:使用读取模式和写入模式的数据模型 (2017)
[2]数据仓库指南，数据仓库指南，(2021)
[3]谷歌，帮助保护从数据湖到数据仓库的管道 (2021)
[4] AWS，AWS 中的混合数据湖 (2021)
如何用 Flash 用几行代码构建一个图像分类器
Flash 简介:面向初学者的高级深度学习框架
Brian Suh 在 Unsplash 上拍摄的照片
介绍
图像分类是一项任务，我们要预测哪一类属于一幅图像。由于图像表示，这项任务很困难。如果我们将图像展平，它将创建一个长的一维向量。此外，该表示将丢失邻居信息。因此，我们需要深度学习来提取特征并预测结果。
有时候，建立深度学习模型可能会成为一项艰巨的任务。虽然我们为图像分类创建了一个基础模型，但是我们需要花费大量的时间来创建代码。我们必须准备代码来准备数据、训练模型、测试模型，并将其部署到服务器。这就是闪光的来源！
Flash 是一个高级深度学习框架，用于快速构建、训练和测试深度学习模型。Flash 基于 PyTorch 框架。所以如果你了解 PyTorch，你会很容易熟悉 Flash。
与 PyTorch 和 Lighting 相比，Flash 易于使用，但不如以前的库灵活。如果你想建立一个更复杂的模型，你可以使用 Lightning 或 straight to the PyTorch。
由作者创作。
使用 Flash，您可以用几行代码构建您的深度学习模型！所以，如果你是深度学习的新手，不要害怕。Flash 可以帮助你建立深度学习模型，而不会因为代码而感到困惑。
本文将向您展示如何使用 Flash 构建图像分类器。没有进一步，让我们开始吧！
履行
安装库
要安装库，您可以像这样使用 pip 命令:
**pip install lightning-flash**
如果这个命令不起作用，您可以使用它的 GitHub 库来安装这个库。该命令如下所示:
**pip install git+**[**https://github.com/PyTorchLightning/lightning-flash.git**](https://github.com/PyTorchLightning/lightning-flash.git)
在我们成功下载包之后，现在让我们加载库。我们也用数字 42 设定种子。下面是实现这一点的代码:
下载数据
在我们安装了库之后，现在让我们来获取数据。为了进行演示，我们将使用名为猫狗数据集的数据集。
该数据集包含分为两类的图像。这些课是猫和狗。要访问数据集，可以在 Kaggle 找到这个数据集。您可以在这里 访问数据集 。
作者捕捉到的。
加载数据
下载完数据后，现在让我们将数据集加载到一个对象中。我们将使用 from_folders 方法将数据放入 ImageClassification 对象。下面是实现这一点的代码:
加载模型
在我们加载数据之后，下一步是加载模型。因为我们不会从头开始创建自己的架构，所以我们将使用基于现有卷积神经网络架构的预训练模型。
我们将使用已经过预训练的 ResNet-50 模型。此外，我们根据数据集设置类的数量。下面是实现这一点的代码:
训练模型
在我们加载模型之后，现在让我们训练模型。我们需要首先初始化教练对象。我们将在 3 个时期训练模型。此外，我们启用 GPU 来训练模型。下面是实现这一点的代码:
初始化对象后，现在让我们训练模型。为了训练模型，我们可以使用一个名为 finetune 的函数。在函数内部，我们设置模型和数据。此外，我们将训练策略设置为冻结，在这里我们不想训练特征提取器。换句话说，我们只训练分类器部分。
下面是实现这一点的代码:
下面是评测结果:
作者捕捉到的。
从结果可以看出，我们的模型达到了大约 97%的准确率。这个不错！现在让我们用几个新数据来测试这个模型。
测试模型
我们将使用未经模型训练的样本数据。以下是我们将对模型进行测试的示例:
为了测试模型，我们可以使用 flash 库中的 predict 方法。下面是实现这一点的代码:
从上面的结果可以看出，模型已经预测到了带有正确标签的样本。真好！现在让我们保存模型以备后用。
保存模型
现在我们已经对模型进行了训练和测试。让我们使用 save_checkpoint 方法保存模型。下面是实现这一点的代码:
如果您想在其他代码上加载模型，您可以使用 load_from_checkpoint 方法。下面是实现这一点的代码:
结束语
干得好！现在，您已经学习了如何使用 Flash 构建图像分类器。正如我一开始所说的，这只需要几行代码！多酷啊。
希望这篇文章能帮助你根据自己的案例建立自己的深度学习模型。如果你想实现一个更复杂的模型，我希望你可以学习 PyTorch。
如果你对我的文章感兴趣，可以在 Medium 上关注我。我会发表数据科学和机器学习相关的文章。还有，如果你有什么问题或者想打个招呼，可以在 LinkedIn 上和我联系。
谢谢你看我的文章！
扫一扫
721
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
