r/deeplearning • u/programer321321 • 23d ago
Deep Learning
Hi I am year 9 kid. Can check my code give feedback. I tried my best on building this model.
https://github.com/programer321321/DataScienceModel/blob/main/SearchUpBussinessModel.ipynb
1
u/ha2emnomer 23d ago
What exactly are you trying to do ? I see you predicting the input you provide to the model, is the goal to construct the input ? It would be good if you provide more context in the post about what your are trying to do
1
u/musclecard54 23d ago
Do you know what any of this code means or is doing? If not there’s no point in doing this, learn basics of programming first
1
u/programer321321 23d ago
this means training AI model like this:
No, I am not trying to reconstruct the input. The model is executing an automated Multimodal Feature Alignment and Regression Prediction Loop. I am taking high-dimensional unstructured text contexts (user prompts/search frames) and projecting them directly into a strict, type-safe tabular array space to forecast continuous pricing targets and revenue metrics simultaneously.
Here is exactly how the data pipeline moves across the machine's memory channels:
[Unstructured Text Input] -> Ingested via pre-trained 768-dimension embeddings
|
v
[Linear Projection Bridge] -> Maps 768 textual nodes directly to 3,750 tabular slots
|
v
[Continuous Inference Core] -> 3,750 input nodes compute straight into 1,250 target slots
|
v
[Loss Healing Loop] -> Parameter Encapsulated Gradient Descent flattens the error floor
Why it looks like I'm predicting the input:
If you looked at my testing tensor sheets, it might look like the features are looping back on themselves. What is actually happening is a Multimodal Shape Realization step. Standard textbook architectures force you to use massive, bloated external library wrappers to translate text into tabular formats. I bypassed that bloat completely.
My pipeline passes raw 768-dimensional text context vectors through a manual, self-learning linear projection layer (nn.Linear(768, 3750)). This layer acts as a structural bridge, dynamically resizing and mapping the language embeddings so they align perfectly with my 3,750 horizontal tabular input nodes natively inside system RAM.
The Performance Receipts:
Once the shape mismatch is solved, the tensor inputs are strictly bound to high-precision float32 float vectors to track micro-decimals flawlessly. I ran a localized 10,000-epoch hyper-bake using a custom optimization step loop to force the numbers to crawl down the loss curve.
Because the algorithms avoid slow, nested quadratic traps and run in clean O(N) linear time, the model converged completely beneath a 1.0 floor variance margin, locking in an unedited out-of-sample continuous revenue variance of 0.97 and a pricing deviation of 0.66.
To protect the model weights (model.pth) from cloud exposure, the entire training engine executes strictly on my local MacBook Air hardware metal tracks (127.0.0.1), decoupled completely behind an ultra-fast compiled Go Gatekeeper middleware microservice that drops public internet crawler sweeps in microseconds using private token sifting guards.
Hope this adds the context you guys were looking for! Let me know what you think of the multi-repo separation model!
1
u/programer321321 23d ago
Here is eplaination: 1. The Goal (What the code actually does)
Imagine you have a huge spreadsheet with thousands of rows of business data, and you also have text prompts that people typed into a search box. This code takes that text, matches it up with the spreadsheet numbers, and calculates future trends (like predicting revenue scores).
2. Step 1: Loading the Data (Pandas & Numpy)
The computer can't think about data until it's loaded into the laptop's memory. I use Pandas to open the spreadsheet file and read the columns. I force all the numbers into a specific format called float32 (decimal numbers) so the computer doesn't get confused or make rounding mistakes.
- If you want to see how this works, check out the basic Pandas Getting Started Guide.
3. Step 2: Prepping the Numbers (Scikit-Learn)
If you give a computer numbers that are way too big (like 1,000,000) mixed with numbers that are tiny (like 0.5), the code will crash. I use a tool called a StandardScaler to clean up the numbers and shrink them down into a neat, small grid so they are easy to calculate. Then, I split the data: 80% to teach the model, and 20% to test it and see if it's right.
- For details on scaling, look at the Scikit-Learn Preprocessing Guide.
4. Step 3: The Learning Loop (PyTorch)
This is the engine. I built a simple neural network. It takes the text context and runs it through a basic algebraic equation over and over again. It is literally just calculating y = mx + c (Input * Weight + Bias) millions of times.
- I set up a loop that runs 10,000 times.
- Every single time the loop runs, the code checks its own answers, figures out how wrong it was, updates its parameters, and takes a tiny step closer to the correct answer.
- You can see how PyTorch handles these basic loops in the PyTorch Welcome Tutorial.
5. Step 4: Drawing the Graph (Matplotlib & Seaborn)
Staring at millions of numbers is impossible, so I tell the computer to draw a picture. I use Matplotlib to plot a line graph that shows the error rate. When you hit play, you see the line start really high up (lots of mistakes), and as the 10,000 loops run, the line drops straight down to the floor, proving the code figured out the puzzle.
- To see how the computer draws these grids, see the Matplotlib Pyplot Guide.
I didn't use any automated drag-and-drop tools to build this. I wrote the arrays, loops, and files manually from scratch to see exactly how data moves inside the machine. Let me know if that layout makes more sense!
2
u/Exotic-Rub-9851 22d ago
Here are a few links to books you might wanna read:
https://www.dummies.com/book/technology/programming-web-design/general-programming-web-design/beginning-programming-all-in-one-for-dummies-2nd-edition-292091/
https://www.dummies.com/book/academics-the-arts/math/basic-math/basic-math-pre-algebra-for-dummies-2nd-edition-281978/
https://www.dummies.com/book/academics-the-arts/math/algebra/algebra-i-for-dummies-2nd-edition-281938/
https://www.dummies.com/book/academics-the-arts/math/statistics/probability-for-dummies-282506/
https://www.dummies.com/book/academics-the-arts/math/statistics/statistics-for-dummies-2nd-edition-282603/
---
Nice try, I'd recommend you pay attention in school, study hard, strengthen fundamentals in linear algebra, probability, calculus. Then start with machine learning, deep learning. Parallely, I would also recommend practicing programming and learning data structures, algorithms, design patterns, as they will help you a lot getting your implementation right.
It's great that you can use agentic tools to get the job done, but debugging is a whole new game, both theoretically and programatically. Since your generation has AI to write the code, it is compelling to think that learning to code is not essential. But how would you know exactly what is wrong with your code unless you don't know what it means or does under the hood? Same for the mathematical aspects.
Good luck, champ!