Influence of Hidden Layers on Neural Network Effectiveness
Advisor: Mr. Peter
Internship Location: Cohesity Inc (2625 Augustine Dr, Santa Clara , CA 95054)(Virtual)
Onsite Mentor: Mr. Chao (Brant) Chen
Most people, when prompted to imagine a neural network, would visualize that classic model of layered nodes and edges. While the model is certainly helpful in outlining the technical process of deep learning, it offers little insight into what is actually happening. We’re not exposed to any of the inherent structure that the learning process creates. My project addresses this by instead visualizing the neural network as a coordinate transformation that stretches the data into distinct clusters. The learning process thus becomes the process of reshaping the space itself so that classes can be cleanly isolated. Although similar visualizations have been done before, they are typically non-interactive, confined to video demonstrations, or require programming expertise. I am creating a user-friendly model where users can toy with parameters and witness the learning process in real time. My model will also serve as a jumping-off point towards a discussion of the Manifold Hypothesis, and an analysis of the separability between different data sets & how that relates to the structure of their approximate manifolds. The usability of this model is critical for my later research on the influence of hidden layers, where I hope to gain insight into their correlation with the accuracy of Neural Networks.
Project Blog
Post 1: Blog 0: A Guide to Neural Networks --- by Neurons, for Neurons
Hi everyone! Whether you’re accompanying me on this journey or from a future when this project’s already complete (please tell me if it went well), I hope I can lay a solid foundation for the basic philosophy and methodology of my project.
Project Description
So what is my project? From the title and abstract, I’m sure you can guess that it involves neural networks. More specifically, I plan to create a set of lesson plans aimed at educators that will progressively give high school students an intuitive sense of what neural networks are and the problems they were created to solve.
The highlight of each lesson will be an interactive model created through Desmos.
Why Desmos?
Because of familiarity, of course! Over the years, Desmos has become the go-to online calculator for teachers and students. And recently, it’s been introduced as the built-in calculator on the SAT and AP tests. That’s all to say that Desmos is a program that people have experience using. So, rather than mimicking the other learning courses that require prerequisite programming knowledge, I hope that using Desmos as the basis will allow for a tool whose functionalities are plainly visible.
Of course, I readily admit that programming experience will inevitably become necessary for students who want to go deeper into neural nets; it nevertheless shouldn’t be a hurdle in the way of understanding their mathematical basis and core ideas.
Preliminary Work
To demonstrate what I plan to create and quell skepticism that a graphing calculator can be used to create interactive models, here are a few barebones graphs I’ve created as a proof of concept.
Mean Squared Error Linear Regression visualization:
https://www.desmos.com/calculator/axdtzkspyy
Hidden layers as coordinates:
https://www.desmos.com/3d/9qygtumzjr
And just for fun, here’s a brick breaker game:
https://www.desmos.com/calculator/xuvt5fsfco
Don’t worry if you don’t understand what’s happening; that’s what my project is for. In fact, my initial senior project proposal got rejected for just that.
That earlier proposal focused narrowly on visualizing hidden layers by treating their outputs as coordinates and plotting them in 3D. While interesting, it became clear that the model alone couldn’t sustain an entire senior project and assumed too much prior understanding for the intended high school audience.
This new version is aimed at addressing those issues. By designing a sequence of lessons, I can gradually build students up to the level needed to make sense of visualizations like that one while also giving time for other creative approaches along the way.
Tangent aside, if any of this sounds interesting to you, I hope you'll tag along. If you’re not one of those time travellers and are actually viewing these posts while I’m posting them, please do let me know if something is unclear. I’ll do my best to clear it up. This project is as much teaching as it is learning how to teach. It’s hard to know what’s effective when one already understands the material, so any feedback will play a big role in shaping these lessons as they evolve.
Week 1: Layout Refinement and Linear Regression
Welcome to the beginning of my Senior Project, creating a Neural Network Course!
Finding a Platform
Naturally, to begin this process, I must first choose a host platform.
There are many great options out there, but I initially chose WordPress.com due to its free plan and familiarity. In fact, it's the same service that's used by this very senior project website. However, I later realized that when researching, I had confused WordPress.com with WordPress.org. Whereas WordPress.org supported the iframe tag, WordPress.com did not unless I installed a plugin, which was not available in its free package.
This meant that I could not embed my Desmos graphs within the page itself, which proved a great hindrance to readability. I had to change platforms. After a bit of further research, I landed on Blogger.com. It's completely free and owned by Google, which, to me, meant a certain level of baseline quality. And I’m happy to say that it’s working quite well.
You can follow my progress here: https://devisnetwork.blogspot.com/
Current Progress
Outlining the Module
Before the actual writing process, I must first define what structure I want the module to have. I took inspiration from Paul’s Online Math Notes, which was a website I held near and dear to my heart from my days learning Calculus. Each section would start with a refresher on relevant material before posing a question that motivates the introduction of the section’s specific concept.
However, rather than practice problems, I decided that the end of my sections would instead be a step-by-step guide on how to implement that concept on Desmos. Taking inspiration from FRCDesign.org’s learning courses, the guide would be an image carousel, displaying a set of images with captions that tell the user what to input.
While image carousels aren’t natively supported on Blogger, they can be added from 3d party applications through the raw HTML.
On a macroscale, the module will cover all contents in a standard introductory course to Machine Learning, beginning with Linear Regression and ending with Regularization and Embedding.
Starting to Write
Before starting this project, I hadn’t quite fully comprehended how much writing would be involved. I was always a slow writer, so I really had to push myself to just start writing and not be too concerned with how well it flowed. I've completed the initial drafts of the General Overview section and a lesson on Linear Regression, but they're unpolished. Like what I said last week, I would really appreciate feedback on those posts on which parts are confusing and what else you want to see.
What I loved the most was creating all the interactive graphs on Desmos. You can find them on Blogger, but here’s two of them now:
Drag the blue point
https://www.desmos.com/calculator/mjgordok0g
https://www.desmos.com/calculator/misajekfgb
It’s a graph of 2d gradient descent. Basically, how it works is that an algorithm keeps moving the blue point downhill until it reaches a local minimum. The top link breaks down each step, while the bottom shows the actual outputs. If you want to know how this relates to Machine Learning, again, please read the post on Blogger.
That’s all for this week, folks. See you guys next week as I begin to finalize these first posts.
Week 2: Making Steady Effort on Mean Squared Error
Welcome to week 2 of my Senior project! This week has primarily been focused on getting into the rhythm of writing lessons while receiving feedback from students and teachers.
Current Progress
Continuing from last week, I’ve finished the lesson on Linear Regression. I decided to forgo the original plan of using an image carousel for the Desmos Walkthrough in favor of plain old images and text. This was primarily motivated by the fact that some users were using the graphing calculator for the first time, so additional instructions and reminders were needed that didn’t fit in an image w/ caption format. The carousel might make a comeback in future lessons, but for now, it’s being shelved.
Going back to the lessons, two more were added this week. The first is a discussion of different types of Loss/Error functions and why Mean Squared Error is standardly used. One of my main goals for this project is to provide the rationale for concepts that are often glossed over in traditional introductions to Machine Learning, and this was at the top of the list. A lot of guides just use Mean Squared Error as a tool without or only with a rudimentary explanation of why it’s the standard, so I made that reasoning a focus of a lesson. As always, go to the blog at https://devisnetwork.blogspot.com/ for the actual explanations, but here’s a graph from that post comparing Linear Regression using Mean Absolute Error and Mean Squared Error:
https://www.desmos.com/calculator/initznlrh4
The second post is more focused on rounding out Linear Regressions, discussing how exact solutions can be found using Linear Algebra and how it can be generalized to higher dimensions. The lesson leans towards the mathy-er side, and is not critical for understanding Neural Networks, so it’s been marked as optional and only for those interested
Feedback
Since the creation process is iterative, feedback is crucial to know what works and what doesn’t.
This week, I’ve been working with my external advisor to make the lessons and structure more standardized, dotting the i’s and crossing the t’s. Stuff like distinguishing the word a from the variable a by putting the variable in single quotes (‘a’) is crucial to avoid reader confusion.
Recently, I’ve also asked some of my high school peers for their review. The consensus seems to be that they find the interactive models intuitive enough, but are sometimes confused with the text due to certain uncommon word choices or inadvertent ambiguity. While those reported have been altered, it seems like I need to keep an eye out for being too verbose in my future posts.
This is as good a time as any to remind you that feedback is sincerely appreciated and strongly encouraged. If you have the time, please point out areas that need improvement. Even if you truly found it without fault, still comment so I can get a small ego boost.
That’s all for this week. Thank you for reading, and remember: Comment, Comment, Comment!
Week 3: Logistic Regression and Lesson Revisions
Welcome back now to week 3 of my Senior Project! This week marks the beginning of bridging the gap between Linear Regression and Neural Networks.
Current progress
I've written two more lessons, “Data Linearization” and “Logistic Regression and Classification.” I'm slowly but surely moving into the realm of Neural Networks. These lessons will serve as the basis for activation functions that I’ll hopefully discuss next week.
As always, you can view the current progress of these lessons here: https://devisnetwork.blogspot.com/
“Data Linearization,” as the name suggests, discusses how data with non-linear relationships could be linearized so that Linear Regression could be performed on it. One memorable moment was the construction of an animation depicting the linearization process of an exponentially correlated dataset. Because the linearization process took the natural log of the data’s y values, I had to zoom in the camera to allow the reader to see the linearized result properly. This meant that I couldn’t use my usual method of Linear Interpolation, which moved points from their initial position to their final position with a constant speed, because the speed doesn’t appear linear due to the camera zooming in. After playing around with different variations of the interpolation formula, I finally found one that worked, with the formula: y^(1-t)+(ln(y))^t-1. This gives the original y value when t=0 and then the linearized ln(y) value when t=1. The GIF of the interpolation can be found on the lesson, but here’s the link to the Desmos Graph as well: https://www.desmos.com/calculator/8hwxyjx74x
“Logistic Regression and Classification” was a lot trickier to explain. I realized that a lot of my own understanding came from intuitions that weren’t easily put into words. After reviewing some contemporary explanations of the concept, I found that most explained how it works, but not why it was important. Similarly, I originally planned on going over Odds and Log Odds, but I scrapped the idea when I realized it was more of an outcome of Logistic Regression rather than the motivating factor behind it. So instead, I went back to the basics, teaching the concept by posing and answering a question. Discussing the difference between data sets with continuous versus discrete outputs helped put into context how and why Logistic Regression came to be, not just its functionality.
That’s pretty much all for this week. I've been slowly chugging along, but next week is when it’ll start ramping up. I'm finally tackling the meat of the course, discussing Neural Networks, the intuition of using a web of connected linear functions, and why activation functions exist. Technically, what I've been doing now with logistic regressions is actually the simplest form of a neural network. Driving upon and expanding this point will be one of my goals to drive home in the upcoming lessons.
Thank you for reading, and see you next week!
Week 4: Now Navigating, Neural Networks
Welcome back to week 4 of my Senior Project. We’re nearing the halfway mark, and finally, we’re at the long-awaited topic of Neural Networks.
Revisions
Considering the importance of the lesson, I began this week by polishing my previous lessons to be more interconnected, ensuring the logical progression to feel more intuitive.
This included reworking a third of the first lesson, mostly on its discussion of gradient descent. I wanted to make it more obvious as to why gradient descent uses both the direction and magnitude of the derivative. To do so, I added a simulation that only used the direction and compared the two. This ended up causing the rest of the section to be illogical, so I spent a while moving stuff around to restore the logical structure. Looking at the page now, it flows much better than before, but that may be the effort justification talking. I wouldn’t know until I get feedback, which will be one of the primary focuses for next week.
Also, for convenience, since there’s a good handful of lessons now, I added some basic navigation to the lesson pages. It’s just a simple “Previous” and “Next” at the bottom of each page right now, but it will get more populated once I’ve finished writing all the lessons. Through this process, I realized the option to have links open in a separate tab was toggleable, so I went back and changed all the previous links accordingly.
As always, if you want to look more closely at my progress, you can view the current progress of these lessons here: https://devisnetwork.blogspot.com/
Lesson Progress
Rather than my usual two lessons per week, I spent this week working exclusively on the one on Neural Networks. It begins with recapping the structure of Logistic Regression I discussed last lesson, and how Neural Networks are a natural progression of that structure. For more details, check out the actual lesson using the link above. The content feels more math-heavy than what I would have liked, using a lot of mathematical symbols that might obfuscate the main points I was trying to make. I added some side-by-side comparisons to logistic regression to hopefully ease that transition, but it’s an issue I might revisit at a later date.
The lesson ends with a step-by-step guide on creating your own Neural Network in Desmos. This guide was one of the main reasons why I chose this project for my Senior Project in the first place. In just ~30 lines of code on Desmos, we’re able to create a fully fledged (albeit quite simple) Neural Network from scratch. I think that’s just amazing. You can see the finished product (with some added UI elements) here: https://www.desmos.com/calculator/j8ikov6k6d
If you want to mess around with the program, I recommend changing the activation function, Learning Rate, Loss function, and/or the data values.
That’s all for this week. As I mentioned briefly above, I will begin the process to receive formal feedback from teachers. This will be through the creation of a questionnaire using a Likert scale, along with space for their experiences and suggestions. Thank you all for reading this blog, and see you next week.
Week 5: Likert, Learning, and Lesson
It’s week 5 of my Senior Project, and we’re halfway done!
Feedback Collection
I began this week by creating feedback forms: An individual feedback form that’s found at the end of each lesson and an overall feedback form that would be administered once the lessons are completed. I decided to use the standard Likert scale, which asks respondents to rate different aspects of the lesson on a scale from 1 to 5. Using a Likert scale usually means that I would be able to analyze the mode and median of the responses to identify common trends. However, although I planned to survey 3–5 teachers, establishing basic patterns and trends typically requires 15–30 responses. For now, since I do not intend this feedback collection to be a formal survey, I decided to rely on the 3–5 responses I expect to receive without performing statistical analysis. While this limits the ability to identify broader trends, the feedback will still be valuable in highlighting areas for improvement.
The small respondent count also makes qualitative feedback more important, as it gives more detailed insights into their experience with the product. Thus, I also included some open-ended questions at the end of the form for more specific feedback.
In particular, the most important aspect of the lessons I want feedback on is the Desmos Implementations. This is the crux of how my project differs from other Introductory Machine Learning Courses. How familiar readers are with the platform is key to the effectiveness of their learning. Because of this, I included a dedicated section in both the Likert scale and the open-ended questions specifically focused on the Desmos implementation.
Current Progress
I initially wanted my next lesson following Neural Networks to be a guide on Backpropagation. The term is often confused with Gradient Descent, when in actuality, it’s a method to efficiently perform Gradient Descent. However, I found that, due to Desmos’s lack of support for matrix computations, performing Backpropagation on the platform would be tedious, and the alternative method without matrices would be quite different from the actual procedure. After a meeting with my Internal Advisor, we agreed that since this isn’t central to the core learning objectives of my project, it would be better to delegate it to an appendix that readers can refer to once they move into more traditional coding environments like Python or MATLAB.
Instead, I decided to pivot the lesson toward activation functions, focusing on how they work and why certain functions are preferred in neural networks. By experimenting with different activation functions, readers can see how they affect the Neural Network. They’ll be able to see why an activation function is necessary to introduce non-linearity, since without them, the Neural Network would be functionally the same as Logistic Regression. While not currently complete, the lesson is projected to be finished by the start of next week.
That’s all for this week. I’m looking forward to finalizing the activation functions lesson and beginning to incorporate the feedback from my survey, which will help refine the clarity of explanations and the interactivity of the Desmos visualizations.
Week 6: Goals, Groundwork, and Growth
Welcome to Week 6 of my Senior Project! After wrapping up the Neural Network lesson last week, this week is focused on stepping back and looking at the course as a whole.
Machine learning courses are everywhere, but what sets mine apart is its focus on giving students the tools to build and explore concepts directly within the interactive environment of Desmos. Re-reading the course, however, I realized that I didn’t take full advantage of that strength.
Revisions
After testing the course with some family and friends, it was apparent that the Desmos Implementation for “Linear Regression and Gradient Descent” was confusing for many. This was because of the way the loss function was defined, which often causes the model to stop prematurely. While this is explained and remedied in the next lesson, “Mean Squared Error,” it made the first lesson feel unnecessarily difficult to follow on its own.
To address this, I integrated “Mean Squared Error” into “Linear Regression and Gradient Descent” so that students are introduced to a more stable loss function when working with gradient descent. This helps make the implementation easier to understand and gives the lesson a clearer progression.
However, this has led to the length of “Linear Regression and Gradient Descent” to be even longer than before. While that’s fine for now, I’m planning to cut it down into three separate lessons: Linear Models, Gradient Descent, and Linear Regression. In particular, a dedicated lesson on Gradient Descent means that the students can model it themselves rather than relying on the animations and simulations I built.
Progress
I also added two additional lessons between Logistic Regression and Neural Networks. The first, “Logistic Regression of Multiple Inputs,” introduces decision boundary plots, which visualize classification models by placing two input variables on the x and y-axis and coloring the background to represent the predicted class.
This is the same type of visualization used in last week’s Neural Network graph. In that lesson, however, I didn’t fully explain the shift in visualization, so this intermediate lesson now serves to bridge that gap and provide a clearer foundation.
The next lesson, “Using different Input Features,” tries to remedy the increased complexity of the Neural Network lesson I discussed last week. Rather than explaining Neural Networks through the usual nodes and edges structure, I had students build on their existing logistic regression model to classify more complex data, guiding them step by step until they essentially constructed a neural network themselves in the revised “Neural Networks” lesson.
Overall, Week 6 has been a week of reflection for my Senior Project. By focusing my efforts on revising the lessons to better reflect the goals of this course, I hope to provide a unique and engaging learning experience that allows students to actively build and explore machine learning concepts for themselves.
As always, you can view my current progress here: https://devisnetwork.blogspot.com/
Next week, I’ll be focused on breaking up the “Linear Regression and Gradient Descent” lesson and hopefully gathering feedback from some teachers.
Thank you, as always, for following along with my Senior Project journey.
See you next week!
Week 7: Revision, Roadblocks, and Records?
After a week-long break, we’re back with Week 7 of my Senior Project. While I had planned to focus on teacher reviews, the breaking up of the “Linear Regression and Gradient Descent” lesson I discussed last week caused some delays.
Revisions
This week started with breaking up the giant that was “Linear Regression and Gradient Descent” into three smaller lessons: “Linear Models”, “Gradient Descent”, and “Linear Regression.” Continuing with what I discussed last week about pushing the Desmos Integration into the limelight, I decided to weave it directly into the lesson rather than treating it as a footnote, as was done previously. The restructuring also freed up space to give the readers a chance to build previously pre-built models themselves, giving them a better glimpse at how they function.
The most prominent is the model on Gradient Descent. Before, students were just shown animations that depict the process, but now, they can create it for themselves. For example, at the end of the lesson, students are expected to use Gradient Descent on functions of multiple variables, getting something like this:
Where the blue point descends down the red function.
This new lesson style also lends itself well to a video format. While outside the scope of the project, I keep finding myself contemplating how much more intuitive the course would be if it were over video. Rather than screenshots followed by instructions, students can see in real time what I’m doing and follow along. Although there isn’t enough time left within the Senior Project, it’s something I’m seriously considering in the future. Video lessons would make the material far more accessible and engaging, allowing it to reach much more of my target audience of high school students.
Setting that aside, one consequence of reworking the first lesson of my course is that teacher evaluation had to be delayed. The course is cumulative, so without the first lesson, the rest of the lessons would be incomprehensible. Not to worry, though, even with the delays, it’s still on pace with my original project timeline. Still, it’s better to get the course into the hands of teachers as soon as possible to give them more time to read over the course, so that will be the priority starting next week.
After the restructuring, I did a comprehensive overview of the entire course, making minor edits along the way. I also went about updating the site navigation, which was largely unmaintained in the previous weeks because it needed to be manually updated after every new lesson and every lesson deletion.
Overall, Week 7 was primarily focused on revision instead of new progress because the course is finishing up. Although it did delay feedback, the restructuring of the first lesson was crucial to maintain consistency between lessons.
Thank you for your continued support. See you all next week, where the focus will be right back on teacher feedback and evaluations. Their feedback will play a crucial role in determining what works and what needs to be improved.
But it’s not just their feedback that’s important. If you have any questions regarding the project, please leave them in the comments below.
Week 8: Vetting, Videos, and Validation
Welcome back to Week 8 of my Senior Project! As mentioned last week, this week started with me sending the course to some teachers for their feedback. While I waited to hear back, I also ran some peer testing on my own.
Progress
I started the week by having a friend work through the course while I observed, allowing me to identify any areas of confusion and make improvements along the way. These were usually minor changes that either added clarification or reworded sentences to make instructions clearer.
However, quite often, I found them asking me how to do a certain Desmos Implementation when it’s explained in the next sentence. This might be an issue with how I phrase instructions, writing the general instructions first and then how specifically it’s implemented. For example, the lesson would ask them to write a function using a summation, but the way to insert a summation into Desmos is only provided in the next sentence. I decided not to change that format, as users will naturally read the next sentence for guidance when working independently. However, that may change if more users have the same issue.
Following along with someone new to Desmos also revealed a more significant oversight. When they were asked to add the “Ticker” to their graph, I realized that I was missing from their interface. The Ticker is essential for much of the course, so this was a major issue. After some digging, I discovered that the Ticker is part of Desmos’s advanced features, which are turned off by default. While I updated the lesson to include a guide on enabling advanced features, I realized that the Desmos implementation itself is still too confusing for users.
To address this, I decided to record videos showcasing the Desmos Implementation for each lesson that the users can reference. This is not to be confused with the video lessons I said I wanted to make last week’s blog. These videos don’t have commentary and purely showcase what to write in Desmos to create the lesson objectives.
Revisions
Along with the minor rewrites from the peer testing, I also rewrote a portion of the “Logistic Regression and Classification” lesson. This continues the trend of the past few weeks of interweaving the Desmos Implementation into the main course contents. Keep an eye on any lesson that still has the “Desmos Implementation” subheading, as those will likely also be changed in the near future to accommodate that shift in philosophy.
Overall, week 8 has been focused on getting feedback and making small but impactful changes that improve the clarity of the course.
While I’m writing this, I’m just getting back the first of my teacher feedback, so see you all next week as I continue these revisions and finalize the course.
Week 9: Lesson Revamped and Loss Rendered
Welcome back to Week 9 of my Senior Project! This week continues the cycle of revisions as I now incorporate teacher feedback.
Revisions
I’ve heard back from a couple of teachers, and a common observation was that the lesson quality seemed to weaken as the course progressed. This makes sense because these past revisions focused mostly on the earlier lessons, and that’s where most of the feedback has been concentrated in peer testing, since those were the lessons encountered first. This actually aligns with my original plan, since I intended to revise the course sequentially to ensure a smooth progression so that each lesson flows well into the next.
So, following the feedback, this week, I began revising the “Neural Network” lesson. However, I quickly realized that the lesson needed to be entirely overhauled. I was revising the course in sequential order, so a change in one lesson meant rippling effects on all subsequent lessons. This kept building up until, now, the original “Neural Network” lesson is too far removed from the rest of the course. The bulk of the substance remained the same, but the style in which it’s introduced needed to be revamped completely, so I found it easier to start writing the lesson from scratch, while occasionally taking references from the original. Unfortunately, the lesson is not in a finished state if you’re reading this right when this is published. It will be out by the start of next week.
I also decided to cut the “Data Linearization” lesson because it proved to be redundant, as it wasn’t referenced at all in later lessons.
Another concern I had was that both peer testing and teacher feedback had the people going through the course in a single sitting. Because of this, the feedback might not reflect the experiences of learners who take breaks between lessons, who might not exactly remember how to access certain tools needed for the Desmos Implementation. I hope this is mitigated by the inclusion of the walkthrough videos I created last week, but I also decided to add a few redundancies within the lessons to remind the learner.
Progress
When I was revising the “Logistic Regression and Classification” lesson last week, I wanted to further explain why Log Loss was preferred over Mean Squared Error for the Loss function of a Logistic Regression. From my research, it appears that this was because the Loss function using Mean Squared Error wasn’t concave, so it would usually prematurely stop at a local minimum rather than the absolute minimum. However, I realized that none of those sources showed an actual graph of the function. Of course, for Logistic Regression of multiple inputs, the Loss function cannot be completely graphed because in our 3D world, we can only graph expressions of at most 3 variables, in the directions x, y, and z. But for Logistic Regression of a single input, with the Loss function consisting of just two variables, it can.
And now, we can see that while the Loss function of a Linear Regression is concave
But it’s quite flat for the Loss function of a Logistic Regression
This isn’t optimal since the method of Gradient Descent, which we use to find the minimum value of a function, becomes very slow when the slope is close to 0.
So instead, we use Log Loss because it’s concave for Logistic Regression.I do admit that this tangent I’ve gone down was part of the reason why the revamp to the “Neural Network” lesson was delayed, but I’m extremely happy with how this turned out, especially considering its absence in other machine learning courses.
That’s all for this week! Looking forward, I plan to send this course to a couple more teachers for their feedback, but with the end of the course coming soon, that might not be possible. Still, any feedback is appreciated, so if you want to give feedback or have anything clarified, please leave it in the comments.
Week 10: The Finale and the Future
Hi everyone! The week marks the end of the Senior Project. First of all, I want to say thank you to everyone who accompanied me on this journey. Thank you to Mr. Peter and Mr. Chen, my Senior Project Advisors, for giving me valuable feedback on my lessons. Thank you to Ms. Nagpal and this school for giving me this opportunity. And thank you to you, the readers and commenters, for your continued support.
Final Progress
Wrapping up the Senior Project, the brunt of this final week focused on creating the Paper and Poster for the upcoming Senior Project Presentation. The downside of creating a learning course in 10 weeks is that it’s difficult to get feedback since it’s impossible to expect volunteers to go through the entire course in just a couple of weeks. That’s why the initial plan was to have educators be the ones to give feedback since they’re more familiar with the field. Sadly, while the responses were positive, the sample size is still too small to perform any statistical analysis, so I had to rely on qualitative evaluation.
That said, at the beginning of this week, I shared my course on the Desmos Discord, and one person completed the entire course within just a few days. Collaborating with them gave me a fresh perspective on areas that could still be improved, such as adding a button to randomize variables whenever users become stuck in a local minimum. As I mentioned before, I hope to continue developing this project long after these 10 weeks and see how far I can take it.
Project Reflection
Ultimately, my project is about Neural Networks, and programming is necessary to dive deeper into the subject. This course can never replace traditional Machine Learning courses. However, I hope that it lowers the barrier of entry for students who would otherwise never engage with Machine Learning concepts and offers insights on key ideas for those starting their journey.
Desmos Implementation
The main focus of the course is on the Desmos implementation. And as I built the lessons around it, I’m amazed at how many concepts can be easily visualized for simple data sets that are just absent in traditional Machine Learning Courses.
From graphing the Loss functions of a Logistic Regression,
to visualizing neural networks with different activation functions.
Whenever I do a project, I always have a nagging feeling that it will turn out to be a worse version of something someone has already done. But after spending 10 weeks working on this project, I feel reassured of its value. I genuinely hope to continue developing this idea and eventually create a video series that can share these concepts with even more people.
Thank you again for all your support throughout this journey. If you enjoyed following this project, feel free to go back to Blog 0 and let my past self know how it all turned out.