Einleitung
Der Zweck dieser Aufgabe besteht darin, Sie in das Erstellen, Trainieren und Testen neuronaler Netzwerkmodelle einzuführen. Sie werden nicht nur mit dem Aufbau neuronaler Netze von Grund auf mit Python-Paketen konfrontiert, sondern auch mit mathematischen Aspekten der Backpropagation und des Gradientenabstiegs. Aber in der realen Welt müssen Sie ein neuronales Netzwerk nicht unbedingt von Grund auf neu implementieren (wie Sie in zukünftigen Labs und Aufgaben sehen werden), diese Aufgabe soll Ihnen eine Vorstellung von der Funktionsweise auf niedriger Ebene vermitteln Pakete wie TensorFlow und Keras erstes Verständnis. In dieser Aufgabe verwenden Sie den MNIST-Datensatz für handgeschriebene Ziffern, um ein einfaches neuronales Klassifikationsnetz mithilfe von Stapellernen zu trainieren und Ihr Modell zu evaluieren.
Englisch (Englisch): http://t.csdn.cn/p8KTX
Link zu diesem Artikel .pdf-Datei
-------------------------------------------------- -------------------------------------------------- -----------------------------
Extraktionscode: v6zc
https://pan.baidu.com/s/1_qFbN0Nhc8MNYCHEyTbkLg%C2%A0
Experiment 2: Numpy handgeschriebenes mehrschichtiges neuronales Netzwerk
Für den Versuch erforderliche Unterlagen
11. Visualisieren Sie die Ergebnisse
Referenzantwort: http://t.csdn.cn/9sdBN
Für den Versuch erforderliche Unterlagen
Dateiübernahme:
Link: https://pan.baidu.com/s/1JQnPdOJQXqQ43W74NuYqwg
Extraktionscode: 2wlg
Dateistruktur:
| - hw2
| - Code
| - Reis
| - 8 .py-Dateien werden verwendet, um die experimentellen Anforderungsfunktionen zu implementieren
| - Zuweisung.py
| - preprocess.py
| - visualisieren.py
| - Daten
| - mnist
| - Vier Datensatzdateien
konzeptionelles Problem
Bitte reichen Sie konzeptionelle Fragen zu Gradescope unter hw2-mlp Conceptual ein. Sie müssen Ihre Einreichung eingeben und die PDF-Datei hochladen. Wir empfehlen die Verwendung von LaTeX.
Vorlage bekommen
Github Classroom Link mit Schablonencode!
Leitfaden auf GitHub und GitHub Classroom
Daten bekommen
Daten können mit download.sh heruntergeladen werden. -Methode zum Ausführen von Bash-Skriptbefehlen.
/script_name.sh (zB: bash ./download.sh).
Dies ist ähnlich wie bei HW1. Verwenden Sie diese Option, um den bereitgestellten Vorlagencode zu entfernen, aber ändern Sie die Vorlage nicht, sofern nicht anders angegeben.
Dies kann zu einer Inkompatibilität mit automatischen Bewertungsprogrammen führen. Ändern Sie keine Methodensignaturen!
Diese Aufgabe erfordert NumPy und Matplotlib. Sie sollten dies bereits von HW1 erhalten. Sehen Sie sich auch den Leitfaden zu virtuellen Umgebungen an, um TensorFlow 2.5 auf Ihrem lokalen Computer einzurichten. fühlen Sie sich frei zu
Wenn Sie Colab verwenden müssen, lesen Sie bitte diese Anleitung.
Stellenübersicht:
In dieser Aufgabe erstellen Sie eine Keras-Nachahmung, Beras (haha lustiger Name), und formulieren eine sequentielle Modellspezifikation, die die Tensorflow/Keras-API nachahmt. Das mit dieser Aufgabe verknüpfte Python-Notebook soll Ihnen ermöglichen, eine Beispielimplementierung zu erkunden, damit Sie Ihre eigene erstellen können!Es gibt keine Aufgaben auf dem Notebook, die Sie erledigen müssen; stattdessen erfolgt das Testen durch Ausführen der Hauptmethode von assign. py . Unsere Vorlage bietet eine Modellklasse mit mehreren Methoden und Hyperparametern, die Sie für Ihr Netzwerk verwenden müssen. Sie werden auch konzeptionelles Fragenmaterial zu Aufgaben und Kursarbeiten beantworten (wenn Sie ein 2470-Student sind, vergessen Sie nicht, die 2470-Fragen zu beantworten!) Sie sollten ein kurzes README-Dokument beifügen, das die Genauigkeit Ihres Modells und alle bekannten erklärt Fehler.
Vor Beginn des Experiments:
Diese Hausaufgabe ist zwei Wochen nach der Veröffentlichung fällig. Die Labs 1-3 bieten bewährte Übungen für diese Aufgabe. Wenn Sie also nicht weiterkommen, können Sie eine Weile darauf warten. Speziell:
☆ -
Implementieren von aufrufbaren/diffusiblen Komponenten : die dafür erforderlichen Fähigkeiten
Kann über Labor 1 gefunden werden. Dazu gehören Kenntnisse in Mathematik
Symbole, Matrixoperationen und die Logik hinter Aufruf- und Verlaufsmethoden .
☆ -
Implementieren des Optimizers : Sie können die BasicOptimizer-Klasse implementieren, indem Sie
Folgen Sie der Logik der Gradientenabstiegsmethode in Übung 1. andere Optimierungen
(z. B. Adam, RMSProp) werden in Lab 2: Optimizer besprochen .
☆ -
Verwenden von batch_step und GradientTape: Sie können lernen, wie Sie sie verwenden, um Ihre Modellierung basierend auf Zuweisungsanweisungen und Implementierungen dieser Anweisungen zu trainieren. Allerdings ahmen sie die Keras-API nach. In Lab 3: Einführung erfahren Sie mehr über all diesen Tensorflow. Wenn Ihr Experiment die Frist überschritten hat, sollte es in Ordnung sein; werfen Sie einen Blick auf die ergänzenden Notizbücher zum Labor. Sie können zuerst tun, was Sie können, und dann hinzufügen, wenn Sie mehr über die Tiefe erfahren. Lerne und erkenne, dass die Konzepte, die du im Unterricht lernst, hier tatsächlich verwendet werden können!Lass dich nicht entmutigen, versuche Spaß zu haben!
Roadmap: In dieser Aufgabe führen wir Sie durch den Trainingsprozess für neuronale Netze, einschließlich der Struktur der Modellklasse und der Methoden, die Sie ausfüllen müssen.
1. Vorverarbeitete Daten
Vor dem Training des Netzwerks müssen die Daten bereinigt werden. Dies umfasst das Abrufen, Ändern und Formatieren von Daten als Eingabe für das Netzwerk. Für diese Aufgabe arbeiten Sie mit dem MNIST-Datensatz. Es ist durch Herunterladen des .sh-Skripts verfügbar, aber es ist auch hier verlinkt (ignorieren Sie, was hw1 steht; wir verwenden dieses Dataset, das diesmal hw2 ist!). Die ursprüngliche Datenquelle ist hier. Sie sollten das Netz nur mit den Trainingsdaten trainieren und dann die Genauigkeit des Netzes anhand der Testdaten testen. Ihr Programm sollte nach Fertigstellung seine Genauigkeit auf dem Testdatensatz ausdrucken.
Hinweis: Der Vorverarbeitungscode muss aus HW1 abgerufen werden.
2. One-Hot-Codierung
Bevor Sie das Modell trainieren oder testen, müssen Sie die Klassenbezeichnungen „One-Hot“ codieren, damit das Modell optimiert werden kann, um jede gewünschte Klasse vorherzusagen. Beachten Sie, dass die Klassenbezeichnungen selbst einfache Kategorien sind und keine numerische Bedeutung haben. In Ermangelung einer One-Hot-Codierung lernt Ihr Modell möglicherweise eine natürliche Reihenfolge zwischen Labels basierend auf Labels verschiedener Klassen (die Labels sind willkürlich). Angenommen, es gibt einen Datenpunkt a, der dem Label „2“ entspricht, und einen Datenpunkt B, der dem Label „7“ entspricht. Wir wollen nicht, dass das Modell weiß, dass B ein höheres Gewicht hat als a, denn numerisch ist 7 > 2. Um Ihre Klassenbeschriftungen auf einmal zu codieren, müssen Sie Ihren 1D-Beschriftungsvektor in einen Vektor der Größe num_classes (die Gesamtzahl der Klassen in Ihrem Datensatz) umwandeln. Für den MNIST-Datensatz sieht es wie die Matrix auf der rechten Seite aus:
Sie müssen die folgende Methode in Beras/onehot.py eingeben:
fit(): [TODO] In dieser Funktion nehmen Sie Daten auf (speichern sie in self.uniq ) und erstellen ein Wörterbuch mit Bezeichnungen als Schlüssel und ihren entsprechenden One-Hot-Codierungen als Werte. Hinweis: Vielleicht möchten Sie np.eye() auf One-Hot-Codierung überprüfen. Schließlich werden Sie es im Wörterbuch self.uniq2oh speichern.
forward(): In dieser Funktion übergeben wir einen Vektor, der alle tatsächlich beschrifteten Trainingssätze im Objekt enthält, und rufen fit() auf, um das uniq2oh-Wörterbuch mit eindeutigen Beschriftungen und ihren entsprechenden One-Hot-Codierungen zu füllen, und verwenden es dann, um ein An zurückzugeben Array von One-Hot-codierten Labels für jedes Label im Trainingssatz.
Diese Funktion ist bereits für Sie ausgefüllt!
● inverse(): In der Funktion kehren wir die One-Hot-Kodierung in das eigentliche Kodierungslabel um.
Dies wurde bereits für Sie erledigt.
Wenn wir zum Beispiel Labels X und Y haben, die als [1,0] und [0,1] One-Hot codiert sind, werden wir das tun
{X: [1,0], Y: [0,1]}. Wie in FIG.
Für MNIST haben Sie 10 Labels, also sollte Ihr Wörterbuch 10 Einträge haben!
Möglicherweise stellen Sie fest, dass einige Klassen von Callable oder Diffable erben. mehr dazu
im nächsten Abschnitt!
3. Kernabstraktion
Betrachten Sie die abstrakte Klasse des folgenden Moduls. Spielen Sie unbedingt mit dieser Python-Notebook-Aufgabe herum, um einen guten Überblick über die abstrakten Module zu bekommen, die core für Sie in Beras/core.py definiert! viel Tiefe, um diese Klassenabstraktionen zu verstehen und zu verwenden!Beachten Sie, dass die folgenden Module der Tensorflow/Keras-API sehr ähnlich sind.
Aufrufbar: Eine Funktion mit einer wohldefinierten Weiterleitungsfunktion. Dies sind die Implementierungen, die Sie benötigen:
● CategoricalAccuracy (./metrics.py): Berechnet die vorhergesagte Genauigkeitswahrscheinlichkeit anhand einer Liste von Ground-Truth-Labels. Da die Genauigkeit nicht optimiert ist, ist es nicht erforderlich, seinen Gradienten zu berechnen. Außerdem ist die Klassengenauigkeit stückweise diskontinuierlich, sodass Steigungen technisch gesehen 0 oder undefiniert sind.
● OneHotEncoder (./onehot.py): Sie können eine Klasseninstanz für eine optimierte Wahrscheinlichkeitsverteilung, die als diskrete Optionen klassifiziert ist, One-Hot-Codierung durchführen:
Differenzierbar: Ein aufrufbares Objekt, das auch differenzierbar ist. Wir können diese in unserer Produktionslinie verwenden und durch sie optimieren!Die meisten dieser Klassen sind also Netzwerkschichten, die für die Verwendung in Ihrem neuronalen System erstellt wurden. Das müssen Sie umsetzen:
Beispiel: Stellen Sie sich eine Instanz einer dichten Schicht vor. Lassen Sie s die Eingabegröße (Quelle), d die Ausgabegröße (Ziel) und b die Stapelgröße bezeichnen. Dann:
GradientTape: Diese Klasse funktioniert genauso wie tf.GradientTape() (siehe Experiment 3). Sie können sich GradientTape als Rekorder vorstellen. Jedes Mal, wenn sich eine Operation im Bereich des Verlaufsbands befindet, zeichnet es die Operation auf, die stattgefunden hat. Dann in
Backprop können wir Gradienten für alle Operationen berechnen. Dies ermöglicht es uns, die endgültige Ausgabe für alle Zwischenschritte zu differenzieren. Wenn Vorgänge außerhalb der Grenzen von GradientTape berechnet werden, werden sie nicht protokolliert, sodass Ihr Code keine Aufzeichnungen darüber enthält und keine Farbverläufe berechnen kann. Sie können sehen, wie dies im Kern implementiert wird!Natürlich ist die Implementierung von Verlaufsbändern in Tensorflow viel komplizierter und erfordert das Erstellen eines Diagramms.
● [TODO] Implementieren Sie die Gradientenmethode, die eine Liste von Gradienten zurückgibt, die einer Liste trainierbarer Gewichtungen im Netzwerk entspricht. Details im Code.
4. Netzwerkschicht
In diesem Artikel implementieren Sie Ihr sequentielles Modell in Beras/layers.py. Sie müssen die folgenden Methoden ausfüllen:
● forward() : [TODO] Implementiert Forward-Pass- und Return-Ausgabe.
● weight_gradients() : [TODO] Berechnet die Gradientengewichtungen und Bias auf . Dies wird verwendet, um die Ebene zu optimieren.
● input_gradients() : [TODO] Berechnet die Eingabe der Verlaufsebene in Bezug auf . Dies wird verwendet, um den Gradienten an die vorherigen Schichten weiterzugeben.
● _initialize_weight() : [TODO] Gewichtungswerte für dichte Schichten initialisieren Standardmäßig werden alle Gewichtungen auf Null initialisiert (was übrigens im Allgemeinen eine schlechte Idee ist). Sie müssen auch komplexere Optionen zulassen (wenn die Initialisierer auf normal, xavier und kaiing gesetzt sind). Folgen Sie den mathematischen Annahmen von Keras!
〇 Normal : Selbsterklärend, Einheitsnormalverteilung.
〇Xavier Normal: Basierend auf keras.GlorotNormal.
〇Kaiing He Normal: Basierend auf Keras.HeNormal.
Wenn Sie diese implementieren, finden Sie möglicherweise np.random.normal hilfreich. Der Aktionsplan erklärt, warum diese verschiedenen Initialisierungsmethoden notwendig sind, aber für weitere Details besuchen Sie diese Seite!Fügen Sie weitere Initialisierungsoptionen hinzu!
5. Aktivierungsfunktion
In dieser Aufgabe implementieren Sie zwei Hauptaktivierungsfunktionen, nämlich: LeakyReLU und Softmax in Beras/activation.py . Da ReLU ein Sonderfall von LeakyReLU ist, haben wir seinen Code bereitgestellt.
● LeakyReLU()
〇forward() : [TODO] Gegebene Eingabe x, LeakyReLU(x) berechnen und zurückgeben.
〇input_gradients() : [TODO] Berechnet die durch Ableitung von LeakyReLU erhaltene Eingabe und gibt sie zurück.
● Softmax(): (NUR 2470)
forward(): [TODO] Gegebene Eingabe x, Softmax(x) berechnen und zurückgeben. Stellen Sie sicher, dass Sie einen stabilen Softmax verwenden, d. h. das Maximum aller Terme subtrahieren, um Überlauf-/Unvimmerflow-Probleme zu vermeiden.
〇input_gradients(): [TODO] Teilweise Eingabe von Softmax().
6. Befüllen Sie das Modell
Lassen Sie uns mit diesen Abstraktionen ein sequentielles Modell für sequentielles Deep Learning erstellen. Sie finden die SequentialModel-Klasse in „assignment.py“, um die Schichten, Parameter (Gewichtungen und Bias) und Hyperparameter (Optimierer, Verlustfunktion, Lernrate, Genauigkeitsfunktion usw.) Ihres neuronalen Netzwerks zu initialisieren. Die SequentialModel-Klasse erbt von Beras/model.py, wo Sie viele nützliche Methoden finden. Diese enthält auch Funktionen, die für Ihre Daten und Ihr Modell geeignet sind, um die Leistung Ihres Modells zu bewerten:
● compile() : Initialisiert den Modelloptimierer, die Verlustfunktion und die Präzisionsfunktion, die als Parameter für die zu verwendende SequentialModel - Instanz eingegeben werden.
● fit() : Trainieren Sie das Modell, um Eingabe und Ausgabe zuzuordnen. Das Training wird für jede Epoche wiederholt, und die Daten werden basierend auf Parametern gestapelt. Es berechnet auch Batch_metrics, epoch_metrics und agg_metrics , die verwendet werden können, um den Trainingsfortschritt des Modells zu verfolgen.
● auswerten() : [TODO] Bewerten Sie die Leistung des endgültigen Modells anhand der in der Testphase erwähnten Metriken. Es entspricht fast der ()-Funktion; denken Sie darüber nach, was zwischen Training und Test passiert).
● call() : [TODO] Tipp: Was bedeutet es, ein sequentielles Modell aufzurufen Denken Sie daran, dass ein sequentielles Modell ein Stapel von Ebenen ist und jede Ebene nur einen Eingabevektor und einen Ausgabevektor hat. Sie können dies in der SequentialModel-Klasse in Assignment.py tun.
● batch_step() : [TODO] Sie werden sehen, dass fit() diese Funktion für jeden Batch aufruft. Zuerst berechnen Sie die Modellvorhersagen für den Eingabebatch. Während der Trainingsphase müssen Sie Gradienten berechnen und Ihre Gewichte entsprechend dem von Ihnen verwendeten Optimierer aktualisieren. Für die Backpropagation während des Trainings verwenden Sie GradientTape aus der Kernabstraktion (core.py), um Operationen und Zwischenwerte aufzuzeichnen. Anschließend verwenden Sie den Optimierer des Modells, um Gradienten auf die trainierbaren Variablen des Modells anzuwenden. Schließlich berechnen und
Gibt den Verlust und die Genauigkeit für diesen Stapel zurück. Sie können dies in der SequentialModel -Klasse in Assignment.py tun.
Wir empfehlen Ihnen, Keras auszuprobieren. SequentialModel im Einführungsnotebook (Untersuchung einer möglichen modularen Implementierung: TensorFlow/Keras) und Referenz kommen zu Lab 3, um ein Gefühl dafür zu bekommen, wie wir Verlaufsbänder beim Deep Learning verwenden können.
7. Verlustfunktion
Dies ist einer der kritischsten Aspekte des Modelltrainings. In dieser Aufgabe werden wir die Verlustfunktion MSE oder Mean Squared Error implementieren. Sie finden die Verlustfunktion in Beras/losses.py .
● forward() : [TODO] Schreiben Sie eine Funktion, die den Mittelwert berechnet und zurückgibt, wenn der quadratische Fehler der vorhergesagten und tatsächlichen Beschriftung gegeben ist.
Hinweis: Was ist MSE?Der mittlere quadratische Fehler ist die Differenz zwischen dem vorhergesagten Wert und dem tatsächlichen Wert unter Berücksichtigung der vorhergesagten und tatsächlichen Bezeichnungen.
● input_gradients() : [TODO] Gradienten berechnen und zurückgeben. Verwenden Sie eine Formel, die diese Gradienten durch Differentiation herleitet.
8. Optimierer
Stellen Sie in der Beras/Optimizer-.py -Datei sicher, dass jeder Optimierertyp unterschiedlich ist. Experiment 2 sollte helfen, viel Glück !
● BasicOptimizer : [TODO] Eine einfache Optimierungsstrategie, wie in Experiment 1 gezeigt.
● RMSProp : [TODO] Wurzel des mittleren Quadrats der Fehlerfortpflanzung.
● Adam : [TODO] Ein allgemeiner Optimierer basierend auf adaptiver Bewegungsschätzung.
9. Genauigkeitsindex
Um schließlich die Leistung Ihres Modells zu bewerten, müssen Sie eine geeignete Genauigkeitsmetrik verwenden. In dieser Aufgabe implementieren Sie die Bewertung der Klassifizierungsgenauigkeit in Beras/metrics.py :
● forward() : [TODO] Gibt die prognostizierten Wahrscheinlichkeiten für die Klassifikationsgenauigkeit des Modells und wahre Labels zurück. Sie sollten eine proportionale vorhergesagte Bezeichnung gleich der wahren Bezeichnung zurückgeben, wobei die vorhergesagte Bezeichnung für das Bild die Bezeichnung ist, die der höchsten Wahrscheinlichkeit entspricht. Beziehen Sie sich auf das Web oder die Vorlesungsfolien für mathematische Klassifizierungsgenauigkeit!
10. Schulung und Prüfung
Schließlich müssen Sie unter Verwendung aller oben genannten Primitive zwei Modelle in " + Assignment.py +" erstellen :
● Ein einfaches Modell in get_simple_model() mit höchstens einer Diffusionsschicht (zB: density - ./layers.py ) und einer Aktivierungsfunktion (in /activation.py ). Obwohl dies möglich ist, wird Ihnen diese Option standardmäßig angeboten. Sie können es ändern, wenn Sie möchten. Ein automatischer Bewerter wertet das Original aus!
● Ein etwas komplexeres Modell in get_advanced_model() mit zwei oder mehr Diffusionsschichten und zwei oder mehr Aktivierungsfunktionen. Wir empfehlen die Verwendung von Adams Optimierer für dieses Modell mit einer relativ niedrigen Lernrate.
Für alle Hyperparameter, die Sie verwenden (Schichtgröße, Lernrate, Epochengröße, Stapelgröße usw.), codieren Sie diese Werte in den Funktionen get_simple_model() und get_advanced_model() fest . Bewahren Sie sie nicht unter dem Haupthandler auf. Sobald alles implementiert ist, verwenden Sie python3 Assignment.py , um Ihre Modellierung auszuführen und den Verlust/die Genauigkeit zu sehen!
11. Visualisieren Sie die Ergebnisse
Wir stellen Ihnen die Methode visual_metrics zur Verfügung, um zu visualisieren , wie sich Ihr Verlust und Ihre Genauigkeit jedes Mal ändern , wenn Sie matplotlib verwenden. Bearbeiten Sie diese Funktion nicht. Nachdem der Verlust und die Genauigkeit gespeichert wurden, sollte jeder Stapel in diesem Funktionsarray in der Hauptmethode aufgerufen werden, die an diese Funktion übergeben wird. Dies sollte eine Linie mit Charge i auf der horizontalen Achse und Chargenverlust-/Genauigkeitswerten auf der vertikalen Achse sein. Der Aufruf ist optional! Wir stellen auch die Methode visual_images bereit , um Ihre Vorhersagen der wahren Beschriftungen mit matplotlib zu visualisieren . Diese Methode verwendet derzeit Beschriftungen der Form [Anzahl der Bilder, 1]. Bearbeiten Sie diese Funktion nicht. Nach dem Training des Modells sollten Sie diese Funktion mit allen Eingaben und Beschriftungen aufrufen. Die Funktion wählt zufällig 500 Stichproben aus Ihrer Eingabe aus und zeichnet die 10 richtigen und 10 falschen Klassifizierungen auf, um Ihnen bei der visuellen Interpretation der Vorhersagen des Modells zu helfen! Sie sollten die letzte Ausführung durchführen, nachdem Sie einen Benchmark für die Testgenauigkeit dieser Aktion erreicht haben.
CS1470 Studenten
- HW2-Konzept ausfüllen und einreichen
- Implementieren Sie Beras gemäß der Spezifikation und erstellen Sie ein SequentialModel in der Assignment.py
- Testen Sie das Modell in main
- Erhalten Sie eine Testgenauigkeit von >=85 % auf MNIST mit standardmäßigen get_simple_model_components.
- Füllen Sie das Exploration notebook.ipny aus und exportieren Sie es in das PDF-Format.
- Jupyter-Notebook "HW2 Intro to Beras" als Referenz .
CS2470 Studenten
- Zusätzlich zu den gleichen Aufgaben wie 1470 zu erledigen :
- Implementierung der Softmax-Aktivierungsfunktion (Forward Pass und Input_Gradient)
– Testgenauigkeit >95 % für MNIST-Modell, erhalten von get_advanced_model_components.
- Sie müssen ein Multi-Layer-Modell spezifizieren, müssen Hyperparameter-Optionen untersuchen und möchten möglicherweise andere Funktionen hinzufügen.
- Andere Merkmale können Regularisierung, andere Gewichtungsinitialisierungsschemata, Aggregationsschichten, Ausfälle, Ratenplanung oder Überspringen von Verbindungen umfassen. Wenn Sie weitere Ideen haben, können Sie Ed gerne öffentlich fragen, und wir lassen es Sie wissen, okay.
- Versuchen Sie bei der Implementierung dieser Funktionen, die Keras-API so weit wie möglich nachzuahmen. Dies ist eine große Hilfe für Ihr Erkundungsnotizbuch.
- Vervollständigen Sie 2470 Komponenten von Erkundungsnotizbüchern und konzeptionellen Fragen.
Grading- und Auto-Grading-Kompatibilität
Konzept: Ihre Bewertungskriterien sind in erster Linie richtig, durchdacht und klar.
Code: Sie werden hauptsächlich nach Funktionalität bewertet. Ihr Modell sollte eine Genauigkeit haben, die mindestens größer ist als ein Schwellenwert für die Testdaten. Für den 1470 kann dies parametrisiert werden, indem ein einfaches Modell bereitgestellt wird. Für den 2470 müssen Sie möglicherweise mit Hyperparametern experimentieren oder einige benutzerdefinierte Komponenten entwickeln. Während Sie mit dem Codestil nicht punkten, sollten Sie im endgültigen Commit nicht zu viele Druckanweisungen haben.
Wichtig: Bitte verwenden Sie nach Möglichkeit vektorisierte Operationen und begrenzen Sie die Anzahl der for-Schleifen, die Sie verwenden. Es gibt zwar keine strenge Zeitbegrenzung für die Ausführung dieses Jobs, aber er sollte normalerweise weniger als 3 Minuten betragen. Die automatische Bewertung wird nach 10 Minuten automatisch beendet. Sie erhalten keine Methoden, die Tensorflow- oder Keras-Funktionen verwenden.
Notizbücher: Expeditionsnotizbücher werden manuell benotet und sollten im PDF-Format eingereicht werden. Fühlen Sie sich frei, "vom Notizbuch zum Latex-PDF" zu verwenden. ipynb "notebooks! Reichen Sie Ihre Aufgaben über Gradescope unter den entsprechenden Projektaufträgen ein, indem Sie Ihren hw2-Ordner komprimieren (der Pfad auf Gradescope muss hw2/code/filename.py sein) oder über GitHub (empfohlen). Über GitHub einreichen, Commit ausführen und alle Änderungen übertragen zu Ihrem Repository zu GitHub. Sie können dies tun, indem Sie die folgenden drei Befehle ausführen (dies ist eine gute Ressource, um mehr über sie zu erfahren):
1. git add file1 file2 file3 (or -A)
2. git commit -m “commit message”
3. git push
Nachdem Sie Ihre Änderungen festgeschrieben und an Ihr Repository gepusht haben (Sie können online nachsehen, ob es funktioniert), können Sie das Repository jetzt auf Gradescope hochladen! Wenn Sie Ihren Code in mehreren Zweigen testen, können Sie den gewünschten Zweig auswählen .
wichtig!
1. Bitte stellen Sie sicher, dass sich alle Dateien in hw2/code befinden. Andernfalls versagt der automatische Grader!
2. Löschen Sie den Datenordner, bevor Sie den Code komprimieren.
3. Fügen Sie eine leere Datei mit dem Namen 2470student im Verzeichnis hw2/code hinzu Diese Datei sollte keine Erweiterung haben und wird als Markierung für 2470-spezifische Anforderungen verwendet. Wenn Sie dies nicht tun, verlieren Sie Punkte!
Danke!