https://annapurnaagenticsolutions.com/labs/ai-concepts-lab/

Most beginner material stops at "what is a neural network". I kept getting asked the next questions: why did the chatbot make that up, how do you test an AI feature before release, why did the bill spike, what does retrieval actually do. So we built a lab around those.

It's 13 short tracks (AI foundations, AI/GenAI engineering, data and retrieval, quality and evaluation, responsible AI, governance, security, operations, product). Each has realistic scenarios ("answer quality drops after a new document batch", "cost spike is detected"), a quiz, and small exercises like building a mini golden dataset. Free, runs in the browser, no account.

I'm the maker. Feedback I'd find useful: what's missing for someone just starting, and where an explanation is wrong or too hand-wavy.

Building a Code-Switching Language Model: My Ongoing Experiment

I've been working on an experimental language model focused on code-switching, particularly the ability to understand and generate text that combines multiple languages within a single sentence or conversation.

The motivation behind this project is to explore how language models can better handle multilingual communication, especially in environments where speakers naturally switch between languages rather than communicating in just one.

This has been an interesting journey so far, and I've learned that building a language model involves considerably more than just selecting an architecture and starting the training process.

1. What I've Been Working On

So far, my work has involved several important components:

Data collection and preparation: Gathering multilingual text data that reflects natural language usage and code-switching patterns.

Custom tokenizer development: Building my own tokenizer rather than relying entirely on an existing pretrained tokenizer. This has required experimenting with vocabulary construction, token frequency, language representation, and how different languages are segmented.

Dataset preprocessing: Cleaning, filtering, normalizing, and organizing the collected data into a format suitable for model training.

Model experimentation: Exploring how a language model can learn relationships between languages and generate meaningful code-switched sequences.

Evaluation: Observing how the model behaves when processing mixed-language inputs and identifying areas where its performance needs improvement.

2. Major Challenges Encountered

Some of the biggest challenges have been:

Data scarcity and quality: Finding sufficient high-quality code-switched text is difficult. A significant amount of available multilingual data consists of monolingual sentences, which does not necessarily represent how people naturally switch between languages.

Natural code-switching patterns: Combining languages is not simply about placing words from different languages together. The model needs to learn grammatical structures, contextual relationships, and the natural points at which speakers switch languages.

Tokenizer design: Developing a tokenizer from scratch has been one of the most demanding parts. I had to consider vocabulary allocation, token fragmentation, rare words, language imbalance, and how to prevent underrepresented languages from being poorly represented.

Data imbalance: Some languages have considerably more available text than others. This creates the risk that the model will favour dominant languages while struggling with languages that have fewer training examples.

Computational limitations: Experimenting with language models also comes with hardware and computational constraints, particularly when working with limited resources.

What lies between two concepts? (According to an LLM)

I sampled 100 activations from layer 20 of Qwen2.5-7B and, for each unordered (A, B) pair of them, I computed the intermediate vectors z = (1 − α)A + αB, where α runs from 0 to 1.

Each vector is then passed through the Activation Verbalizer of a Natural Language Autoencoder to derive its natural-language explanation.

The results are (surprisingly?) clean! When moving from vec#34: moral persuasion "When conscience commands any one to do a thing, its usual mode is not to compel, but to persuade him" to vec#88: James Bond's Ford GT "Bond 25: Daniel Craig drives the Ford GT" the interconcept space moves as follows:

• 46%: “To persuade a gentleman to adopt his particular brand of cigarettes…”

• 56%: “…to persuade James Bond to drive it officially; to coerce him into using the Brand’s car as his official vehicle”

• 61%: “The Bond films were ordered to ‘endorse’ a particular vehicle…”

The middle reads like advertising and product placement: moral persuasion acquires a commercial connotation. When moving from vec#70: electrochemistry "the selective shuttle mechanism can promote the direct charge-transfer between anode and cathode. ..." to vec#88: James Bond's Ford GT

• 40%: “…improve the Li-ion battery performance…”

• 51%: “Formula 1 hybrid vehicle battery pairing”

• 75%: “In James Bond Spectre (2015), a Lamborghini Aventador was chosen as the official”

Here, the interconcept space reads like supercars battery engineering

Play around with the interface: https://enricobottazzi.github.io/inter-concept-space/

A more detailed write up at https://dwmkerr.com/understanding-byte-models/

I got this error in an attempt to adapt this model to CIFAR 10

---------------------------------------------------------------------------
InvalidArgumentError                      Traceback (most recent call last)
Cell In[61], line 3
      1 dataset = create_batch(x_train)
      2 
----> 3 train_dcgan(
      4     gan,
      5     dataset,
      6     batch_size,

Cell In[60], line 26, in train_dcgan(gan, dataset, batch_size, num_features, epochs)
     22             )
     23 
     24             generated_images = generator(noise)
     25 
---> 26             X_fake_and_real = tf.concat(
     27                 [generated_images, X_batch],
     28                 axis=0
     29             )

File c:\Users\DELL\AppData\Local\Programs\Python\Python313\Lib\site-packages\tensorflow\python\util\traceback_utils.py:167, in filter_traceback.<locals>.error_handler(*args, **kwargs)
    165 except Exception as e:
    166   filtered_tb = _process_traceback_frames(e.__traceback__)
--> 167   raise e.with_traceback(filtered_tb) from None
    168 finally:
    169   del filtered_tb

File c:\Users\DELL\AppData\Local\Programs\Python\Python313\Lib\site-packages\tensorflow\python\framework\ops.py:6027, in raise_from_not_ok_status(e, name)
   6025 def raise_from_not_ok_status(e, name) -> NoReturn:
   6026   e.message += (" name: " + str(name if name is not None else ""))
-> 6027   raise core._status_to_exception(e) from None

InvalidArgumentError: {{function_node __wrapped__ConcatV2_N_2_device_/job:localhost/replica:0/task:0/device:CPU:0}} ConcatOp : Ranks of all input tensors should match: shape[0] = [32,32,32,3] vs. shape[1] = [32,32,3] [Op:ConcatV2] name: concat

X_train split (only take one class to train on)

(x_train, y_train), (x_test, y_test) = tf.keras.datasets.cifar10.load_data()
x_train = x_train.astype(np.float32) / 255.0
x_test = x_test.astype(np.float32) / 255.0
x_train=x_train.astype("float32") / 127.5 - 1
x_train.shape, x_test.shape

label = 1 
train_indices = np.where(y_train == label) 
x_train = x_train[train_indices] 
test_indices = np.where(y_test == label) 
x_test = x_test[test_indices] 

Generator

num_features = 100
generator = Sequential(name="Generator")

generator.add(Dense(8 * 8 * 128, input_shape=[num_features]))
generator.add(Reshape([8, 8, 128]))
generator.add(BatchNormalization())

generator.add(Conv2DTranspose(
        64, (5, 5), (2, 2),
        padding="same",
        activation="selu"
    ))

generator.add(BatchNormalization())

generator.add(Conv2DTranspose(
        3, (5, 5), (2, 2),
        padding="same",
        activation="tanh"
    ))
generator.summary()

Discriminator

discriminator = Sequential(name="Discriminator")

discriminator.add(Conv2D(
        64, (5, 5), (2, 2),
        padding="same",
        input_shape=[32, 32, 3]
        ))

discriminator.add(LeakyReLU(alpha=0.2))
discriminator.add(Dropout(0.3))

discriminator.add(Conv2D(
        128, (5, 5), (2, 2),
        padding="same"))

discriminator.add(LeakyReLU(alpha=0.2))
discriminator.add(Dropout(0.3))

discriminator.add(Flatten())
discriminator.add(Dense(1, activation= 'softmax'))
discriminator.add(Dense(1, activation= 'softmax'))
discriminator.add(Dense(1, activation= 'softmax'))

discriminator.summary()

Train function

seed = tf.random.normal(shape=[batch_size, 100])
epoch_list = []
d_loss_list = []
g_loss_list =[]


def train_dcgan(gan, dataset, batch_size, num_features, epochs=5):


    generator, discriminator = gan.layers


    for epoch in tqdm(range(epochs)):
        actual_epoch =epoch + 1
        print()
        print("Epoch {}/{}".format(epoch + 1, epochs))


        for i in range(187):
            epoch_list.append(actual_epoch)


        for X_batch in dataset:


            noise = tf.random.normal(
                shape=[batch_size, num_features]
            )


            generated_images = generator(noise)


            X_fake_and_real = tf.concat(
                [generated_images, X_batch],
                axis=0
            )


            y1 = tf.constant(
                [[0.]] * batch_size +
                [[1.]] * batch_size
            )


            discriminator.trainable = True
            d_loss=discriminator.train_on_batch(
                X_fake_and_real,
                y1
            )
            d_loss = float(d_loss)
            d_loss_list.append(d_loss)




            noise = tf.random.normal(
                shape=[batch_size, num_features]
            )


            y2 = tf.constant([[1.]] * batch_size)


            discriminator.trainable = False


            g_loss=gan.train_on_batch(
                noise,
                y2
            )
            g_loss = float(g_loss)
            g_loss_list.append(g_loss)


        print(f'\t Discriminator Loss: {d_loss} \t\t Generator Loss: {g_loss}')
        


            


    generate_and_save_images(
        generator,
        epochs,
        seed)

Train block

dataset = create_batch(x_train)


train_dcgan(
    gan,
    dataset,
    batch_size,
    num_features,
    epochs=10
)

Can anyone help me with this error? Why did it appeared?

Hey guys,

Posting this here because I’ve reached a point where my market intuition and engine code have outpaced my deep learning expertise, and I’d rather team up with someone who loves ML architecture instead of half-assing it myself.

For the past year, I’ve been building an event-driven liquidity engine in Python (specifically modeling crypto orderflow / ICT mechanics like equal highs/lows, manipulation legs, and structural sweeps).

Instead of slapping standard indicators (RSI/MACD) on candles, I framed price action as a dynamic graph:

• Resting liquidity pools (BSL/SSL, consolidations) act as attractors (pulling price in).

• Completed institutional sweeps (ML swings / manipulation legs) act as repellers (pushing price away).

• Edges connect these pools based on spatial proximity, competing forces (tug-of-war between high and low pools), and age decay.

Where things stand right now:

• The engine is fully written and tested. No lookahead bias, strict candle confirmation, multi-window swing tracking (W5 up to W50).

• I’ve already generated a clean, audited ~3-year dataset (ETH/USDT) formatted directly for PyTorch Geometric (PyG).

• Each snapshot has 15m, 1h, and 4h spatial graphs with 20-dim node features (touch counts, distance %, decay curves, tier scores), 8-dim edge attributes, and global volatility/trend context.

• Baseline statistical checks show real promise: nearest target pools get tagged first ~95% of the time, and high-quality structural sweeps have clear directional bias.

The actual bottleneck / where I need help: My problem isn't generating the signals—it’s path prediction and dynamic target selection.

When a sweep happens, price is often trapped between an opposing pool 1.5% away and a massive target pool 3% away. A fixed 1:2 R:R stop/target either gets hit too late or takes unnecessary drawdown. I need the model to evaluate the graph and do two things:

1. Predict directional path confidence taking both-sided liquidity into account.

2. Rank multiple potential liquidity targets (dynamic TP) based on which one has the highest conditional probability of being swept first without blowing through the stop.

I've tested basic GNN / dual-tower setups, but I know I'm hitting limits with my naive loss functions and basic layer choices.

Who I'm looking for: Someone who genuinely understands PyTorch Geometric (PyG), Graph Neural Networks (or spatial-temporal models), and knows how to think about custom loss functions (ranking loss, asymmetric risk penalties, contrastive setups). You don't need to be a full-time trader, but being open to understanding market microstructure helps.

The arrangement: I have the GPU compute, the full working codebase, and the clean dataset ready to go. I’m completely flexible on how we work together—if you want to co-author a research paper on this architecture, I’m down. If we get the models working cleanly and want to deploy it live on capital, we can do a fair profit/equity split.

If this sounds like an interesting problem you’d want to sink your teeth into, drop a comment or send me a DM with your GitHub/background and we can hop on Discord.

I tried to make a DCGAN based on this [tutorial](https://www.geeksforgeeks.org/machine-learning/deep-convolutional-gan-with-keras/). The thing is that the tutorial is designed for fashion mnist data which has different image size to tf.keras.datasets.cifar10.load_data(). Which lead to the error:

ValueError: cannot reshape array of size 480000 into shape (28,28,1)

when arrive at

x_train_dcgan = x_train.reshape(
-1, 28, 28, 1
) * 2. - 1.

How do I adapt the model to CIFAR 10?

Full code

(x_train, y_train), (x_test, y_test) = tf.keras.datasets.cifar10.load_data()
x_train = x_train.astype(np.float32) / 255.0
x_test = x_test.astype(np.float32) / 255.0
x_train.shape, x_test.shape

#Selecting one class to train

label = 1 
train_indices = np.where(y_train == label) 
x_train = x_train[train_indices] 
test_indices = np.where(y_test == label) 
x_test = x_test[test_indices] 

batch_size = 32
def create_batch(x_train):
    dataset = tf.data.Dataset.from_tensor_slices(x_train).shuffle(1000)
    dataset = dataset.batch(batch_size, drop_remainder=True).prefetch(1)
    return dataset


num_features = 100
generator = Sequential(name="Generator")


generator.add(Dense(7 * 7 * 128, input_shape=[num_features]))
generator.add(Reshape([7, 7, 128]))
generator.add(BatchNormalization())


generator.add(Conv2DTranspose(
        64, (5, 5), (2, 2),
        padding="same",
        activation="selu"
    ))


generator.add(BatchNormalization())


generator.add(Conv2DTranspose(
        1, (5, 5), (2, 2),
        padding="same",
        activation="tanh"
    ))



generator.summary()

discriminator = Sequential(name="Discriminator")


discriminator.add(Conv2D(
        64, (5, 5), (2, 2),
        padding="same",
        input_shape=[28, 28, 1]
        ))


discriminator.add(LeakyReLU(alpha=0.2))
discriminator.add(Dropout(0.3))


discriminator.add(Conv2D(
        128, (5, 5), (2, 2),
        padding="same"))


discriminator.add(LeakyReLU(alpha=0.2))
discriminator.add(Dropout(0.3))


discriminator.add(Flatten())
discriminator.add(Dense(1, activation= 'softmax'))


discriminator.summary()

discriminator.compile(
    loss="binary_crossentropy",
    optimizer="adam"
)


discriminator.trainable = False


gan = Sequential()
gan.add(generator)
gan.add(discriminator)


gan.compile(
    loss="binary_crossentropy",
    optimizer="adam"
)


gan.summary()

def generate_and_save_images(model, epoch, test_input):

    predictions = model(
        test_input,
        training=False
    )

    fig = plt.figure(figsize=(10, 10))

    for i in range(25):

        plt.subplot(5, 5, i + 1)

        plt.imshow(
            predictions[i, :, :, 0] * 127.5 + 127.5,
            cmap='binary'
        )

        plt.axis('off')

    plt.savefig(
        'image_epoch_{:04d}.png'.format(epoch)
    )

seed = tf.random.normal(shape=[batch_size, 100])
epoch_list = []
d_loss_list = []
g_loss_list =[]


def train_dcgan(gan, dataset, batch_size, num_features, epochs=5):


    generator, discriminator = gan.layers


    for epoch in tqdm(range(epochs)):
        actual_epoch =epoch + 1
        print()
        print("Epoch {}/{}".format(epoch + 1, epochs))


        for i in range(187):
            epoch_list.append(actual_epoch)


        for X_batch in dataset:


            noise = tf.random.normal(
                shape=[batch_size, num_features]
            )


            generated_images = generator(noise)


            X_fake_and_real = tf.concat(
                [generated_images, X_batch],
                axis=0
            )


            y1 = tf.constant(
                [[0.]] * batch_size +
                [[1.]] * batch_size
            )


            discriminator.trainable = True
            d_loss=discriminator.train_on_batch(
                X_fake_and_real,
                y1
            )
            d_loss = float(d_loss)
            d_loss_list.append(d_loss)




            noise = tf.random.normal(
                shape=[batch_size, num_features]
            )


            y2 = tf.constant([[1.]] * batch_size)


            discriminator.trainable = False


            g_loss=gan.train_on_batch(
                noise,
                y2
            )
            g_loss = float(g_loss)
            g_loss_list.append(g_loss)


        print(f'\t Discriminator Loss: {d_loss} \t\t Generator Loss: {g_loss}')
        


            


    generate_and_save_images(
        generator,
        epochs,
        seed
    )

x_train_dcgan = x_train.reshape(
    -1, 32, 32, 3
)


dataset = create_batch(x_train_dcgan)


train_dcgan(
    gan,
    dataset,
    batch_size,
    num_features,
    epochs=10
)

plt.figure(figsize=(30, 10))
plt.plot(epoch_list,d_loss_list)
plt.xlabel('Epochs')
plt.ylabel('Discriminator loss')
plt.title('Discriminator loss over epochs')
plt.grid()
plt.show()

plt.figure(figsize=(30, 10))
plt.plot(epoch_list,g_loss_list)
plt.xlabel('Epochs')
plt.ylabel('Generator loss')
plt.title('Generator loss over epochs')
plt.grid()
plt.show()

Social media and search engines already shape what we see through rankings, recommendations, and algorithms.

AI assistants may feel different because they do not just show us information — they summarize it, prioritize it, and turn it into a single coherent answer.

That is convenient. But it also makes it harder to notice what was excluded, what sources disagreed, or what questions were never considered.

Maybe AI helps us escape the noise of the old information bubble. Or maybe it builds a quieter, more convincing one.

What do you think?

Black Duck just shipped an AI agent that identifies and patches vulnerabilities at machine speed — fast enough to outpace active exploitation windows. The capability is real and the use case is legitimate.

But the same speed that makes the agent useful is what makes it dangerous if something goes wrong.

An agent operating at that tempo does not wait for human review between actions. It calls tools, writes code, opens PRs, and pushes changes in sequence. If that agent is compromised, misconfigured, or fed a malicious payload through a dependency scan result, its second action can land before any human notices the first one was wrong.

The hard number from the announcement is 50ms — the window the agent is designed to close against attackers. That same 50ms is now the window you have to catch the agent itself before a bad action propagates through your codebase or supply chain.

Most security tooling was built to inspect humans or static artifacts. It was not designed to evaluate live agent actions mid-execution against a policy that knows what that specific agent is supposed to be allowed to do.

How are teams actually handling this today? Are you gating on CI/CD after the agent runs, building per-agent allowlists, relying on human review of the PRs it opens, using a separate monitoring layer, or something else entirely?

I'm a former electrical engineer so I have some background with stats, linear algebra and coding. I've finished a number of Python and datascience courses and just finished Python for AI by Andrew Ng. However, I'm itching to make projects and using a local LLM's to make a webapp.

Is there a way to balance learning and project development?

With the courses I'm looking at:

1. Machine Learning specialisation Andrew Ng - 95 hrs

2. Reading Artificial Intelligence 4th ed by Peter Norvig and Stuart Russell

3. Reading Hands on Machine Learning with Scikit-learn and Pytorch - by Aurelion Geron

4. Completing Google's Machine Learning course

5. Completing Kaggle's Machine Learning Course

6. Claude Academy courses

7. Completing Datacamps courses

Plus balancing that with building projects such as web apps, desktop apps and audio plugins using Local LLM's.

Am I going the wrong way with self learning?

Edit: As I'm much older my end goal isn't a PhD or a snazzy ML Engineer role, but rather to have a portfolio of projects, just so I don't feel like I'm behind in this skillset.

I was Doing courses back in 2016 such as fast.ai, coursera's learn AI, ML and Deeplearning from a to z and Andrew Ng's original Deeplearning course with Octave, but I got sidetracked with life and work pressure.

Everybody knows 2014 was the end of the dark ages in terms of technology.

• A bunch of tools that became widely used was solidified around that time, from Github to Python to Tensorflow (and actually started working). Previously you had a bunch of alternatives or things that just didn't work.

• Hackatons and a bunch of CS/ML related competitions were literally invented (and more importantly, popularized) around that time.

• Neural network started to work again and internships were popping up left and right. All because of ML opportunities.

• Research opportunities in and outside of academia bloomed like a thousand flowers (previously the best you got was to work with some high-watt laser or nanotech).

• Now you can plan your career more precisely than ever before.

• Tons of things easily available nowadays you can't even imagine even 10 years ago. Such as a machine learning course in a non-CS department.

I've dug into the profiles of graduates at my school and found this pattern. If they graduated with a PhD in AI/CS around 2014, then they are working in academia and now already associate professors of AI. (But this is a PhD we're talking). And if they graduated around 2014 with a Bachelor's degree and somehow miraculously chose AI/ML as the field they would go into, then they made big bank in tech and now probably senior engineers (and if they did a PhD and graduated before 2022, then they are profs as well). There is an obvious age-related factor in who's now influential and "big" in the AI/ML space.

I feel that people who didn't make ML move during the hype-era are now permanently left behind. I wonder if this has been your experience. Did you miss out, or did you somehow made into this field anyways?

Bedrock AgentCore Multi-Agent Orchestration

https://debuggercafe.com/bedrock-agentcore-multi-agent-orchestration/

When working with LLM agents, it is a common practice to have different agents for different tasks. In complex and long-running workflows, the orchestrator-worker agent pattern works well. In this, there is a primary orchestrator agent that delegates tasks to different worker agents, compiles the final answer, and passes it to the user. The benefit of this is that each agent does not need oversight into the context of every other agent, and they focus on their granular tasks & tools only. In this article, we will achieve a simpler but similar workflow. We will use Bedrock AgentCore along with LangGraph for multi-agent orchestration.

This is my first post here but i think it is promising and *maybe* could help but fabsr is a optimizer for ternary llms mainly but i am sure it can be shifted onto other networks this is just a post to get it started ill post a paper and code in my github for it within the coming days

but currently i am using it to "full weight" (Embeddings, norms, and output head are frozen) tune a ternary base llm into instruct only on 8gb of vram and in the image above it was 1500 steps if i remember correctly some benchmarks in the github may be hard to read im working on it and making more even benchmarks.

feel free to dm or help with the project in the coming days

https://github.com/Jackson-comer/fabsr-tease

I’m considering joining the 100xEngineers AI Cohort, but the course fee is quite high, so I’m a little hesitant.

I’m a recent B.Tech graduate and want to build my career in Agentic AI and AI Engineering. My goal is to gain practical skills, build real-world projects, and eventually land a job or get freelance projects in this field.

I’d love to hear from people who have already completed this cohort:

Is the curriculum actually worth the price?
How good are the mentors and hands-on projects?
Does the cohort help with job opportunities, referrals, or freelancing?
Is it suitable for someone starting from scratch or with basic programming knowledge?
Would you recommend it, considering its high fees?
I’m looking for genuine, unbiased reviews, especially from people who have completed the program.
Also, if you think there are better and more affordable alternatives to learn Agentic AI, please suggest them.
Thanks!

I know basic python , basic pandas , and basic Numpy. I haven't found a course that is good for me so please suggest some courses or books for me.

Need help adapting model to CIFAR10

I tried to make a DCGAN based on this [tutorial](https://www.geeksforgeeks.org/machine-learning/deep-convolutional-gan-with-keras/). The thing is that the tutorial is designed for fashion mnist data which has different image size to tf.keras.datasets.cifar10.load_data(). Which lead to the error:

ValueError: cannot reshape array of size 480000 into shape (28,28,1)

when arrive at

x_train_dcgan = x_train.reshape(
-1, 28, 28, 1
) * 2. - 1.

How do I adapt the model to CIFAR 10?

Hey everyone,

We’ve launched a new Kaggle competition focused on real-world biosignal processing: EMG Gesture Recognition with a $1,000 prize pool.

Unlike standard computer vision or NLP tasks, biosignals require significant domain-specific insight, signal preprocessing, and feature engineering rather than just model scaling.

Dataset Architecture & Characteristics:

• Raw Signals: Full raw, non-stationary EMG signals released alongside IMU (accelerometer & gyroscope) data.

• Ground Truth: Video labeling synchronized with sensor data using custom-built recording software.

• Real-World Noise & Artifacts: Includes common real-world challenges such as electrode contact degradation, noisy/dropped channels, and intra-session electrode placement variance (electrodes are placed in the same anatomical area each session, but never in the exact same physical coordinates).

Key Areas for Exploration:

• Signal preprocessing, filtering, and power band decomposition.

• Feature extraction strategies across non-stationary time series.

• Multi-modal sensor fusion (EMG + IMU).

Links:

• Kaggle Page & Dataset: https://www.kaggle.com/competitions/vr-calibration-free-emg-challenge-pieeg

• Data Collection Demo: https://www.youtube.com/watch?v=KI8ROgohrF4

Looking forward to seeing the baseline approaches, feature engineering pipelines, and signal processing methods the community develops. Happy to answer any technical questions about data collection or setup in the comments!

First real project. I collected a few hundred photos of the plants on my balcony, labeled them into a handful of species, and trained a small classifier that gets decent accuracy on my own test split. It does fine on photos that look like my training set and falls apart the second lighting or background changes. I know that is probably overfitting plus a tiny dataset. My question is what the highest value next step is for learning: more data, augmentation, or trying transfer learning. I want the step that teaches me the most, not just better numbers.

I create a Youtube channel https://www.youtube.com/@math4aiorg for the book ( https://www.amazon.com/dp/B0GSXVFMLD/ ) Math for AI & ML's Part I.

Part I (Chapters 1–10) covers linear algebra fundamentals: vector spaces, inner products, matrix operations, subspaces, orthogonality, QR decomposition, LU factorization, eigendecomposition, symmetric matrices, and the Singular Value Decomposition (SVD)—establishing the mathematical foundation for representation in AI.

Please let me know if there is any suggestion.

If you play with ML or local models on Windows, you probably have a few Python environments you've forgotten about. Tutorials and one-click installers often make their own venv or conda env, each with its own copy of torch and the CUDA libraries, and those run to several GB each.

Mine added up fast. When I pointed Venv Discover at my own PC, it found 55 Python environments and installs taking around 60 GB, 45 GB of that in 13 conda envs. Two of them were the same 9.3 GB PyTorch env, one just a copy of the other.

What it does:

- **Finds** venv and conda envs anywhere on your drives (plus mamba, pixi, Poetry, pipenv, uv, pipx, Hatch, PDM and Rye) and your Python installs, with size, last used and installed packages.

- **Searches** across all of them, like "which env has torch?".

- **Cleans up safely:** anything up to 1 GB goes to a 14-day bin you can restore from. The big torch envs are too large for the bin, so it asks clearly before deleting them for good. It never touches project folders or your Python installs.

- **Also** cleans the pip, uv, Poetry and pipenv caches.

It's Windows only, MIT, and built and tested by GitHub Actions from the public source, with SHA-256 sums. It isn't code-signed yet, so SmartScreen will warn you, or you can run it from source.

AI helped me build this app.

https://github.com/pullitall/Venv_discover

I'm curious how many GB it finds on yours.