With the books from 10-01 and the courses from 10-02 you have content for years. What no material provides is what accelerates learning most: other people. Someone who already ran into your scikit-learn error and solved it; someone who reviews your notebook and points out a data leak you could not see; someone who shares a paper that changes how you frame a problem; someone whom you, in a few months, will help. This lesson explains why to take part in communities, how to ask well (the most profitable skill a junior can have, with a worked example of a bad question against a good one), which communities exist and what each is for (questions and answers, competitions and data, open source, aggregators, chats, newsletters and blogs, events, Spanish-language communities), which rules of etiquette and security must be respected (never share customer data or keys: this ties in with the GDPR from 02-03), how to contribute even as a beginner, and ends with a summary table and how NovaMarket would use communities without exposing anything.

As throughout this module: we cite only real, well-established communities, by name; platforms change their rules, their activity and even their existence, so check their status before devoting time to them.

1. Why take part: learning, getting unstuck, professional network and staying current
2. How to ask well: the minimal reproducible example
3. Question-and-answer communities
4. Competition and data platforms
5. Open source: GitHub and the Hugging Face Hub
6. Aggregators, discussion, chats and project forums
7. Reference newsletters and blogs
8. Events: meetups, PyData and academic conferences
9. Spanish-language communities
10. Netiquette, security and how to contribute
11. Summary table and how it lands at NovaMarket
12. Common Mistakes and Tips
13. Exercises
14. Conclusion

Four reasons, from the most immediate to the most lasting:

• Getting unstuck. An installation error, a cryptic PyTorch exception, a pipeline that gives a suspicious AUC of 0.99 (data leakage, for sure): someone has seen it before. Searching well and, if nothing turns up, asking well saves days.
• Learning from how others do it. Reading the top-rated notebooks of a competition, the accepted answers on a forum or the discussions in an issue teaches judgement: what counts as good practice and why.
• Professional network. Meetups and open contributions are the most natural way to become known for what you do, not for your CV. Many first opportunities come from there.
• Staying current without being overwhelmed. A well-chosen weekly newsletter and an active community filter the noise better than any search.

And one more reason, in the opposite direction: teaching is the best way to learn. Answering a simple question forces you to understand it properly.

Almost all question-and-answer communities share a set of rules that Stack Overflow sums up in its "How to ask" guide. The central idea is the minimal reproducible example (MRE): the smallest fragment of code, with the minimum data, that reproduces the problem on someone else's machine.

Elements of a good question:

1. A specific title with the library and the symptom ("ValueError in scikit-learn Pipeline.fit with OneHotEncoder and new columns in test").
2. What you are trying to achieve, in one or two sentences, without the whole back-story.
3. Minimal code that can be run as is: imports, toy data generated in the code itself (never your real data), the lines that fail.
4. The complete error (the whole traceback, not just the last line) or the result obtained against the one expected.
5. Versions (Python, library, system) and what you have already tried and what happened.
6. Before posting: search (it has probably been answered), reduce the example until removing one more line makes the error disappear, and reread it as if you were the one answering.

Bad question:

Title: "scikit-learn doesn't work, urgent help"

Hi, I have a fraud model for my company and when I run it with this month's data I get an error saying the columns don't match. I'm attaching the orders CSV (2 MB). Does anyone know what's going on? I need it for tomorrow.

Problems: empty title, no code, no complete error, no versions, and it attaches real company data (a possible breach of the GDPR and of internal policy). Nobody can help, and on top of that it creates a risk.

Good question:

Title: "ValueError: columns are missing when calling predict with a fitted ColumnTransformer, after dropping a column from the input DataFrame (scikit-learn 1.4)"

I have a Pipeline with ColumnTransformer + LogisticRegression trained on the columns ["amount", "country", "n_previous_orders"]. At inference time, the new DataFrame no longer includes n_previous_orders and predict fails. I want to know whether there is a recommended way to tolerate missing columns (filling them in) without retraining, or whether the right thing is to guarantee the schema beforehand.

Minimal reproducible example:

import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder, StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline

X = pd.DataFrame({"amount": [10.0, 200.0, 35.0, 500.0],
                  "country": ["ES", "FR", "ES", "PT"],
                  "n_previous_orders": [3, 0, 12, 1]})
y = [0, 1, 0, 1]
pre = ColumnTransformer([("num", StandardScaler(), ["amount", "n_previous_orders"]),
                         ("cat", OneHotEncoder(handle_unknown="ignore"), ["country"])])
model = Pipeline([("pre", pre), ("clf", LogisticRegression())]).fit(X, y)

X_new = X.drop(columns=["n_previous_orders"])
model.predict(X_new)   # ValueError: columns are missing: {'n_previous_orders'}

Full traceback: (pasted in full).

Versions: Python 3.11, scikit-learn 1.4, pandas 2.2, Linux.

I have tried X_new["n_previous_orders"] = 0 before predict and it works, but I am worried that a zero distorts the StandardScaler; I have also looked at the ColumnTransformer documentation and I cannot see an option for missing columns. What is the recommended practice?

Notice: a title with symptom and context, a clear goal, toy data generated in the code (there is no real customer anywhere), the error, versions, what was tried and a specific question. It is the kind of question that gets answered in minutes and that, moreover, helps the next people who search for that error.

Rule of thumb: if the problem is "this code fails", Stack Overflow; if it is "I don't know whether this is set up properly", Cross Validated or Data Science SE.

Kaggle (kaggle.com) is at once a competition platform, a repository of datasets, a free notebook environment with limited GPU (check the current conditions), micro-courses (10-02) and forums: every competition and every dataset has its discussion, where participants explain approaches, mistakes and tricks. How to make the most of it as a junior:

• Start with Titanic or House Prices (10-02) and, above all, read the most-voted notebooks and the discussions: it is a free masterclass in feature engineering and validation.
• Publish your own notebook, however modest, with a clear explanation; the comments you receive are worth more than the score.
• The public datasets let you practise the NovaMarket cases with "real" data (retail sales, reviews, time series) without using internal data.
• Beware the reflex of "optimising the leaderboard": in real work the metric is the business one (08-01), not that of a public table.

GitHub is not just where you keep your novamarket_ai/ repository (07-04); it is the largest technical community:

• Issues on scikit-learn, pandas, PyTorch: when something looks like a bug, search the open and closed issues first; very often it is explained there, with a workaround.
• Discussions (on the repositories that enable them) for usage questions, more informal than an issue.
• Contributing: you do not have to start with code. Fixing a typo in the documentation, adding an example, improving an error message or reporting a bug with an MRE are real, valued contributions. Large projects tag tasks for beginners (look for labels along the lines of "good first issue"). Always read the project's contribution guide (CONTRIBUTING.md).

Hugging Face Hub (huggingface.co) is the "GitHub of models": shared models, datasets and demos (Spaces), each with its model card (the same idea as in 08-01; in fact its template is inspired by the Mitchell et al. paper from 10-01). Its forums (discuss.huggingface.co) and the discussions on each model are the place for questions about transformers, fine-tuning and deployment. For NovaMarket it is where Marta would look for a pre-trained English sentiment model for the reviews and read its model card before using it.

• Reddit: r/MachineLearning (research, paper discussion, announcements; high level, useful for reading, not for basic questions) and r/learnmachinelearning (beginners' questions, resources, projects; a good place to ask for guidance on learning paths). There are also communities per tool (Python, data).
• Hacker News (news.ycombinator.com): a general technology aggregator with a lot of AI; interesting for the comments from professionals, with a critical spirit. Use it for the pulse of the sector, not as your only source.
• Community Discords and Slacks: many projects and courses have their own chat, with their own activity and rules: fast.ai's (linked to its forum and course), Hugging Face's (very active in NLP and open models), and the PyTorch Forums (discuss.pytorch.org), a classic forum where the PyTorch team itself answers technical doubts. Availability and chat invitations change; check each project's official website.

Chats are immediate but ephemeral; forums and Stack Overflow stay indexed and help the next people. Prefer the forum for questions that others could reuse.

• The Batch (DeepLearning.AI): a weekly newsletter with news commented by Andrew Ng, accessible and with judgement. Ideal for someone in Diego's position.
• Distill (distill.pub): an online journal of visual, interactive explanations of deep learning; it has been on pause for some time, but its articles remain a model of how to explain (attention, feature visualization, momentum).
• The research blogs of the big labs (Google/DeepMind, Meta AI, OpenAI, Anthropic, Microsoft Research, among others): first-hand announcements and explanations; read them with the caveat that they are also corporate communication.
• Towards Data Science and similar platforms for articles by independent authors: there is excellent material and weak material too; apply judgement (does the author show code and data? cite sources? are the results plausible?). Used well, they are good for tutorials on specific cases.
• The personal blogs of leading figures (for example, those of Chollet, Karpathy or Huyen, cited in 10-01 and 10-02) are usually worth more than many aggregators.

• Local meetups on data, Python or AI in your city: short talks, people nearby, free or cheap. It is where the most networking happens; going with a prepared question and a project to talk about (your portfolio from 10-04) multiplies the value.
• PyData (pydata.org): the NumFOCUS foundation's international network of communities and conferences on the Python data ecosystem; there are chapters in many cities, Spanish ones included, with regular events and published videos.
• Academic conferences (NeurIPS, ICML, ICLR, AAAI, and by area ACL or CVPR): they are where the research in the 10-01 table gets published. For a junior they are a reference, not an immediate destination: they help you know what is being researched (the papers and many videos are published openly) and understand where the tools of two years from now come from.

If you also speak Spanish, the Spanish-speaking community is large and active, though more scattered. With the caution of not recommending anything we cannot vouch for:

• PyData and data/AI meetups in Spanish and Latin American cities: there are active chapters and local groups in several cities; search for "PyData" or "AI/data meetup" together with your city and check recent activity.
• Spain AI and similar associations organise talks, working groups and gatherings in Spain; check their website for the current programme.
• Local Python communities (user groups and each country's national Python conferences) usually have data and AI tracks or talks and are very welcoming to beginners.
• Many Spanish speakers also take part in the international communities of the previous sections; the shared technical language is English, and asking in English multiplies who can help you, even if it is not perfect.

The criterion for any community, in Spanish or not: recent activity, a published code of conduct and helpful answers to newcomers' questions.

Netiquette (rules of good conduct):

• Search before asking; say thank you and mark the answer that solved it; report back on what worked (it helps the next people).
• Be specific and polite; do not demand urgency ("for tomorrow"); do not post the same question in five places at once.
• Respect each community's code of conduct; almost all have one.

Security and confidentiality, the most important thing for anyone working at a company like NovaMarket:

• Never share customer data (not one row, not "anonymised by hand"): names, emails, addresses, real orders. The GDPR and your company's policy forbid it (remember 02-03); a question on a forum is public and permanent. Generate synthetic data that reproduces the problem, as in the good question of section 2 or as you did with incidents.csv in 09-04.
• Never paste keys, tokens, passwords or internal URLs into questions, public notebooks or repositories (07-04: environment variables and .gitignore). If one slips out, revoke it immediately.
• Do not describe confidential business details (fraud thresholds, margins, suppliers) beyond what the technical question needs.
• Before uploading a notebook to Kaggle or GitHub, review cell outputs and attached files: that is where data leaks out unintentionally most often.

How to contribute even as a beginner: answer easy questions, fix documentation, add an example to a gallery, report bugs with an MRE, translate materials, give a short talk at a meetup about a project of your own. Every one of these is visible and counts as experience.

NovaMarket without exposing data. Marta would set a three-line team rule: (1) every public question is asked with synthetic data generated in the code itself (they already have the generators for orders_nm.csv and incidents.csv); (2) no notebook leaves the repository without reviewing outputs and passing through the .gitignore from 07-04; (3) service keys (the case 7 LLM when it is built) live in environment variables and never in questions or examples. With that, the team would use Stack Overflow for pipeline errors, the Hugging Face forum to choose a pre-trained English sentiment model for the reviews, Kaggle to practise with public retail data, and a local meetup to explain (without confidential figures) how they deployed the predictor in batches with queues and a model card, which also attracts talent. Diego, for his part, would subscribe to The Batch and go along with Marta to the meetup: it is the cheapest way for operations to understand what is being done in the sector.

• Asking without searching and without a reproducible example: the question gets closed or ignored, and you learn that "the community is hostile" when the problem was the question.
• Pasting real data or keys "just a little bit": that is a breach, not a shortcut. Synthetic data always.
• Multiplying channels: five Discords, three newsletters, two subreddits. Choose one question channel, one newsletter and one regular event.
• Reading without taking part for years. Answering one easy question a month changes your relationship with the community and your confidence.
• Taking the most-voted answer as truth without checking it against your version; libraries change.
• Tip: when you solve something that cost you effort, write the answer up (on the forum, on your blog or in the notes of your repository): it is contribution, portfolio and memory all at once.

1. Write a good question. Take a real error you had during the course (for example, a dimension error in the 09-03 network or a pandas KeyError in 07-02) and write it up following section 2: title, goal, MRE with toy data, error, versions, what you tried.
2. Choose communities. Using the table in section 11, choose one question channel, one newsletter and one regular event for the next six months, and justify each choice in two lines according to your path.
3. Security review. Imagine you are going to publish the NovaMarket returns predictor notebook on Kaggle. Write a six-point checklist you would go through before pressing "publish".

1. Example: Title: "RuntimeError: mat1 and mat2 shapes cannot be multiplied in nn.Linear after nn.EmbeddingBag (PyTorch 2.x)". Goal: classify reviews with EmbeddingBag followed by a linear layer. MRE: a 10-word vocabulary, EmbeddingBag(10, 8), Linear(16, 2) (here is the error: the embedding output has dimension 8, not 16), a toy batch of indices and the call to the model. Error: full traceback. Versions: Python 3.11, PyTorch 2.x, CPU. Tried: changing the batch size (no effect). Question: how to derive the input dimension of the linear layer from the embedding.
2. Example (ML/MLOps path): Questions: Stack Overflow (scikit-learn and deployment errors). Newsletter: The Batch (weekly, good judgement, little time). Event: my city's PyData (talks on data in production, local network).
3. Example: (1) Is all the data synthetic or public? (2) Have I reviewed the outputs of every cell in case they show real rows? (3) Are there internal paths, server names or company URLs? (4) Are there keys or tokens in the code or the configuration? (5) Are the thresholds, business figures or supplier names necessary, or can I replace them with example values? (6) Has someone else on the team reviewed it?

You have seen why to take part in communities (getting unstuck, learning from others, network, staying current, and teaching), how to ask well with a minimal reproducible example (and the difference between the bad question with a real CSV attached and the good one with toy data, error, versions and a specific doubt), which community serves which purpose (Stack Overflow, Cross Validated and Data Science SE; Kaggle; GitHub and the Hugging Face Hub; Reddit and Hacker News; Discord/Slack and the PyTorch Forums; The Batch, Distill and blogs; meetups, PyData and the conferences as a reference; Spanish-language communities with caution), which rules of conduct and security are non-negotiable (GDPR, synthetic data, keys kept out) and how to contribute from day one. You now have content (10-01, 10-02) and people (10-03). The last thing is missing: where to go. In the final lesson of the course (10-04) you will do a self-assessment of what you have learned, see the map of AI professional profiles and four detailed learning paths with resources, a portfolio project and milestones, and the next steps of Marta and Diego at NovaMarket, before closing the course with a recap of the ten modules.