Unveiling corruption and inspiring action—because accountability starts with us!
The Martin Shkreli Report is posted to YouTube today. It’s the first of many (increasingly improving) reports to spread class consciousness and redirecting the anger of the middle and poverty classes.
https://www.youtube.com/watch?v=Od7KkasNTkM
Part 1: Fact-Checking RAGECOGNITO’s Blog Post on Martin Shkreli
SOURCE: Two Boot Clan
Note from RAGECOGNITO: I welcome reports like this. They give me room to improve my content and presentation!
In the growing ecosystem of political commentary and investigative reporting, new voices can either illuminate hidden truths or muddy the waters with misinformation. One such voice is RAGECOGNITO, whose online presence spans a blog and a YouTube channel offering social and political commentary. Our first installment in this series assesses the credibility and depth of RAGECOGNITO’s content, beginning with his blog post titled “Unapologetic: Martin Shkreli.”
The article presents a critical narrative of Martin Shkreli’s controversial tenure in the pharmaceutical industry, focusing on his infamous Daraprim price hike and broader implications. Below, we examine the factual accuracy of the claims and the context provided.
Fact-Based Analysis
The blog post outlines several key aspects of Shkreli’s actions, most of which align with well-documented facts:
Omissions and Contextual Considerations
While the blog post offers a compelling critique of Shkreli, certain nuances are absent:
Assessment of Good Faith
RAGECOGNITO’s self-proclaimed mission, “Unveiling corruption and inspiring action—because accountability starts with us,” suggests a commitment to exposing unethical behavior. The article’s reliance on verifiable facts and its critical stance toward Shkreli indicate a genuine effort to inform and provoke thought. However, the omission of broader industry context and systemic issues raises questions about whether the focus is on sensationalism rather than comprehensive analysis.
Conclusion RAGECOGNITO’s article on Martin Shkreli is factually grounded and aligns with documented events. It effectively critiques Shkreli’s actions but would benefit from a more holistic approach that situates his behavior within the broader pharmaceutical industry and explores systemic regulatory failures. As a new voice in the public sphere, RAGECOGNITO shows promise but must balance critical narratives with contextual depth to earn credibility as a reliable source.
Further Resources
For readers interested in exploring more of RAGECOGNITO’s content, his blog is available at RAGECOGNITO’s Website. He also provides commentary on his YouTube channel. He contributes to a soon-to-open YouTube channel called “Quiet Part Loud.”
This is an ongoing series, so more reports are on the way covering RAGECOGNITO’s worldview, whether he is acting in good faith, and the factual basis of his content.
Martin Shkreli, former pharmaceutical executive, became infamous for drastically raising the price of Daraprim, an antiparasitic drug essential for treating toxoplasmosis. This decision, which increased the price over 5000% from $13.50 to $750 per pill, ignited public outrage and epitomized broader issues in the pharmaceutical industry. It also jeopardized countless vulnerable lives.
The Making of “Pharma Bro”
Born and raised in Brooklyn, New York, in a working-class immigrant family, Shkreli’s origins might suggest a natural empathy for the underprivileged. Instead, his career trajectory reveals someone determined to distance himself from his roots. After graduating from Baruch College with a degree in business administration, Shkreli entered the financial world, earning a reputation for exploiting market inefficiencies with little regard for ethics.
Early in his career, Shkreli founded the hedge fund Elea Capital Management, which folded after a failed bet against Lehman Brothers. He later established MSMB Capital Management, where he began targeting pharmaceutical companies for short-selling. This strategy involved betting against the success of companies by anticipating their stock prices would fall. To achieve this, Shkreli would highlight vulnerabilities in their operations, such as regulatory weaknesses or financial instability, often undermining investor confidence in the process. While legal, such tactics were criticized for destabilizing companies critical to patient care.
In 2011, Shkreli founded Retrophin, a biotechnology firm ostensibly focused on developing treatments for rare diseases. Allegations of fraud and misconduct marred his tenure. He was accused of misappropriating Retrophin funds to repay disgruntled investors, effectively running something similar to a Ponzi scheme. These actions drained resources meant for research and development, leading to lawsuits and his eventual ousting in 2014. His fraudulent tactics ultimately led to lawsuits from Retrophin itself, further tarnishing his reputation. Undeterred, Shkreli launched Turing Pharmaceuticals, through which he orchestrated the Daraprim price hike.
SOURCE: https://ethicsunwrapped.utexas.edu/video/daraprim-price-hike
The Daraprim Debacle: Profit Over People
Shkreli defended his decision to raise Daraprim’s price as a “smart business move”. Although claiming that the increased revenue would fund research and development, little evidence of such initiatives ever materialized. Instead, the decision laid bare the vulnerabilities in America’s healthcare system, where essential drugs can be commodified and weaponized for profit.
For patients with toxoplasmosis—particularly those with compromised immune systems, such as individuals with HIV/AIDS—the price hike was catastrophic. Toxoplasmosis caused 789 deaths in the U.S. from 2000 to 2010, disproportionately affecting immunocompromised patients, including those with HIV/AIDS. Shkreli’s price hike exacerbated barriers to treatment, particularly for Black and Hispanic communities already facing healthcare inequities. The societal cost extended beyond the human toll, with productivity losses exceeding $815 million. By exploiting a life-saving drug for profit, Shkreli exacerbated systemic inequities, disproportionately harming already vulnerable communities.
Toxoplasmosis
His response to public outrage? Smirking defiance during a Congressional hearing, where he invoked his Fifth Amendment rights, followed by mocking detractors on social media.
A Pattern of Disdain
Shkreli’s actions and behavior consistently underscored his detachment from societal norms. His $2 million purchase of the sole copy of Wu-Tang Clan’s album Once Upon a Time in Shaolin became emblematic of his extravagance and disdain for public opinion. When criticized, he threatened to destroy the album, although it was later seized by the government and sold to an anonymous buyer.
Wu-Tang Clan‘s Once Upon A Time in Shaolin album.
Even his legal troubles failed to humble him. Convicted of securities fraud in 2017 and sentenced to seven years in prison, Shkreli referred to his incarceration as “the most relaxed prison experience one could ever have.” Upon his release in 2022, he showed no evidence of regret or reflection. His trajectory exemplifies a harsh reality: steal a dollar, and you’re a criminal; steal a million, and you’re celebrated in certain circles.
The Socio-Economic Disconnect
Shkreli’s story is not an anomaly. It’s a symptom of a broader issue: the growing disconnect between the ultra-wealthy and the working class. Shkreli’s actions reflect a troubling trend in the pharmaceutical industry, where lifesaving drugs are treated as commodities. For example, another pharmaceutical company faced criticism for pricing its Hepatitis C drug at $84,000 for a 12-week course. Shkreli’s actions reflect a worldview in which financial gain is the ultimate metric of success, no matter the human cost.
SOURCE: DALL-E
Pharmaceutical executives frequently justify exorbitant drug prices by citing the high costs of research and development, even as their companies report record profits and award multimillion-dollar bonuses to their executives. For instance, Pfizer reported $81 billion in revenue in 2021, largely driven by its COVID-19 vaccine, while its CEO, Albert Bourla, received $24 million in compensation. Simultaneously, the company faced criticism for price hikes on other essential drugs, highlighting the tension between public health contributions and profit-driven motives. Shkreli’s unapologetic greed merely spotlighted a systemic cruelty that often operates more discreetly.
Lessons Learned from Shkreli
The public outrage spurred by Shkreli’s actions has catalyzed few changes, save perhaps the bipartisan efforts to cap insulin costs. It did not, however, address the structural issues enabling such exploitation. Corporations and wealthy individuals continue to wield disproportionate influence over healthcare policies, often to the detriment of the public.
While Shkreli serves as a convenient villain, the problem transcends any one individual. His story is a cautionary tale of unchecked greed and the lack of accountability that permeates certain socio-economic circles. It underscores the urgent need for systemic reforms that prioritize human dignity over corporate profits.
As Shkreli continues to live seemingly unbothered by the harm he caused, it falls upon society to ensure that his brand of unapologetic greed is no longer rewarded. Until then, the struggles of everyday people will remain a mere footnote in the relentless pursuit of wealth and power by the few.
Welcome back (previous post) to my machine learning journey! In the last post, I explained the setup environment and demonstrated the first steps of building an interactive machine learning model. Today, I’ll attempt to (with my limited knowledge) explain creating the web application using Flask. It serves as an example of the many ways you could interact with a model in real-time.
Flask is a lightweight web framework for Python that’s perfect for building simple web applications quickly and efficiently. It provides the tools needed to set up routes, handle requests, and render templates.
To get started with Flask, you’ll need to install it:
bashCopy codepip install FlaskOnce installed, you can create a basic Flask app by defining routes that handle different actions.
The core functionality of our web app revolves around querying instances from the pool and allowing users to label them. Let’s set up the necessary routes and create HTML templates for user interaction.
Here’s the basic structure of our Flask app:
pythonCopy codeimport numpy as np
import joblib
from flask import Flask, request, render_template, redirect, url_for
from modAL.models import ActiveLearner
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
# Load the ActiveLearner model
learner = joblib.load('active_learner_model.pkl')
# Load the pool data
X_pool, y_pool = joblib.load('X_y_pool.pkl')
# Split the pool data into train and test sets
X_pool, X_test, y_pool, y_test = train_test_split(X_pool, y_pool, test_size=0.2, random_state=42)
# Initialize Flask app
app = Flask(__name__)
# Global variable to store labeled instances
labeled_instances = []
@app.route('/')
def home():
return render_template('index.html')
@app.route('/query', methods=['GET', 'POST'])
def query():
global X_pool, y_pool, query_instance, query_idx, labeled_instances
if request.method == 'POST':
# Get the label from the user
label = int(request.form['label'])
# Teach the model the new label
learner.teach(X_pool[query_idx].reshape(1, -1), np.array([label]))
# Store the labeled instance and its label
labeled_instances.append((X_pool[query_idx].reshape(1, -1), label))
# Remove the queried instance from the pool
X_pool = np.delete(X_pool, query_idx, axis=0)
y_pool = np.delete(y_pool, query_idx, axis=0)
# Evaluate the model
accuracy = learner.score(X_test, y_test)
# Query the model for the next instance
query_idx, query_instance = learner.query(X_pool)
return render_template('query.html', instance=query_instance.tolist(), accuracy=accuracy)
# Initial query
query_idx, query_instance = learner.query(X_pool)
accuracy = learner.score(X_test, y_test)
return render_template('query.html', instance=query_instance.tolist(), accuracy=accuracy)
@app.route('/review')
def review():
accuracy = learner.score(X_test, y_test)
return render_template('review.html', labeled_instances=labeled_instances, accuracy=accuracy, enumerate=enumerate)
@app.route('/correct', methods=['POST'])
def correct():
global labeled_instances, learner, X_pool, y_pool
try:
# Get the index and new label from the form
index = int(request.form['index'])
new_label = int(request.form['new_label'])
# Ensure the index is within the valid range
if 0 <= index < len(labeled_instances):
# Update the label in the labeled instances
instance, _ = labeled_instances[index]
labeled_instances[index] = (instance, new_label)
# Recreate the dataset with corrected labels
X_corrected = np.vstack([instance for instance, label in labeled_instances])
y_corrected = np.array([label for instance, label in labeled_instances])
# Clear and reinitialize the learner with corrected data
learner = ActiveLearner(
estimator=RandomForestClassifier(),
X_training=X_corrected,
y_training=y_corrected
)
accuracy = learner.score(X_test, y_test)
return render_template('review.html', labeled_instances=labeled_instances, accuracy=accuracy, enumerate=enumerate)
else:
return f"Error: Index {index} is out of range. Valid range is 0 to {len(labeled_instances) - 1}.", 400
except Exception as e:
return str(e), 500
if __name__ == '__main__':
app.run(debug=True)
One of the critical features of our app is the ability to correct labels. This ensures that any mistakes made during the labeling process can be rectified, improving the model’s learning over time.
In the review route, users can see all labeled instances and correct any mistakes:
pythonCopy code@app.route('/review')
def review():
accuracy = learner.score(X_test, y_test)
return render_template('review.html', labeled_instances=labeled_instances, accuracy=accuracy, enumerate=enumerate)
@app.route('/correct', methods=['POST'])
def correct():
global labeled_instances, learner, X_pool, y_pool
try:
# Get the index and new label from the form
index = int(request.form['index'])
new_label = int(request.form['new_label'])
# Ensure the index is within the valid range
if 0 <= index < len(labeled_instances):
# Update the label in the labeled instances
instance, _ = labeled_instances[index]
labeled_instances[index] = (instance, new_label)
# Recreate the dataset with corrected labels
X_corrected = np.vstack([instance for instance, label in labeled_instances])
y_corrected = np.array([label for instance, label in labeled_instances])
# Clear and reinitialize the learner with corrected data
learner = ActiveLearner(
estimator=RandomForestClassifier(),
X_training=X_corrected,
y_training=y_corrected
)
accuracy = learner.score(X_test, y_test)
return render_template('review.html', labeled_instances=labeled_instances, accuracy=accuracy, enumerate=enumerate)
else:
return f"Error: Index {index} is out of range. Valid range is 0 to {len(labeled_instances) - 1}.", 400
except Exception as e:
return str(e), 500
Creating the web application presented several challenges, from handling data correctly to ensuring that the user interface was intuitive and responsive. Here are some of the key challenges I faced and how I overcame them:
learner.teach(X_pool[query_idx].reshape(1, -1), np.array([label]))X_pool, X_test, y_pool, y_test = train_test_split(X_pool, y_pool, test_size=0.2, random_state=42)X_corrected = np.vstack([instance for instance, label in labeled_instances]) y_corrected = np.array([label for instance, label in labeled_instances])Reflecting on this part of the journey, I realized the importance of building a user-friendly interface and the need for careful data handling. These elements are essential for creating a robust interactive machine learning model.
In the next post, we’ll explore how visualizing data can help us understand our model better. Stay tuned!
Welcome back (previous post!) to my machine learning journey! In the last post, we tackled some of the challenges I faced and the solutions I discovered along the way. Today, we’ll explore the power of data visualization and how it can provide deeper insights into our machine learning model.
Data visualization is a crucial aspect of data science and machine learning. It allows us to transform complex data into visual formats that are easier to understand and interpret. By visualizing data, we can uncover patterns, trends, and insights that might not be immediately apparent from raw data.
For our machine learning model, visualization helps in:
One of the key visualizations for understanding our model is plotting feature vectors. Feature vectors represent the data points in a high-dimensional space, and visualizing them can help us understand how the model processes and distinguishes between different instances.
Here’s how to plot the feature vectors of queried instances:
pythonCopy codeimport matplotlib.pyplot as plt
import io
import base64
def generate_plot(instance):
# Plot the feature vector
plt.figure(figsize=(10, 2))
plt.bar(range(len(instance[0])), instance[0])
plt.xlabel('Feature Index')
plt.ylabel('Feature Value')
plt.title('Feature Vector of Queried Instance')
# Save plot to a string in base64 format
buf = io.BytesIO()
plt.savefig(buf, format='png')
buf.seek(0)
plot_url = base64.b64encode(buf.getvalue()).decode('utf8')
plt.close()
return plot_url
This code generates a bar plot of the feature vector, providing a visual representation of the instance’s features. The plot is saved as a base64-encoded string, making it easy to embed in our web application.
Different types of visualizations can provide various insights into our data and model. Here are a few examples:
Let’s create a scatter plot to visualize the relationship between two features:
pythonCopy codedef generate_scatter_plot(X, feature1, feature2):
plt.figure(figsize=(8, 6))
plt.scatter(X[:, feature1], X[:, feature2], alpha=0.5)
plt.xlabel(f'Feature {feature1}')
plt.ylabel(f'Feature {feature2}')
plt.title(f'Scatter Plot of Feature {feature1} vs Feature {feature2}')
buf = io.BytesIO()
plt.savefig(buf, format='png')
buf.seek(0)
plot_url = base64.b64encode(buf.getvalue()).decode('utf8')
plt.close()
return plot_url
This code generates a scatter plot for two specified features, providing a visual representation of their relationship.
Visualizing data has been an enlightening experience. It has allowed me to gain deeper insights into my machine learning model and better understand its behavior. Here are some key takeaways:
I encourage you to explore data visualization in your own projects. It can transform the way you understand and interact with your data, providing valuable insights and enhancing your machine learning journey.
In the next post, we’ll recap the entire journey, reflecting on the progress made and the lessons learned. Stay tuned!
Welcome back (previous post!) to my machine learning journey! In the last post, we built an interactive web application using Flask, allowing us to interact with our model in real-time. Today, we’ll dive into some of the challenges I faced and the solutions I discovered along the way.
One of the first issues I encountered was related to data dimensionality. The model expected 2D arrays but received 3D arrays, leading to errors. This problem often arises when dealing with reshaping data for machine learning models.
The Issue: When the model queried instances from the pool, it received data in an unexpected format, causing an error.
The Solution: To resolve this, I ensured that the data reshaping maintained the correct dimensions. Here’s the corrected code snippet:
pythonCopy code# Teach the model the new label
learner.teach(X_pool[query_idx].reshape(1, -1), np.array([label]))
By reshaping the queried instance to a 2D array with .reshape(1, -1), the model could correctly process the data, allowing the learning process to continue smoothly.
Consistent and accurate measurement of the model’s performance is crucial for understanding its learning progress. Initially, I struggled with fluctuating accuracy metrics, which made it difficult to gauge the model’s true performance.
The Issue: Inconsistent accuracy measurements due to varying test sets.
The Solution: To ensure consistent accuracy measurement, I used a fixed test set derived from the initial pool data. This approach provided a more reliable metric for evaluating the model’s performance on unseen data.
pythonCopy code# Split the pool data into train and test sets
X_pool, X_test, y_pool, y_test = train_test_split(X_pool, y_pool, test_size=0.2, random_state=42)
By maintaining a fixed test set, I could accurately track the model’s performance over time, providing valuable insights into its learning capabilities.
An essential feature of the interactive web app is the ability to review and correct labels. Ensuring accurate labels is critical for the model’s learning process, as incorrect labels can lead to misleading results.
The Issue: Incorrect labels in the dataset leading to inaccurate model training.
The Solution: I implemented functionality to allow users to review and correct labeled instances. This ensures that any mistakes made during the initial labeling can be rectified, improving the model’s accuracy over time.
pythonCopy code@app.route('/correct', methods=['POST'])
def correct():
global labeled_instances, learner, X_pool, y_pool
try:
# Get the index and new label from the form
index = int(request.form['index'])
new_label = int(request.form['new_label'])
# Ensure the index is within the valid range
if 0 <= index < len(labeled_instances):
# Update the label in the labeled instances
instance, _ = labeled_instances[index]
labeled_instances[index] = (instance, new_label)
# Recreate the dataset with corrected labels
X_corrected = np.vstack([instance for instance, label in labeled_instances])
y_corrected = np.array([label for instance, label in labeled_instances])
# Clear and reinitialize the learner with corrected data
learner = ActiveLearner(
estimator=RandomForestClassifier(),
X_training=X_corrected,
y_training=y_corrected
)
accuracy = learner.score(X_test, y_test)
return render_template('review.html', labeled_instances=labeled_instances, accuracy=accuracy, enumerate=enumerate)
else:
return f"Error: Index {index} is out of range. Valid range is 0 to {len(labeled_instances) - 1}.", 400
except Exception as e:
return str(e), 500
Reflecting on these challenges, I realized that problem-solving is a significant part of the machine learning journey. Each hurdle provided an opportunity to learn and grow, deepening my understanding of the intricacies involved in building and refining machine learning models.
I hope sharing these challenges and solutions helps you in your own machine learning journey. Remember, every problem is an opportunity to learn and grow. In the next post, we’ll explore how visualizing data can provide deeper insights into our model. Stay tuned!
Unfiltered truth-telling can be a dangerous game. You think you’re dropping truth bombs, but you’re more likely to get yourself blown up. It’s a lesson I’ve learned the hard way in the trenches of politics, the military, and even around the family dinner table.
When Keeping it Real Goes Wrong
Remember that classic Chappelle Show skit? Brenda, the queen of “keeping it real,” ends up behind bars. It’s funny as hell, but it also hits a nerve. Sometimes, honesty isn’t the best policy. Refraining from saying the quiet part out loud can be a solid survival strategy.
I’ve got a few war stories of my own.
There was that time in politics when I exposed some shady dealings, only to be labeled a troublemaker by the good ol’ boys club.
There were more than a few occassions in the military where speaking truth got me ostracized?
Even my family hasn’t been immune to the fallout of my unfiltered honesty.
But here’s the thing: I’m not saying you should lie or sugarcoat the truth. I’m saying you need to be strategic.
Ragecognito’s Rules for Tactical Truth-Telling
I’ve learned a few hard-earned lessons about how to navigate this minefield:
The Price of Honesty
We live in a world that often punishes those who dare to speak out, but that doesn’t mean we should stay silent. We just need to be smarter about it. Smarter, not harder.
Check out Episode 2 – When Keeping It Real Goes Wrong and be sure to share your stories in the comments there or right here at the end of this post. I still keep it real, even if it means getting a little bruised along the way. I’m more strategic about it now, and maybe I’ll be able to inspire you to do the same.
Remember, we’re not living in a fairy tale. The truth can be messy, complicated, and downright painful, but it’s also essential for change. Let’s keep fighting the good fight, armed with the knowledge that sometimes, a little tact can go a long way.
In the second episode of Late Stage Rage, RAGECOGNITO looks at the perils of unfiltered honesty. Using hilarious and sobering anecdotes from his own life, he explores the fine line between “keeping it real” and self-sabotage.
From political campaigns based entirely on keeping it real, to military mishaps and family feuds, Ragecognito shares his hard-earned lessons on how to navigate a world that punishes truth in favor of a collective lie.
He offers practical advice on picking your battles, knowing your audience, and working strategically to expose the truth without becoming a martyr. If you’ve ever paid the price for speaking your mind, this episode is for you. Get ready to laugh, learn, and rage along with Ragecognito as he dissects the art of tactical truth-telling.
Listen to the embedded episode above, or check it out on YouTube!
My Machine Learning Adventure (A Series)
Welcome back (previous post)! My journey to understand machine learning began a year ago, but as someone who has always been curious about the capabilities of AI, I’ve only recently made any real beginner breakthroughs. My new approach is to interactively work with various GPT models and formats to design an interactive machine learning model that learns directly through my inputs. In this blog series, I document my experiences, the challenges I faced, and the solutions I discovered along the way.
In the first post, I introduced the project and shared my excitement about the concept of active learning. Today, we’ll get our hands dirty by setting up the environment and taking the first steps towards building our interactive machine learning model.
Remember, I’m no machine learning expert. I’m learning just like you!
Quick hits: I used Jupyter Notebook and JupyterLab, as installed in the Anaconda Navigator Package. The coverage of those particular processes will not be extensive in this series, but maybe I’ll try to highlight them in the future.
Before building my model, I needed to set up the necessary tools. With the assistance of Machine Learning GPT, I chose the following set of libraries:
I installed them in JupyterLab by opening a terminal in my project folder environment and entering the following command:
pip install modAL scikit-learn numpy pandas joblibThis installs the libraries in the environment so they are not rerun in the code.
These libraries provide a solid foundation for the project, allowing efficient data handling and building robust machine learning models.
With the libraries installed, it was time to create some data. I used make_classification from scikit-learn to generate a synthetic dataset that simulates a binary classification problem, such as whether a picture is or is not a dog, or whether sentiment in text is positive or negative.
This dataset served as the foundation for training and testing the model. Imports required:
import numpy as np
import joblib
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
The next portion of code generates a dataset that simulates a binary classification problem as mentioned earlier.
# Generate a synthetic dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=2, n_redundant=10, random_state=42)
By saving the dataset using joblib, I ensured that it could be easily loaded and used later in the project.
# Save the dataset
joblib.dump((X, y), 'X_y_data.pkl'The data was then split into training and pool sets, where the training set would initialize the model, and the pool set would be used for querying.
# Split the dataset
X_train, X_pool, y_train, y_pool = train_test_split(X, y, test_size=0.75, random_state=42)Let’s break down what the previous block of code does in a way that’s easier to understand, because I struggled with it.
Imagine you have a big list of data (like numbers, images, or text), and you want to use this data to teach a computer to do something, like recognizing cats in pictures or predicting how much your favorite sports team will score in a game. This dataset has x “input” data (like pictures of animals) and y labels (such as “dog” or “cat”).
You can’t use all your data to teach the computer (train it). You need to keep some data aside to test if the computer has learned correctly.
This code splits your data into two parts: one part for training and one part for testing or other purposes.
train_test_split is a function that does the splitting for you.X_train and y_train are the parts of your data that you’ll use to train the computer.X_pool and y_pool are the parts of your data that you’ll keep aside for later (like testing).X and y: Your whole dataset.test_size=0.75: This means 75% of your data will be kept aside (in X_pool and y_pool), and 25% will be used for training (in X_train and y_train).random_state=42: This is like setting a “seed” so that if you run this code again, you get the same split every time. It’s useful for consistency.Even though I didn’t realize what I’d done at the time, I’d generated a synthetic dataset and split the data into training and testing data. The next step was to initialize the active learner model.
I chose the RandomForestClassifier from scikit-learn as the base estimator for my active learner.
from modAL.models import ActiveLearner
from sklearn.ensemble import RandomForestClassifierKeeping with our cats/dogs categorizing example, a learner is like a student that learns from these examples. Active learning is a special way of teaching the computer. Instead of showing it all the pictures at once, you start by showing it a few, and then it asks for more examples of things it is unsure about. This way, it learns more efficiently.
# Initialize the learner
learner = ActiveLearner(
estimator=RandomForestClassifier(),
X_training=X_train, y_training=y_train
)I saved the model and data.
# Save the model and the pool data
joblib.dump(learner, 'active_learner_model.pkl')
joblib.dump((X_pool, y_pool), 'X_y_pool.pkl')The model was initialized with the training data and saved for future use. This step marked the completion of our initial setup, providing a solid base for building the interactive elements of our project.
One of the initial challenges I faced was ensuring that all libraries were correctly installed and compatible with each other. That was mostly due to my misunderstanding about how “pip” works. I initially had everything in my notebook, but once I realized the libraries should be installed through the terminal/command line, I was able to make progress.
Once the environment was set up, the process of generating and saving data, as well as model initialization, went smoothly. This part of my adventure was crucial for understanding the basic components needed for the project and building a strong foundation. It took me days to figure out…
, I realized the importance of patience and attention to detail. Patience is definitely not a large part of my personality or temperament, but I realized through this endeavor that it (and attention to detail) are vitally important. Setting up the environment might seem like a straightforward task, but it’s the backbone of the entire project. Ensuring that everything is correctly installed and configured saves a lot of time and frustration down the line.
In the next post, we’ll dive into building the interactive web application using Flask. This is where the project starts to come to life, allowing us to interact with the model in real-time. Stay tuned!
My journey to understand machine learning began a year ago, but as someone who has always been curious about the capabilities of AI, I’ve only recently made any real beginner breakthroughs. My new approach is to interactively work with various GPT models and formats to design an interactive machine learning model that learns directly through my inputs. In this blog series, I document my experiences, the challenges I faced, and the solutions I discovered along the way.
Machine learning and artificial intelligence have both always seemed intriguing and intimidating. With so many technical terms and complex algorithms, it’s easy to feel overwhelmed. I was determined to push past the initial confusion and embark on a project that would not only teach me the fundamentals of machine learning but also allow me to build something interactive and useful.
I won’t pretend to be an expert here, but one concept that particularly caught my attention was active learning. Unlike traditional machine learning models that passively receive data, active learning models actively query the user for data labels, focusing on the most informative samples to improve their performance. This approach seemed perfect for someone like me, eager to learn through hands-on interaction.
It wasn’t without its fair share of challenges and setbacks.
Throughout this series, I’ll share the step-by-step process of setting up my machine learning environment, building the interactive web app, and tackling the various challenges that arose. Here’s a sneak peek at what’s coming up:
I hope you’ll join me on this exciting adventure of machine learning. Stay tuned for the next post, where I’ll take you through the initial setup process and the first steps of my project. Feel free to share your thoughts and experiences in the comments—let’s learn together!