u/CircuitsToNeurons

Hi r/careerguidance ,

I've spent 15+ years in software testing / QA automation and I'm now making a serious transition into AI/ML development. Instead of just asking "how do I break in," I decided to build my way in. Sharing my latest project here and would genuinely love feedback — especially from anyone who hires for AI/ML roles.

The project: Focused Research Agent

A full-stack agentic AI research system, live-deployed on HuggingFace.

🔗 Live demo: https://tushark2111-focused-research-agent.hf.space

📦 GitHub: https://github.com/tusharkhoche/focused-research-agent

Given any research question, the agent plans search queries, searches the web via Tavily, ranks sources, and synthesizes a cited answer. Three modes: Quick Research, Conversational Chat with memory, and Full Report with images.

What I built it with:

LangGraph · FastAPI · Streamlit · Groq (Llama 3.3 70B) · Tavily · SQLite · Docker · pytest · SonarCloud

My background for context:

• 15+ years: Lead QA Engineer / Automation (Java, Selenium, CI/CD)

• PGP in AI & ML — Great Lakes × UT Austin McCombs (2021)

• IEEE-published paper in Computer Vision

• Previous projects: RAG application (LangChain + ChromaDB) and a LangGraph journaling agent

My honest question for this community:

Does a portfolio like this — a live deployed system, 175 tests, clean architecture, real tech stack — actually move the needle when transitioning from QA into AI/ML roles? Or do hiring managers still default to requiring a CS degree or formal master's?

I'm not looking for validation — I want honest feedback on whether this is enough to start applying seriously, or what's still missing. Thank you!

Hi r/learnmachinelearning,

When I first started learning neural networks, I struggled to truly understand backpropagation — most tutorials show the code but skip over the actual math. So I sat down with pen and paper and worked through the chain rule for a 4-layer network step by step, from forward propagation all the way to gradient descent.

I published these notes on Kaggle a couple of years ago and just rediscovered them while reviewing my work as I transition from software testing into AI/ML development. Sharing them here in case they help anyone trying to build a real intuition for what's happening under the hood.

What's covered:

• Forward propagation for a 4-layer network with the W_{To,From}^{Layer} notation

• General matrix form of forward propagation

• Loss function derivation (MSE)

• Backpropagation chain rule, layer by layer (Layer 4 → 3 → 2 → 1)

• Definition of the error term δ at each layer

• A worked gradient descent example with f(x) = (x−1)² showing how the algorithm converges to the minimum

📖 Kaggle notebook: https://www.kaggle.com/code/tusharkhoche/mathematics-of-a-simple-neural-network

These are handwritten notes (photographed and pasted into the document) — not LaTeX. I deliberately kept them handwritten because that's how I learned it, and I find handwritten math easier to follow when you're trying to understand a derivation.

What I'd genuinely love feedback on:

• Did I get the chain rule decomposition right at every step?

• Is there a cleaner way to introduce the δ (error term) notation for someone learning this for the first time?

• Anything I missed that would help a beginner?

I'm still learning and would deeply appreciate corrections or improvements from people who teach or understand this material well. Thanks! 🙏

Hey everyone! 👋

Over the past while I've been putting together a series of Kaggle notebooks that try to build a clean, intuitive understanding of sequence models — starting from the motivation behind RNNs all the way through to how Transformers work.

The goal was to explain the why behind each concept, not just the how — so each notebook tries to build genuine understanding rather than just showing code.

Here's the full series:

1. 📌 Why Simple RNN was introduced
2. 📌 How LSTM works
3. 📌 LSTM Backpropagation
4. 📌 How the Encoder-Decoder model works
5. 📌 LSTM Encoder-Decoder Implementation
6. 📌 What is a Transformer? — Part 1
7. 📌 What is a Transformer? — Part 2
8. 📌 What is a Transformer? — Part 3

The series is structured as a progression — each notebook builds on the previous one, so I'd recommend going through them in order if you're new to the topic.

Why I wrote this: When I was learning sequence models, I found a lot of resources either jumped straight into code without building intuition, or explained theory without connecting it to implementation. I wanted to create something that bridges both.

I'd genuinely love your feedback:

• Is the progression from RNN → LSTM → Encoder-Decoder → Transformer logical and easy to follow?
• Are there any concepts that feel rushed, unclear, or insufficiently explained?
• Is there anything important I've missed or got wrong?
• Any topics you'd want covered as a follow-up?

All feedback — critical or otherwise — is very welcome. I'd rather know what's wrong and fix it than have something misleading sitting out there!

And if you find any of the notebooks useful, an upvote on Kaggle would mean a lot and helps other learners discover the series 🙏

Thanks for reading!

Hey r/learnpython  👋

I've been working on a structured, depth-first learning plan to go from basic Python knowledge to genuine expertise — covering core language features, OOP, SOLID principles, and the Gang of Four design patterns.

The plan is built around books and free resources (no paid course dependency), with project deliverables at every phase to make sure the learning actually sticks.

**A quick note on how this was made:** I used AI (Claude) to help research, structure, and refine this plan. I've reviewed everything carefully and believe the content is solid, but that's exactly why I'm posting here — I'd love expert human eyes on it to catch anything the AI and I may have missed or got wrong.

**Here's a quick overview of the 8 phases:**

- **Phase 0** – Foundation audit + professional tooling setup (venv, ruff, black, mypy, pytest)

- **Phase 1** – Core language deep dive (data model, sequences, functions, type hints)

- **Phase 2** – Advanced features + testing (decorators, generators, async, pytest)

- **Phase 3** – Python internals + typing system (CPython, GIL, Protocols, dataclasses, debugging)

- **Phase 4** – OOP mastery (inheritance, composition, descriptors, metaclasses, ABCs)

- **Phase 5** – SOLID principles (one week per principle, applied in Python)

- **Phase 6** – Gang of Four design patterns (all 23, with Pythonic adaptations noted)

- **Phase 7** – Mastery project + open source contributions

**Primary books used:**

- Fluent Python (2nd Ed.) — Ramalho

- Python OOP (4th Ed.) — Lott & Phillips

- Effective Python (3rd Ed.) — Slatkin

- Clean Code in Python — Anaya

- Head First Design Patterns — Freeman & Robson

- Python Testing with pytest — Okken

**My goals with this plan:**

1. Become genuinely expert-level in Python
2. Be able to implement OOP as an expert
3. Apply SOLID principles fluently
4. Have a strong grasp of GoF design patterns

I've attached the full plan as a PDF — it includes a detailed weekly breakdown, book shopping list, practice platforms, and a sample weekly schedule.

Python_Mastery_Plan_v2

I'd love to hear from this community:

- Is there anything important that's missing?

- Any topics you'd add, remove, or restructure?

- Any book or resource recommendations I may have overlooked?

- Does the phase ordering make sense for a depth-first learner?

All feedback — big or small — is genuinely appreciated. Thanks in advance! 🙏

Hey r/PythonLearning 👋

I've been working on a structured, depth-first learning plan to go from basic Python knowledge to genuine expertise — covering core language features, OOP, SOLID principles, and the Gang of Four design patterns.

The plan is built around books and free resources (no paid course dependency), with project deliverables at every phase to make sure the learning actually sticks.

**A quick note on how this was made:** I used AI (Claude) to help research, structure, and refine this plan. I've reviewed everything carefully and believe the content is solid, but that's exactly why I'm posting here — I'd love expert human eyes on it to catch anything the AI and I may have missed or got wrong.

**Here's a quick overview of the 8 phases:**

- **Phase 0** – Foundation audit + professional tooling setup (venv, ruff, black, mypy, pytest)

- **Phase 1** – Core language deep dive (data model, sequences, functions, type hints)

- **Phase 2** – Advanced features + testing (decorators, generators, async, pytest)

- **Phase 3** – Python internals + typing system (CPython, GIL, Protocols, dataclasses, debugging)

- **Phase 4** – OOP mastery (inheritance, composition, descriptors, metaclasses, ABCs)

- **Phase 5** – SOLID principles (one week per principle, applied in Python)

- **Phase 6** – Gang of Four design patterns (all 23, with Pythonic adaptations noted)

- **Phase 7** – Mastery project + open source contributions

**Primary books used:**

- Fluent Python (2nd Ed.) — Ramalho

- Python OOP (4th Ed.) — Lott & Phillips

- Effective Python (3rd Ed.) — Slatkin

- Clean Code in Python — Anaya

- Head First Design Patterns — Freeman & Robson

- Python Testing with pytest — Okken

**My goals with this plan:**

1. Become genuinely expert-level in Python
2. Be able to implement OOP as an expert
3. Apply SOLID principles fluently
4. Have a strong grasp of GoF design patterns

I've attached the full plan as a PDF — it includes a detailed weekly breakdown, book shopping list, practice platforms, and a sample weekly schedule.

Python_Mastery_Plan_v2

I'd love to hear from this community:

- Is there anything important that's missing?

- Any topics you'd add, remove, or restructure?

- Any book or resource recommendations I may have overlooked?

- Does the phase ordering make sense for a depth-first learner?

All feedback — big or small — is genuinely appreciated. Thanks in advance! 🙏

Hi r/learnmachinelearning,

When I first started learning neural networks, I struggled to truly understand backpropagation — most tutorials show the code but skip over the actual math. So I sat down with pen and paper and worked through the chain rule for a 4-layer network step by step, from forward propagation all the way to gradient descent.

I published these notes on Kaggle a couple of years ago and just rediscovered them while reviewing my work as I transition from software testing into AI/ML development. Sharing them here in case they help anyone trying to build a real intuition for what's happening under the hood.

What's covered:

• Forward propagation for a 4-layer network with the W_{To,From}^{Layer} notation

• General matrix form of forward propagation

• Loss function derivation (MSE)

• Backpropagation chain rule, layer by layer (Layer 4 → 3 → 2 → 1)

• Definition of the error term δ at each layer

• A worked gradient descent example with f(x) = (x−1)² showing how the algorithm converges to the minimum

📖 Kaggle notebook: https://www.kaggle.com/code/tusharkhoche/mathematics-of-a-simple-neural-network

These are handwritten notes (photographed and pasted into the document) — not LaTeX. I deliberately kept them handwritten because that's how I learned it, and I find handwritten math easier to follow when you're trying to understand a derivation.

What I'd genuinely love feedback on:

• Did I get the chain rule decomposition right at every step?

• Is there a cleaner way to introduce the δ (error term) notation for someone learning this for the first time?

• Anything I missed that would help a beginner?

I'm still learning and would deeply appreciate corrections or improvements from people who teach or understand this material well. Thanks! 🙏

Hi r/learnmachinelearning,

When I first started learning neural networks, I struggled to truly understand backpropagation — most tutorials show the code but skip over the actual math. So I sat down with pen and paper and worked through the chain rule for a 4-layer network step by step, from forward propagation all the way to gradient descent.

I published these notes on Kaggle a couple of years ago and just rediscovered them while reviewing my work as I transition from software testing into AI/ML development. Sharing them here in case they help anyone trying to build a real intuition for what's happening under the hood.

What's covered:

• Forward propagation for a 4-layer network with the W_{To,From}^{Layer} notation

• General matrix form of forward propagation

• Loss function derivation (MSE)

• Backpropagation chain rule, layer by layer (Layer 4 → 3 → 2 → 1)

• Definition of the error term δ at each layer

• A worked gradient descent example with f(x) = (x−1)² showing how the algorithm converges to the minimum

📖 Kaggle notebook: https://www.kaggle.com/code/tusharkhoche/mathematics-of-a-simple-neural-network

These are handwritten notes (photographed and pasted into the document) — not LaTeX. I deliberately kept them handwritten because that's how I learned it, and I find handwritten math easier to follow when you're trying to understand a derivation.

What I'd genuinely love feedback on:

• Did I get the chain rule decomposition right at every step?

• Is there a cleaner way to introduce the δ (error term) notation for someone learning this for the first time?

• Anything I missed that would help a beginner?

I'm still learning and would deeply appreciate corrections or improvements from people who teach or understand this material well. Thanks! 🙏

Hey r/langgraph,

I'm a software testing professional transitioning into AI development and I just finished my most ambitious project yet — a production-grade agentic research agent. Sharing it here for feedback from the community.

🔗 Live demo: https://tushark2111-focused-research-agent.hf.space
📦 GitHub: https://github.com/tusharkhoche/focused-research-agent

What it does:
Given any research question, the agent runs a full pipeline:
Scope clarification → Query planning (3–6 queries) → Web search (Tavily) → Source ranking → Answer synthesis with citations → Structured result

Three modes:
• Quick Research — concise sourced answer in ~15 seconds
• Conversational Chat — multi-turn research with SQLite-persisted memory
• Full Report — structured 4-section report with images from web search

Architecture (6 layers, each with one responsibility):
→ Streamlit UI — thin HTTP client, no business logic
→ FastAPI — versioned routing, dependency injection, centralized exception handling
→ Application layer — research, chat, and report use cases
→ LangGraph — directed graph with state-based error routing
→ Services — Groq/Ollama LLM + Tavily search provider abstraction
→ SQLite — conversation and report persistence via Repository Pattern

⚙️ Key technical decisions:

1. Function-based nodes, class-based providers
2. Graph nodes are pure stateless functions. Providers (Groq, Tavily) are classes that hold client state. Applied consistently across the entire codebase.
3. State-based error routing
4. Nodes record errors in state instead of raising exceptions. A conditional edge after each node routes to handle_error if errors exist. The graph always terminates cleanly.
5. Provider abstraction via interfaces
6. LLMProvider and SearchProvider are abstract base classes. Swapping Groq for Ollama requires one environment variable change and zero application code changes.
7. Repository Pattern
8. Only repository.py touches SQLAlchemy. Switching from SQLite to PostgreSQL is one line in .env.
9. Shared validation
10. One validate_and_clean_question function used by both Pydantic schemas (AfterValidator) and application layer use cases.

LangGraph design decisions:
• Nodes never raise exceptions — errors recorded in shared state, graph always terminates cleanly
• Conditional error routing after every node → handle_error terminal node

Testing:
175 tests across 8 strategies — unit, smoke, graph error paths, provider, API, database, use case, and UI HTTP client. SonarCloud quality gate in CI.

Stack: LangGraph · LangChain · FastAPI · Streamlit · Groq · Tavily · SQLAlchemy · Docker · pytest · SonarCloud · uv

Happy to answer any questions about the architecture, LangGraph design patterns, or the testing approach. Feedback welcome! 🙏

Hi r/careeradvice,

I've spent 15+ years in software testing / QA automation and I'm now making a serious transition into AI/ML development. Instead of just asking "how do I break in," I decided to build my way in. Sharing my latest project here and would genuinely love feedback — especially from anyone who hires for AI/ML roles.

The project: Focused Research Agent

A full-stack agentic AI research system, live-deployed on HuggingFace.

🔗 Live demo: https://tushark2111-focused-research-agent.hf.space

📦 GitHub: https://github.com/tusharkhoche/focused-research-agent

Given any research question, the agent plans search queries, searches the web via Tavily, ranks sources, and synthesizes a cited answer. Three modes: Quick Research, Conversational Chat with memory, and Full Report with images.

What I built it with:

LangGraph · FastAPI · Streamlit · Groq (Llama 3.3 70B) · Tavily · SQLite · Docker · pytest · SonarCloud

My background for context:

• 15+ years: Lead QA Engineer / Automation (Java, Selenium, CI/CD)

• PGP in AI & ML — Great Lakes × UT Austin McCombs (2021)

• IEEE-published paper in Computer Vision

• Previous projects: RAG application (LangChain + ChromaDB) and a LangGraph journaling agent

My honest question for this community:

Does a portfolio like this — a live deployed system, 175 tests, clean architecture, real tech stack — actually move the needle when transitioning from QA into AI/ML roles? Or do hiring managers still default to requiring a CS degree or formal master's?

I'm not looking for validation — I want honest feedback on whether this is enough to start applying seriously, or what's still missing. Thank you!

Hey r/MachineLearning,

I'm a software testing professional transitioning into AI development and I just finished my most ambitious project yet — a production-grade agentic research agent. Sharing it here for feedback from the community.

🔗 Live demo: https://tushark2111-focused-research-agent.hf.space
📦 GitHub: https://github.com/tusharkhoche/focused-research-agent

What it does:
Given any research question, the agent runs a full pipeline:
Scope clarification → Query planning (3–6 queries) → Web search (Tavily) → Source ranking → Answer synthesis with citations → Structured result

Three modes:
• Quick Research — concise sourced answer in ~15 seconds
• Conversational Chat — multi-turn research with SQLite-persisted memory
• Full Report — structured 4-section report with images from web search

Architecture (6 layers, each with one responsibility):
• Streamlit UI → FastAPI REST API → Application layer → LangGraph graph → LLM/Search providers → SQLite/PostgreSQL

LangGraph design decisions:
• Nodes never raise exceptions — errors recorded in shared state, graph always terminates cleanly
• Conditional error routing after every node → handle_error terminal node
• Provider abstraction: swap between Groq (Llama 3.3 70B), Ollama Cloud, or Ollama Local with one env variable change — zero code changes

Testing:
175 tests across 8 strategies — unit, smoke, graph error paths, provider, API, database, use case, and UI HTTP client. SonarCloud quality gate in CI.

Stack: LangGraph · LangChain · FastAPI · Streamlit · Groq · Tavily · SQLAlchemy · Docker · pytest · SonarCloud · uv

Happy to answer any questions about the architecture, LangGraph design patterns, or the testing approach. Feedback welcome! 🙏