结合逻辑回归和决策树
安杰伊·西曼斯基
降低逻辑回归的线性度
逻辑回归是最常用的机器学习技术之一。它的主要优点是结果清晰，并且能够以简单的方式解释从属特征和独立特征之间的关系。它需要相对较少的处理能力，并且通常比随机森林或梯度增强更快。
然而，它也有一些严重的缺点，主要是它解决非线性问题的能力有限。在本文中，我将演示如何通过将决策树合并到回归模型中来改进非线性关系的预测。
这个想法与证据权重非常相似，这是一种在金融领域广泛用于构建记分卡的方法。WoE 采用一个特征(连续的或分类的),并将其分成多个带，以最大限度地区分商品和坏商品(正面和负面)。决策树执行非常类似的任务，将数据分成节点，以实现积极和消极之间的最大隔离。主要区别在于，WoE 是为每个特征单独构建的，而决策树的节点同时选择多个特征。
我们知道决策树善于识别从属和独立特征之间的非线性关系，因此我们可以将决策树的输出(节点)转换为分类变量，然后通过将每个类别(节点)转换为虚拟变量，将其部署在逻辑回归中。
在我的专业项目中，在 1/3 的情况下，在模型中使用决策树节点会优于逻辑回归和决策树结果。然而，我一直在努力寻找任何可以复制它的公开数据。这可能是因为可用的数据只包含少数预先选择和清理的变量。根本没多少可挤的！当我们有成百上千的变量可供支配时，找到从属特征和独立特征之间关系的其他维度就容易得多。
最后，我决定使用来自银行活动的数据。使用这些数据，我已经设法得到了一个次要的，但仍然是一个改进的组合逻辑回归和决策树超过这两种方法单独使用。
导入数据后，我做了一些清理。本文使用的代码是 GitHub 上的可用的。我已经将清理后的数据保存到一个单独的文件中。
由于频率较小，我决定使用 SMOTE 技术对数据进行过采样。
import pandas as pd
from sklearn.model_selection import train_test_split
from imblearn.over_sampling import SMOTEdf=pd.read_csv('banking_cleansed.csv')
X = df.iloc[:,1:]
y = df.iloc[:,0]os = SMOTE(random_state=0)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)
columns = X_train.columns
os_data_X,os_data_y=os.fit_sample(X_train, y_train)
os_data_X = pd.DataFrame(data=os_data_X,columns=columns )
os_data_y= pd.DataFrame(data=os_data_y,columns=['y'])
在接下来的步骤中，我构建了 3 个模型:
- 决策图表
- 逻辑回归
- 具有决策树节点的逻辑回归
决策树
如果你想和逻辑回归结合，保持决策树深度最小是很重要的。我希望决策树的最大深度为 4。这已经给出了 16 个类别。太多的类别可能会导致基数问题，并使模型过拟合。在我们的示例中，深度 3 和 4 之间的可预测性增量很小，因此我选择最大深度= 3。
from sklearn.tree import DecisionTreeClassifier
from sklearn import metrics
from sklearn.metrics import roc_auc_scoredt = DecisionTreeClassifier(criterion='gini', min_samples_split=200,min_samples_leaf=100, max_depth=3)
dt.fit(os_data_X, os_data_y)
y_pred3 = dt.predict(X_test)print('Misclassified samples: %d' % (y_test != y_pred3).sum())
print(metrics.classification_report(y_test, y_pred3))
print (roc_auc_score(y_test, y_pred3))
下一步是将节点转换成新的变量。为此，我们需要编写决策树规则。幸运的是，有一个程序可以帮我们做到这一点。下面的函数产生了一段代码，它是决策树拆分规则的复制。
现在运行代码:
tree_to_code(dt,columns)
输出如下所示:
现在，我们可以将输出复制并粘贴到下一个函数中，用它来创建新的分类变量。
现在，我们可以快速创建一个新变量(“节点”)并将其转移到虚拟变量中。
df['nodes']=df.apply(tree, axis=1)
df_n= pd.get_dummies(df['nodes'],drop_first=True)
df_2=pd.concat([df, df_n], axis=1)
df_2=df_2.drop(['nodes'],axis=1)
添加节点变量后，我重新运行 split 来训练和测试组，并使用 SMOTE 对训练数据进行过采样。
X = df_2.iloc[:,1:]
y = df_2.iloc[:,0]os = SMOTE(random_state=0)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)
columns = X_train.columns
os_data_X,os_data_y=os.fit_sample(X_train, y_train)
现在，我们可以运行逻辑回归，并比较虚拟节点对可预测性的影响。
排除虚拟节点的逻辑回归
我已经创建了一个所有功能的列表，不包括虚拟节点:
nodes=df_n.columns.tolist()
Init = os_data_X.drop(nodes,axis=1).columns.tolist()
并使用初始化列表运行逻辑回归:
from sklearn.linear_model import LogisticRegression
lr0 = LogisticRegression(C=0.001, random_state=1)
lr0.fit(os_data_X[Init], os_data_y)
y_pred0 = lr0.predict(X_test[Init])print('Misclassified samples: %d' % (y_test != y_pred0).sum())
print(metrics.classification_report(y_test, y_pred0))
print (roc_auc_score(y_test, y_pred0))
带节点虚拟模型的逻辑回归
在下一步中，我重新运行回归，但是这次我包含了节点虚拟对象。
from sklearn.linear_model import LogisticRegression
lr1 = LogisticRegression(C=0.001, random_state=1)
lr1.fit(os_data_X, os_data_y)
y_pred1 = lr1.predict(X_test)print('Misclassified samples: %d' % (y_test != y_pred1).sum())
print(metrics.classification_report(y_test, y_pred1))
print (roc_auc_score(y_test, y_pred1))
结果比较
具有虚拟节点的逻辑回归具有最好的性能。尽管增量改进并不巨大(尤其是与决策树相比)，但正如我之前所说，很难从只包含少量预选变量的数据中挤出任何额外的东西，我可以向您保证，在现实生活中，差异可能会更大。
我们可以通过使用模型提升来比较正面和负面在十分位数分数上的分布，对模型进行更多的审查，我在我的上一篇文章中已经介绍过了。
第一步是获得概率:
y_pred0b=lr0.predict_proba(X_test[Init])
y_pred1b=lr1.predict_proba(X_test)
接下来我们需要运行下面的函数:
现在我们可以检查这两个模型之间的差异。首先，我们来评估一下没有决策树的初始模型的性能。
ModelLift0 = lift(y_test,y_pred0b,10)
ModelLift0
在应用决策树节点之前提升模型…
…接下来是带有决策树节点的模型
ModelLift1 = lift(y_test,y_pred1b,10)
ModelLift1
具有决策树节点的模型的前 2 个十分位数的响应有所改善，Kolmogorov-Smirnov 测试(KS)也是如此。一旦我们将提升转化为财务价值，这种最小的增量改进可能会在我们的营销活动中产生可观的回报。
总的来说，逻辑回归和决策树的结合不是一个众所周知的方法，但它可能优于决策树和逻辑回归的单独结果。在本文给出的例子中，决策树和第二逻辑回归之间的差异可以忽略不计。然而，在现实生活中，当处理未加工的数据时，结合决策树和逻辑回归可能会产生更好的结果。这在我过去管理的项目中相当常见。节点变量可能不是魔棒，但绝对是值得了解和尝试的东西。
结合医学和数据科学来预测心脏病
裘德·贝克在 Unsplash 上的照片
介绍
这个项目的目的是结合数据科学和医学的原理，开发一个可以预测心脏病的模型。这种模型的优势在于它易于解释，并且与医学文献同步，不像其他机器学习模型产生不可解释的结果。采用这种方法帮助我建立了一个模型，通过筛查 34%的人口就可以预测 84%的心脏病发病率。
根据世卫组织的数据，心脏病(广泛称为心血管疾病或心血管疾病)每年夺去约 1790 万人的生命，占全球死亡人数的 31%。这将心血管疾病列为全球头号死因。[1]
现在，如果我们可以建立一个有意义的模型，仅仅根据一些参数就可以预测病人患心脏病的可能性，会怎么样？这里的‘有意义’这个词很重要。我们不一定想要一个能给我们最高准确率的模型，而是一个包含重要特征并能从医学角度解释的模型。对于这个项目，我使用 Google Colab 来开发我的模型。
资料组
我使用了来自 Kaggle 的“UCI 克里夫兰心脏病”数据集(该数据集最初由 UCI 发布在他们的 ML 知识库中，标题为“心脏病数据集”)。Kaggle 数据集包含 297 名患者的数据、13 个特征和 1 个称为“条件”的二元目标变量(0 =无心脏病，1 =有心脏病)。所有 14 个属性的详细描述已经包含在这里。
第一步:医学文献要说什么？
医学研究强调 5 个因素对预测心脏病最有影响。
- 年龄——年龄增长会增加患心脏病的风险[2]
- 性别——男性比绝经前的女性患心脏病的风险更高。男性和绝经后女性的风险相当。[3]
- 血清胆固醇水平——血清胆固醇水平升高有助于心脏病的发展。[4]
- 血压——高血压或高血压是心脏病发展的巨大风险因素。[5]
- 胸痛——大约 25–50%的心脏病患者患有无症状心肌缺血(SMI)，这意味着他们不会感到任何胸部不适。因此，即使没有胸痛也可以表明存在心脏病。[6]
幸运的是，上述所有 5 个因素都作为变量包含在我们的数据集中！让我们快速看一下它们是如何分布的。
**图一。**顶行:分别为年龄、性别和胆固醇(chol)分布；底部一行:分别为静息血压(trestbps)和胸痛(cp)的分布
观察
- 患者年龄分布广泛，平均约 55 岁。
- 总的来说，在这项研究中，男性(类别= 1)比女性(类别= 0)多。从这个图中可以明显看出，男性比女性更容易患心脏病。患心脏病的男性比不患心脏病的男性多。相反，患心脏病的女性比不患心脏病的女性少得多。
- 血清胆固醇水平分布广泛，平均约为 250 mg/dl。
- 静息血压的分布相当不规律，平均约为 130 毫米汞柱。
- 在患有心脏病的人中，大多数患者是无症状的(类别= 3)。因此，数据支持医学文献。典型心绞痛(类别= 0)、非典型心绞痛(类别= 1)和非心绞痛(类别= 2)形式的胸痛主要由没有心脏病的患者报告。
第二步:用所有 13 个特征运行逻辑回归模型。
我的第一直觉是运行一个包含所有 13 个特征的逻辑回归模型，以检查最具包容性的模型是否也是最具医学意义的模型。我选择了逻辑回归，因为它很容易解释。该模型对测试数据的总体准确率为 86.7%，并能够正确预测 82.9%的患者存在心脏病(预测类别= 1)。很好，对吧？当我看到每个变量的系数时，我非常失望。
**图二。**13 特征逻辑回归模型结果
第一个系数(-0.03121)对应于年龄变量。就在几分钟前，我们讨论了医学文献如何表明年龄增长会增加患心脏病的风险。既然如此，年龄不应该有一个正系数吗？类似地，空腹血糖的系数为负(-0.41832)。根据医学文献，当 fbs > 100 mg/dL 时(在这种情况下，如果 fbs >120 mg/dL，class = 1；如果 fbs < 120 mg/dL，class = 0)，心脏病的风险大大增加[7]。因此，理想情况下，系数的符号应为正。
从医学角度来看，接受一个变量符号不正确的模型是不正确的，即使它是高度准确的。
步骤 3:根据医学文献运行新的逻辑回归模型
既然我已经建立了一个完全基于机器学习的模型，我决定尝试一个更有意义的模型。我想构建一个包含 13 个特征子集的模型，只包括那些符合医学文献的特征。因此，我最终得到了一个逻辑回归模型，根据医学文献，该模型具有 5 个最重要的特征— 年龄、性别、血清胆固醇水平(chol)、静息血压(trestbps)和胸痛(cp) 。
该模型对测试数据的总体准确率为 74.4%，并能够正确预测 75.6%的患者存在心脏病(预测类别= 1)。模型的特征系数和截距如下所示。
**图三。**五特征逻辑回归模型结果
所有的系数都是正的，正如我们所料！虽然这个模型可能不是最准确的，但它是有意义的，并且可以被任何医疗从业者容易地解释。
第四步:如何使新模型更加可靠？
具有变量子集的新的逻辑回归模型是有意义的，但是低于 13 特征模型的预测能力(82.9%对 75.6%)。
为了克服这些缺点，我们必须用另一个包含所有 13 个特征的 ML 模型来补充它。这种结合将更好地预测病人是否患有心脏病。
我开发了具有所有 13 个特征的 5 ML 模型，下表总结了它们的性能。
**图四。**所有五个 13 特征模型的结果汇总
虽然逻辑回归恰好是五个模型中最准确的，但基于上面概述的原因(变量的非直观迹象)，我有意识地忽略了它。我们最好的选择是选择随机森林模型，该模型对测试数据的总体准确率为 83.33%，并正确预测 78.05%的患者存在心脏病(预测类别= 1)。随机森林(RF)要素重要性图表如下所示。
**图 5。**随机森林模型特征重要性图表
有趣的是，根据 RF，前 4 个变量是达到的最大心率(thalach)、胸痛(cp)、荧光透视着色的主要血管数量(ca)和心脏缺陷(thal)，而我们的逻辑模型的重要特征(年龄、性别、胆固醇、静息血压)则位于底部。这告诉我们，随机森林模型本身不应该被信任，而应该与我们的 5 特征逻辑回归模型结合使用，以获得良好的预测结果。
步骤 5:结合两个模型和最终建议
这一部分讲述了我结合两个分数得出最佳预测的方法。我创建了一个表格，比较模型预测和我们测试数据集中所有真正患有心脏病的患者的实际情况。我在本节中使用的符号也在下面进行了描述。
**图 6。**使用的符号
**图七。**比较所有真正患有心脏病的患者的组合模型预测和实际状况的表格
有意思！如果我们仅仅依靠我们的逻辑模型来正确预测心脏病(LH)，我们将得到 31/44 或 70.5%的准确率。另一方面，如果我们只依赖我们的随机森林模型(RH)，我们将得到 31/36 或 86.11%的准确度分数。RF 得分很高，因为 100%出现在 LLRH 类中，这可能是该类样本量小的结果，即只有 5 名患者。
如果我们依赖两个模型的组合(LHRH)，我们最终只选择了 31 名患者(31/90 =我们测试样本的 34%)，他们的心脏病发生率是 26/31 或 84%。因此，我们已经能够将命中率从 50%(发现心脏病的几率为 50-50%)提高到 84%，同时确保医学文献的神圣性。该模型是有效的，并且做了很好的预测。
至于逻辑模型和 RF 模型给出冲突预测的类别(LHRL 和 LLRH)，需要更多的研究。
结论
在医学领域，最精确的模型可能不是最有意义的，反之亦然。像这样的模型是我们可以将机器学习模型形式的数据科学原理与医学文献相结合的方式的一个例子，以给我们提供可能的最佳结果。这种模型的优点是易于解释，并且与医学文献同步。关于心脏病的准确预测，它已经能够将只筛查 34%人口的命中率从 50%提高到 84%。这种模式可以用于远程医疗，特别是在没有心脏病专家的不发达国家。未来的努力可能需要与心脏病专家合作，在其他医学数据集上工作，并检查这个模型的神圣性。
这个项目的代码可以在这里找到。
参考
《心脏病克利 UCI》数据集上https://www.kaggle.com/cherngs/heart-disease-cleveland-uci?select = heart _ Cleveland _ upload . CSV
数据集原始来源:【https://archive.ics.uci.edu/ml/datasets/Heart+Disease】T4
[1] 心血管疾病世卫组织 (2020 年)，https://www . who . int/health-topics/cardio vascular-Diseases/# tab = tab _ 1
[2] R. Dhingra 和 R.S. Vasan，年龄作为心血管危险因素 (2012)，https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3297980/
[3] J.L. Sullivan，铁与心脏病风险的性别差异 (2003)，https://www . science direct . com/science/article/ABS/pii/s 0140673681924636
[4] W.B. Kannel，W.P. Castelli，T. Gordon 和 p . m . mcn amara，血清胆固醇、脂蛋白和冠心病的风险 (1971)，https://www . ACP journals . org/doi/ABS/10.7326/0003-4819-74-1-1
[5] C. Rosendorff，H.R. Black，C.P. Cannon，B.J. Gersh，J. Gore，J.L. IzzoJr，N.M. Kaplan，C.M. O’Connor，P.T. O’Gara 和 S. Oparil，缺血性心脏病预防和管理中的高血压治疗 (2007 年)，https://www . aha journals . org/doi/full/10.1161/circulation ha
[6] A.H. Ahmed，K.J. Shankar，H. Eftekhari，M.S. Munir，J. Robertson，A. Brewer，I.V. Stupin 和 S.W. Casscells，无症状心肌缺血:当前观点和未来方向 (2007)，https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2359606/
[7] C. Park，E. Guallar，J.A. Linton，D. Lee，Y. Jang，D.K. Son，E. Han，S.J. Baek，Y.D. Yun，S.H. Jee 和 J.M. Samet，空腹血糖水平与动脉粥样硬化性心血管疾病事件的风险 (2013)，https://pubmed.ncbi.nlm.nih.gov/23404299/
在深度神经网络中结合数字和文本特征
如何使用 Keras 多输入模型为文本和数字数据训练一个端到端的深度神经网络
马里乌斯·马萨拉尔在 Unsplash 上的照片
在应用机器学习中，数据通常由多种数据类型组成，例如文本和数字数据。为了建立一个结合两个领域特征的模型，有必要将这些特征堆叠在一起。这篇文章展示了在 Keras(端到端学习)的一个单一模型中结合自然语言处理和传统功能的不同解决方案。
真实世界的数据是不同的
科学数据集通常仅限于一种数据，例如文本、图像或数字数据。这很有意义，因为我们的目标是将新的模型和现有的方法进行比较。在现实世界的场景中，数据通常更加多样化。为了利用端到端学习神经网络，而不是手动堆叠模型，我们需要在神经网络内部组合这些不同的特征空间。
假设我们想要解决一个文本分类问题，并且我们的语料库中的每个文档都有额外的元数据。在简单的方法中，我们的文档由一个单词包向量表示，我们可以将元数据作为附加单词添加到向量中，这样就完成了。但是当使用像单词嵌入这样的现代方法时，就有点复杂了。
特殊代币
简单的解决方案是添加我们的元数据作为额外的特殊嵌入。类似于语言模型中的特殊标记，如 BERT ，这些嵌入是可以像单词一样出现的标记。它们是二元的，因此我们没有连续的值空间。我们需要通过宁滨或一键编码将数据转换成分类特征。在我们确定了我们需要多少额外的特征之后，我们可以根据额外特征的数量来扩展词汇表，并将它们视为额外的单词。
我们的字典有 100 个单词，我们还有 10 个额外的功能。
该图显示了每个序列是如何以编码为特殊嵌入的特征开始的
嵌入序列现在总是从元数据特征(特殊标记)开始，因此我们必须将序列长度增加 10。这 10 个特殊嵌入中的每一个都代表了一个增加的特性。
这种解决方案有几个缺点。我们只有分类特征，没有连续值，更重要的是，我们的嵌入空间混合了文本和元数据。
多输入模型
为了构建一个可以处理连续数据和文本数据而没有这些限制因素的模型，我们来看看模型内部数据的内部表示。在某些时候，每个神经网络都有数据的内部表示。通常，这种表示就在涉及网络的最后(全连接)层之前。对于 NLP 中的递归网络(例如 LSTMs ),这种表示是文档嵌入。通过用我们的附加特征扩展这种表示，我们克服了限制。
在这样的模型中发生的事情是，我们基本上将两个模型堆叠在彼此之上，但是保留由相同的目标标签同时训练的能力。因此，它被称为端到端模型。
举例:
在 Keras 中，这对于多输入模型是可能的。我们又有了 100 个单词和 10 个附加特征。
nlp_input = Input(shape=(seq_length,))
meta_input = Input(shape=(10,))
emb = Embedding(output_dim=embedding_size, input_dim=100, input_length=seq_length)(nlp_input)
nlp_out = Bidirectional(LSTM(128))(emb)
concat = concatenate([nlp_out, meta_input])
classifier = Dense(32, activation='relu')(concat)
output = Dense(1, activation='sigmoid')(classifier)
model = Model(inputs=[nlp_input , meta_input], outputs=[output])
我们使用双向 LSTM 模型，并将其输出与元数据相结合。因此，我们定义了两个输入层，并在不同的“数据路径”中处理它们( nlp_input 和 meta_input )。我们的 NLP 数据经过嵌入变换和 LSTM 层。元数据正在进行一些规范化，所以我们可以直接将它与 LSTM 输出连接起来( nlp_out )。这个组合的向量现在是我们输入的完整表示，并且可以最终被分类在完全连接的层中。
一个简单的多输入模型的结构
这个概念可用于任何其他领域，其中来自 RNNs 的序列数据与非序列数据混合。更进一步，甚至可以将图像、文本和序列混合到一个单一的模型中。
这篇文章最初发表在我的博客上。
在 Tensorflow 中结合众多艺术风格
神经类型转换在 Tensorflow 中非常容易，但只有一种类型。了解如何对图像应用多种样式。
安妮·斯普拉特在 Unsplash 上的照片
去年，发布了一篇关于使用 Tensorflow Lite 的艺术风格转换的文章，其中内容图像的风格根据您喜欢的任何风格进行更改。这是超级有趣，非常容易使用。你只需要指定图片的路径就可以了。它使用两个 TfLite 模型，一个用于预测样式，另一个用于转换。
一些图片风格转换的例子。来源。
因此，它在将单一样式传递到内容图像方面非常有效，但是我们如何传递多种样式呢？这就是你将在这篇文章中发现的。
目录
- 艺术风格转移阐释
- 组合样式
- 等量地
- 一个的样式和一个的颜色
- 一个支配另一个
艺术风格转移阐释
在这一节中，我将解释风格转换是如何工作的。如果你已经了解它，只是想结合不同的风格，请随意进入下一部分。进行必要的导入，如 TensorFlow、NumPy 和 Matplotlib。设置内容和样式图像的路径，并下载所需的 Tensorflow Lite 模型。
import tensorflow as tf
import matplotlib.pyplot as plt
import matplotlib as mpl
mpl.rcParams['figure.figsize'] = (12,12)
mpl.rcParams['axes.grid'] = False
import numpy as npcontent_path = content.jpg
style_path = style.jpgstyle_predict_path = tf.keras.utils.get_file('style_predict.tflite', 'https://tfhub.dev/google/lite-model/magenta/arbitrary-image-stylization-v1-256/int8/prediction/1?lite-format=tflite')
style_transform_path = tf.keras.utils.get_file('style_transform.tflite', 'https://tfhub.dev/google/lite-model/magenta/arbitrary-image-stylization-v1-256/int8/transfer/1?lite-format=tflite')
加载图像和模型后，我们需要对它们进行预处理。图像应该是 RGB 格式的 float32 值，像素值需要在 0 和 1 之间。样式图像的尺寸应为(1，256，256，3)，内容图像的尺寸应为(1，384，384，3)。在 Tensorflow 博客中，宽度和高度的较小维度分别根据样式或内容图像等于 256 或 384，然后在中央裁剪。
# Function to load an image from a file, and add a batch dimension.
def load_img(path_to_img):
img = tf.io.read_file(path_to_img)
img = tf.io.decode_image(img, channels=3)
img = tf.image.convert_image_dtype(img, tf.float32)
img = img[tf.newaxis, :] return img# Function to pre-process by resizing an central cropping it.
def preprocess_image(image, target_dim):
# Resize the image so that the shorter dimension becomes 256px.
shape = tf.cast(tf.shape(image)[1:-1], tf.float32)
short_dim = min(shape)
scale = target_dim / short_dim
new_shape = tf.cast(shape * scale, tf.int32)
image = tf.image.resize(image, new_shape) # Central crop the image.
image = tf.image.resize_with_crop_or_pad(image, target_dim, target_dim) return image# Load the input images.
content_image = load_img(content_path)
style_image = load_img(style_path)# Preprocess the input images.
preprocessed_content_image = preprocess_image(content_image, 384)
preprocessed_style_image = preprocess_image(style_image, 256)print('Style Image Shape:', preprocessed_style_image.shape)
print('Content Image Shape:', preprocessed_content_image.shape)
现在，我们需要使用加载的模型来预测样式图像上的样式。如果你想知道如何在 Python 中使用 Tensorflow Lite，你可以看看这篇文章。创建模型的解释器并获取其输出。样式模型输出一个样式瓶颈，它有一个(1，1，1，100)的形状，我们将对它进行修改以组合多种样式。
# Function to run style prediction on preprocessed style image.
def run_style_predict(preprocessed_style_image):
# Load the model.
interpreter = tf.lite.Interpreter(model_path=style_predict_path) # Set model input.
interpreter.allocate_tensors()
input_details = interpreter.get_input_details()
interpreter.set_tensor(input_details[0]["index"], preprocessed_style_image) # Calculate style bottleneck.
interpreter.invoke()
style_bottleneck = interpreter.tensor(
interpreter.get_output_details()[0]["index"]
)() return style_bottleneck# Calculate style bottleneck for the preprocessed style image.
style_bottleneck = run_style_predict(preprocessed_style_image)
print('Style Bottleneck Shape:', style_bottleneck.shape)
在这之后，我们需要在我们的内容图像上应用这个样式瓶颈来改变它的样式，所以我们使用另一个加载的模型。
# Run style transform on preprocessed style image
def run_style_transform(style_bottleneck, preprocessed_content_image):
# Load the model.
interpreter = tf.lite.Interpreter(model_path=style_transform_path) # Set model input.
input_details = interpreter.get_input_details()
interpreter.allocate_tensors() # Set model inputs.
interpreter.set_tensor(input_details[0]["index"], preprocessed_content_image)
interpreter.set_tensor(input_details[1]["index"], style_bottleneck)
interpreter.invoke() # Transform content image.
stylized_image = interpreter.tensor(
interpreter.get_output_details()[0]["index"]
)() return stylized_image# Stylize the content image using the style bottleneck.
stylized_image = run_style_transform(style_bottleneck, preprocessed_content_image)# Visualize the output.
stylized_image = tf.squeeze(stylized_image, axis=0)
plt.imshow(stylized_image)
plt.title('Stylized Image')
这篇文章中的流程图最好地概括了这个过程。
组合样式
我将要处理的图像如下所示。
前两张是文章中的相同图片，第三张取自这里。
任何人对组合它们的第一个猜测都是先应用一种样式，然后在生成的图像上应用第二种样式。让我们看看我们通过它得到的结果。
前两张图片是个人风格。在第三幅图像中，样式 2 应用于第一幅图像
在第三个图像中，样式 1 应用于第二个图像
这样的结果不太好。结果看起来有点笨拙，只有应用于它的最终样式的颜色。所以，让我们来研究一下风格瓶颈，看看会发生什么。
等量地
为了给两种风格以同等的权重，我们可以采用风格瓶颈的平均值。
style_bottleneck = style_bottleneck1.copy()
for i in range(100):
style_bottleneck[0, 0, 0, i] += style_bottleneck2[0, 0, 0, i]
style_bottleneck[0, 0, 0, i] /= 2
通过手段结合他们的风格瓶颈后的结果。
这看起来比我们之前得到的结果更好，而且颜色组合得更好。
一个的样式和一个的颜色
这个结果完全出乎意料，是瞎混的结果。这并不是说其他风格不会像我们获得的第一个结果那样对图像的颜色有任何发言权，在此之后我们继续进行风格瓶颈，但这将是微妙的，并淡化其他风格。将您想要的颜色样式放在所有偶数索引处，将您想要的纹理样式放在奇数索引处。
style_bottleneck = style_bottleneck1.copy()
for i in range(100):
if i % 2 == 0: # change 0 to 1 for second image
style_bottleneck[0, 0, 0, i] = style_bottleneck2[0, 0, 0, i]
第二种款式的颜色和第一种的质地。
第一款的颜色和第二款的质地。
一个支配另一个
我们知道风格瓶颈的大小是(1，1，1，100)。因此，如果我们取一种风格的前 50 个值，取另一种风格的后 50 个值，那么取前 50 个值的风格应该更占优势。
style_bottleneck = style_bottleneck1.copy()
for i in range(50, 100): #change to (50) for second image
style_bottleneck[0, 0, 0, i] = style_bottleneck2[0, 0, 0, i]
风格 1 优于风格 2
风格 2 优于风格 1
我尝试在一张图片中结合两种风格。你可以试着把两个以上的组合起来，看看是什么样子。完整的代码如下所示。
如何使用 SQL 连接表以组合数据集
在保持社交距离的同时学习数据科学
使用 SQL 关键字 UNION、UNION ALL、INNER JOIN、LEFT OUTER JOIN 和 RIGHT OUTER JOIN 找出澳大利亚哪里的喜鹊最危险
介绍
在过去的 4 周里，我和我的朋友们在保持社交距离的同时互相帮助学习新技能。我们正在以在线学习小组的形式学习数据科学。我们几乎完成了 SQL 部分。我为每个人的努力和他们尝试新事物的意愿感到骄傲。
在过去的几周里，我的父母甚至决定尝试一下我的课程。他们只有几周的时间来补上，所以听听他们的想法会很有趣。
前一课
上周，我们利用辣妹组合发行的三张专辑的数据来判断哪张专辑是最好的。我们使用 GROUP BY 关键字这样做，以便我们可以聚合每个专辑的统计数据。
这一课
现在我们知道了如何分组和聚合表中的数据，本周我们将学习如何将表连接在一起。
能够组合数据集是有帮助的。尤其是如果每个表中有不同的细节。通过将它们连接在一起，你可以进行一些计算。或者，您可以创建一个新表，在一个数据集中包含所有不同的详细信息。
为了合并表，我们将使用 UNION、UNION ALL、INNER JOIN、LEFT OUTER JOIN 和 RIGHT OUTER JOIN 关键字。
主要学习内容
- 使用关键字 UNION 堆叠没有重复值的数据集
- 使用关键字 UNION ALL 来堆叠具有重复值的数据集
- 使用关键字 INNER JOIN 将两个表连接在一起，只获得重叠的值
- 使用关键字 LEFT OUTER JOIN 将两个表连接在一起，并且不会丢失左表中的任何数据，即使那些记录在右表中没有匹配项
- 使用关键字 RIGHT OUTER JOIN 将两个表连接在一起，并且不会丢失右表中的任何数据，即使是那些在左表中没有匹配项的记录
- 理解 UNION 和 UNION ALL 关键字的区别
- 理解内部连接、左外部连接和右外部连接之间的区别。
问题是
每个人都知道澳大利亚充满了危险的动物。然而，一种鲜为人知的食肉动物是喜鹊。这种鸟猛扑向毫无防备的受害者，锋利的喙装备精良，可以挖出一只眼睛。我们想知道澳大利亚各州喜鹊攻击事件有多普遍。哪里要戴防护帽？😜
弗兰克·布施在 Unsplash 上的照片
数据
为了解决我们的问题，我们有几个数据表。
首先是一个表格，根据网站喜鹊警报，包含了澳大利亚各州报告的喜鹊攻击数量。需要注意的是，这个网站的数据是众包的。当人们被喜鹊袭击时，他们会自我报告。因此，根据网站最受欢迎的地方，可能会有一些偏差。
喜鹊攻击表
我们的第二组数据是 dropbear 攻击的表格。北极熊是另一种凶猛的澳大利亚动物。我们可以将此表与喜鹊攻击数据进行比较。
免责声明: dropbears 不是真的，所以数据是我编造的😃
Dropbear 攻击表
除了关于动物袭击的两个表格，我们还有我从维基百科获得的澳大利亚各州的数据。我们可以使用这个表来标准化我们的动物攻击表，以反映各州之间的人口或地区差异。
澳大利亚州和地区表
组合表格的语法
将两个表组合在一起的最简单的方法是使用关键字 UNION 或 UNION ALL。这两种方法将一批选定的数据堆积在另一批数据之上。
SELECT
name_column_one,
name_column_three
FROM
name_of_table_one
UNION
SELECT
name_column_one,
name_column_three
FROM
name_of_table_two
;
这两个关键字之间的区别在于 UNION 只接受不同的值，而 UNION ALL 则保留所有选中的值。两者使用相同的语法。
SELECT
name_column_one,
name_column_three
FROM
name_of_table_one
UNION ALL
SELECT
name_column_one,
name_column_three
FROM
name_of_table_two
;
如果您想根据匹配值合并表，该怎么办？
有几种不同的方法可以根据值匹配来组合表。它们包括内部连接、完全外部连接、左外部连接和右外部连接。
在不同版本的 SQL 语言中，可用的连接略有不同。我们一直在学习 MySQL。因此，我们将只关注 MySQL 中可用的连接。在 MySQL 中可以使用内连接、左外连接和右外连接，但不能使用全外连接。
如果你想学习如何做一个完整的外连接，我的另一篇关于 SQL 中的内连接和外连接的区别的文章中有介绍。
如果您只想要两个表都包含匹配值的数据，该怎么办？
如果要执行的联接只包含两个表在指定列中包含匹配值的数据，则可以使用内部联接。
内部连接图:内部连接的结果将只包含 Table_1 和 Table_2 重叠的黄色部分
内部联接只返回两个数据集重叠的部分。这样，只有在两个表中要连接的列中有匹配值时，才会返回记录。内部联接的语法如下所示:
SELECT *
FROM
name_of_table_one
INNER JOIN
name_of_table_two
ON
name_of_table_one.name_column_one = name_of_table_two.name_column_one
在上面的示例中，表一和表二的记录都将被返回，但前提是表一第一列中的值与表二第一列中的值匹配。内部联接不会返回任何没有匹配值的记录。
我们在前面的课程中没有遇到的连接语法的一部分是通过表名和列名来引用列。这在连接表时很重要，因为两个表可能有同名的列。如果在选择同名列时不包括表名，程序将不会知道您引用的是哪一个。
为了避免混淆，我们使用由句号分隔的表名和列名来为每一列创建唯一的标识符。
如果您想连接一个匹配值，但只想保留左侧表中的所有数据，并且只保留右侧表中匹配的记录，该怎么办？
要基于列匹配连接两个表而不丢失左表中的任何数据，可以使用左外连接。
左外部连接图:左外部连接的结果将包含 Table_1 和 Table_2 重叠的黄色部分，以及包含 Table_1 其余部分的黄色部分
当您希望从一个表中获取所有值，但只从右表中获取与左表匹配的记录时，可以使用左外连接。
SELECT *
FROM
name_of_table_one
LEFT OUTER JOIN
name_of_table_two
ON
name_of_table_one.name_column_one = name_of_table_two.name_column_one
在上面左侧的外部连接示例中，将返回表一中的所有行，以及表二和表一中基于每个表中的列一共有的行。
左外连接和右外连接有什么区别？
右外连接图:右外连接的结果将包含 Table_1 和 Table_2 重叠的黄色部分，以及包含 Table_2 其余部分的黄色部分
右外连接的语法与左外连接的语法相同。两者之间唯一的区别是右边的表，在我们的示例表 2 中，将保留它的所有记录。而在左边的表中，表 1 将只保留其第一列和表 2 的第一列匹配的记录。
SELECT *
FROM
name_of_table_one
RIGHT OUTER JOIN
name_of_table_two
ON
name_of_table_one.name_column_one = name_of_table_two.name_column_one
现在让我们试一试
- 前往https://www.db-fiddle.com/
- 在左栏中，将 CREATE TABLE 和 INSERT 放入下面的查询中
CREATE TABLE magpie_attacks(
state_code varchar(255),
state_name varchar(255),
animal varchar(255),
number_of_attacks int(255)
);INSERT INTO magpie_attacks(
state_code,
state_name,
animal,
number_of_attacks
)
VALUES
('SA', 'South Australia', 'magpie', 154),
('VIC', 'Victoria', 'magpie', 972),
('TAS', 'Tasmania', 'magpie', 0),
('NSW', 'New South Whales', 'magpie', 823),
('QLD', 'Queensland', 'magpie', 1141),
('WA', 'Western Australia', 'magpie', 287),
('ACT', 'Australian Capital Territory', 'magpie', 668);CREATE TABLE dropbear_attacks(
state_code varchar(255),
state_name varchar(255),
animal varchar(255),
number_of_attacks int(255)
);INSERT INTO dropbear_attacks(
state_code,
state_name,
animal,
number_of_attacks
)
VALUES
('SA', 'South Australia', 'dropbear', 21),
('VIC', 'Victoria', 'dropbear', 67),
('TAS', 'Tasmania', 'dropbear', 30),
('NSW', 'New South Whales', 'dropbear', 19),
('QLD', 'Queensland', 'dropbear', 40),
('WA', 'Western Australia', 'dropbear', 37)
;CREATE TABLE australian_states(
state_code varchar(255),
state_name varchar(255),
population int(255),
area_km2 int(255)
);INSERT INTO australian_states(
state_code,
state_name,
population,
area_km2
)
VALUES
('SA', 'South Australia', 1751693, 1044353),
('VIC', 'Victoria', 6594804, 237657),
('TAS', 'Tasmania', 534281, 90758),
('NSW', 'New South Whales', 8089526, 809952),
('QLD', 'Queensland', 5095100, 1851736),
('WA', 'Western Australia', 2621680, 2642753),
('ACT', 'Australian Capital Territory', 426709, 2358),
('NT', 'Northern Territory', 245869, 1419630)
;
3.在右栏中输入您的查询，并使用左上角的“运行”按钮运行它们
4.运行下面的查询，看看它是否会返回您所期望的结果:
SELECT
*
FROM
magpie_attacks
UNION
SELECT
*
FROM
dropbear_attacks
;
5.运行下面的查询，看看它是否会返回您所期望的结果:
SELECT
state_code,
state_name
FROM
magpie_attacks
UNION
SELECT
state_code,
state_name
FROM
dropbear_attacks
;
6.运行下面的查询，并将结果与之前的查询进行比较:
SELECT
state_code,
state_name
FROM
magpie_attacks
UNION ALL
SELECT
state_code,
state_name
FROM
dropbear_attacks;
7.运行下面的查询，看看它是否会返回您所期望的结果:
SELECT
magpie_attacks.state_code,
magpie_attacks.number_of_attacks AS magpie_attacks,
dropbear_attacks.number_of_attacks AS dropbear_attacks
FROM
magpie_attacks
INNER JOIN
dropbear_attacks
ON
magpie_attacks.state_code = dropbear_attacks.state_code;
8.运行以下查询，并将结果与之前的查询进行比较:
SELECT
magpie_attacks.state_code,
magpie_attacks.number_of_attacks AS magpie_attacks,
dropbear_attacks.number_of_attacks AS dropbear_attacks
FROM
magpie_attacks
LEFT OUTER JOIN
dropbear_attacks
ON
magpie_attacks.state_code = dropbear_attacks.state_code;
9.运行下面的查询，并将结果与前两个查询进行比较:
SELECT
magpie_attacks.state_code,
magpie_attacks.number_of_attacks AS magpie_attacks,
dropbear_attacks.number_of_attacks AS dropbear_attacks
FROM
magpie_attacks
RIGHT OUTER JOIN
dropbear_attacks
ON
magpie_attacks.state_code = dropbear_attacks.state_code;
10.运行下面的查询，并将结果与前两个查询进行比较:
SELECT
magpie_attacks.state_code,
magpie_attacks.number_of_attacks AS magpie_attacks,
dropbear_attacks.number_of_attacks AS dropbear_attacks,
dropbear_attacks.number_of_attacks / magpie_attacks.number_of_attacks * 100 AS 'dropbear_attacks_as_percentage_of_magpie_attacks'
FROM
magpie_attacks
INNER JOIN
dropbear_attacks
ON
magpie_attacks.state_code = dropbear_attacks.state_code
;
练习 1: 使用我们在本课中学到的每一种不同的 union 和 join 方法，组合 magpie_attacks 表和 australian_states 表。为了运行查询，您可以根据需要随意选择任意多或任意少的列。
练习 2: 写一个查询，找出澳大利亚哪个州的喜鹊攻击次数占该州人口的百分比最高。提示:如果需要，您可以使用步骤 10 中的查询作为参考。
学习回顾
学完本课后，你应该知道:
- 如何使用关键字 UNION 来堆叠没有重复值的数据集
- 如何使用关键字 UNION ALL 来堆叠具有重复值的数据集
- 如何使用关键字 INNER JOIN 将两个表连接在一起，并且只获得重叠的值
- 如何使用关键字 LEFT OUTER JOIN 将两个表连接在一起，并且不丢失左表中与右表不匹配的任何数据
- 如何使用关键字 RIGHT OUTER JOIN 将两个表连接在一起，并且不会丢失右表中与左表不匹配的任何数据
- 理解 UNION 和 UNION ALL 关键字的区别
- 理解内部连接、左外部连接和右外部连接之间的区别。
下一课
下一课将回顾我们在过去 5 课中学到的关于 SQL 的知识。我总是认为练习新技能来巩固课程是个好主意。希望复习课也能让我们以一种更独立的方式使用在课上学到的所有技能。到目前为止，这些练习与之前的例子非常相似。然而，我希望下节课我们将学到的部分内容是如何选择使用什么方法来解决问题。
除了数据，我的另一个爱好是绘画。你可以在 www.katemarielewis.com 找到我的野生动物艺术
社交距离学习数据科学(LDSWSD)系列中的所有课程
阅读《走向数据科学》中关于 Ldswsd 的文章。共享概念、想法和代码的媒体出版物。
towardsdatascience.com](https://towardsdatascience.com/tagged/ldswsd)
将基于树的模型与线性基线模型相结合以改进外推
实践教程
编写自己的 sklearn 函数，第 1 部分
这篇文章是一个简短的介绍，介绍如何结合不同的机器学习模型以达到实用的目的，在它们的优缺点之间找到一个好的平衡。在我们的例子中，我们将集成一个随机森林，一个非常强大的非线性、非参数的基于树的全能者，一个经典的线性回归模型，一个非常容易解释并且可以使用领域知识验证的模型。
对于许多问题来说，梯度推进或随机森林是最常用的模型。他们经常胜过许多其他模型，因为他们能够学习几乎任何线性或非线性关系。然而，树模型的一个缺点是，它们不能很好地处理新数据，它们通常推断得很差——阅读更多关于这个的内容。出于实际目的，这可能会导致不期望的行为，例如在预测时间、距离或成本时，稍后将对此进行概述。
我们可以快速验证随机森林模型的 sklearn 实现可以很好地学习给定范围(0 到 50)的标识，但是对于训练数据范围之外的值却很失败:
import numpy as np
import matplotlib.pyplot as plt
import seaborn as snsfrom sklearn.ensemble import RandomForestRegressormodel = RandomForestRegressor()X = np.arange(0, 100).reshape(-1, 1)
y = np.arange(0, 100)# train on [0, 50]
model.fit(X[:50], y[:50]);# predict for [0, 100]
## RandomForestRegressor()
plt.ylim(0, 100);
sns.lineplot(X.reshape(-1,), model.predict(X));
plt.show()
树模型很难预测样本外的图像。
与树模型相比，线性模型以不同的方式处理新数据。他们可以很容易地推断预测，但当然也有只学习线性关系的缺点。此外，线性模型允许一个简单的解释，简单地通过查看回归系数，我们实际上可以将其与领域知识进行比较，并实际验证它。
因此，对于一些回归问题，将这两种方法结合起来是有意义的，我们可以用一个例子来详细说明:假设我们想要使用历史数据(包含车辆类型、距离和行驶时间的数据集)来估计不同车辆相对于行驶距离的行驶时间。我们可能会考虑使用线性或非线性模型，这也取决于我们的预期。如果我们的目标是估计自行车的旅行时间，距离的增加会导致时间的比例变化(如果你骑自行车的时间增加一倍，你可能会旅行两倍的距离)。如果我们训练一个线性模型，它将是一个很好的拟合，并且系数表达了距离和时间之间的比例。
但是线性模型的一个缺点是，它可能很难了解其他车辆类型(如汽车)的时间与距离的关系。如果开车旅行的距离增加，我们可能会走高速公路，而不是更短的距离，所以旅行时间的增加可能不再是线性比例的。在这种情况下，非线性模型会表现得更好。然而，如果我们在观察到的行驶汽车距离上训练非线性树模型，它将在新数据上表现不佳，即看不见的距离:如果我们的训练数据仅包含 100 公里的汽车行程，则 200 公里的估计将非常糟糕，而线性模型仍将提供良好的外推估计。
为了解决这个问题，我们可以通过以下方式用线性模型支持树模型:如果树模型的预测离我们的基线线性模型的预测太远，我们默认使用线性模型预测。因此，对于我们的示例:如果 200 公里汽车行驶的非线性模型预测是 2 小时(因为它只看到了 2 小时的汽车行驶)，但线性模型预测是 3 小时，我们默认为 3 小时。然而，如果非线性模型的预测与线性模型的验证预测相差不太远(比如说小于 25%)，我们就坚持它(因为我们预期它通常会表现得更好)。
编写您自己的组合估计器
在sklearn中，我们可以通过创建我们自己的估计器以下面的方式实现这一点。请注意，这第一个实现还不符合 sklearn API 标准——我们将在本文末尾根据接口改进这个版本。
我们简单地拟合两个估计量，并使用两个估计量进行预测。然后，我们可以比较两种预测，并相应地调整我们的预测。如果在线性预测的一定范围内，我们将采用树模型预测。除了比较两个模型并选择更合理的预测，我们还可以取两个预测的平均值或以不同方式混合它们。此外，我们可以使用网格搜索优化参数upper和lower(为此，我们将需要实现一些进一步的方法，如get_params和set_params)。
让我们使用非线性函数f(x)=x+sqrt(x)+rnorm(0, 3)生成一些样本数据来评估模型:
import pandas as pddef f(x):
if isinstance(x, int):
return np.sqrt(x) + np.random.normal(0, 3)
else:
return np.sqrt(x) + np.random.normal(0, 3, len(x))def generate_data(n=100, x_max=100):
x = np.random.uniform(0, x_max, n)
return pd.DataFrame.from_records({'x': x}), f(x)
我们现在可以在我们的小样本数据集上训练三个不同的模型:RandomForestRegressor、LinearRegression和我们的定制CombinedRegressor。
from sklearn.metrics import mean_absolute_errornp.random.seed(100)
X, y = generate_data(n=100)for model_name, model in models.items():
print(f'Training {model_name} model.')
model.fit(X, y);
print(f'Training score: {model.score(X, y)}')
print(f'In-sample MAE: {mean_absolute_error(y, model.predict(X))} \n')
## Training tree model.
## RandomForestRegressor()
## Training score: 0.8620816087110539
## In-sample MAE: 1.081361379476639
##
## Training linear model.
## LinearRegression()
## Training score: 0.28917115492576073
## In-sample MAE: 2.586843328406717
##
## Training combined model.
## CombinedRegressor()
## Training score: 0.35418433030406293
## In-sample MAE: 2.3593815648352554
如果我们观察所有三个模型预测和真实值的图(见下文),我们可以很快看到最初讨论的问题:树模型不能真正外推
正如所料，随机森林模型在样本内平均绝对误差方面表现最佳。现在，如果我们评估样本外(150，而不是训练数据中的最大值 100)，事情看起来会有所不同:
np.random.seed(101)x = [150]
X_new, y_new = pd.DataFrame({'x': x}), f(x)for model_name, model in models.items():
y_pred = model.predict(X_new)
print(f'Testing {model_name} model.')
print(f'y_new: {y_new}, y_pred: {y_pred}')
print(f'Test MAE: {mean_absolute_error(y_new, y_pred)} \n')
## Testing tree model.
## y_new: [20.36799823], y_pred: [7.81515835]
## Test MAE: 12.552839880512696
##
## Testing linear model.
## y_new: [20.36799823], y_pred: [13.39757247]
## Test MAE: 6.970425764867624
##
## Testing combined model.
## y_new: [20.36799823], y_pred: [13.39757247]
## Test MAE: 6.970425764867624
由于不能外推，树模型做得不好，线性模型做得更好，因此由线性回归支持的集合模型做得更好。同时，它仍将在样本内表现良好，并且如果我们大幅增加范围，它将表现良好(仅比树模型好，比线性回归差):
np.random.seed(102)X_new, y_new = generate_data(n=100, x_max=200)for model_name, model in models.items():
y_pred = model.predict(X_new)
print(f'Testing {model_name} model.')
print(f'Test MAE: {mean_absolute_error(y_new, y_pred)} \n')
## Testing tree model.
## Test MAE: 3.67092130330585
##
## Testing linear model.
## Test MAE: 2.5770058863460985
##
## Testing combined model.
## Test MAE: 2.6143623109839984
我们还可以绘制一些随机数据(训练样本内外)的单个预测，并快速查看之前未看到的 x 值和树模型的初始讨论问题，该问题变平了。线性模型继续趋势，组合版本有不愉快的颠簸，但一旦树模型偏离太多，至少跟随趋势。
我们不同模型的外推行为——图片由作者完成。
Sklearn 兼容性
如果我们想实现完全 sklearn 兼容性(型号选择、管道等。)并使用 sklearn 的机载测试工具，我们必须对估计器进行一些修改:
- 我们需要为参数添加 setters 和 getters(我们使用 sklearn 的约定，用名称和两个下划线作为参数的前缀，即
base_regressor__some_param) - 随机状态的一致处理
这可以通过以下方式实现:
然后，我们可以在我们的自定义估计器上运行超参数网格搜索:
我们还可以使用sklearn.utils.estimator_checks工具来检查我们的估计器:
在某些情况下，您可能无法满足特定的验证，例如，在这种情况下，您可以将特定检查的返回值伪造为 true:
import mockfrom sklearn.utils.estimator_checks import check_estimatorwith mock.patch('sklearn.utils.estimator_checks.check_estimators_data_not_an_array', return_value=True) as mock:
check_estimator(CombinedRegressor())
包裹
如果我们有一个模型，它对一组特定的输入非常有效，但是一旦输入变得更加奇特，我们就会失去信心，那么这种方法就非常有用。在这种情况下，我们可以通过使用更透明的(例如线性)方法，我们可以很容易地与领域知识同步，并保证特定的行为(例如外推、比例增量)。
除了使用组合估计器，我们还可以使用具有更好外推行为的非线性模型，如神经网络。另一种替代方法是向训练数据集添加一些人工样本，以增加支持的响应范围。
最初发表于【https://blog.telsemeyer.com】。
喜剧还是戏剧？
教机器幽默感的尝试
查尔斯·德鲁维奥在 Unsplash 上拍摄的照片
如果你是 YouTube 或网飞的用户，你一定知道在你观看每个视频后会弹出的*‘推荐给你’*视频。这是一个商业如何使用自然语言处理(NLP)技术开发数据驱动产品的经典例子。无论是有监督的还是无监督的 NLP 变体，都一直吸引着我去深入挖掘和研究这些黑箱模型。作为一个了解更多的实验用例，我试图开发一个流派分类器(版本 1.0.0 ),根据其情节/剧情简介预测电影是喜剧还是戏剧。让我们开始吧。
数据
我把这个项目建立在 IMDB 数据集上。原始数据集包含了从电影语言到演员细节的大量信息。对于我目前的用例，我将只局限于电影的情节和类型。原始数据集包含 26 个流派，然而，我决定一步一步来，目标是首先在 2 个类别上安装二元分类器，即喜剧和戏剧。这是我的原始数据的样子:
我从来没有听说过的电影情节！
预处理和设计
第一项任务是将文本转换成机器能够理解的语言。这包括很多步骤，比如标记化和嵌入，每一步都有不同的风格。如果你是 NLP 新手，这篇文章将带你快速了解处理 NLP 问题的一般技术。
作为 Keras 库的热心用户，使用 Keras 对文本进行了处理和标记。对于我的单词嵌入，我选择了手套。虽然 Keras 嵌入为您提供了使用多个单词嵌入的灵活性，但预训练手套嵌入带来的性能提升是无与伦比的。
任何数据科学项目的一个重要要点是 GIGO(垃圾输入，垃圾输出)，再多的模型开发也无法弥补垃圾数据。这个 Kaggle 内核将向您展示选择正确的文本预处理和单词嵌入如何对最终模型产生影响。一旦我们准备好数据，我们就可以继续进行模型构建。
在几个世纪的时间里，我尝试了不同的排列和组合，最终构建了一个双向 LSTM 神经网络，它给了我一个合理的性能(在测试集上有 85%的准确率)。
最终模型
最终密集层中的 softmax 激活函数返回潜在结果的概率分布。因此，例如，如果模型返回 70%喜剧和 30%戏剧的概率分布，则电影情节将被分类为喜剧。
图片胜过千言万语！
观察和结果
现在，事情变得有趣了。我在一些我最喜欢的电影的不同情节上尝试了我的模型。因为有太多的模特，我把模特表现特别好的那些列入了候选名单。先说我最喜欢的一部喜剧电影的节选。
婚礼前两天，道格和三个朋友开车去拉斯维加斯参加一个疯狂而难忘的男性聚会。事实上，当三个伴郎第二天早上醒来时，他们什么都不记得了；他们也找不到道格。时间不多了，三个朦胧的伙伴试图重新追踪他们的脚步，找到道格，这样他们就可以让他及时回到洛杉矶，走上红毯。
正如一些人可能已经猜到的，这是《宿醉》的梗概。我的模型对这个情节做出了如下预测。
“宿醉”的预测
在我的另一部最爱，莱昂纳多迪卡普里奥的戏剧电影*《血钻》*上尝试，产生了以下结果。
随着 20 世纪 90 年代塞拉利昂内战的爆发，两个男人，一个南非雇佣兵和一个门德渔民加入了一个共同的追求，寻找一种能够改变他们生活的稀有宝石。在一名美国记者的帮助下，这些人踏上了穿越叛军领地的危险旅程，以实现他们的目标。”
“血钻”的预测
这些都是相当准确的预测。然而，它并不总是阳光和彩虹，因为模型远非完美！。NLP 模型的驱动引擎是词汇表及其与其他相似单词的相应空间关联。而且，就像人类的大脑一样，这个引擎必须经过调整和训练，才能理解单词的上下文。这是我的模型无法清晰描述的。当它看到脱离上下文的单词时，它会有一点挣扎。比如电影*‘小丑’。*
失败的喜剧演员亚瑟·弗莱克永远独自在人群中，当他走在高谭市的街道上时，他寻求联系。亚瑟戴着两个面具——一个是他为日常工作画的小丑面具，另一个是他徒劳地试图感觉自己是周围世界的一部分的伪装面具。受到社会的孤立、欺凌和忽视，弗莱克开始慢慢陷入疯狂，他变成了被称为小丑的犯罪大师。
“小丑”的预测
可能是受到了单词*‘喜剧演员’，的影响，这个模型把上面的错误归类为‘喜剧’*，而这部电影，实际上，完全相反。
从好的方面来看，有一些先进的技术可以处理这个问题，我将在接下来构建多类分类器的过程中探索这些技术。非常感谢您的阅读。我将很快上传一个记录在案的 Colab 笔记本，所以你可以以此为基础来改进它和/或尝试你的想法。
Python 的空间科学:彗星——来自远方的游客
用 Python 进行空间科学
系列教程的第 7 部分“用 Python 进行空间科学”将开始一个小的科学项目，在那里我们将熟悉冰冷的宇宙访客:彗星
艺术家对来自另一个恒星系的星际访客“Oumuamua”彗星的印象。鸣谢:ESA/哈勃，NASA，ESO，m . Kornmesser；许可: 知识共享署名 4.0 国际许可
前言
这是我的 Python 教程系列“用 Python 进行空间科学”的第 7 部分。这里显示的所有代码都上传到了GitHub上。尽情享受吧！
介绍
每一代都有它的“大彗星”。从地球上肉眼可见的彗星，以其模糊的外观和长长的尾巴在夜空中闪耀数周或数月。对我来说，它是 20 世纪 90 年代末的海尔-波普彗星。我的父母给我买了一个望远镜，从我们公寓的阳台上，一个终生的激情诞生了。
从远处看，彗星经常被称为“肮脏的冰球”。固体“球”就是所谓的原子核。如果这样一个核靠近太阳，它就会升温，释放出气体和尘埃粒子。气体和尘埃大量释放出来，在彗星的核心部分形成了三个结构。这三个部分是:
- 彗发:围绕着原子核的球形大气状结构，包含气体和尘埃/冰粒
- 尘埃尾:尘埃粒子沿着彗星的轨道/路径分布
- 离子尾:由于太阳的辐射，气体粒子带电，并受到太阳磁场和太阳风(太阳发射的带电粒子)的强烈影响。离子尾径向远离太阳
除了水和矿物质，我们知道彗星还含有氨基酸和其他重要的生命构成元素。这些科学见解只有通过向这些宇宙流浪者发送机器人航天器才有可能实现。未完成的任务有:
- 乔托:1980 年末欧洲航天局对哈雷彗星的探测任务
- 星尘:美国国家航空航天局的一项任务，15 年前从 81P / Wild 2 号彗星的尾部收集尘埃颗粒并将其送回地球
- Rosetta :欧空局对彗星 67P/Churyumov-Gerasimenko 的任务。经过 10 年的旅程，飞船于 2014 年抵达彗星，并部署了一个名为菲莱的着陆器
但是彗星是从哪里来的？为什么有些出现的频率更高？他们是威胁还是我们都认识他们？()*
在本节课和接下来的几节课中，我们将仔细研究这些数据。我们将确定彗星的起源，并计算一些基本属性来回答这些问题。
现代空间科学和天体物理研究与数据科学和机器学习密切相关。但是作为任何数据科学工作，我们需要从数据工程部分开始，在那里我们收集数据并为我们未来的工作做准备。
小行星中心
在我们开始使用数据之前，我们需要看一下我们现在使用的库。就像在我们上次的会议中一样，我们需要像 datetime (用于日期时间解析)、 numpy 和 pandas 这样的库来进行数据准备和工程。我们稍后使用 pathlib 创建一个子目录，并加载 spicepy 以使用 NASA 的 SPICE 工具包来执行空间科学任务。
上次我们创建了一个函数，允许我们从互联网下载文件(例如，SPICE 内核文件)并将其存储在本地目录中。该功能存储在名为 _auxiliary 的新主文件夹中。目前，我们只有一个公共函数，不需要为一个任务创建单独的 Python 库。因此，使用包 sys 和函数 sys.path.insert (第 12 行和第 13 行)，我们从*_ 辅助*文件夹(第 14 行)添加脚本和内容。
第 1/10 部分
已知彗星的详细列表由小行星中心 (MPC)提供。MPC 收集所有居住在我们太阳系的小天体的信息。我们下载以压缩 JSON 格式提供的数据，并将它们存储在一个名为 raw_data 的文件夹中。(第 3 + 4 行定义文件夹和 MPC URL 第 7 行调用下载函数，该函数创建子目录并存储文件cometels.json.gz。MPC 提供了文件内容的详细描述。我们一会儿就需要这些信息。
第 2/10 部分
出于测试目的，我们将在下一节计算彗星的状态向量。这样就加载了一个 SPICE 内核元文件…
第 3/10 部分
…路径指向 gm_de431.tpc (包含其他行星常数)和 naif0012.tls (包含时间和闰秒信息)内核。
\begindataKERNELS_TO_LOAD = (
‘../_kernels/pck/gm_de431.tpc’
‘../_kernels/lsk/naif0012.tls’,
)
现在，压缩的 JSON 文件被加载。 pandas 函数 read_json 直接读取压缩文件并创建数据帧。
第 4/10 部分
让我们看看提供的数据。该文件包含轨道要素、彗星名称、参考文献等。和:2 个不同的日期时间；根据文档:
**Columns F77 Use**
[...]
15 - 18 i4 Year of perihelion passage
20 - 21 i2 Month of perihelion passage
23 - 29 f7.4 Day of perihelion passage (TT)
[...]
82 - 85 i4 Year of epoch for perturbed solutions
86 - 87 i2 Month of epoch for perturbed solutions
88 - 89 i2 Day of epoch for perturbed solutions
基于轨道元素，我们想要计算状态向量。对于这个计算，我们将应用 SPICE 函数 二次曲线 。该函数需要一个天体的平均异常值和相应的星历时间，称为历元。平均异常是使用近日点方向作为参考方向的角度。因此，“年”、“月”和“近日点通过日”是需要的日期时间。与近日点通过的日期时间相对应的平均异常是(根据定义)0 度！
让我们基于三个日期列(第 10 到 14 行)创建一个 UTC 时间戳。应用 lambda 函数，将年、月和日字符串合并为格式为年-月-日的日期。日期是以十进制数给出的。例如，15.5 对应于 UTC 第 15 天的 12:00:00。“十进制时间”需要转换成适当的时间格式。首先(第 18 行)，我们定义一个占位符日期，它可以与第 23 到 26 行中的datetime . time delta函数一起使用。将十进制的日期和时间添加到占位符日期(第 25 行)，并使用 strftime 函数将得到的日期时间对象转换为小时:分钟:秒(第 26 行)。
现在，日期和时间在第 29 到 32 行合并，并且相应的星历时间(ET)可以在第 35 行使用 SPICE 函数 utc2et 计算。
第 5/10 部分#
我们现在准备计算一个用于测试的状态向量，看看我们是否正确地处理了数据。
伟大的海尔波普
大彗星 C/1995 O1 的图像(海尔-波普)。上世纪末，这颗彗星有一年多的时间是可见的。蓝色的尾巴是所谓的离子尾，主要受太阳风的影响。灰/白尾巴由沿着彗星轨道分布的尘埃和冰粒组成。信用:ESO/e . Slawik；许可: 知识共享署名 4.0 国际许可
对于测试用例，我们选择海尔-波普彗星。不得不承认，我个人的喜好是选择这颗特殊彗星的原因。
对于 圆锥曲线 函数，我们需要轨道元素(存储在数据帧 c_df 中)以及太阳的 GM* 参数。第 4+5 行使用 SPICE 函数 bodvcd 从对应的行星内核中提取并定义 GM* 常数。第 8 行创建了一个 Hale-Bopp 数据帧。代码部分…
c_df[‘Designation_and_name’].str.contains(‘Hale-Bopp’)
…使用 Designation_and_name 列，搜索包含 Hale-Bopp 的子串。通过 loc 功能，分配相应的 Hale-Bopp 数据帧行。
第 13 行到第 21 行定义了一个输入数组，该数组包含了 二次曲线 函数的正确格式的所有数据(距离以 km 为单位，角度以弧度为单位，平均异常等于 0 度)。
第 6/10 部分
彗星的状态向量是为协调世界时 2020 年 5 月 5 日(午夜)计算的(第 2+3 行)。我们使用 NASA 地平线网络接口来计算参考状态向量，以便与(**)进行比较:
第 7/10 部分
结果如下所示。可以看出，基于 MPC 轨道数据的结果与 NASA HORIZONS 数据非常一致。
Comparison of the computed state
vector with the NASA HORIZONS results
==========================================
X in km (Comp): 5.347972e+08
X in km (NASA): 5.348377806424425E+08
==========================================
Y in km (Comp): -2.702078e+09
Y in km (NASA): -2.702225247057124E+09
==========================================
Z in km (Comp): -5.904119e+09
Z in km (NASA): -5.904425343521862E+09
==========================================
VX in km/s (Comp): 6.856500e-01
VX in km/s (NASA): 6.857065492623227E-01
==========================================
VY in km/s (Comp): -3.265125e+00
VY in km/s (NASA): -3.265390887669909E+00
==========================================
VZ in km/s (Comp): -4.968756e+00
VZ in km/s (NASA): -3.265390887669909E+00
科学数据库
我们从 MPC 下载了彗星数据。我们通过比较计算出的状态向量和 NASA 地平线系统的结果来检查数据的一致性。因此，我们为进一步的彗星研究打下了坚实的数据基础！
我们创建了一个 SQLite 数据库，而不是重新加载数据帧和解析 JSON 文件。SQLite 允许生成一个存储在一个文件中的全功能 SQL 数据库。这种嵌入式解决方案用于例如移动设备上。甚至更大的数据集也可以存储在这个嵌入式解决方案中，而不需要专用服务器或分布式文件系统(轶事:在我的硕士论文和后来的博士研究中，我一直使用 SQLite。我创建并使用了大小约为 250 GB 的 SQLite 数据库，令人惊讶的是，它们具有良好的性能。
但是首先，让我们增加两个参数，我们可以很容易地从轨道元素中得到:半长轴(第 2 到 5 行)和远日点(第 8 到 11 行)。我们只计算偏心率小于 1 的闭合轨道的值。
第 8/10 部分
在教程的主文件夹中，为(comets)数据库创建了一个新目录(第 3 行)。第 6 行连接(分别创建)一个 SQLite 数据库，第 7 行设置一个游标。现在，创建了一个名为 comets_main 的表(第 11 到 25 行)。主键是彗星的指定名称。整数或分类主键更好更快，例如，在不同的表之间创建连接。在我们的例子中，我们只有几百行和几列。这场演出对我们的目的来说足够好了。此外，一切都保持“人类可读”。第 20 行添加了平均异常，并设置默认值为 0 度，因为平均异常不是由 MPC 数据提供的(只有近日点通过时间)。
第 9/10 部分
我们现在使用命令执行命令将数据写入数据库。我们现在为进一步的科学工作做好了准备！
第 10/10 部分
结论与展望
今天我们开始了我们的彗星科学之旅。我们从小行星中心下载了数据，分析了数据，并使用海尔-波普数据来验证内容。在接下来的教程中，我们的分析将基于创建的 SQLite 数据库。数据工程、准备和清理是数据科学以及任何其他科学领域的关键要素。
下一次，我们将熟悉数据，并从 800 颗彗星中获得科学见解()，例如，什么是 C 或 P 轨道类型？)。我们将学习一些基本的 SQL 命令。如果你想看一下数据库，我建议你使用一个 SQLite 浏览器，比如 SQLiteBrowser 。由于数据库相当小，它也被上传到 GitHub 上。
托马斯
脚注
(*)彗星、小行星、流星体、行星、矮行星等等……*这些天体有什么区别？有什么不同吗？*除了“Python 的空间科学”系列，我还想在一些“补充空间科学文章”中与您分享一些空间科学知识。
(**) NASA HORIZONS 只是许多其他伟大工具中的一个工具。无论是作为网络界面还是桌面应用程序:“补充空间科学文章”也可以涵盖有用工具和程序的附加信息。
请让我知道如果一些简短的补充空间科学文章将不胜感激。
常见的激活功能以及为什么你必须知道它们
对常用激活功能的实现、额外好处、注意事项和使用的总结
激活函数是神经网络的基本构件。然而，在人们能够有效地使用它们之前，必须仔细地研究它们。这是因为激活函数有活动区域和死亡区域，使得它们在模型中要么学习要么行动死亡。让我们一个接一个地讨论它们的正确使用和它们的缺点。
Sigmoid 函数
Sigmoid 函数或 logistic 函数或软阶跃函数是研究神经网络性能的共同出发点。从数学上讲，这个函数及其导数可以表示为图 1 所示。
图 1 Sigmoid 函数和导数(图片由作者提供)
该函数可以如图 2 所示绘制。
图 2 Sigmoid 函数(图片由作者提供)
我们可以看到该函数只能在大致-4 到 4 的范围内帮助训练。这是因为，在任何一侧超过这些限制，梯度都不显著。让我们看看图 3 所示的梯度曲线。
图 3 sigmoid 函数的导数(图片由作者提供)
我们可以看到，在绿线和红线所示的[-4，4]的限制之外，梯度并不那么显著。这就是所谓的消失渐变的问题。由于这个原因，在深层网络中使用 sigmoid 函数是不理想的。此外，如果你想把更小的值(< 1)不断相乘，你最终会得到非常小的值。这在深层网络中是不利的条件。所以 sigmoid 根本就不是深度学习想要的激活。 ReLU 是克服 sigmoid 函数不良结果的第一个变通方法。
虽然 sigmoid 函数不用于隐藏层，但它是输出层的理想选择。这是因为 sigmoid 给出了[0，1]范围内的值，这可以帮助我们训练一个用于二进制编码输出的网络。这应当连同一个 二元交叉熵 损失函数一起完成。
ReLU ( R 有效 L 线性单位)函数
ReLU 只是简单地输出一个神经元的非负输出。在数学上，这可以表示为如图 4 所示。
图 4 ReLU 函数和导数(图片由作者提供)
我们可以绘制函数及其导数，如图 5 所示。
图 5 ReLU 及其衍生产品(图片由作者提供)
如图 5 所示，导数永远不会死在正区域。此外，由于值是在没有任何阻尼的情况下输出的，因此值不会像我们在 sigmoid 函数中看到的那样消失。因此， ReLU 成为深度学习的理想候选。然而，正如你可能已经注意到的， ReLU 根本不存在于负空间中。这通常是可以的，因为神经网络的输入值和输出值是正的。然而，如果你有范围[-1，1]内的标度值或标准化值，这可能会杀死一些无法恢复的神经元。这种现象被称为垂死的 ReLU 。虽然这不是人们应该担心的事情(可以通过使用最小-最大缩放器进行缩放来避免)，但了解变通方法是值得的。注意，由于值通过 ReLU 网络的爆炸性质，通常不希望在输出层中使用 ReLU 。此外，爆炸值会导致爆炸梯度的现象。然而，使用适当的 剪裁 和 规则化 可以有所帮助。
ReLU 变量和其他线性单位函数
ReLU 有几个变种，有助于克服死 ReLU 的问题。
PReLU(参数 ReLU)和泄漏 ReLU
参数化 ReLU 试图将负输入参数化，从而使垂死 ReLU 恢复。然而，该参数是一个可学习的参数，但 Leaky ReLU 除外，它为负分量使用一个固定参数。通常这个参数被选择为一个小值，因为网络的典型输出被认为是正的。
图 6 PReLU 和衍生工具(图片由作者提供)
对于给定的𝛂值(0.1)，我们绘制了如图 7 所示的图表。这是漏 ReLU 的场景，0.1 为负乘数。
图 7 ⍺=0.1 的泄漏 ReLU(图片由作者提供)
注意，负区域中的梯度是细微的，但不为零。还有，节点面对太多负面数字也不会死。
ELU(指数线性单位)函数
在该函数中，负分量使用指数表示法建模。然而，我们仍然有可学习的参数𝛂.
图 8 ELU 函数(图片由作者提供)
我们可以将其绘制成图 9 所示。这里，为了更好的可视性，我们假设𝛂=0.5。
图 9 ELU 函数及其导数(图片由作者提供)
既然我们已经讨论了深度网络中使用的几个重要函数，那么让我们来看看一些常见但不那么复杂的函数。
Tanh 函数
谭是 LSTM 网络背后的驱动力。这有助于避免 RNNs 的缺点。
图 10 双曲正切函数和导数(图片由作者提供)
我们可以将其绘制成图 11 所示。
图 11 双曲正切函数和导数(图片由作者提供)
更多的激活功能
- **恒等函数:**这是
f(x)=x带导数f'(x)=1的朴素函数。 - **Softmax 函数:**该函数保证输出加起来为 1 的层的值。这主要用于使用 分类交叉熵 作为损失函数的分类分类，并且主要用于输出层。
笔记
激活函数的设计主要考虑导数。这就是为什么你会看到一个很好的简化的导数函数。
必须通过查看输入值的范围来选择激活函数。然而， ReLU 或 PReLU 是一个很好的起点，带有s 形或 softmax 到输出层。
具有可学习参数的激活功能通常被实现为单独的层。这更直观，因为参数是通过相同的反向传播算法学习的。
希望你喜欢阅读这篇文章。
干杯！😃
常见 Pipenv 错误及解决方法:为什么不能锁定？！
Pipenv 无法锁定时该怎么办
本文是众多介绍 Python 包和使用 Pipenv 进行环境管理的文章之一。在这里，您将学习如何解决 Pipenv 安装和锁定问题。有关 Pipenv 或环境的更多信息，请查看这篇 中型文章 ！
马科斯·迈尔在 Unsplash 上的照片
Pipenv 是什么？
Pipenv 将软件包管理和虚拟环境控制结合到一个工具中，用于安装、删除、跟踪和记录您的依赖关系；以及创建、使用和管理您的虚拟环境。Pipenv 本质上是将 pip 和 virtualenv 包装在一个产品中。
当您使用 Pipenv 开始一个项目时，该工具会自动创建一个虚拟环境、一个 Pipfile 和一个 Pipfile.lock。当您用pipenv install安装一个包时，Pipfile 会自动用新的依赖项更新。
锁定问题:Pipfile 包含对不存在的包的引用
当 Pipfile 试图安装不存在的软件包，即错别字时，它不会锁定。
例如:
pipenv install panadas
Pipenv 查找您指定的包，不管它是否存在。当包不存在或由于其他原因找不到时，您会在终端中看到以下错误和更多错误。现在，我们将把重点放在这两个方面。
安装错别字
Pipenv 找不到 Panadas 的版本
锁定失败！请注意,“panadas”被添加到 Pipfile 的包中。这种打字错误将成为一个问题，因为现在我们的 Pipfile 包含一个错误，任何使用这个 Pipfile 的人都会遇到锁定和依赖错误。请注意，“安装成功”警报是不真实的；没有要安装的 Panadas。所发生的只是将“panadas”添加到 Pipfile 中。Pipfile 中的拼写错误是锁定失败的最常见原因。
只要 Pipfile 中存在这种输入错误，安装一个包，不管存在与否，都会导致锁定失败。您需要在文本编辑器中修复 Pipfile。我用的是纳米。你可以使用任何你觉得舒服的编辑器；Sublime，VS 代码，Atom 等。只需将 Panadas 改为 Pandas，然后pipenv install.
现在让我们看看锁定失败时控制台中出现的其他一些错误消息。
注意建议pipenv install --skip-lock。这应该只在极端或因果编程环境中使用，因为它绕过了 Pipfile。锁的主要用途；锁定软件包版本并创建安装环境依赖项的公式。
pip 文件管理:指定版本
锁定失败的第二个最常见的原因是我们试图安装一个预发布版本的包。您可以通过在安装中添加--pre标志来解决预发布版本冲突。
pipenv install --pre
在这个命令之后，您的 Pipfile 有了一个新变量； allow_prereleases = true。请注意，这将允许在您的环境中安装任何预发行软件包。现在是固定特定包版本有用的时候了。固定版本是一个很好的习惯，可以防止将来出现依赖问题。
请注意上面“要求”部分下的 Pipfile 图像；你看python_version = 3.7。Pipfile 在这里指定了 Python 版本。
要使用特定的 Python 版本构建 Pipfile 或环境，请使用以下语法。
pipenv --python 3
需要时还可以指定包版本。
pipenv install django=1.11.10
结论
通过 Pipenv 和 Pipfile，您向其他人展示了一种安装项目依赖项以及测试和开发需求的标准化方法。任何拥有您的 Pipfile 副本的人都可以使用下面的命令重新创建您的环境。
pipenv install
这将创建一个由 Pipfile 指定的环境。确保 Pipfile 没有打字错误，并且在共享之前指定了正确的包和 Python 版本！
如果这不是您正在寻找的 pipenv 解决方案，请查看这篇中型文章以获得有关其他 Pipenv 错误的帮助！
Pipenv 错误及其解决方案的集合。
towardsdatascience.com](/common-pipenv-errors-3a6f8ce81562)
我的通用 Git 命令备忘单
在这篇博客中，我记录了一些我经常使用或者为了特定目的使用过几次的常用 git 命令。这肯定不是一个详尽的列表，但更全面，是为了快速参考。
初始化/克隆 GIT 存储库
要创建新的本地 git 存储库:
git init
要从本地 git 存储库复制:
git clone /path/to/repository
要从本地 git 存储库复制:
git clone username@host:/path/to/repository
从远程存储库更新本地存储库
要实现(合并)从远程存储库到本地存储库的更改，请执行以下操作:
git pull
或者
git fetch
git merge <branch_name>
NB: git pull 只不过是应用了自动分支策略的 git 获取和合并分支。
Git 配置
要配置本地存储库的用户名和电子邮件:
git config user.name "your_name"
git config user.email "your_email_address"
要为所有提交配置用户名和电子邮件:
git config --global user.name "your_name"
git config --global user.email "your_email_address"
分支
要创建新的分支和交换机:
git checkout -b <branch_name>
要切换到现有分支:
git checkout <branch_name>
要查看工作分支:
git branch
要删除分支:
git branch -d <branch_name>
将变更添加到本地存储库中
- 对文件进行更改。
- 验证已更改文件的文件列表以及尚未转移或提交的文件:
git status
3.将文件添加到暂存/索引:
git add <file_name>
4 .将阶段性更改提交给 head:
git commit -m "Your_message_about_the_commit"
要提交已添加到暂存中的任何更改以及此后更改但尚未暂存的文件，请执行以下操作:
git commit -a "Your_message_about_the_commit"
5.要将更改推送到分支:
git push origin <branch_name>
6.要将更改推送到母版:
git push origin master
理想情况下，在协作软件开发环境中拉请求用于批准对主所做的更改。因此，我们应该将我们的变更推送到我们的工作分支，并打开一个拉请求来合并变更。
使用 Git Stash
要记录工作目录和索引的当前状态并返回到干净的工作目录:
git stash save "your_message"
“您的消息”使您更容易在存储列表中找到存储状态。
要获得隐藏的工作目录的有序列表:
git stash list
输出是一个编号列表，如 stash@{0}、stash@{1}等。
要清除所有存储状态:
git stash clear
要删除选定的存储树，在这种情况下，是倒数第二个存储状态:
git stash drop stash@{1}
默认—最后一次隐藏状态
要从隐藏列表中删除所选的隐藏状态并应用于当前工作树状态，请执行以下操作:
git stash apply stash@{1}
默认—最后一次隐藏状态
从隐藏列表中删除选定的隐藏状态，并应用于当前工作树状态之上。此外，它删除弹出的存储状态。
git stash pop stash@{1}
默认-上次隐藏状态
GIT 命令的日志和历史记录
丹尼尔·利维斯·佩鲁西在 Unsplash 上的照片
要检查 git 命令历史记录(仅 HEAD):
git reflog [show]
要检查 git 命令历史记录:
git reflog show --all
要检查所有 git 命令的历史记录:
git reflog --date=iso
要检查所有“特定命令”(如拉/提交/存储)命令历史记录，包括时间:
git reflog --date=iso|grep specific_command
要查看分支中的提交日志:
git log origin/master
刘汉宁·奈巴霍在 Unsplash 上的照片
感谢光临。希望这有帮助！
每个数据科学家都需要知道的通用 Git 命令
通过使用 Git 和 GitHub 成为更好的数据科学家的指南
马库斯·温克勒在Unsplash【1】上的照片。
目录
- 介绍
- GitHub 设置
- 命令
- 摘要
- 参考
介绍
对于软件工程师、数据工程师、机器学习工程师和数据科学家来说，GitHub 是一个非常有价值和有用的工具。起初，作为一名学生，甚至是一名专业的数据科学家，我倾向于远离 GitHub，因为它令人困惑，而且似乎不是我作为一名数据科学家需要了解的东西。但是，随着时间的推移，我逐渐意识到，为了扩展您的代码和模型，尤其是如果涉及到不止一个人(，通常是)，以及采用精确的版本控制，Git 和 GitHub 是必不可少的。虽然您可以选择在 Jupyter 笔记本上完成大部分工作，但是一旦您的模型准备好进行部署，文件的数量就会增加，因为。py 文件很可能都是面向对象的，其中的代码不是以研究为中心，而是像软件工程师一样高效地编码，GitHub 将是这一过程的解决方案。下面，我将讨论 GitHub 及其非常有用的 Git 命令，它们将帮助您成为更好的数据科学家。
GitHub 设置
作者截图[2]。
在这种情况下，GitHub[3]是数据科学家通过使用 Git 进行协作和使用版本控制的工具。它可以用于研究目的，但主要分配给机器学习模型的部署代码。使用它的最佳方式是通过使用拉请求。这有助于确保多个人(这是一个可编辑的字段)审查和批准您的代码更改。上图是创建第一个存储库的一般设置。我不会过多地关注这一点，因为我们将讨论有用的 Git 命令，但是需要注意的是，在使用所描述的命令之前，这是整个过程的第一步。
在这里可以找到从您的终端创建存储库的设置代码:
echo "# article" >> README.md
git init
git add README.md
git commit -m "first commit"
git remote add origin https://github.com/mprzybyla123/article.git
git push -u origin master
命令
照片由 Yancy Min 在Unsplash【4】上拍摄。
一旦建立了存储库，就可以按照这些有用的 Git 命令在终端中移动存储库。由于许多人将在同一个存储库上工作，所以创建分支是很重要的，这将是您的工作空间，一旦拉请求被批准，它将最终合并到主存储库中。以下是常见数据科学命令的代码示例及其相关信息。
git branch
这个分支命令返回您的存储库的所有分支，以后可能会超过 20 个，所以这个命令将以绿色突出显示，而其他分支是白色的，这是您当前所在的分支。这个命令非常重要，这样您就不会意外地将不正确的代码推送到您的主分支——通过确保您不在主分支上。
git branch name_of_branch
要复制主分支并创建自己的分支，请使用上面的 branch 命令。这确保了您在一个单独的分支上工作，在 pull 请求被批准后，该分支也可以与新的代码变更合并在一起。将分行名称更改为您想要的分行名称。
git pull
在检查您的分支，并切换到主分支时，这个命令将获取所有新的代码更改，您的主分支将完全更新。建议您经常执行此 pull 命令。
git status
一旦你真正进入了你的仓库，在文件之间切换并创建变更，你将需要知道你改变了什么。在对主分支进行新的代码更改之前，检查您的更改状态是非常有用的。
接下来的 4 个命令将是连续的命令，以便添加更改、提交更改并将其推送到您的 GitHub respiratory，它将与您的主分支进行比较，最终在获得批准后合并。
git add folder_name/folder_name/folder_name/file.py
上面的 add 命令是三个文件夹目录的一个例子，这三个文件夹包含了你要添加的文件，所以你可以随意用你实际文件夹的名字替换那些文件夹的名字，也可以把文件. py 改成你实际的文件夹。py 文件。
git commit -m “Added file change”
commit 命令是这个过程中的第二步，它不仅命名您所做的更改，还提交代码更改。
git push
要将前面的所有步骤一起编译，您将使用 push 命令将文件及其更改发送到存储库。注意:您不必在之后执行拉请求，但这通常是大多数人在这个过程中会采取的步骤。
git push --set-upstream origin name_of_branch
如果您一直在本地处理您的分支机构，并且这是您第一次将它托管为共享和公共的(在您的公司分支机构内)，您将必须使用这个推送命令，它将作为一个建议被自动提示。分支的名称将替换为您已经命名的分支。
虽然这段代码很简单，但它非常强大，可以让您成为一名数据科学家，在代码中使用带有检查和平衡的受控系统。现在，您可以将您的代码更改与同样在同一模型上工作的其他数据科学家或软件工程师进行比较。最后，您将看到一个绿色图标，询问您是否要’创建一个拉取请求。然后，您将能够创建、可视化和查看您的代码与主代码相比如何。在代码被比如说两个人批准之后，您可以将您的更改合并到 master 中，并删除您的分支。
摘要
本文描述了如何快速设置您的存储库，以便在本地计算机上使用，同时还能够应用于整个主分支，该分支将存放您的数据科学或机器学习模型的生产级代码。
使用所讨论的通用 Git 命令，您将能够成功地将代码更改应用到您的 data science GitHub 存储库中。
- *检查你在哪个分支——*git 分支
- *从您的主分支创建一个新的分支—*git branch branch _ name
- 提取主分支，使其保持最新— git 提取
- 检查您的文件(代码)变更— git 状态
- 添加您的文件(代码)从您的分支— git 添加
- *从您的分支提交您的更改—*git commit-m " Added change "
- 从你的分支推送你的变更— git 推送
参考
[1]马库斯·温克勒在 Unsplash 上拍摄的照片，(2020)
[2] M.Przybyla，GitHub 的截图，(2020 年)
[3] GitHub， GitHub 主页，(2020)
[4]照片由 Yancy Min 在Unsplash(2019)上拍摄
常见的图论问题
图论简化版
这篇文章旨在使用图论给出一组广泛而直观的问题陈述和可能的解决方案。
我们每天遇到的许多问题都可以被解释为一个图问题或者一个近似的子问题。因此，需要对不同的图形变体及其应用有所了解。如果你想重温一下图论的基础知识，你一定要去参观一下这个。后者将让你对不同类型的图及其表示有一个简要的了解。
最短路径问题
最常见的图形问题之一就是最短路径问题。给定一个加权图，我们必须找出从节点 A 到 g 的最短路径。所有可能路径中的最短路径肯定是优化成本函数的路径。
作者照片
例如，考虑上面给出的图中的节点是世界上不同的城市。如果您仔细观察该图，我们可以看到与每个边缘相关的成本。所以这是一个有向加权图。回到我们的直觉，与每对城市相关联的权重被认为是城市间旅行的成本。为了方便起见，让我们将每个成本乘以 100 美元，得到一个真实的数字。因此，在城市 A 和 B 之间旅行的费用是 300 美元，B 和 F 之间的费用是 600 美元，以此类推。如果我们想在两个城市之间计划一次划算的旅行，我们应该参考这张图表来估算总成本。两个城市之间可能有多条路径，我们最寻求的路径应该是成本最低的路径。这是最短路径问题的一个非常基本但可以理解的例子。
幸运的是，有一些算法可以以最小的代价把我们从节点 A 引导到节点 B。 广度优先搜索 ， 迪杰斯特拉的 ， 贝尔曼-福特 ， 弗洛伊德-沃肖 ， A* 还有很多算法可以用来解决最短路径问题。
连通性
顾名思义，连通性是图论中的一个大问题，它表示从节点 A 到 B 是否存在一条路径。需要注意的一点是，我们不关心最小成本，只关心路径。
作者照片
解决这个问题的最基本方法是进行广度优先搜索或深度优先搜索。
负周期
有时我们的图会有负边，这可能会破坏图的整个流。我要说的是，负面循环是一个永无止境的陷阱。因此，我们检查，是否存在任何一对节点之间的负加权边，如果是这样，它如何形成一个循环。
作者照片
在给定的图中存在负边。显然，它对负面循环的形成有所贡献。一个这样的循环是***【B，C，D】***。如果我们循环通过这些边缘，我们将永远以最小的成本进行下去。然而，在某些情况下，负面循环扮演了天使的角色。例如，如果我们运行一个从一种货币到另一种货币再到另一种货币的货币兑换游戏，我们可以使用这样一个负图，这反过来可能会产生一些成本效益。这只是一个假设，可能会也可能不会成为事实，因为货币汇率不会保持不变这么久。有某些算法如 贝尔曼-福特 和 弗洛伊德-沃肖尔 来检测负周期。
强连通分量
这些是有向图中的独立循环，因此循环中的每个节点都可以到达同一循环中的所有其他节点。
作者照片
重要的是要看是否有强连接的组件。红色方框内的循环就是这些组件的示例。用于检测这些组件的不同算法是 Tarjan 的和 Kosaraju 的算法。
旅行推销员问题
如果没有听过这个学期，没有人会完成他们的计算机科学学位。如果你没有，我很抱歉。但是它非常容易理解，并且有很多实际应用。
图片来自文章公司的博客
该问题的结构是给定一个城市列表和每对可能的城市之间的成本或距离。然后，销售人员必须在相同的节点开始和结束，但必须以最小的成本或距离访问轨迹中的每个城市一次，这取决于目标函数。这个问题看起来非常简单，并且在路径估计和成本优化问题中得到了广泛的关注。诸如分支定界和 hold-Karp 的几种算法可用于解决这个问题。这仍然是一个计算上具有挑战性但研究仍在继续的问题。
布里奇斯
桥是图中的边，移除桥可以增加图中连通分量的数量。网桥非常重要，因为它们代表了图中的漏洞和瓶颈。
照片由onion-router.net拍摄
移除连接节点 G 和 N 的边将导致两个单独的组件被连接。如果那是一座真的桥，拆除它将会导致两个孤立的城市。所以，桥总是一个弱点，因为它的断开会造成额外的麻烦。
类似地， 关节点 是一个节点，其移除导致连接的组件的总数增加。
最小生成树
最小生成树是连接所有顶点以形成最小成本树的边的子集。
照片由萨尔萨克·阿加瓦尔通过commonlounge.com拍摄
正如你所看到的，给定的图形是加权的和无向的。粗边表示连接所有顶点的最小成本生成树，但代价最小。我们将不同的问题，如路线规划、电路设计和更多的问题公式化为最小生成树，这些问题可以通过 Kruskal 的和 Prim 的算法来解决。
最大网络流量
顾名思义，这些问题可以用来估计一个图所能容纳的最大体积(取决于问题)。例如，如果我们将电网视为我们的图形，将电线杆视为图形中的不同节点。我们可以假设在不影响电网的情况下，有多少电力可以通过网络发送。另一个例子是移动网络，其中每个用户充当图中的一个节点。与前一个示例一样，我们可以计算出在没有网络流量的情况下可以保持在线的最大用户数量。
作者照片
这个公式可以回答所有问题中的最大值，并预测潜在的瓶颈。使用的不同算法有 福特-富尔克森 和 埃德蒙兹卡普&迪尼奇的算法。
我们已经讨论了图论中几乎所有的问题。我们将在接下来的文章中讨论这里提到的每一个算法。我非常兴奋能和你们分享所有的这些。在那之前，再见！
Python 中常用的图像处理技术
使用 PIL 和 OpenCV 学习简单而强大的图像处理技术
在这篇文章中，你将学习
- 使用 PIL 和 OpenCV 的常见图像处理技术，如将 RGB 图像转换为灰度图像、旋转图像、去除图像噪声、检测图像边缘以及裁剪图像中的感兴趣区域
- 使用 OpenCV 的模板匹配在图像中搜索物体
必需的库:
PIL、OpenCV 和 imutils
为什么需要学习图像处理技术？
深度学习用于分析、识别和生成对图像中对象的智能理解。一些常见的应用是**图像分类、对象检测、实例分割、**等。因此，必须对图像处理技术有深入的了解，如图像增强，包括裁剪图像、去除图像中存在的噪声或旋转图像等。，以建立更好的训练数据集。
图像处理技术同样有助于光学字符识别(OCR)
图像处理技术通过帮助识别关键特征或从图像中读取文本来增加图像的可解释性，以分类或检测图像中存在的对象。
此处提供代码和图片
导入所需的库
**import cv2
from PIL import Image**
让我们先用 OpenCV 和 PIL 显示图像
使用 OpenCV 读取并显示图像
# Reading and Displaying the file
**image = cv2.imread(r'love.jpg')
cv2.imshow("Image", image)
cv2.waitKey(0)**
如果图像太大，那么显示图像的窗口将不适合屏幕。
那么我如何在屏幕上显示完整的图像呢？
默认情况下，当显示超大图像时，您会看到裁剪后的显示。要查看完整图像，您将使用 OpenCV 的 namedWindow(name，flag) 创建一个新窗口。第一个参数， name， 是窗口的标题，将被用作标识符。当您将 标志 设置为 **cv2 时。WINDOW_NORMAL，**然后显示完整图像，您可以调整窗口大小。flag 参数还有其他选项。
# Resizing the image for the user to resize the window
**image = cv2.imread(r'love.jpg')
cv2.namedWindow('Normal Window', cv2.WINDOW_NORMAL)
cv2.imshow('Normal Window', image)
cv2.waitKey(0)**
调整图像大小
当我们调整图像大小时，我们改变图像的高度和/或宽度，并保持纵横比。图像的宽高比是图像的宽高比。
**image= cv2.imread(r'taj.jpg')**
**scale_percent =200** # percent of original size
**width = int(image.shape[1] * scale_percent / 100)**
**height = int(image.shape[0] * scale_percent / 100)
dim = (width, height)
resized = cv2.resize(image, dim, interpolation = cv2.INTER_AREA)
cv2.imshow("Resize", resized)
cv2.waitKey(0)**
使用 PIL 读取并显示图像
您将使用 open() 加载图像，然后使用 show() 进行显示。
***形象。*show()**创建一个临时文件。
**pil_image= Image.open(r'love.jpg')
pil_image.show("PIL Image")**
如果你对识别图像中的边缘或其他特征感兴趣怎么办？
灰度图像用于识别边缘。灰度图像还有助于理解图像中存在的对比度或阴影梯度，以及理解它们在分析图像特征中的作用。
与灰度图像的 2D 通道相比，RGB 图像有三个通道:红色、绿色和蓝色。与彩色图像相比，灰度图像的每像素信息更少，因此灰度图像的处理时间更快。
利用 OpenCV 实现彩色图像的灰度化
我们正在使用 cvtColor()， 将彩色图像转换为灰度图像，这将把图像从一个色彩空间保存到另一个色彩空间。
#Converting image to grayscale
**image = cv2.imread(r'love.jpg')
gray_image= cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
cv2.namedWindow('Gray Image', cv2.WINDOW_NORMAL)
cv2.imshow('Gray Image', gray_image)
cv2.waitKey(0)**
使用 PIL 对彩色图像进行灰度缩放
***【convert()***返回此图像的转换副本；灰度使用“L”模式，彩色使用“RGB”模式。
# Gray image using PIL
**pil_image= Image.open(r'love.jpg')
gray_pil=pil_image.convert('L')
gray_pil.show()**
使用 OpenCV 进行边缘检测
使用 canny 边缘检测器检测图像中的边缘。Canny 边缘检测器通过多阶段算法使用灰度图像。
Canny() : 第一个参数是**输入图像，**第二个和第三个参数是 threshold1 和 threshold2 值。
强度梯度大于阈值 2 的边缘被认为是边缘，而低于阈值 1 的边缘被认为是非边缘。非边缘将被移除。两个阈值之间的任何梯度强度值基于它们的连通性被分类为边缘或非边缘。
**image= cv2.imread(r'taj.jpg')
cv2.namedWindow("Edge", cv2.WINDOW_NORMAL)
denoised_image = cv2.Canny(image, 100,200 )
cv2.imshow("Edge", denoised_image)
cv2.waitKey(0)**
Canny 边缘检测器
如果图像有歪斜或轻微旋转，想对图像进行纠偏怎么办？
倾斜文本的 OCR 效果不好，因此我们需要进行倾斜校正。可以使用 OpenCV 和 PIL 的 rotate() 对图像进行纠偏。
使用 OpenCV 旋转图像
rotate() 将根据 **rotationCode，**旋转图像，该代码为旋转函数的第二个参数。
旋转码的值为
- cv2。顺时针旋转 90 度，
- cv2。逆时针旋转 90 度
- cv2。旋转 _180 度
#Rotating the image
**image = cv2.imread(r'love.jpg')
cv2.namedWindow("Rotated Image", cv2.WINDOW_NORMAL)
rotated_img= cv2.rotate(image,cv2.ROTATE_90_CLOCKWISE )
cv2.imshow("Rotated Image", rotated_img)
cv2.waitKey(0)**
使用 OpenCV 顺时针旋转 90 度的图像
如果我想只旋转图像一个特定的角度怎么办？
根据特定角度旋转图像
在下面的代码中，使用 imutils 的 rotate() 将图像旋转 60 度
**import imutils
import numpy as np****image = cv2.imread(r'love.jpg')**# loop over the rotation angles
**for angle in np.arange(0, 360, 60):
cv2.namedWindow("Rotated", cv2.WINDOW_NORMAL)
rotated = imutils.rotate(image, angle)
cv2.imshow("Rotated", rotated)
cv2.waitKey(0)**
使用 imutils 以 60 度为增量旋转图像
使用 PIL 旋转图像
这里的图像使用 PIL 旋转了 110 度
# Rotate image using PIL
**pil_image= Image.open(r'love.jpg')
rotate_img_pil=pil_image.rotate(110)
rotate_img_pil.show()**
使用 PIL 旋转 110 度的图像
当图像质量因噪声的存在而变差并影响图像分析时，如何增强图像质量？
利用 OpenCV 实现图像去噪
噪声是不想要的信号，就图像而言，它是颜色的随机变化。
使用 OpenCV 最小化图像中的噪声。
**image= cv2.imread(r'taj.jpg')
cv2.namedWindow("Noised Image", cv2.WINDOW_NORMAL)
cv2.imshow("Noised Image", image)
cv2.waitKey(0)**
OpenCV 中有不同的方法来去除图像中的噪声。下面用的是cv . fastnlmeansdenoisingcolored(**)，**就是去除彩色图像中的噪点。
fast nimeans 降噪方法的常见参数有
- src :来源图片
- dst :输出与 src 相同大小和类型的图像
- h :调节过滤强度。较高的 h 值完美地去除了图像细节中的噪声，较小的 h 值将保留图像细节和一些噪声。
- hForColorComponents :与 h 相同，但仅用于彩色图像，通常与 h 相同
- templateWindowSize :应该是奇数。(推荐 7)
- searchWindowSize :应该是奇数。(推荐 21)
**image= cv2.imread(r'taj.jpg')
cv2.namedWindow("Denoised Image", cv2.WINDOW_NORMAL)
denoised_image = cv2.fastNlMeansDenoisingColored(image,None, h=5)
cv2.imshow("Denoised Image", denoised_image)
cv2.waitKey(0)**
如何从一幅图像中提取某些感兴趣的区域？
裁剪图像
裁剪图像可让您提取图像中感兴趣的区域。
我们将裁剪泰姬陵的图像，只保留泰姬陵，并删除图像中的其他细节。
使用 OpenCV 裁剪图像
OpenCV 中的裁剪是通过对图像数组进行切片来完成的，我们通过 y 坐标的起点和终点，然后是 x 坐标的起点和终点。
图像【y_start:y_end，x _ start:x _ end】
**image= cv2.imread(r'taj.jpg')
resized_img= image[15:170, 20:200]
cv2.imshow("Resize", resized_img)
cv2.waitKey(0)**
使用 PIL 裁剪图像
PIL 的 crop() 允许我们裁剪图像的一个矩形区域，参数 crop() 是 左坐标、上坐标、右坐标和下像素坐标。
# Opens a image in RGB mode
**pil_image = Image.open(r'taj.jpg')**
# Get the Size of the image in pixels
**width, height = pil_image.size**
# Setting the cropped image co-ordinates
**left = 3
top = height /25
right = 200
bottom = 3 * height / 4**
# Crop the image based on the above dimension
**cropped_image = pil_image.crop((left, top, right, bottom))**
# Shows the image in image viewer
**cropped_image.show()**
使用 PIL 裁剪图像
模板匹配
您可以提供一个模板，并使用 OpenCV 的***match template()***在图像中搜索该模板并提取其位置。
模板像卷积神经网络一样在整个图像上滑动，并试图将模板与输入图像匹配。
minMaxLoc() 用于获取最大/最小值，它将是矩形的左上角连同宽度和高度。
有 6 种方法可用于模板匹配
- cv2。TM_SQDIFF
- cv2。TM_SQDIFF_NORMED
- cv2。TM_CCORR
- cv2。TM_CCORR_NORMED
- cv2。TM_CCOEFF
- cv2。TM_CCOEFF_NORMED
在下面的例子中，我从主图像中裁剪了一小部分来创建模板。
用于模板匹配的方法是 TM_CCOEFF_NORMED。匹配的阈值设置为 0.95。它定位具有大于 95%的较高匹配概率的位置，然后在对应于匹配的区域周围绘制矩形。
import cv2
**import numpy as np
from matplotlib import pyplot as plt
img = cv2.imread(r'love.jpg',0)****cv2.imshow("main",img)
cv2.waitKey(0)****template = cv2.imread(r'template1.png',0)
cv2.imshow("Template",template**)
**cv2.waitKey(0)****w, h = template.shape[::-1]
methods = [ 'cv2.TM_CCOEFF_NORMED']****for meth in methods:
method = eval(meth)**# Apply template Matching
**res = cv2.matchTemplate(img,template,method)
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)
threshold=0.95
loc=np.where(res>threshold)
if len(loc[0])>0:**# If the method is TM_SQDIFF or TM_SQDIFF_NORMED, take minimum
**if method in [ cv2.TM_SQDIFF_NORMED]:
top_left = min_loc
bottom_right = (top_left[0] + w, top_left[1] + h)****cv2.rectangle(img,top_left, bottom_right,100,20)****plt.subplot(121),plt.imshow(res,cmap = 'gray')
plt.title('Matching Result'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(img,cmap = 'gray')
plt.title('Detected Point'), plt.xticks([]), plt.yticks([])
plt.suptitle(meth)****plt.show()
else:
print("Template not matched")**
结论:
我们已经讨论了最常见的图像处理技术，这些技术可用于图像分类、对象检测以及 OCR 的图像分析。
参考资料:
在本章中，您将学习模板匹配是一种搜索和查找模板位置的方法…
docs.opencv.org](https://docs.opencv.org/master/d4/dc6/tutorial_py_template_matching.html) [## 参考—枕头(PIL 叉)3.1.2 文件
编辑描述
pillow.readthedocs.io](https://pillow.readthedocs.io/en/3.1.x/reference/)
https://opencv-python-tutroals.readthedocs.io/en/latest/
引用完整性经常被忽略，但却很重要
让我们来看看数据完整性的一个关键组成部分的常见情况。
引用完整性的重要性
引用完整性是一个简单但强大的工具。在数据湖、个性化推荐和深度数据分析工具的世界里，基本概念有时会被遗忘。但是我们不能放弃。当我们设计数据模型时，这个概念应该一直在我们的脑海中。它是数据系统中数据完整性的支柱。
我假设本文的所有潜在读者都知道如何实现它，但是简单的提醒总是有用的。引用表(数据集，数据实体)的外键仍必须引用和被引用表中的有效行。参照完整性确保两个表之间的关系在执行更新和删除指令期间保持同步。
在左边的一般情况下—在右边的特定示例情况下
当然，在标准生活应用中，设计越来越复杂，结构具有嵌套和圆形形式:
虽然我将要提出的清单并不详尽，但它代表了现实世界的问题。注意，这些问题都是我在职业生涯中发现的。没有猜测，也没有二手故事。我知道有些用户案例和项目不需要引用完整性(但我认为大多数生活应用程序需要引用完整性)。让我们一起来回顾一下这些令人痛心的案例:
引用完整性不适用
这是最糟糕的情况，不仅仅是因为后果(数据丢失、重复、数据丢失、内部不一致等)，还因为它意味着:
- 缺乏知识
最初的开发者 d 根本不知道引用完整性。我在不止一个初创企业和小企业中看到过这个问题。通常，造成这种混乱的罪魁祸首是来自不同业务部门的人，他们做得很快，或者是非开发人员重新转变为开发人员。 - 完全不小心
对我来说，这是最痛苦的。而肇事者知道如何正确实施，却不去做。最典型的借口是:这是一个订单，我想缩短上市时间，或者这只是一个概念证明。
参照完整性的设计错误
也许这可以包括在缺乏知识这一点中，但是在这种情况下，开发/数据人员知道引用完整性。尽管如此，由于执行不力，最终结果是错误的。这些是我经常发现的情况:
- 忘记添加两个或多个表之间的关系。
- 忘记添加确保级联更新和删除的触发器。
- 应用了错误的数据完整性类型。最常见的是在部分完整性是正确选择时使用弱完整性(反之亦然，这很常见)。但是我也看到了不同组合的错位:弱完整代替强，部分完整代替强，强完整代替部分，等等。
引用完整性由应用程序应用，而不是由数据库引擎应用
让我明确这一点:如果可能的话，依靠数据库引擎。这样做，你就可以避免将来的问题。这是一个明显的重新发明轮子的场景:在最好的情况下，你的开发会像预期的那样工作。在最坏的情况下，您将不得不处理一个巨大的混乱，混合和丢失的数据。客户、合作伙伴、同事和经理会对你大喊大叫，要求你提供一个很可能是不可能的解决方案。
请记住，即使有一个好的初始设计和完美的实现，在未来的开发迭代中，总有添加 bug 的风险。当我们谈到数据完整性时，一个小错误可能会产生相当大的影响，以后可能会有一个很难解决的问题。此外，其他部门可能会访问原始数据，并由于数据库引擎中缺乏一致性而产生问题。
此外，DB 引擎一直以提供最佳性能而著称。投入时间和资源来达到 DB 默认提供的相同结果是一个非常糟糕的主意。
数据库引擎没有引用完整性功能
一个很好的例子是在 MongoDB 版本 4 之前的实现。我听过几次断言在非 SQL 数据库中不需要添加参照完整性。我完全不同意这样的肯定。虽然引用完整性对任何关系数据库都是至关重要的，但它对非 SQL 数据库也很有用。
我将用一个例子来说明这一点。首先，我们来看下面这个集合:
这样的设计将对应于一个希望以最快的方式提供 Book 元素的系统，就像在一个高需求的 GET RESTful 端点中所需要的那样。
现在来看看这两个系列:
该模型将允许执行更平滑的聚合操作和更好的性能。它还可以在作者之间提供更有效的查询。这并没有放弃第一个解决方案的面向文档的设计(但是检索书籍的性能较低)。最后，我的观点是，对于使用非纯关系数据库，当需要引用完整性时，您不应该放弃它。
Python 中常见的机器学习编程错误
机器学习中常见的 Python 错误
马库斯·斯皮斯克在的照片
在这篇文章中，我将回顾我在 python 建模和开发过程中遇到的一些最常见的错误。出于演示目的，我们将使用在 Kaggle 上可以找到的身高/体重数据。数据包括性别、身高(英寸)和体重(磅)。
根据我的经验，最常见的错误如下:
进口
- 名称错误
- ModuleNotFoundError
- 属性错误
- 导入错误
读取数据
6.FileNotFoundError
选择列
7.键盘错误
数据处理
8.值错误
我们将构建一个简单的线性回归模型，并修改代码以显示上述错误在实践中是如何出现的。
首先让我们使用 pandas 导入数据并打印前五行:
import pandas as pd
df = pd.read_csv("weight-height.csv")
print(df.head())
如你所见，数据集非常简单，有性别、身高和体重三列。接下来我们可以使用 matplotlib 和 seaborn 来可视化数据:
import matplotlib.pyplot as pltplt.scatter(df['Weight'], df['Height'])
plt.xlabel("Weight")
plt.ylabel("Height")
plt.show()
从体重与身高的散点图中我们可以看出，这种关系是线性的。
接下来，让我们定义我们的输入(X)和输出(y ),并为训练和测试拆分数据:
from sklearn.model_selection import train_test_split
import numpy as npX = np.array(df["Weight"]).reshape(-1,1)
y = np.array(df["Height"]).reshape(-1,1)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 42, test_size = 0.33)
然后，我们可以定义线性回归模型，拟合我们的训练数据，对测试集进行预测，并评估模型的性能:
from sklearn.linear_model import LinearRegression
reg = LinearRegression()
reg.fit(X_train, y_train)
y_pred = reg.predict(X_test)
print("R^2 Accuracy: ", reg.score(X_test, y_test))
我要讨论的第一个错误是 NameError ，例如，如果我忘记导入一个包，就会出现这个错误。在下面的代码中，我删除了“import numpy as np”:
from sklearn.model_selection import train_test_splitX = np.array(df["Weight"]).reshape(-1,1)
y = np.array(df["Height"]).reshape(-1,1)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 42, test_size = 0.33)
如果我试图在缺少该行代码的情况下运行脚本，我会得到以下错误:
我会收到类似的消息，因为我忽略了 seaborn、matplotlib 和 pandas 的导入语句:
另一个问题是意外地试图导入一个由于拼写错误而不存在的包，这导致了一个 ModuleNotFoundError 。例如，如果我将“pandas”拼错为“pandnas”:
import pandnas as pd
或者，如果我忘记了 matplotlib 散点图导入中的“pyplot ”,我们会得到一个 AttributeError :
import matplotlib as plt
类似地，如果我忘记了 sklearn 导入中的 linear_regression 和 model_selection 属性，我将得到一个 ImportError :
from sklearn import LinearRegression
from sklearn import train_test_split
在读取文件方面，如果我拼错了文件名，我会得到一个 FileNotFoundError :
df = pd.read_csv("weight-heigh1t.csv")
此外，如果我试图从 pandas 数据框中选择一个不存在的列，我会得到一个 KeyError :
plt.scatter(df['Weight1'], df['Height'])
如果我忘记将 pandas 系列的“体重”和“身高”转换成 numpy 数组，我会得到一个值 Error 。这是因为 sklearn 方法只接受 numpy 数组。我经常发现自己忘记了从 pandas 系列转换到 numpy 数组的简单步骤:
X = df["Weight"]
y = df["Height"]
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 42, test_size = 0.33)reg = LinearRegression()
reg.fit(X_train, y_train)
或者，如果我忘记将 numpy 数组整形为一个二维数组，我也会得到一个值 Error :
X = np.array(df["Weight"])
y = np.array(df["Height"])
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 42, test_size = 0.33)reg = LinearRegression()
reg.fit(X_train, y_train)
导致值错误的另一个常见原因是在进行列车试运行时。我经常忘记 X 和 y 数组的顺序:
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 42, test_size = 0.33)
其中我切换 X_test 和 y_train:
X_train, y_train, X_test, y_test = train_test_split(X, y, random_state = 42, test_size = 0.33)
这在拟合时给出了以下误差:
最后，当试图拟合与特定类别或人群相对应的模型数据时，我经常会遇到没有足够数据的问题。让我们过滤我们的数据框架来重现这个问题。让我们过滤数据，只包括“权重”等于 241.893563 的记录。这将产生恰好一行数据:
df = df[df['Weight'] == 241.893563]
如果我们尝试构建我们的模型，我们会在拆分数据的行中得到以下错误:
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 42, test_size = 0.33)reg = LinearRegression()
reg.fit(X_train, y_train)
y_pred = reg.predict(X_test)print("R^2 Accuracy: ", reg.score(X_test, y_test))
如果我们试着去适应，我们会得到下面的错误:
#X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 42, test_size = 0.33)reg = LinearRegression()
reg.fit(X, y)
最后，如果数据有缺失值或无穷大值，fitting while 将抛出一个错误。让我们用“nan”(非数字)值重新定义 weight 列，以生成以下错误:
df['Weight'] = np.nanX = np.array(df["Weight"]).reshape(-1,1)
y = np.array(df["Height"]).reshape(-1,1)X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 42, test_size = 0.33) reg = LinearRegression()
reg.fit(X_train, y_train)
我们会得到相同的错误消息，其中包含无限个值:
df['Weight'] = np.infX = np.array(df["Weight"]).reshape(-1,1)
y = np.array(df["Height"]).reshape(-1,1)X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 42, test_size = 0.33)reg = LinearRegression()
reg.fit(X_train, y_train)
在这篇文章中，我们回顾了用 python 开发模型时出现的不同错误。我们回顾了与导入包、读取文件、选择列和处理数据相关的错误。在生产机器学习代码时，对开发机器学习模型时出现的不同类型的错误有扎实的知识会很有用。了解这一点可以防止错误发生，并在错误发生时通知可用于捕捉这些错误的逻辑。
我每天都会遇到更多的错误，但我在这篇文章中列出的错误是我经验中最常见的。我希望这篇文章有用。这篇文章的代码可以在 GitHub 上找到。感谢您的阅读！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
