Lesson proposal: Creating Deep Neural Networks for Regression Analysis Proposal (PH/JISC/TNA)

[tiagosousagarcia]

The Programming Historian has received the following proposal for a lesson on 'Creating Deep Neural Networks for Regression Analysis Proposal' by @nabsiddiqui. The proposed learning outcomes of the lesson are:

• Investigate how machine learning can provide humanities scholars new tools for image analysis.
• Generate a deep neural network for regression analysis that provides a range of outputs for different paintings.
• Assess the role that different layers, architectures, and tasks of a neural network function.

In order to promote speedy publication of this important topic, we have agreed to a submission date of no later than 24/01/2022. The author(s) agree to contact the editor in advance if they need to revise the deadline.

If the lesson is not submitted by 24/01/2022, the editor will attempt to contact the author(s). If they do not receive an update, this ticket will be closed. The ticket can be reopened at a future date at the request of the author(s).

The main editorial contact for this lesson is @tiagosousagarcia.

Our dedicated Ombudsperson is (Ian Milligan - http://programminghistorian.org/en/project-team). Please feel free to contact him at any time if you have concerns that you would like addressed by an impartial observer. Contacting the ombudsperson will have no impact on the outcome of any peer review.

[drjwbaker]

@svmelton and I discussed potential editors for this article. Sarah will confirm if the preferred editor has capacity.

[svmelton]

@scottkleinman will serve as the editor for this piece.

[anisa-hawes]

(I am co-assigning myself here so that I can shadow the editorial process).

[drjwbaker]

@scottkleinman so pleased to have you as editor on this. Note that this article is part of a special series for which we have funding. As a rresult @tiagosousagarcia and I will be offering additional support. For example, Tiago will do the technical edit and has identified potential peer reviewers. So do write to us https://programminghistorian.org/en/project-team when you are ready!

[tiagosousagarcia]

This lesson has now been submitted and staged here: https://programminghistorian.github.io/ph-submissions/en/drafts/originals/image-classification-neural-networks, and I will be doing a technical review shortly. Many thanks to @nabsiddiqui for submitting on time, and my renewed apologies for the delay in getting this up.

[tiagosousagarcia]

@nabsiddiqui, congratulations on a brilliant tutorial -- I think this is something that will be of interest to many PH readers, and it offers an excellent explanation of some core Machine Learning Concepts.

Apologies for the delay in moving your article forward -- as you know, there were a few personal reasons that kept me away from this for a while.

I've made an initial technical review 78f5984, making small changes as I went along. A summary of these are:

Changes made

• header: added header
• refactored heading levels
• l. 24 -- added wiki link to machine learning and computer vision
• l. 26 -- added wiki link to convulotional neural network
• l. 30 -- added 'using'
• l. 32 -- corrected dataset location
• l. 38 -- changed curved quotation marks to straight quotation marks
• ll. 40, 41 and elsewhere -- corrected inclusion of images
• l. 53 -- added wiki link to ReLu activation function
• l. 61 -- added wiki links to algorithms
• l. 69 -- added link to teachable machine
• l. 79 -- changed curved quotation marks to straight quotation marks
• l. 90 -- changed curved quotation marks to straight quotation marks
• l. 113 -- added 'of'
• l. 117 -- script.js --> sketch.js
• l. 136 -- added space to em dashes
• l. 299 -- added missing quotation marks

Additionally, I would also suggest you consider the following before we send your article for peer-review:

Suggestions

• general -- required knowledge and links to supporting tutorials should be added at the start of the tutorial. Although the introduction to ML and training is excellent, when we reach the section with the JS implementation, it assumes a slight more-than-advanced level of knowledge of how JS works.
• l. 69 -- maybe add a small note saying that, although we will be using Google's teachable machines for this tutorial, there are other options to train a CNN, so that users have a learning path open to them, if they so wish (and also that, in the future, there are other options if teachable machines is closed down or changed).
• l. 95 -- offer a minimum time for the training process (i.e, is should take at least x seconds), plus note that training time will change depending on hyperparameters, quantity of data, etc. etc.
• l. 181 -- Hum, I think most readers might need a little more hand holding -- perhaps expand a little the instructions to start a live server, and move it to the section right after the creation of the html and js files?

Once again, my apologies for the delay in getting this staged and reviewed. lf my suggestions make sense and you can implement them within a couple of weeks, @scottkleinman and I can start contacting potential peer-reviewers.

Thank you again for submitting!

[scottkleinman]

So happy to be on board! Thanks, @drjwbaker and @tiagosousagarcia for the extra support. I'll have some first feedback towards the end of the week.

[nabsiddiqui]

Thank you @tiagosousagarcia. I will go ahead and start making changes when I receive @scottkleinman feedback.

[scottkleinman]

I've made some small editorial changes summarised below. I'll get my larger suggestions up in a separate post as soon as I can.

• para 1: Change "has" to "have"
• para 3: Change "data set" to "dataset". I've normalised this silently throughout the rest of the tutorial for consistency; if you prefer "data set", it is easy make that change universally.
• para 3:
  • Change "series paintings" to "series of paintings".
  • Change "rotation" to "circulation".
• para 4: Add "ArtUK".
• para 6: Add code formatting.
• para 36: Add code formatting and change hyphens to colons. Add "This" for parallel construction.
• para 39:
  • Add "browser's".
  • Change "JavaScript" to "Javascript".
• Add "use it to".
• para 40: Change "boiler plate" to "boilerplate".
• para 42: Add "in your browser".
• para 43: Change "JavaScript" to "Javascript".
• para 44: Change "We should probably also place our code that outputs the current version of ml5js to the console there as well" to "we will also add some code to output the current version of mk5js to the console".
• para 47: Change "could" to "can".
• para 49: Add code formatting.
• para 49: Add code formatting.
• para 52: Add code formatting.
• para 53: Change "had" to "have".
• para 59:
  • Change "JavaScript" to "Javascript".
  • Change "a Javascript object" to "Javascript objects".
• para 62: Change "Object" to "object".

[scottkleinman]

@nabsiddiqui, this was a wonderful tutorial, and I really learnt a lot (despite the fact that the resulting model thinks a picture of me and my wife is a "boat"!). I second all of @tiagosousagarcia's suggestions, although I think it might be a good idea to add a new "Setup" section in which you instruct the user to create something like a project folder, copy in all the necessary files, and start a server running in that folder. Then there would be no need to interrupt the main flow of the discussion with such details.

Here are some other suggestions:

• If this is truly aimed at beginners, the diagram of the neural network may not be very useful. It might a good idea to explain what x, y, and sigma represent.
• You introduce CNNs almost as an aside to the use of Teachable Machine and MobileNet. I think it would be better to introduce CNNs as part of the "theory" section and then introduce Teachable Machine and MobileNet as part of the shift to implementation.
• I occasionally found the interface for Teachable Machine confusing. I was also startled at the end to find it predicting what I looked like on my webcam — without my permission! So it might be a good idea to do a little more hand-holding in guiding the user through it. In particular, I think it would be useful to instruct the user more explicitly to drag subfolders from the training folder into TM and then change the class name to the name of the folder.
• It might be worth highlighting more visibly that the user should not navigate away from the browser tab whilst training is occurring.
• When Tensorflow.js first comes onto the scene in the Importing section, it might be worth a sentence just to say what it is. Maybe a few sentences describing how the user might not be locked into ml5js as a means of working with their model.
• Some things went wrong for me when I created the HTML and Javascript files. First, I think that I started testing things in the browser console. When I eventually figured out that the javascript should be saved to sketch.js, I ended up duplicating the let classifier, which of course returned an error. Eventually, I gave up and used the final complete code, which worked. This suggests to me that it might be a good idea to give that first and then break it down into snippets with explanations afterwards.
• In general, I think it is also a good idea to steer users away from the browser console wherever possible. This will help with @tiagosousagarcia's observation that the Javascript section is more advanced. Also, the console is filled with irrelevant clutter such as errors because a favicon fails to load and overexuberant emojis from ml5js.
• On the last note, I would recommend a change to getResults(). When outputting the results to the DOM, it might be a good idea to do something like

let confidence = " (" + (results[0].confidence * 100).toFixed(2) + "%)";
let label = results[0].label;
text("Most Likely " + label + confidence, width/2 , height/2+200);

You could make this code more elegant, but the basic idea is to output the confidence score to the screen as well as to the console.

Hopefully, these are things you can implement without too much extra work. If you think it might take more than a couple of weeks, I can let you know what I think would be the top priorities.

[nabsiddiqui]

Thank you @scottkleinman and @tiagosousagarcia. Do we have a strict deadline on when this needs to be completed? My March is shaping up to be very busy, but I have a much more relaxed April. I will try to work on it in March when possible, but it may be April when it gets done. I hope this is ok.

[tiagosousagarcia]

Hi @nabsiddiqui -- I don't think we have a hard set deadline for this, though we will hold off on peer-review. If we could get them by early April, that would be great. How does that sound?

[scottkleinman]

Yes, that timetable is fine for me as well. Let us know if you have any questions.

[tiagosousagarcia]

Dear @nabsiddiqui and @scottkleinman -- @drjwbaker and I were just talking, and we came to the conclusion that, to make sure we keep this tutorial moving swiftly, it might be helpful to have a more concrete deadline for these corrections. With that in mind, would it be possible to to have them by April 6?

[nabsiddiqui]

@tiagosousagarcia Yes that should be doable.

[scottkleinman]

@nabsiddiqui, In reviewing the submission, I put together a set of instructions for making clear how to use Teachable Machine; however, I then lost it when posting my suggestions above. I've found it again, so I am pasting it here in the hope that it's of some use to you.

Procedure for working with Teachable Machine:

1. Click "Get Started".
2. Click "Image Project".
3. Click "Standard image model".
4. Under "Class 1", click "Choose images from your files, or drag & drop here".
5. Select the "aircraft" folder from the dataset and drag it into the Teachable Machine window.
6. Click the pencil icon next to "Class 1" and change the name to "aircraft".
7. Repeat this process for the other folders in the dataset. After the second time, you will need to click "+ Add a class" for each new folder.

Once the model is trained, Teachable Machine will display your webcam and continuously predict the likelihood that what it sees belongs to any of the classes the model has been trained on. If you don't like being told how much you look like a boat, turn this off by clicking the "Input" toggle switch.

To export the model, click "Export Model". In the "TensorFlow.js" tab, click the "Download" radio button. Then click "Download my model".

[nabsiddiqui]

Thank you, @scottkleinman. I will keep these in mind as I revise.

[nabsiddiqui]

Hey @tiagosousagarcia and @scottkleinman. I have updated the lesson based on your requests. Let me know if you need anything else from me.

[tiagosousagarcia]

Many thanks @nabsiddiqui! @scottkleinman, once you're happy, we can move it to peer-review

[scottkleinman]

I've made a few more copy edits, but, otherwise, I am happy to move this to peer review.

[tiagosousagarcia]

@melvinwevers has kindly agreed to be one of the reviewers for this tutorial. We can expect his review by 17th of June. Many thanks!

[tiagosousagarcia]

@zentralwerkstatt has kindly agreed to review this tutorial. We can expect his review by the 30th of June. Many thanks!

[scottkleinman]

The Programming Historian has received the following tutorial on 'Creating Deep Neural Networks for Regression Analysis' by @nabsiddiqui. This lesson is now under review and can be read at:

https://programminghistorian.github.io/ph-submissions/en/drafts/originals/image-classification-neural-networks

Please feel free to use the line numbers provided on the preview if that helps with anchoring your comments, although you can structure your review as you see fit.

I will act as editor for the review process (with help from @tiagosousagarcia and @drjwbaker). My role is to solicit two reviews from the community and to manage the discussions, which should be held here on this forum. I have already read through the lesson and provided feedback, to which the author has responded.

Members of the wider community are also invited to offer constructive feedback which should post to this message thread, but they are asked to first read our Reviewer Guidelines and to adhere to our anti-harassment policy (below). We ask that all reviews stop after the second formal review has been submitted so that the author can focus on any revisions. I will make an announcement on this thread when that has occurred.

I will endeavour to keep the conversation open here on Github. If anyone feels the need to discuss anything privately, you are welcome to email me.

Our dedicated Ombudsperson is (Ian Milligan - http://programminghistorian.org/en/project-team). Please feel free to contact him at any time if you have concerns that you would like addressed by an impartial observer. Contacting the ombudsperson will have no impact on the outcome of any peer review.

Anti-Harassment Policy

This is a statement of the Programming Historian's principles and sets expectations for the tone and style of all correspondence between reviewers, authors, editors, and contributors to our public forums.

The Programming Historian is dedicated to providing an open scholarly environment that offers community participants the freedom to thoroughly scrutinize ideas, to ask questions, make suggestions, or to requests for clarification, but also provides a harassment-free space for all contributors to the project, regardless of gender, gender identity and expression, sexual orientation, disability, physical appearance, body size, race, age or religion, or technical experience. We do not tolerate harassment or ad hominem attacks of community participants in any form. Participants violating these rules may be expelled from the community at the discretion of the editorial board. Thank you for helping us to create a safe space.

[melvinwevers]

First of all, I welcome tutorials on image analysis, especially those aimed at (art) historians. Some disclosure is at place here. I am a co-author on a lesson that has been submitted to Programming Historian on neural networks for image analysis. I believe this lesson is still under review. Especially in terms of theory there's quite some overlap.

It might be a good idea to see where the overlap exists and see if these lessons can be bundled.

In what follows, I have noted some general and specific points of feedback. Overall, I think the article needs to be better aimed at historians and focused on transferring re-usable skills. Too much time is spent on JavaScript and presenting the results in a browser. I believe a python based approach using notebooks or Google Colab (with GPU access) would be much more efficient in conveying how neural networks coudl be used.

General and Major Comments

• I think the introduction woudl benefit from references to articles that have applied computer vision on historical material. The author now argues that these models could be used to infer 'topics' (I would not use this word), and that this can be of use for historians. I believe it's better to back this up with existing studies or references to research projects that are already using these methods.
• While the author references to dangers of bias and the use of AI at the end of the article, I think some of these dangers could be included in the article. For example, a more extensive error analysis could help readers become better skilled at detecting bias and dealing with it.
• The audience is not very clear to me. The author is looking for engagement with activists. Why? I think the audience here are historians. The text would benefit from clearer connections to the questions asked by historians and the data available to historians. Moreover, I'm not sure these methods necessarily lead (or should lead) to new questions. They could also be used to answer long-standing questions or to replicate findings and thereby confirm existing knowledge.
• Sustainability. I am not sure why JavaScript is the way to go. Python is a much more common language for these tasks, with a larger community and thus better other resources. Fast.ai, for example, offers great tutorials and a high level framework for working with images. I'm not sure how sustainable Teachable Machine is, as Google is known to suddenly stop offering certain services. Moreover, how dependent is this tutorial on certain JS libraries and their versions.
• In general, I think this tutorial shows how neural networks work but it doesn't give historians actual tools to use them for research. The tutorial is too limited. I would fix this by tagging onto existing tutorials (in Python) and making a tutorial specific for historians. This means incorporating a relevant research question, actual data, and showing how to analyse the results.
• Moreover, the results generated by the model are not really usuable as they are overfitting to the data (see high loss and stable loss on test set, and low loss on training data). For educational purposes this might not be an issue, but the author should reflect on this.
• the title refers to regression analysis. I'm not sure why.

Minor comments

• The author writes: "the step-wise activation function described above is uncommon. More complex activation functions like ReLu and Sigmoid have been shown to have better results." Why are ReLu and Sigmoid more complex? I think it helps to explain the sigmoid function especially when talking about transfer learning as it is mostly this last layer that users need to understand.

• Explain what a hidden layer is.

• The author writes: "Since we are going to work with classifying images, you may wonder how this process of guessing numbers can apply to our own example" This process is not explained at this point in the text.

• The author writes that the network saves the spatial arrangement of pixels. It would explain what convolutions are and how the network learns and stores these convolutions, which are needed to transform the images through the layers of the network. The spatial arrangement is indirectly stored by this but I think this is misleading.

• Neural networks are not exclusively supervised, for example KSOM or auto-encoders are unsupervised.

• Batch size also has an effect on the generalization and convergence of the model, not just on the training time.

• In teachable machine a test set is made. This, however, is not explained. User might be confused since they uploaded their training set.

• Why copy image from testing folder to root? It's a better practice to refer to the actual location in the folder.

• In the repeated code blocks indicate new lines. Code block under par.62 is not easily copied over the code under par.61, thereby losing the callback.

Typos

Direchlet -> Dirichlet Paramaters > Parameters outptuts > outputs

[zentralwerkstatt]

Major

Framing: I appreciate the framing of technical knowledge as a prerequisite for the critical analysis of machine learning systems. This perspective could be even further emphasized, for instance by pointing out potential "injection points" for bias in the technical part.

Structure: This is an inspiring tutorial that pays excellent attention to detail without losing focus on its larger pedagogical goals. It is well written, clearly structured, and proceeds nicely from a theoretical reflection of machine learning principles to questions of implementation.

Implementation: As @melvinwevers has pointed out, the tutorial builds upon a specific toolchain that includes, on the one hand, a proprietary Web application by Google, and on the other, a set of open-source JavaScript libraries. I certainly see the pedagogical value of the Teachable Machine which beautifully demonstrates the power of transfer learning. Still, I feel that the tutorial spends way too much time on "shallow" technical knowledge, like setting up a highly idiosyncratic chain of JavaScript libraries (tensorflow.js + P5.js + ML5.js). At times, the tutorial reads like a P5.js tutorial focused on machine learning rather than a machine learning tutorial using P5.js. Today, other than in the early days of machine learning, the (open-source) toolchain for both academic and commercial machine learning work is pretty much agreed upon, with only very few real "choices" (e.g. PyTorch or JAX) remaining. Any deviation from this toolchain comes with a cost that, in my opinion, needs to be well-justified. Especially as the tutorial is aimed at people without much technical knowledge, the existence of documentation and support beyond the tutorial is vital. This documentation and support is simply not given for the chosen toolchain, beyond very simple example applications (i.e. more of the same). All that being said, I am aware that the tutorial is built around this specific toolchain which makes it difficult to argue for a fundamental revision. A potential compromise would be to a) discuss the "industry standard" somewhere in the tutorial and focus on the pedagogical benefits of the Teachable Machine (i.e. focus more on demonstrations of the theoretical concepts discussed in the tutorial, rather than creating a "reusable" model), or b) supply additional technical content in the form of Python code contained in Jupiter/CoLab notebooks. Again: I am not arguing for a fundamental revision of the tutorial. Rather, as the tutorial is aimed at beginners, I am arguing for a clear delineation between exclusively pedagogical and actually reusable and easily extendable content.

Minor (paragraph-specific)

3: This tutorial only discusses CNNs, which should be made clear at the beginning, especially due to the current omnipresence of transformers.

11: I very much appreciate the comparison with iterative programming. This could be extended to other parts of the tutorial, as readers might have some experience with iterative programming even if they are new to machine learning.

18f: The difference between biological and artificial neurons should be made even more explicit. It would also be advisable to briefly discuss the "spatial" language used throughout the tutorial (neurons, layers, networks, etc.) vs. the underlying mathematics.

20: Should mention some examples of "mathematical properties" (functions?) applied to the dataset.

21: Neural networks famously do not neatly disentangle features in a hierarchical manner but rather develop quite idiosyncratic ways of seeing. While this is not necessarily relevant to the audience of this tutorial, it should be mentioned if the tutorial's goal is indeed to support the critique, and not only the application of, machine learning methods.

37: To again echo @melvinwevers' review, the Teachable Machine is indeed intentionally designed to overfit to the user-supplied data, this should be made explicit.

62: I think the "training image" should be "testing image"? In general, the tutorial would benefit from a brief discussion of training vs. testing, and the importance to keep training, validation, and testing data separate.

[scottkleinman]

Thanks to our two reviewers, @melvinwevers and @zentralwerkstatt. There are a lot of good suggestions there. @nabsiddiqui, I'll be taking stock over the weekend, and I'll try to get you some next steps in the next couple of days.

[scottkleinman]

After re-reading the tutorial and our reviewers' thoughts, I think the biggest issue is the choice of Javascript as the language for exploring the model. This has implications for both the audience who will be best served by the tutorial and the tutorial's wider applicability for scholarly work using image classification. My sense is that there is a place for image classification in the browser and that the use of P5js and ML5js operate as abstractions for the tutorial's purpose so that the user does not have to begin by learning TensorFlow.js. This points to an entry-level audience: someone who not only wants to understand how image classification works but who is also interested in the possibilities of dissemination or interaction on the web. However, as the reviewers point out, the discussion of P5js and ML5js makes it seem like the focus of the tutorial is on those libraries and maybe even gives a misleading impression of their use in the field.

So I have the following suggestion. Why not make the entire project library (index.html and sketch.js) downloadable, along with the training data, and instruct the user to deposit their exported model file into the project folder. There is then no need to go into the ins and outs of the Javascript libraries and the various functions in the main body of the tutorial. This is not to say that this discussion should be removed, as it is still valuable. I am proposing that it go in an appendix, where anyone interested in, say, customising the output can gain a better understanding of what is going on.

This would leave more room for some discussion of the current environment for image classification. In place of the Javascript explanation, you could provide one or two paragraphs that (a) indicate the relationship between CNN and transformer models, and (b) give a sense of the environment for image classification by giving a sense of what might lead the user to explore PyTorch or TensorFlow. I think some of that material is in the bibliography, but it may need some more dedicated discussion in the main body of the tutorial. This is what I think Fabian means by discussing the "industry standard" and the pedagogical benefits of the Teachable Machine. That's only a partial fix of the sustainability issue surrounding Teachable Machine, but I think it gives the user enough to go on if the tool goes away.

One alternative (or additional) approach might be to place a "What next?" discussion in the conclusion. Here might be a reasonable place to reference Melvin's tutorial, which would be a nice place to go next. Even if this tutorial is published first, you could always go back and add a reference.

I also want to address a few more questions about the audience. Like Melvin, I wondered about the engagement with activists. I would drop this or else place it in the context of a more expanded discussion of the ethics of image classification. How do this without derailing the entire tutorial? The point Fabian makes about Teachable Machine being designed to overfit may be the way to approach this. Perhaps raising this in the conclusion would be a good way to return to the comments about ethics at the beginning of the tutorial.

Both reviewers recommend including Python code as a way to make the tutorial more applicable, but I think this would require too thorough a revision of its scope. Perhaps moving some of the links in the bibliography to the main body (as well as links to other PH tutorials) would be sufficient. I am on the fence about Melvin's suggestion to make "a tutorial specific for historians [by] incorporating a relevant research question, actual data, and showing how to analyse the results." I think this would be useful for fostering engagement with the ArtUK dataset, but it might stretch the tutorial beyond acceptable limits. Perhaps there is some scope in one of the suggestions made in paragraph 10? For instance, if there are untagged images in the collection, you could illustrate how well the model tags them. But, without knowing the data, I hesitate to send you down this path.

At this stage, I don't want to address the reviewers' more minor suggestions, as I think you will incorporate them as you go about revision. One thing that I think should be done is that CNNs should somehow be incorporated into the title to indicate that this is the methodology the tutorial employs.

Whilst I think everyone is trying not to propose changes that are too extensive, this already seems like a lot. So I am going to stop here to see whether others have feedback and to ask @nabsiddiqui whether any of this is valuable going forward.

[nabsiddiqui]

@scottkleinman, @zentralwerkstatt , @melvinwevers

Thank you for the comments and the kind words about the tutorial. They are really helpful, and I am happy to incorporate your suggestions into the lesson to the best of my ability. Here are some responses to the initial review and my general comments. My current goal is to have this done by lets say end of September?

General Comments

• JavaScript-I think some background on why this was chosen is important. There is already a tutorial by @davanstrien that looks at Image Analysis using Python with a Kaggle Notebook. I was the editor for that tutorial, and one of the issues that came up throughout our discussion was that there was a lot of setup to get the notebook and dataset downloaded. As a result, this was pitched as a way to provide some theoretical background and overview before going into more advanced tutorials. It is designed specifically to move away from R and Python. I can include some information in the beginning stating "Python and R are the most popular languages for machine learning...." that will provide additional links and some justification. However, I do not believe that incorporating Python or R at this point would be beneficial. As all of you mentioned, this tutorial is more based on providing a pedagogical overview rather than workable product. I will make this explicit though.
• Google Teachable Machine-At the time of the original pitch, this tutorial was focused purely on JavaScript and Ml5js. Unfortunately, training the machine learning module requires a fairly advanced understanding of JavaScript's asynchronous nature and including them would have made the tutorial significantly more difficult. I have tried to avoid things like JavaScript promises, etc. when possible for those that may not have that coding background. The recommended practice is to use Google's Teachable Machine, so while it may seem strange to jump from Teachable Machine to JavaScript, this is currently the way most individuals use this library. You can see the GitHub issues on this here: https://github.com/ml5js/ml5-library/issues/887#. My reopened issue is here: https://github.com/ml5js/ml5-library/issues/1253. At this time, I don't believe the individuals behind ml5js believe incorporating this directly in their library helps and recommend Teachable Machine. I share concerns about the sustainability if Google decides to stop the library, and I am hoping to keep it updated should something change.

Response to @melvinwevers

• References in Introduction to Other Tutorials and Historical Research-Will incorporate in revision.
• Audience-I believe that incorporating more background literature will help solve this. Will also add a paragraph or two in the introduction that says something like "Who is the audience for this article?" Will remove reference to activists.
• Overfitting-I will make a note of the overfitting and bias-variance tradeoff.
• Title-This was an error in the initial proposal submission that got replicated in the issue's title. I don't believe GitHub allows you to change the title retroactively (see https://github.com/GitHawkApp/GitHawk/issues/2054). This should not make any major difference once the article is done and we have documented the naming issue here for those that are curious.
• Step Wise Activation Function-Will add information on ReLu and Sigmoid function
• Hidden Layer-Will add a few sentences about what a hidden layer is.
• Neural Networks Supervised-Will make a note to the effect of writing something like "While most neural networks are supervised, there are also others like KSOM or auto-encoders."
• Error Analysis-Will add some additional information about this.
• Batch Size-Will add that batch size has an effect on generalization and convergence of the model and not just training time.
• Test Set-Will make information about test vs training set more explicit.
• Repeated Code Blocks Not copying-Will fix.

Response to @zentralwerkstatt

• Javascript Choice-See above.
• Convolutions-Will explain further.
• CNNs-Will make explicit that the article does not discuss transformers.
• Biological and Artificial Neurons-I will see if I can add some more information about this. However, I don't know if this really helps and can lead to some confusion. For instance, Andrew Glassner writes in Deep Learning: A Visual Approach: "The “neurons” we use in machine learning are inspired by real neurons in the same way that a stick figure drawing is inspired by a human body. There’s a resemblance, but only in the most general sense. Almost all of the details are lost along the way, and we’re left with something that’s more of a reminder of the original, rather than even a simplified copy."
• Hierarchical manner and disentangling-I will make a few sentences about this.

Response to @scottkleinman

• Putting JS in Index-See above about the discussion of JavaScript and my reasoning for keeping this. If the tutorial does go too long, I will put this in the index. However, I believe at this point, it makes more sense to keep it as is. If this is a problem, I can revisit this suggestion after the changes above.
• What Next Section-Will try to incorporate
• Activists-Will remove the information about activists
• Data-I agree. I will try my best to incorporate a little bit more on the data, but with the additional information I hope to add, I think it would make the tutorial too long.
• Title-Will Change Title to Include CNNs

[nabsiddiqui]

@tiagosousagarcia and @scottkleinman I have updated the tutorial now with the revisions that were requested. Please let me know what else you need on my end or any comments you believe I have not addressed.

[scottkleinman]

Thanks, @nabsiddiqui. I should be able to get to this by Monday and will update this issue then.