Überblick
Für Programmierer ist es eine sinnvolle Sache, an einem Top-Open-Source-Projekt mitzuwirken, aber es ist natürlich keine leichte Aufgabe. Wenn Sie an künstlicher Intelligenz arbeiten, müssen Sie über Open-Source-Projekte wie Google Tensorflow und Facebook Pytorch Bescheid wissen. Lassen Sie uns darüber sprechen, wie Sie Mitwirkender dieser Top-Open-Source-Projekte werden können.
Vorbereiten
1. Zunächst müssen Sie Github-Benutzer werden und mit der grundlegenden Logik des Hostings von Code auf Github vertraut sein.
2. Für Open-Source-Projekte der obersten Ebene müssen Sie im Allgemeinen eine Contributor License Agreement (kurz CLA) unterzeichnen, z. B. Tensorflow-Projekte, Einzelpersonen unterzeichnen TF-Einzel-CLA, Unternehmen unterzeichnen TF-Unternehmens-CLA und einige Projekte in Pytorch müssen unterzeichnen Facebook CLA. Erst dann wird Ihr Code akzeptiert.
3. Machen Sie den Code, den Sie schreiben, standardisierter. Allgemeine Open-Source-Projekte müssen im Google Python-Stil sein, sogar Pytorch folgt dieser Spezifikation, ganz zu schweigen von Googles eigenem Tensorflow.
4. Der von Ihnen beigesteuerte Code besteht häufig aus Klassen oder Funktionen (mit Ausnahme von Dokumentbeiträgen). Sie benötigen daher ein Komponententestprogramm, das wie Codekommentare ein wesentlicher Bestandteil des Code-Sharing-Prozesses ist. Ohne sie wird Ihr Code nicht zusammengeführt, selbst wenn er korrekt ist, und Sie werden am Ende aufgefordert, Unit-Test-Skripte bereitzustellen.
5. Viele Open-Source-Projekte erfordern, dass jedes Ihrer Py-Skripte mit einem Lizenzzertifikat beginnt, z. B. Tensorflow. Dies ist ein Beispiel für sein Python-Lizenzzertifikat: Python-Lizenzbeispiel, das ist natürlich sehr einfach.
# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# =============================================================================
Werkzeug
Als nächstes stellen wir die Verwendung verwandter Tools vor, die uns effektiv dabei helfen können, die vorbereitenden Arbeiten vor dem Beitrag abzuschließen, wie z. B. Codespezifikation und Unit-Tests.
Code-Spezifikationstool
Um die Anforderungen des Codes an den Google-Stil zu erfüllen, benötigen wir zunächst ein Tool zur Erkennung von Codespezifikationen. Hier verwenden wir den offiziell empfohlenen Pylint.
Installieren:
pip install pylint
verwenden:
# 使用pylint检测脚本代码，默认将按照PEP8标准
# 这里我们需要指定配置文件，即按照Google Style标准
# myfile.py代表你写好的python脚本文件
pylint --rcfile=pylintrc myfile.py
Den Inhalt von pylintrc finden Sie unter: pylintrc
Und da der Code, den wir ursprünglich geschrieben haben, oft zu zufällig ist, gibt es möglicherweise zu viele Stellen, die direkt mit Pylint geändert werden müssen, was Ihrem jungen Geist ernsthaften Schaden zufügen kann. Daher ist hier ein weiteres Tool, das von vielen Open-Source-Projekten empfohlen wird: black, it kann Ihnen direkt dabei helfen, die grundlegenden Probleme im Code zu ändern (es gibt immer noch viele Probleme, die nicht bestimmt werden können und von Pylint erkannt werden müssen).
Installieren:
pip install black
verwenden:
# 这里的-l代表代码的每行最大长度
# 默认是88，但是Google Style要求为80
# 因此这里指定为80
black myfile.py -l 80
Beispiel für einen Codestil:
def my_op(tensor_in, other_tensor_in, my_param, other_param=0.5,
output_collections=(), name=None):
"""My operation that adds two tensors with given coefficients.
Args:
tensor_in: `Tensor`, input tensor.
other_tensor_in: `Tensor`, same shape as `tensor_in`, other input tensor.
my_param: `float`, coefficient for `tensor_in`.
other_param: `float`, coefficient for `other_tensor_in`.
output_collections: `tuple` of `string`s, name of the collection to
collect result of this op.
name: `string`, name of the operation.
Returns:
`Tensor` of same shape as `tensor_in`, sum of input values with coefficients.
Example:
>>> my_op([1., 2.], [3., 4.], my_param=0.5, other_param=0.6,
output_collections=['MY_OPS'], name='add_t1t2')
[2.3, 3.4]
"""
with tf.name_scope(name or "my_op"):
tensor_in = tf.convert_to_tensor(tensor_in)
other_tensor_in = tf.convert_to_tensor(other_tensor_in)
result = my_param * tensor_in + other_param * other_tensor_in
tf.add_to_collection(output_collections, result)
return result
output = my_op(t1, t2, my_param=0.5, other_param=0.6,
output_collections=['MY_OPS'], name='add_t1t2')
Unit-Test-Tools
·Unit-Tests sind für die Teamentwicklung sehr wichtig und eine wichtige Grundlage für das Testen der Codequalität. Daher muss jeder Ihrer vollständigen Codes mit Unit-Test-Skripten ausgestattet sein. Hier verwenden wir das Mainstream-Unit-Test-Tool Unittest von Python.
· Installieren:
pip install unittest
Verwendung: Hier demonstrieren wir nur die Kernnutzungsmethode. Genauere Inhalte finden Sie in der Unittest-Dokumentation
# 导入unittest工具包
import unittest
# 我们首先要建立一个测试类，它将包含你所有需要进行测试的函数
# 这个类不使用__init__(self)，但可以使用setUp(self)来定义公有部分
# 它需要继承unittest.TestCase, 类名往往也建议以Test开头
class TestStringMethods(unittest.TestCase):
# 类的里面依次是你需要进行测试的函数
# 这些函数建议以test_开头
# 这些函数一般情况不设置参数，而是直接在函数中具体化需要的参数
# 当然你也可以设置原始的参数，然后在外部具体化参数并调用该函数
# 在测试函数中必须存在assert...来断定测试结果
# 常用的assert...包括: assertEqual, assertTrue, assertFalse,
# assertRaises, assertIn, assertNotIn, assertIs, assertIsNot...
def test_upper(self,):
# 使用assertEqual判断两个字符串是否相等
self.assertEqual(
"foo".upper(), "FOO",
)
def test_isupper(self,):
# 使用assertTrue/False断定条件为真/假
self.assertTrue("FOO".isupper())
self.assertFalse("Foo".isupper())
def test_split(self,):
# 设定任意输入
s = "hello world"
# 使用assertIn断定列表包含关系
self.assertIn(
s.split(), [["hello", "world"]],
)
# 注意：这里with self.assertRaises来断定异常
with self.assertRaises(TypeError):
s.split("asd")
# 这里是主函数，如果使用python运行该脚本测试，则必须存在
# 如果使用pytest(后面会介绍)，则可以省略
if __name__ == "__main__":
# 使用unittest.main运行所有继承unittest.TestCase的类
unittest.main()
Verwendung von Dekoratoren: Eine der am häufigsten verwendeten Unittest-Methoden sind Klassen-/Funktionsdekoratoren.
# 对于一些特殊需要强制跳过的测试的类/函数使用下方装饰器，但你必须说明原因
# @unittest.skip("长得太帅，不需要测试，给我跳过！")
# 如果条件为真，则该测试被强制跳过。比如：检测GPU是否可用
# @unittest.skipIf(TEST_CUDA, "CUDA available")
# 除非条件为真，否则该测试被强制跳过。比如: 检测某些依赖包是否安装
# @unittest.skipUnless(has_unittest, "unittest dependencies are not installed")
# 函数异常测试的表达方式，函数出现异常则测试通过，比之前说的内部异常粒度更大
# @unittest.expectedFailure
import torch
try:
import unittest
except ImportError:
has_unittest = False
else:
has_unittest = True
if torch.cuda.is_available():
TEST_CUDA = True
else:
TEST_CUDA = False
# 条件为真，不跳过
@unittest.skipUnless(has_unittest, "unittest dependencies are not installed")
# 条件为真，跳过；条件为假，不跳过
@unittest.skipIf(TEST_CUDA, "CUDA available")
class TestStringMethods(unittest.TestCase):
def test_upper(self,):
self.assertEqual(
"foo".upper(), "FOO",
)
@unittest.skip("长得太帅，不需要测试，给我跳过！")
def test_isupper(self,):
self.assertTrue("FOO".isupper())
self.assertFalse("Foo".isupper())
@unittest.expectedFailure
def test_split(self,):
s = "hello world"
self.assertIn(
s.split(), [["hello", "world"]],
)
# 这里预计抛出异常，但实际没有异常，本质上这也算一种异常
# 可以使用@unittest.expectedFailure
with self.assertRaises(TypeError):
s.split("ZMZ")
if __name__ == "__main__":
unittest.main()
Führen Sie Ihr Testskript aus:
# 建议使用pytest执行测试脚本，你的python中往往自带这个工具包
# 这时你不必写下主函数，并且他的输出形式更美观
pytest test_myfile.py
Ausgabeeffekt:
======================== test session starts =========================
platform linux -- Python 3.7.3, pytest-5.0.1, py-1.8.0, pluggy-0.12.0
rootdir: /root
plugins: remotedata-0.3.1, celery-4.3.0, doctestplus-0.3.0, arraydiff-0.3, openfiles-0.3.2
collected 3 items
test_myfile.py sx. [100%]
=========== 1 passed, 1 skipped, 1 xfailed in 0.34 seconds ===========
Echte Unit-Test-Skripte finden Sie unter Pytorch-Tests und Tensorflow-Tests
Verfahren
Bevor Sie bereit sind, Mitwirkender zu werden, stellen Sie sicher, dass Sie mit der Nutzung des Projekts vertraut sind. Klären Sie dann die Art des Quellcodes, den Sie beitragen möchten, ob es sich um „Fix Bug“ oder „Implement New Feature“ (neue Funktionen implementieren) handelt. Für einen unerfahrenen Mitwirkenden ist natürlich „Fix Bug“ die einzige Wahl. Sofern Sie den spezifischen Inhalt Ihres Beitrags nicht durch Ihre eigene Praxis identifiziert haben, wird empfohlen, dass Sie die folgenden Schritte befolgen:
erster Schritt:
Suchen Sie nach offenen Problemen in den Github-Problemen von Open-Source-Projekten. Hier finden Sie Tensorflow-Probleme und Pytorch-Probleme Diskussionsbereich Besprechen oder reichen Sie die PR ein, um weiter zu klären, ob Sie sich an der Lösung des Problems beteiligen sollten. (Die Ausgaben vieler Open-Source-Projekte werden mit der Aufschrift „Beiträge willkommen“ versehen sein, sodass Sie sie sich zunächst einmal ansehen können.)
Schritt zwei:
Wenn Sie das Problem identifiziert haben, das Sie lösen möchten, müssen Sie dieses Open-Source-Projekt vor dem offiziellen Schreiben des Codes in Ihr eigenes Github-Warehouse verzweigen und das Warehouse dann auf den dafür vorgesehenen Server klonen, damit Sie die PR schließlich einreichen können .
# 例如:
git clone https://github.com/AITutorials/tensorflow.git
An diesem Punkt können Sie über git remote -v feststellen, dass wir nur mit unserem Remote-Warehouse (Origin/Master) verbunden sind.
Zu diesem Zeitpunkt müssen wir auch eine Verbindung mit dem Remote-Warehouse des Open-Source-Projekts (Upstream/Master) herstellen.
# 以tensorflow为例建立连接
git remote add upstream https://github.com/tensorflow/tensorflow.git
# 查看到upstream
git remote -v
Dann müssen Sie Ihren eigenen Zweig erstellen. Natürlich können Sie zuerst den Remote-Zweig überprüfen
# 查看远程分支
git branch -a
# 创建自己的远程分支cnsync
git checkout -b cnsync
dritter Schritt:
Im zweiten Schritt haben Sie den Quellcode des Projekts erhalten und Ihren eigenen Zweig erstellt. Zu diesem Zeitpunkt beginnen Sie mit der Leistung, Codierung und Überprüfung, und die zuvor vorbereiteten Codespezifikationstools und Unit-Testtools werden sich als nützlich erweisen .
der vierte Schritt:
Übertragen Sie Ihren Code und erstellen Sie eine PR in Github.
# 把内容添加到暂存区
git add .
# 提交更改的内容
git commit -m "添加你的改变说明"
# push到自己的远程仓库
git push origin cnsync
Hinweis: Obwohl Sie hier nur auf Ihr eigenes Remote-Warehouse pushen, ist Ihr Remote-Warehouse tatsächlich mit dem Warehouse des Quellprojekts verbunden. Das heißt, Sie können zu diesem Zeitpunkt entscheiden, ob Sie eine PR des Quellprojekts erstellen möchten, indem Sie Ihr eigenes Remote-Warehouse betreiben (diese Prozesse können auf der Projektseite implementiert werden, die Sie gerade gegabelt haben, einschließlich des Ausfüllens des Titels und des Kommentars des Projekts). PR, und manchmal müssen Sie auch einen Titel eingeben, z. B. [Entwurf]/[WIP]/[RFR] usw.).
der fünfte Schritt:
Warten Sie geduldig, wenn sich Ihr PR im Status „Bereit zur Überprüfung“ befindet, wird er bald in den Prozess des automatisierten Testens und der Intervention der Jury eintreten, und Sie werden in naher Zukunft Feedback erhalten, Ihr Codeplan wird möglicherweise übernommen, und Möglicherweise sind weitere Überarbeitungen oder Tests erforderlich.