LangGraph Multi-Agent Swarm is a Python library designed to orchestrate multiple AI agents as a cohesive “swarm.” It builds on LangGraph, a framework for constructing robust, stateful agent workflows, to enable a specialized form of multi-agent architecture. In a swarm, agents with different specializations dynamically hand off control to one another as tasks demand, rather than a single monolithic agent attempting everything. The system tracks which agent was last active so that when a user provides the next input, the conversation seamlessly resumes with that same agent. This approach addresses the problem of building cooperative AI workflows where the most qualified agent can handle each sub-task without losing context or continuity. LangGraph Swarm aims to make such multi-agent coordination easier and more reliable for developers. It provides abstractions to link individual language model agents (each potentially with their tools and prompts) into one integrated application. The library comes with out-of-the-box support for streaming responses, short-term and long-term memory integration, and even human-in-the-loop intervention, thanks to its foundation on LangGraph. By leveraging LangGraph (a lower-level orchestration framework) and fitting naturally into the broader LangChain ecosystem, LangGraph Swarm allows machine learning engineers and researchers to build complex AI agent systems while maintaining explicit control over the flow of information and decisions. LangGraph Swarm Architecture and Key Features At its core, LangGraph Swarm represents multiple agents as nodes in a directed state graph, edges define handoff pathways, and a shared state tracks the ‘active_agent’. When an agent invokes a handoff, the library updates that field and transfers the necessary context so the next agent seamlessly continues the conversation. This setup supports collaborative specialization, letting each agent focus on a narrow domain while offering customizable handoff tools for flexible workflows. Built on LangGraph’s streaming and memory modules, Swarm preserves short-term conversational context and long-term knowledge, ensuring coherent, multi-turn interactions even as control shifts between agents. LangGraph Swarm’s handoff tools let one agent transfer control to another by issuing a ‘Command’ that updates the shared state, switching the ‘active_agent’ and passing along context, such as relevant messages or a custom summary. While the default tool hands off the full conversation and inserts a notification, developers can implement custom tools to filter context, add instructions, or rename the action to influence the LLM’s behavior. Unlike autonomous AI-routing patterns, Swarm’s routing is explicitly defined: each handoff tool specifies which agent may take over, ensuring predictable flows. This mechanism supports collaboration patterns, such as a “Travel Planner” delegating medical questions to a “Medical Advisor” or a coordinator distributing technical and billing queries to specialized experts. It relies on an internal router to direct user messages to the current agent until another handoff occurs. State Management and Memory Managing state and memory is essential for preserving context as agents hand off tasks. By default, LangGraph Swarm maintains a shared state, containing the conversation history and an ‘active_agent’ marker, and uses a checkpointer (such as an in-memory saver or database store) to persist this state across turns. Also, it supports a memory store for long-term knowledge, allowing the system to log facts or past interactions for future sessions while keeping a window of recent messages for immediate context. Together, these mechanisms ensure the swarm never “forgets” which agent is active or what has been discussed, enabling seamless multi-turn dialogues and accumulating user preferences or critical data over time. When more granular control is needed, developers can define custom state schemas so each agent has its private message history. By wrapping agent calls to map the global state into agent-specific fields before invocation and merging updates afterward, teams can tailor the degree of context sharing. This approach supports workflows ranging from fully collaborative agents to isolated reasoning modules, all while leveraging LangGraph Swarm’s robust orchestration, memory, and state-management infrastructure. Customization and Extensibility LangGraph Swarm offers extensive flexibility for custom workflows. Developers can override the default handoff tool, which passes all messages and switches the active agent, to implement specialized logic, such as summarizing context or attaching additional metadata. Custom tools simply return a LangGraph Command to update state, and agents must be configured to handle those commands via the appropriate node types and state-schema keys. Beyond handoffs, one can redefine how agents share or isolate memory using LangGraph’s typed state schemas: mapping the global swarm state into per-agent fields before invocation and merging results afterward. This enables scenarios where an agent maintains a private conversation history or uses a different communication format without exposing its internal reasoning. For full control, it’s possible to bypass the high-level API and manually assemble a ‘StateGraph’: add each compiled agent as a node, define transition edges, and attach the active-agent router. While most use cases benefit from the simplicity of ‘create_swarm’ and ‘create_react_agent’, the ability to drop down to LangGraph primitives ensures that practitioners can inspect, adjust, or extend every aspect of multi-agent coordination. Ecosystem Integration and Dependencies LangGraph Swarm integrates tightly with LangChain, leveraging components like LangSmith for evaluation, langchain\_openai for model access, and LangGraph for orchestration features such as persistence and caching. Its model-agnostic design lets it coordinate agents across any LLM backend (OpenAI, Hugging Face, or others), and it’s available in both Python (‘pip install langgraph-swarm’) and JavaScript/TypeScript (‘@langchain/langgraph-swarm’), making it suitable for web or serverless environments. Distributed under the MIT license and with active development, it continues to benefit from community contributions and enhancements in the LangChain ecosystem. Sample Implementation Below is a minimal setup of a two-agent swarm: from langchain_openai import ChatOpenAI from langgraph.checkpoint.memory import InMemorySaver from langgraph.prebuilt import create_react_agent from langgraph_swarm import create_handoff_tool, create_swarm model = ChatOpenAI(model="gpt-4o") # Agent "Alice": math expert alice = create_react_agent( model, [lambda a,b: a+b, create_handoff_tool(agent_name="Bob")], prompt="You are Alice, an addition specialist.", name="Alice", ) # Agent "Bob": pirate persona who defers math to Alice bob = create_react_agent( model, [create_handoff_tool(agent_name="Alice", description="Delegate math to Alice")], prompt="You are Bob, a playful pirate.", name="Bob", ) workflow = create_swarm([alice, bob], default_active_agent="Alice") app = workflow.compile(checkpointer=InMemorySaver()) Here, Alice handles additions and can hand off to Bob, while Bob responds playfully but routes math questions back to Alice. The InMemorySaver ensures conversational state persists across turns. Use Cases and Applications LangGraph Swarm unlocks advanced multi-agent collaboration by enabling a central coordinator to dynamically delegate sub-tasks to specialized agents, whether that’s triaging emergencies by handing off to medical, security, or disaster-response experts, routing travel bookings between flight, hotel, and car-rental agents, orchestrating a pair-programming workflow between a coding agent and a reviewer, or splitting research and report generation tasks among researcher, reporter, and fact-checker agents. Beyond these examples, the framework can power customer-support bots that route queries to departmental specialists, interactive storytelling with distinct character agents, scientific pipelines with stage-specific processors, or any scenario where dividing work among expert “swarm” members boosts reliability and clarity. At the same time, LangGraph Swarm handles the underlying message routing, state management, and smooth transitions. In conclusion, LangGraph Swarm marks a leap toward truly modular, cooperative AI systems. Structured multiple specialized agents into a directed graph solves tasks that a single model struggles with, each agent handles its expertise, and then hands off control seamlessly. This design keeps individual agents simple and interpretable while the swarm collectively manages complex workflows involving reasoning, tool use, and decision-making. Built on LangChain and LangGraph, the library taps into a mature ecosystem of LLMs, tools, memory stores, and debugging utilities. Developers retain explicit control over agent interactions and state sharing, ensuring reliability, yet still leverage LLM flexibility to decide when to invoke tools or delegate to another agent. Check out the GitHub Page. All credit for this research goes to the researchers of this project. Also, feel free to follow us on Twitter and don’t forget to join our 90k+ ML SubReddit. Sana HassanSana Hassan, a consulting intern at Marktechpost and dual-degree student at IIT Madras, is passionate about applying technology and AI to address real-world challenges. With a keen interest in solving practical problems, he brings a fresh perspective to the intersection of AI and real-life solutions.Sana Hassanhttps://www.marktechpost.com/author/sana-hassan/ByteDance Introduces Seed1.5-VL: A Vision-Language Foundation Model Designed to Advance General-Purpose Multimodal Understanding and ReasoningSana Hassanhttps://www.marktechpost.com/author/sana-hassan/Researchers from Tsinghua and ModelBest Release Ultra-FineWeb: A Trillion-Token Dataset Enhancing LLM Accuracy Across BenchmarksSana Hassanhttps://www.marktechpost.com/author/sana-hassan/Coding Agents See 75% Surge: SimilarWeb’s AI Usage Report Highlights the Sectors Winning and Losing in 2025’s Generative AI BoomSana Hassanhttps://www.marktechpost.com/author/sana-hassan/Rethinking Toxic Data in LLM Pretraining: A Co-Design Approach for Improved Steerability and Detoxification

Email continues to be the primary attack vector for cybercriminals targeting organizations across all industries. These attacks arrive disguised as legitimate communications, often mimicking trusted senders and creating a false sense of security that bypasses technical defenses by taking advantage of human error. Understanding the distinctions between business email compromise (BEC) vs phishing is crucial, as both represent sophisticated yet very different threat methods. The financial impact of email-based threats has reached unprecedented levels. According to the FBI’s Internet Crime Complaint Center, BEC scams resulted in over $2.77 billion across 21,442 reported incidents in 2024 alone. What makes a BEC attack different from a typical phishing email is its highly targeted nature. While phishing often involves mass distribution of generic threats designed to lure people in, BEC attacks specifically impersonate executives or trusted partners to target individuals with financial authority. The 2023 Verizon Data Breach Investigations Report also revealed that phishing attempts increased by 18% year-over-year, with 74% of breaches in financial services involving phishing as the initial attack method. Organizations can significantly strengthen their security posture through a combination of employee awareness training and effective security controls. Teaching staff how to identify suspicious emails represents a critical first line of defense, while implementing email authentication protocols provides essential protection.  DMARC solutions for businesses, like those provided by EasyDMARC, help organizations verify sender legitimacy, prevent domain spoofing, and block unauthorized emails before they reach employee inboxes, effectively neutralizing these threats before they can exploit various vulnerabilities. This multi-layered approach not only protects sensitive information but also preserves business continuity, shields organizational reputation, and maintains the trust that customers and partners place in your digital communications. In this article, we’ll go over what a BEC attack looks like, what makes a BEC attack different from a typical phishing email attack, recent trends, and what you can do to prevent these types of attacks.  Key Takeaways for BEC vs Phishing BEC attacks and phishing attacks are similar in that they both use social engineering tactics, typically involve email as an attack vector, and the end goal is often financial gain, data theft, or unauthorized access. While BEC attacks and phishing are similar, BEC issues are far more sophisticated and personalized to the target.  Best practices for preventing BEC attacks include training employees, using MFA, and implementing DMARC protocols.  What is a BEC Attack? BEC attacks are sophisticated email scams that target organizations, often with financial motives or to gain access to sensitive information. These highly targeted attacks involve cybercriminals impersonating executives, trusted vendors, or business partners to manipulate employees into taking actions that benefit the attacker. Unlike mass phishing campaigns that cast wide, generic nets, BEC attacks are meticulously researched and personalized. Attackers often spend weeks studying their targets’ organizational structures, business relationships, and communication patterns before launching their assault. They identify key individuals with financial authority or access to sensitive information, then craft convincing impersonations designed to exploit established relationships. The most common BEC scenario involves an urgent wire transfer request that appears to come from a company executive. For example, an employee might receive what looks like an authentic email from their CEO requesting an immediate wire transfer to a vendor. The message often emphasizes urgency and discretion, discouraging verification through normal channels. When the employee complies, the funds are transferred directly to the attacker’s account and typically moved multiple times within hours, making recovery virtually impossible. The financial damage from BEC attacks can be devastating. But beyond immediate financial losses, organizations face potential regulatory penalties, litigation costs, reputational damage, and lost business opportunities. In one case, a multinational corporation lost $47 million in a single BEC attack when an executive was tricked into authorizing multiple transfers for a supposed acquisition. How to Prevent Business Email Compromise Attacks The best way to prevent BEC attacks is by using a multi-layered approach, combining employee training, multi-factor authentication, and email security protocols. Employee Training Regular security training equips employees with the right tools to spot dangerous emails before they do damage. Teaching staff to adhere to email security best practices is a great way to ensure your employees are helping build a security-conscious culture. Multi-Factor Authentication Multi-factor authentication (MFA) provides multiple layers of defense through different authentication factors. These typically include something you know (like a password), something you have (such as a smartphone), and something you are (biometric data like fingerprints). Even if a password is compromised, these additional authentication layers prevent unauthorized access, dramatically reducing the risk of account infiltration. The multiple verification steps create a robust security mechanism that goes far beyond traditional password protection. Email security protocols like DKIM (DomainKeys Identified Mail), SPF (Sender Policy Framework), and DMARC (Domain-based Message, Authentication, Reporting, and Conformance) provide critical layers of protection against email spoofing and phishing attempts. These protocols work together to verify the authenticity of email senders and prevent unauthorized use of domain names. To best identify email security issues, users can use tools like SPF lookups, DKIM Record Checkers, and DKIM Record Generators. However, these tools can only go so far.  To ensure the best possible protection against BEC attacks, organizations must have DMARC properly set up to achieve the most secure email authentication. To do so, users can make use of online DMARC solutions to help them implement the strongest DMARC policies and get support with the continual monitoring of their domains.  Start Your 14-day Free Trial What is a Phishing Attack?  A phishing attack is one in which attackers impersonate trusted entities to trick victims into revealing sensitive information. They typically arrive via email, text messages, or social media, masquerading as legitimate communications from banks, service providers, colleagues, or other trusted sources.  Today’s phishing attacks have evolved far beyond the obvious grammatical errors and implausible scenarios of early attempts. Modern phishing emails often feature perfect spelling, convincing logos, and accurate sender information. They create a false sense of urgency, leverage fear or curiosity, and provide seemingly legitimate reasons for immediate action. The most common phishing scenario involves an email claiming to be from a trusted organization, alerting the recipient to a supposed account problem requiring immediate attention. Recent phishing statistics reveal that the most targeted industry in 2024 was the IT sector. This industry faces greater risk due to its critical role in infrastructure and access to valuable data. Cybercriminals exploit software vulnerabilities and employee susceptibility to phishing scams to gain access to sensitive information and important systems.  The Evolution of Phishing Since their inception in the 90s, phishing attacks have progressed significantly. Early attacks often contained obvious red flags like poor grammar and unlikely scenarios. Since then, cyber criminals have refined their tactics, creating more convincing messages that mimic legitimate organizations with increasing accuracy.  Modern attacks often include spear phishing, which targets individuals through the use of personal relevant information, clone phishing, which replicates legitimate emails but replaces attachments with malicious versions, vishing, involving voice phishing via phone calls, and pharming, which redirects website traffic to fake sites without user interaction. Today’s most sophisticated phishing attacks employ AI-generated content that can adapt to targets in real-time, creating highly personalized and convincing communications. According to SlashNext’s 2023 State of Phishing Report, AI-enhanced phishing attacks increased by 1,265% in 2022 alone, with attackers using machine learning to craft increasingly convincing messages. The Real Cost of Phishing The damage from phishing attacks extends far beyond initial credential theft, creating long-lasting consequences for organizations that fall victim to them. When attackers gain access to accounts or systems, they can steal sensitive data, including financial information and intellectual property. These breaches often lead to substantial financial loss, with the average cost of a data breach reaching $4.45 million in 2023.  Even more devastating can be the deployment of ransomware across corporate networks, as seen in high-profile cases where companies paid millions in ransom and still faced weeks of operational disruption. The repercussions continue to ripple outward as cybercriminals establish persistent access for extended campaigns, sometimes maintaining hidden footholds for months before being detected. Using compromised accounts, attackers frequently target an organization’s partners and customers, exploiting established trust relationships to spread their reach.  This cascade effect severely damages brand reputation and erodes customer confidence, as demonstrated when major retailers experienced phishing breaches that led to measurable customer churn and required expensive brand rehabilitation campaigns. The combined impact of regulatory fines, litigation, remediation costs, and lost business opportunities often transforms what seemed like a simple email attack into an existential threat for many businesses. Recent Trends and Emerging Threats Phishing threats continue to evolve at a rapid pace. Recent trends include: QR Code Phishing: Attackers embed malicious QR codes in emails that direct victims to credential-harvesting sites MFA Bypass Techniques: Sophisticated phishing kits that can intercept and replay authentication tokens in real-time AI-Generated Content: Using large language models to create highly convincing and contextually appropriate phishing messages Collaboration Platform Targeting: Focused attacks on workplace tools like Microsoft Teams, Slack, and Google Workspace How to Prevent a Phishing Attack To best prevent phishing attacks, as with BEC attacks, we recommend a multi-layered approach, combining technical solutions like DMARC, human awareness including security training, and organizational processes like MFA.  Detecting email security vulnerabilities requires specialized tools such as SPF lookup utilities, DKIM record verification and generation tools, DMARC verification services, and phishing link checkers.  For optimal defense against phishing attacks, organizations should implement properly configured DMARC protocols to maximize email authentication security. Dedicated DMARC solutions like EasyDMARC offer assistance in deploying robust DMARC policies and providing ongoing domain monitoring support. Get Started Now Is Business Email Compromise the Same as Phishing? BEC and phishing attacks are closely related and often overlap, as both rely on deception to trick victims into taking harmful actions. However, they differ in execution, targeting, and sophistication. Similarities Between BEC and Phishing  Both use social engineering tactics to manipulate victims. Both typically involve email as the primary attack vector. The end goal of both is often financial gain, data theft, or unauthorized access. Differences Between BEC and Phishing  Targeting: BEC attacks are highly targeted, often aimed at specific individuals like executives or finance personnel, while phishing is usually broader and sent to large groups. Tactics: BEC relies on impersonation and pretexting without malware or links, whereas phishing often uses malicious links or attachments to compromise systems. Complexity: BEC attacks are generally more sophisticated and customized, requiring research and planning, whereas phishing is typically automated and generic. EasyDMARC Can Prevent BEC Attacks and Stop Phishing As cyber threats continue to evolve, organizations must understand the nuances between BEC and phishing attacks to build more effective defenses. Both attack types exploit human trust and communication habits, but BEC attacks stand out for their precision, research, and high financial stakes, while phishing typically relies on volume and opportunism. Regardless of the method, email remains the most exploited vector, making email security a critical priority. At EasyDMARC, we equip businesses with the tools needed to identify, categorize, and neutralize both BEC and phishing threats, as well as countless other attacks. By implementing email authentication protocols like DMARC, SPF, and DKIM, organizations can verify sender identity and prevent domain spoofing.  Our platform also offers powerful tools to help users detect weaknesses and take action before attackers can exploit them. Features like real-time alerting and aggregate reporting give organizations the visibility and agility needed to respond quickly and decisively to suspicious activity. Looking ahead, phishing attacks continue to rise year upon year, becoming increasingly targeted and convincing. Meanwhile, BEC attacks are growing in sophistication and financial impact. The most effective way to stay ahead of these evolving threats is by adopting a proactive, layered defense strategy that includes email authentication. With the right tools, policies, and training in place, organizations can significantly reduce their exposure and build long-term resilience against the next wave of email-based attacks. Frequently Asked Questions What is a BEC cyber attack? A Business Email Compromise (BEC) cyber attack is a type of email fraud that targets businesses and organizations to trick employees, executives, or partners into transferring money or sensitive information to the attackers. It typically involves the spoofing or compromising of a legitimate business email address to manipulate the victim into taking actions that result in financial or data losses. Attackers will often impersonate other people at the company, particularly management or higher-ups. What is an example of a BEC? BEC attacks almost always involve impersonation of a company employee, so they often begin with an email from an attacker impersonating someone at the company. In some cases, the attacker will target the company’s accounts payable department with an email containing a malicious link or attachment. Once the link is clicked, the attacker can gain access to the accounts payable email, making stealing money much easier.  Here is an example of what an email from a BEC attack may look like. “Hi [Employee Name],I need you to process an urgent payment of $100,000 to [Vendor Name]. This payment is time-sensitive, and we need it completed by the end of the day. Please wire the funds to the following account:Account Number: 1234567890  Routing Number: 987654321  Bank Name: [Fake Bank Name]Let me know once it’s done. This is very important.Best,  [CEO Name] What makes a BEC attack different than a typical phishing? A Business Email Compromise (BEC) attack differs from a typical phishing attack in several key ways. While both types of attacks use social engineering to manipulate victims into taking actions that benefit the attacker, BEC attacks are usually aimed at businesses, focusing on financial transactions or stealing confidential data. The emails appear legitimate, making it harder to detect, and often involve impersonating high-level employees. On the other hand, phishing is usually more generic and aimed at a wide audience, trying to trick victims into clicking on malicious links or downloading malware to steal personal information, such as login credentials. Phishing emails often include suspicious links or attachments, while BEC emails are more subtle and business-focused. Who do BEC attacks typically target? Business Email Compromise (BEC) attacks typically target specific individuals within an organization who have access to financial transactions, sensitive company data, or the ability to authorize actions such as fund transfers. The attackers often focus on individuals who are more likely to be tricked into complying with requests that appear legitimate. What is the difference between BEC and EAC? BEC involves attackers impersonating executives or trusted partners to trick employees into transferring money or sensitive data. It’s highly targeted and often financially motivated. In contrast, EAC (Email Account Compromise) occurs when an attacker gains unauthorized access to an individual’s email account to steal information or monitor communications. While BEC focuses on financial fraud, EAC is generally more about unauthorized access and data theft. What is the best way to prevent BEC attacks? The best way to prevent BEC attacks is employee training. Teaching your employees what to look for gives them the knowledge needed to recognize when an email looks suspicious and trains them not to click on links or attachments in emails.  Other effective approaches include using multi-factor authentication and implementing email authentication protocols like DMARC, DKIM, and SPF. Services like EasyDMARC makes implementing these protocols easy, fast, and secure. 

Photo Credit: Wikimedia Commons Hikers Find 600 Gold Coins in Czech Forest, Uncovering a Mysterious Historical Treasure Trove Highlights 600 gold coins found by hikers in Czech forest near Polish border Coins date back to 1808–1915, span Austria-Hungary to Ottoman Empire Treasure may have been hidden during Nazi or post-WWII upheaval Advertisement Two hikers accidentally discovered a treasure trove in Czech Republic . While taking a stroll in the forests surrounding Zvičina Hill in the Krkonoše Mountains near Poland's border, they spotted an aluminium can and an iron box protruding slightly above the surface in a stone mound. The containers contained about 600 gold coins and a stunning assortment of gold artifacts. Discovery of this treasure worth more than $340,000 has drawn attention of researchers, arising questions about both the origin of the coins and how did they end up in such a remote location.Tracing the origin of coinsAccording to the report by Vojtěch Brádle, a numismatist from the Museum of Eastern Bohemia, the majority of the coins were minted between 1808 and 1915. They originate from the Austria-Hungarian Empire, particularly under the reign of Emperor Franz Joseph I. Some of the coins feature countermarks minted in the Kingdom of Serbs, Croats, and Slovenians after the collapse of the Austro-Hungarian Empire.The 598 coins cover a broad historical period, containing currency from France, Belgium, the Ottoman Empire, and Russia too. The range of provenances makes it difficult to track how the coins got to where they were, or just why they were stashed away at all. “It is hard to say whether it was Czech, German, or Jewish gold,” said Petr Grulich, director of the Museum of Eastern Bohemia, according to Dailymail.Theories about the hiding placeThere are several theories and speculation about how these coins and artifacts were hidden in such a remote location. One theory suggests that the items were concealed during Nazi Germany's occupation of Czechoslovakia.Following the Munich Agreement of 1938, large numbers of Jews and Czechs fled their homes in the annexed Sudetenland to escape persecution. Some historians believe that the treasure was buried during this time in an effort to protect it from the invading Nazi forces. For the latest tech news and reviews, follow Gadgets 360 on X, Facebook, WhatsApp, Threads and Google News. For the latest videos on gadgets and tech, subscribe to our YouTube channel. If you want to know everything about top influencers, follow our in-house Who'sThat360 on Instagram and YouTube. Further reading: Czech Republic, Gold-Coins, Treasure Discovery Gadgets 360 Staff The resident bot. If you email me, a human will respond. More Related Stories

Documents reveal team tested options including building over station’s entire listed trainshed New image of Acme's proposals for the station's main entrance 1/22 show caption The City of London has published the planning application for Network Rail’s proposed redevelopment of Liverpool Station, revealing new images of how the scheme could look when built. The £1bn Acme designed scheme was submitted at the beginning of April and has been validated by Square Mile planners in the space of just six weeks.  A highly controversial previous version designed by Herzog & de Meuron for Network Rail and its former development partner Sellar, which has since been dropped, took more than six months to appear on the City’s planning portal. More than 20 previously unseen images of the new proposals, set to be one of the largest schemes in London, have been unveiled along with new details about how the scheme would be built. Acme’s plans would see a 21-storey office block built above the 1980s extension to the grade II-listed station’s train shed and a set of new vaulted gothic entrances built to replace the building’s existing gateways. These entrances would be faced predominately with yellow stock bricks, the same type used for the original 1875 station building and its 20th century extension, with bricks from parts of the extension set to be demolished to be reused in the new entrances. Acme has also proposed incorporating amber-tinted glass bricks, which will be “speckled” in the upper parts of the 18m-high entrance vaults and concentrated at the top of the concave areas of the arches between the ribs. Network Rail said the glass bricks will “serve as one of the contemporary subversions of an otherwise historic typology”, adding a “crystalline light scatter of the material [to] mark the stations thresholds as spaces of architectural interest”. The application documents also reveal Network Rail had considered building over the entire listed train shed roof prior to opting for a limited development over the 1980s concourse area. Options tested included a single block facing Exchange Square at the northern end of the train shed, three blocks spaced over the length of the train shed, elongated blocks running along either side and a large block containing multiple light wells which would sprawled over the full extent of the station. Options for the over-station development tested by Network Rail prior to the selection of the current proposal for a building above the concourse A further option to build a tower scheme over the existing Metropolitan Arcade opposite the main station building on Liverpool Street was also considered but was ruled out due to ownership issues and below ground constraints of the Circle and Elizabeth Lines. Network Rail initially favoured an over station development facing Exchange Square but concluded this was scrapped because of its impact on train services, its engineering complexity and difficulty in creating viable entrances. The preferred development above the concourse was identified as the most viable, although it will not include building above the grade II*-listed former Great Eastern Hotel which had been one of the most controversial aspects of Herzog & de Meuron’s proposals for the site. The plans confirm Network Rail’s pledge last year to take a more “heritage-led” approach to the redevelopment compared to the previous scheme, which had proposed interventions in a strikingly different design to the 19th century station. That scheme was abandoned last year with Network Rail’s development partner Sellar dropped after the application amassed more than 2,000 objections from members of the public and criticism from heritage groups including Historic England. A selection of Acme’s early design concepts for the station entrances Network Rail’s property arm, Network Rail Property, is now leading the redevelopment and has sought closer collaboration with heritage groups on the design, although the Victorian Society, which led the campaign against the previous proposals, is still objecting to the new designs and has described the planned over-station office tower as “perverse”. The office component is being used to fund improvements to the rest of the station, which is currently the UK’s busiest with around 118 million people a year crossing its concourse with annual passenger numbers expected to hit 158 million by 2041. Network Rail said the redevelopment, which will significantly enlarge the building’s concourse, will enable the station to serve more than 200 million passengers a year. It also aims to turn the station into a “destination in its own right” with new retail, leisure and workspace, aligning with the City of London’s Destination City ambition to diversify its economy. The project team includes Aecom on engineering and transport, Certo as project manager, Newmark, previously known as Gerald Eve, on planning, Gleeds as cost manager, Donald Insall Associates on heritage and townscape, GIA on daylight and sunlight and SLA as landscape architect.

The data quality used in pretraining LLMs has become increasingly critical to their success. To build information-rich corpora, researchers have moved from heuristic filtering methods, such as rule-based noise removal and deduplication, to model-driven filtering, which leverages neural classifiers to identify high-quality samples. Despite its benefits, this approach still faces key issues: it lacks efficient validation mechanisms to assess data quality promptly and often relies on manually curated seed datasets that introduce subjectivity. While early datasets like C4 and Pile laid the groundwork for model development, recent efforts like RefinedWeb, Dolma, and DCLM have scaled significantly, incorporating up to trillions of tokens. Model-driven filtering has gained traction in these newer corpora for its ability to refine massive datasets and enhance LLM performance across downstream tasks. Nevertheless, the effectiveness of model-driven filtering is limited by the high costs and inefficiencies of current validation methods and the absence of clear standards for seed data selection. Recent datasets, such as FineWeb-edu and Ultra-FineWeb, have demonstrated improved model performance by using multiple classifiers to cross-verify data quality. These datasets outperform previous versions on benchmarks like MMLU, ARC, and C-Eval, indicating that refined filtering methods can enhance English and Chinese understanding. To further optimize this process, some studies propose using LLMs for multi-dimensional data evaluation via prompts or leveraging token-level perplexity scores. These innovations aim to lower computational overhead while improving data quality, ultimately enabling more effective training with fewer tokens.  Researchers from ModelBest Inc., Tsinghua University, and Soochow University developed an efficient data filtering pipeline to improve LLM training. They introduced a verification strategy that uses a nearly-trained LLM to evaluate new data by observing performance gains during final training steps, reducing computational costs. A lightweight fastText-based classifier further enhances filtering speed and accuracy. Applied to FineWeb and Chinese FineWeb datasets, this method produced the Ultra-FineWeb dataset, containing 1 trillion English and 120 billion Chinese tokens. LLMs trained on Ultra-FineWeb showed notable performance gains, confirming the pipeline’s effectiveness in improving data quality and training efficiency.  The study outlines an efficient, high-quality data filtering pipeline to reduce computational costs while maintaining data integrity. It begins by using a cost-effective verification strategy to select reliable seed samples from a candidate pool, which are then used to train a data classifier. Positive seeds are sourced from LLM annotations, curated datasets, textbooks, and synthesized content, while negatives come from diverse corpora. Classifier training avoids over-iteration, focusing instead on high-quality seed selection. A fastText-based classifier is used for scalable filtering, offering competitive performance at significantly lower inference costs compared to LLM-based methods, with preprocessing steps ensuring balanced, clean data input.  The models were trained using MegatronLM with the MiniCPM-1.2 B architecture on 100B tokens. Evaluations used Lighteval across English and Chinese benchmarks. The results show that models trained on Ultra-FineWeb consistently outperformed those trained on FineWeb and FineWeb-edu, individually and in mixed-language settings. Ultra-FineWeb-en achieved the highest English average score, while Ultra-FineWeb-zh improved performance on Chinese tasks. Ablation studies revealed that Ultra-FineWeb maintains balanced token lengths and benefits from efficient filtering strategies, highlighting its superior quality and effectiveness in improving model performance.  In conclusion, the study presents Ultra-FineWeb, a high-quality multilingual dataset comprising about 1 trillion English tokens and 120 billion Chinese tokens. Built upon FineWeb and Chinese FineWeb, it leverages a novel, efficient data filtering pipeline featuring a fastText-based lightweight classifier and a low-cost verification strategy. The pipeline enhances filtering accuracy, reduces reliance on manual seed data selection, and ensures robust performance with minimal computational overhead. Experimental results show that models trained on Ultra-FineWeb consistently outperform those trained on earlier datasets, demonstrating improved performance across benchmarks. The methodology ensures reproducibility and offers valuable insights for optimizing data quality in future LLM training.  Check out theTwitter and don’t forget to join our 90k+ ML SubReddit. Sana HassanSana Hassan, a consulting intern at Marktechpost and dual-degree student at IIT Madras, is passionate about applying technology and AI to address real-world challenges. With a keen interest in solving practical problems, he brings a fresh perspective to the intersection of AI and real-life solutions.Sana Hassanhttps://www.marktechpost.com/author/sana-hassan/Coding Agents See 75% Surge: SimilarWeb’s AI Usage Report Highlights the Sectors Winning and Losing in 2025’s Generative AI BoomSana Hassanhttps://www.marktechpost.com/author/sana-hassan/Rethinking Toxic Data in LLM Pretraining: A Co-Design Approach for Improved Steerability and DetoxificationSana Hassanhttps://www.marktechpost.com/author/sana-hassan/A Step-by-Step Guide on Building, Customizing, and Publishing an AI-Focused Blogging Website with Lovable.dev and Seamless GitHub IntegrationSana Hassanhttps://www.marktechpost.com/author/sana-hassan/NVIDIA AI Introduces Audio-SDS: A Unified Diffusion-Based Framework for Prompt-Guided Audio Synthesis and Source Separation without Specialized Datasets

Valve has dismissed widespread reports of a data breach that supposedly compromised the account details of over 89 million Steam users. In a brief but firm post, Valve said it has examined the leaked data and confirmed that Steam’s systems had not been breached, and users did not need to change their passwords or phone numbers. The leak consisted of old text messages containing one-time authentication codes that had all expired. These were linked to the phone numbers they were sent to, but the phone numbers were not linked to any account details. “The leaked data did not associate the phone numbers with a Steam account, password information, payment information or other personal data,” Valve said. “Old text messages cannot be used to breach the security of your Steam account, and whenever a code is used to change your Steam email or password using SMS, you will receive a confirmation via email and/or Steam secure messages. “You do not need to change your passwords or phone numbers as a result of this event. It is a good reminder to treat any account security messages that you have not explicitly requested as suspicious.” Valve said it has not determined the source of the leak, noting that SMS messages like those leaked are unencrypted and pass through multiple providers. Earlier reports had suggested that a vendor used by Valve to send the authentication codes was the source. According to the initial reports, such as this LinkedIn post by Underdark.ai, the data had been posted on the dark web for sale at a price of $5,000. So, we can all rest easy. But it’s a good reminder to turn on two-factor authentication for Steam (and all your online accounts), and to be suspicious of unsolicited messages.

Bagging and boosting are two powerful ensemble techniques in machine learning – they are must-knows for data scientists! After reading this article, you are going to have a solid understanding of how bagging and boosting work and when to use them. We’ll cover the following topics, relying heavily on examples to give hands-on illustration of the key concepts: How Ensembling helps create powerful models Bagging: Adding stability to ML models Boosting: Reducing bias in weak learners Bagging vs. Boosting – when to use each and why Creating powerful models with ensembling In Machine Learning, ensembling is a broad term that refers to any technique that creates predictions by combining the predictions from multiple models. If there is more than one model involved in making a prediction, the technique is using ensembling! Ensembling approaches can often improve the performance of a single model. Ensembling can help reduce: Variance by averaging multiple models Bias by iteratively improving on errors Overfitting because using multiple models can increase robustness to spurious relationships Bagging and boosting are both ensemble methods that can perform much better than their single-model counterparts. Let’s get into the details of these now! Bagging: Adding stability to ML models Bagging is a specific ensembling technique that is used to reduce the variance of a predictive model. Here, I’m talking about variance in the machine learning sense – i.e., how much a model varies with changes to the training dataset – not variance in the statistical sense which measures the spread of a distribution. Because bagging helps reduce an ML model’s variance, it will often improve models that are high variance (e.g., decision trees and KNN) but won’t do much good for models that are low variance (e.g., linear regression). Now that we understand when bagging helps (high variance models), let’s get into the details of the inner workings to understand how it helps! The bagging algorithm is iterative in nature – it builds multiple models by repeating the following three steps: Bootstrap a dataset from the original training data Train a model on the bootstrapped dataset Save the trained model The collection of models created in this process is called an ensemble. When it is time to make a prediction, each model in the ensemble makes its own prediction – the final bagged prediction is the average (for regression) or majority vote (for classification) of all of the ensemble’s predictions. Now that we understand how bagging works, let’s take a few minutes to build an intuition for why it works. We’ll borrow a familiar idea from traditional statistics: sampling to estimate a population mean. In statistics, each sample drawn from a distribution is a random variable. Small sample sizes tend to have high variance and may provide poor estimates of the true mean. But as we collect more samples, the average of those samples becomes a much better approximation of the population mean. Similarly, we can think of each of our individual decision trees as a random variable — after all, each tree is trained on a different random sample of the data! By averaging predictions from many trees, bagging reduces variance and produces an ensemble model that better captures the true relationships in the data. Bagging Example We will be using the load_diabetes1 dataset from the scikit-learn Python package to illustrate a simple bagging example. The dataset has 10 input variables – Age, Sex, BMI, Blood Pressure and 6 blood serum levels (S1-S6). And a single output variable that is a measurement of disease progression. The code below pulls in our data and does some very simple cleaning. With our dataset established, let’s start modeling! # pull in and format data from sklearn.datasets import load_diabetes diabetes = load_diabetes(as_frame=True) df = pd.DataFrame(diabetes.data, columns=diabetes.feature_names) df.loc[:, 'target'] = diabetes.target df = df.dropna() For our example, we will use basic decision trees as our base models for bagging. Let’s first verify that our decision trees are indeed high variance. We will do this by training three decision trees on different bootstrapped datasets and observing the variance of the predictions for a test dataset. The graph below shows the predictions of three different decision trees on the same test dataset. Each dotted vertical line is an individual observation from the test dataset. The three dots on each line are the predictions from the three different decision trees. Variance of decision trees on test data points – image by author In the chart above, we see that individual trees can give very different predictions (spread of the three dots on each vertical line) when trained on bootstrapped datasets. This is the variance we have been talking about! Now that we see that our trees aren’t very robust to training samples – let’s average the predictions to see how bagging can help! The chart below shows the average of the three trees. The diagonal line represents perfect predictions. As you can see, with bagging, our points are tighter and more centered around the diagonal. image by author We’ve already seen significant improvement in our model with the average of just three trees. Let’s beef up our bagging algorithm with more trees! Here is the code to bag as many trees as we want: def train_bagging_trees(df, target_col, pred_cols, n_trees): ''' Creates a decision tree bagging model by training multiple decision trees on bootstrapped data. inputs df (pandas DataFrame) : training data with both target and input columns target_col (str) : name of target column pred_cols (list) : list of predictor column names n_trees (int) : number of trees to be trained in the ensemble output: train_trees (list) : list of trained trees ''' train_trees = [] for i in range(n_trees): # bootstrap training data temp_boot = bootstrap(train_df) #train tree temp_tree = plain_vanilla_tree(temp_boot, target_col, pred_cols) # save trained tree in list train_trees.append(temp_tree) return train_trees def bagging_trees_pred(df, train_trees, target_col, pred_cols): ''' Takes a list of bagged trees and creates predictions by averaging the predictions of each individual tree. inputs df (pandas DataFrame) : training data with both target and input columns train_trees (list) : ensemble model - which is a list of trained decision trees target_col (str) : name of target column pred_cols (list) : list of predictor column names output: avg_preds (list) : list of predictions from the ensembled trees ''' x = df[pred_cols] y = df[target_col] preds = [] # make predictions on data with each decision tree for tree in train_trees: temp_pred = tree.predict(x) preds.append(temp_pred) # get average of the trees' predictions sum_preds = [sum(x) for x in zip(*preds)] avg_preds = [x / len(train_trees) for x in sum_preds] return avg_preds The functions above are very simple, the first trains the bagging ensemble model, the second takes the ensemble (simply a list of trained trees) and makes predictions given a dataset. With our code established, let’s run multiple ensemble models and see how our out-of-bag predictions change as we increase the number of trees. Out-of-bag predictions vs. actuals colored by number of bagged trees – image by author Admittedly, this chart looks a little crazy. Don’t get too bogged down with all of the individual data points, the lines dashed tell the main story! Here we have 1 basic decision tree model and 3 bagged decision tree models – with 3, 50 and 150 trees. The color-coded dotted lines mark the upper and lower ranges for each model’s residuals. There are two main takeaways here: (1) as we add more trees, the range of the residuals shrinks and (2) there is diminishing returns to adding more trees – when we go from 1 to 3 trees, we see the range shrink a lot, when we go from 50 to 150 trees, the range tightens just a little. Now that we’ve successfully gone through a full bagging example, we are about ready to move onto boosting! Let’s do a quick overview of what we covered in this section: Bagging reduces variance of ML models by averaging the predictions of multiple individual models Bagging is most helpful with high-variance models The more models we bag, the lower the variance of the ensemble – but there are diminishing returns to the variance reduction benefit Okay, let’s move on to boosting! Boosting: Reducing bias in weak learners With bagging, we create multiple independent models – the independence of the models helps average out the noise of individual models. Boosting is also an ensembling technique; similar to bagging, we will be training multiple models…. But very different from bagging, the models we train will be dependent. Boosting is a modeling technique that trains an initial model and then sequentially trains additional models to improve the predictions of prior models. The primary target of boosting is to reduce bias – though it can also help reduce variance. We’ve established that boosting iteratively improves predictions – let’s go deeper into how. Boosting algorithms can iteratively improve model predictions in two ways: Directly predicting the residuals of the last model and adding them to the prior predictions – think of it as residual corrections Adding more weight to the observations that the prior model predicted poorly Because boosting’s main goal is to reduce bias, it works well with base models that typically have more bias (e.g., shallow decision trees). For our examples, we are going to use shallow decision trees as our base model – we will only cover the residual prediction approach in this article for brevity. Let’s jump into the boosting example! Predicting prior residuals The residuals prediction approach starts off with an initial model (some algorithms provide a constant, others use one iteration of the base model) and we calculate the residuals of that initial prediction. The second model in the ensemble predicts the residuals of the first model. With our residual predictions in-hand, we add the residual predictions to our initial prediction (this gives us residual corrected predictions) and recalculate the updated residuals…. we continue this process until we have created the number of base models we specified. This process is pretty simple, but is a little hard to explain with just words – the flowchart below shows a simple, 4-model boosting algorithm. Flowchart of simple, 4 model boosting algorithm – image by author When boosting, we need to set three main parameters: (1) the number of trees, (2) the tree depth and (3) the learning rate. I’ll spend a little time discussing these inputs now. Number of Trees For boosting, the number of trees means the same thing as in bagging – i.e., the total number of trees that will be trained for the ensemble. But, unlike boosting, we should not err on the side of more trees! The chart below shows the test RMSE against the number of trees for the diabetes dataset. Unlike with bagging, too many trees in boosting leads to overfitting! – image by author This shows that the test RMSE drops quickly with the number of trees up until about 200 trees, then it starts to creep back up. It looks like a classic ‘overfitting’ chart – we reach a point where more trees becomes worse for the model. This is a key difference between bagging and boosting – with bagging, more trees eventually stop helping, with boosting more trees eventually start hurting! With bagging, more trees eventually stops helping, with boosting more trees eventually starts hurting! We now know that too many trees are bad, and too few trees are bad as well. We will use hyperparameter tuning to select the number of trees. Note – hyperparameter tuning is a huge subject and way outside of the scope of this article. I’ll demonstrate a simple grid search with a train and test dataset for our example a little later. Tree Depth This is the maximum depth for each tree in the ensemble. With bagging, trees are often allowed to go as deep they want because we are looking for low bias, high variance models. With boosting however, we use sequential models to address the bias in the base learners – so we aren’t as concerned about generating low-bias trees. How do we decide how the maximum depth? The same technique that we’ll use with the number of trees, hyperparameter tuning. Learning Rate The number of trees and the tree depth are familiar parameters from bagging (although in bagging we often didn’t put a limit on the tree depth) – but this ‘learning rate’ character is a new face! Let’s take a moment to get familiar. The learning rate is a number between 0 and 1 that is multiplied by the current model’s residual predictions before it is added to the overall predictions. Here’s a simple example of the prediction calculations with a learning rate of 0.5. Once we understand the mechanics of how the learning rate works, we will discuss the why the learning rate is important. The learning rate discounts the residual prediction before updating the actual target prediction – image by author So, why would we want to ‘discount’ our residual predictions, wouldn’t that make our predictions worse? Well, yes and no. For a single iteration, it will likely make our predictions worse – but, we are doing multiple iterations. For multiple iterations, the learning rate keeps the model from overreacting to a single tree’s predictions. It will probably make our current predictions worse, but don’t worry, we will go through this process multiple times! Ultimately, the learning rate helps mitigate overfitting in our boosting model by lowering the influence of any single tree in the ensemble. You can think of it as slowly turning the steering wheel to correct your driving rather than jerking it. In practice, the number of trees and the learning rate have an opposite relationship, i.e., as the learning rate goes down, the number of trees goes up. This is intuitive, because if we only allow a small amount of each tree’s residual prediction to be added to the overall prediction, we are going to need a lot more trees before our overall prediction will start looking good. Ultimately, the learning rate helps mitigate overfitting in our boosting model by lowering the influence of any single tree in the ensemble. Alright, now that we’ve covered the main inputs in boosting, let’s get into the Python coding! We need a couple of functions to create our boosting algorithm: Base decision tree function – a simple function to create and train a single decision tree. We will use the same function from the last section called ‘plain_vanilla_tree.’ Boosting training function – this function sequentially trains and updates residuals for as many decision trees as the user specifies. In our code, this function is called ‘boost_resid_correction.’ Boosting prediction function – this function takes a series of boosted models and makes final ensemble predictions. We call this function ‘boost_resid_correction_pred.’ Here are the functions written in Python: # same base tree function as in prior section def plain_vanilla_tree(df_train, target_col, pred_cols, max_depth = 3, weights=[]): X_train = df_train[pred_cols] y_train = df_train[target_col] tree = DecisionTreeRegressor(max_depth = max_depth, random_state=42) if weights: tree.fit(X_train, y_train, sample_weights=weights) else: tree.fit(X_train, y_train) return tree # residual predictions def boost_resid_correction(df_train, target_col, pred_cols, num_models, learning_rate=1, max_depth=3): ''' Creates boosted decision tree ensemble model. Inputs: df_train (pd.DataFrame) : contains training data target_col (str) : name of target column pred_col (list) : target column names num_models (int) : number of models to use in boosting learning_rate (float, def = 1) : discount given to residual predictions takes values between (0, 1] max_depth (int, def = 3) : max depth of each tree model Outputs: boosting_model (dict) : contains everything needed to use model to make predictions - includes list of all trees in the ensemble ''' # create initial predictions model1 = plain_vanilla_tree(df_train, target_col, pred_cols, max_depth = max_depth) initial_preds = model1.predict(df_train[pred_cols]) df_train['resids'] = df_train[target_col] - initial_preds # create multiple models, each predicting the updated residuals models = [] for i in range(num_models): temp_model = plain_vanilla_tree(df_train, 'resids', pred_cols) models.append(temp_model) temp_pred_resids = temp_model.predict(df_train[pred_cols]) df_train['resids'] = df_train['resids'] - (learning_rate*temp_pred_resids) boosting_model = {'initial_model' : model1, 'models' : models, 'learning_rate' : learning_rate, 'pred_cols' : pred_cols} return boosting_model # This function takes the residual boosted model and scores data def boost_resid_correction_predict(df, boosting_models, chart = False): ''' Creates predictions on a dataset given a boosted model. Inputs: df (pd.DataFrame) : data to make predictions boosting_models (dict) : dictionary containing all pertinent boosted model data chart (bool, def = False) : indicates if performance chart should be created Outputs: pred (np.array) : predictions from boosted model rmse (float) : RMSE of predictions ''' # get initial predictions initial_model = boosting_models['initial_model'] pred_cols = boosting_models['pred_cols'] pred = initial_model.predict(df[pred_cols]) # calculate residual predictions from each model and add models = boosting_models['models'] learning_rate = boosting_models['learning_rate'] for model in models: temp_resid_preds = model.predict(df[pred_cols]) pred += learning_rate*temp_resid_preds if chart: plt.scatter(df['target'], pred) plt.show() rmse = np.sqrt(mean_squared_error(df['target'], pred)) return pred, rmse Sweet, let’s make a model on the same diabetes dataset that we used in the bagging section. We’ll do a quick grid search (again, not doing anything fancy with the tuning here) to tune our three parameters and then we’ll train the final model using the boost_resid_correction function. # tune parameters with grid search n_trees = [5,10,30,50,100,125,150,200,250,300] learning_rates = [0.001, 0.01, 0.1, 0.25, 0.50, 0.75, 0.95, 1] max_depths = my_list = list(range(1, 16)) # Create a dictionary to hold test RMSE for each 'square' in grid perf_dict = {} for tree in n_trees: for learning_rate in learning_rates: for max_depth in max_depths: temp_boosted_model = boost_resid_correction(train_df, 'target', pred_cols, tree, learning_rate=learning_rate, max_depth=max_depth) temp_boosted_model['target_col'] = 'target' preds, rmse = boost_resid_correction_predict(test_df, temp_boosted_model) dict_key = '_'.join(str(x) for x in [tree, learning_rate, max_depth]) perf_dict[dict_key] = rmse min_key = min(perf_dict, key=perf_dict.get) print(perf_dict[min_key]) And our winner is — 50 trees, a learning rate of 0.1 and a max depth of 1! Let’s take a look and see how our predictions did. Tuned boosting actuals vs. residuals – image by author While our boosting ensemble model seems to capture the trend reasonably well, we can see off the bat that it isn’t predicting as well as the bagging model. We could probably spend more time tuning – but it could also be the case that the bagging approach fits this specific data better. With that said, we’ve now earned an understanding of bagging and boosting – let’s compare them in the next section! Bagging vs. Boosting – understanding the differences We’ve covered bagging and boosting separately, the table below brings all the information we’ve covered to concisely compare the approaches: image by author Note: In this article, we wrote our own bagging and boosting code for educational purposes. In practice you will just use the excellent code that is available in Python packages or other software. Also, people rarely use ‘pure’ bagging or boosting – it is much more common to use more advanced algorithms that modify the plain vanilla bagging and boosting to improve performance. Wrapping it up Bagging and boosting are powerful and practical ways to improve weak learners like the humble but flexible decision tree. Both approaches use the power of ensembling to address different problems – bagging for variance, boosting for bias. In practice, pre-packaged code is almost always used to train more advanced machine learning models that use the main ideas of bagging and boosting but, expand on them with multiple improvements. I hope that this has been helpful and interesting – happy modeling! Dataset is originally from the National Institute of Diabetes and Digestive and Kidney Diseases and is distributed under the public domain license for use without restriction. The post Strength in Numbers: Ensembling Models with Bagging and Boosting appeared first on Towards Data Science.

Valve has dismissed widespread reports of a data breach that supposedly compromised the account details of over 89 million Steam users. In a brief but firm post, Valve said it has examined the leaked data and confirmed that Steam’s systems had not been breached, and users did not need to change their passwords or phone numbers. The leak consisted of old text messages containing one-time authentication codes that had all expired. These were linked to the phone numbers they were sent to, but the phone numbers were not linked to any account details. “The leaked data did not associate the phone numbers with a Steam account, password information, payment information or other personal data,” Valve said. “Old text messages cannot be used to breach the security of your Steam account, and whenever a code is used to change your Steam email or password using SMS, you will receive a confirmation via email and/or Steam secure messages. “You do not need to change your passwords or phone numbers as a result of this event. It is a good reminder to treat any account security messages that you have not explicitly requested as suspicious.” Valve said it has not determined the source of the leak, noting that SMS messages like those leaked are unencrypted and pass through multiple providers. Earlier reports had suggested that a vendor used by Valve to send the authentication codes was the source. According to the initial reports, such as this LinkedIn post by Underdark.ai, the data had been posted on the dark web for sale at a price of $5,000. So, we can all rest easy. But it’s a good reminder to turn on two-factor authentication for Steam (and all your online accounts), and to be suspicious of unsolicited messages.

In this tutorial, we demonstrate how to construct an automated Knowledge Graph (KG) pipeline using LangGraph and NetworkX. The pipeline simulates a sequence of intelligent agents that collaboratively perform tasks such as data gathering, entity extraction, relation identification, entity resolution, and graph validation. Starting from a user-provided topic, such as “Artificial Intelligence,” the system methodically extracts relevant entities and relationships, resolves duplicates, and integrates the information into a cohesive graphical structure. By visualizing the final knowledge graph, developers and data scientists gain clear insights into complex interrelations among concepts, making this approach highly beneficial for applications in semantic analysis, natural language processing, and knowledge management. !pip install langgraph langchain_core We install two essential Python libraries: LangGraph, which is used for creating and orchestrating agent-based computational workflows, and LangChain Core, which provides foundational classes and utilities for building language model-powered applications. These libraries enable seamless integration of agents into intelligent data pipelines. import re import networkx as nx import matplotlib.pyplot as plt from typing import TypedDict, List, Tuple, Dict, Any from langchain_core.messages import HumanMessage, AIMessage from langgraph.graph import StateGraph, END We import essential libraries to build an automated knowledge graph pipeline. It includes re for regular expression-based text processing, NetworkX and matplotlib for creating and visualizing graphs, TypedDict and typing annotations for structured data handling, and LangGraph along with langchain_core for orchestrating the interaction between AI agents within the workflow. class KGState(TypedDict): topic: str raw_text: str entities: List[str] relations: List[Tuple[str, str, str]] resolved_relations: List[Tuple[str, str, str]] graph: Any validation: Dict[str, Any] messages: List[Any] current_agent: str We define a structured data type, KGState, using Python’s TypedDict. It outlines the schema for managing state across different steps of the knowledge graph pipeline. It includes details like the chosen topic, gathered text, identified entities and relationships, resolved duplicates, the constructed graph object, validation results, interaction messages, and tracking the currently active agent. def data_gatherer(state: KGState) -> KGState: topic = state["topic"] print(f"📚 Data Gatherer: Searching for information about '{topic}'") collected_text = f"{topic} is an important concept. It relates to various entities like EntityA, EntityB, and EntityC. EntityA influences EntityB. EntityC is a type of EntityB." state["messages"].append(AIMessage(content=f"Collected raw text about {topic}")) state["raw_text"] = collected_text state["current_agent"] = "entity_extractor" return state This function, data_gatherer, acts as the first step in the pipeline. It simulates gathering raw text data about a provided topic (stored in state[“topic”]). It then stores this simulated data into state[“raw_text”], adds a message indicating the data collection completion, and updates the pipeline’s state by setting the next agent (entity_extractor) as active. def entity_extractor(state: KGState) -> KGState: print("🔍 Entity Extractor: Identifying entities in the text") text = state["raw_text"] entities = re.findall(r"Entity[A-Z]", text) entities = [state["topic"]] + entities state["entities"] = list(set(entities)) state["messages"].append(AIMessage(content=f"Extracted entities: {state['entities']}")) print(f" Found entities: {state['entities']}") state["current_agent"] = "relation_extractor" return state The entity_extractor function identifies entities from the collected raw text using a simple regular expression pattern that matches terms like “EntityA”, “EntityB”, etc. It also includes the main topic as an entity and ensures uniqueness by converting the list to a set. The extracted entities are stored in the state, an AI message logs the result, and the pipeline advances to the relation_extractor agent. def relation_extractor(state: KGState) -> KGState: print("🔗 Relation Extractor: Identifying relationships between entities") text = state["raw_text"] entities = state["entities"] relations = [] relation_patterns = [ (r"([A-Za-z]+) relates to ([A-Za-z]+)", "relates_to"), (r"([A-Za-z]+) influences ([A-Za-z]+)", "influences"), (r"([A-Za-z]+) is a type of ([A-Za-z]+)", "is_type_of") ] for e1 in entities: for e2 in entities: if e1 != e2: for pattern, rel_type in relation_patterns: if re.search(f"{e1}.*{rel_type}.*{e2}", text.replace("_", " "), re.IGNORECASE) or \ re.search(f"{e1}.*{e2}", text, re.IGNORECASE): relations.append((e1, rel_type, e2)) state["relations"] = relations state["messages"].append(AIMessage(content=f"Extracted relations: {relations}")) print(f" Found relations: {relations}") state["current_agent"] = "entity_resolver" return state The relation_extractor function detects semantic relationships between entities within the raw text. It uses predefined regex patterns to identify phrases like “influences” or “is a type of” between entity pairs. When a match is found, it adds the corresponding relation as a triple (subject, predicate, object) to the relations list. These extracted relations are stored in the state, a message is logged for agent communication, and control moves to the next agent: entity_resolver. def entity_resolver(state: KGState) -> KGState: print("🔄 Entity Resolver: Resolving duplicate entities") entity_map = {} for entity in state["entities"]: canonical_name = entity.lower().replace(" ", "_") entity_map[entity] = canonical_name resolved_relations = [] for s, p, o in state["relations"]: s_resolved = entity_map.get(s, s) o_resolved = entity_map.get(o, o) resolved_relations.append((s_resolved, p, o_resolved)) state["resolved_relations"] = resolved_relations state["messages"].append(AIMessage(content=f"Resolved relations: {resolved_relations}")) state["current_agent"] = "graph_integrator" return state The entity_resolver function standardizes entity names to avoid duplication and inconsistencies. It creates a mapping (entity_map) by converting each entity to lowercase and replacing spaces with underscores. Then, this mapping is applied to all subjects and objects in the extracted relations to produce resolved relations. These normalized triples are added to the state, a confirmation message is logged, and control is passed to the graph_integrator agent. def graph_integrator(state: KGState) -> KGState: print("📊 Graph Integrator: Building the knowledge graph") G = nx.DiGraph() for s, p, o in state["resolved_relations"]: if not G.has_node(s): G.add_node(s) if not G.has_node(o): G.add_node(o) G.add_edge(s, o, relation=p) state["graph"] = G state["messages"].append(AIMessage(content=f"Built graph with {len(G.nodes)} nodes and {len(G.edges)} edges")) state["current_agent"] = "graph_validator" return state The graph_integrator function constructs the actual knowledge graph using networkx.DiGraph() supports directed relationships. It iterates over the resolved triples (subject, predicate, object), ensures both nodes exist, and then adds a directed edge with the relation as metadata. The resulting graph is saved in the state, a summary message is appended, and the pipeline transitions to the graph_validator agent for final validation. def graph_validator(state: KGState) -> KGState: print("✅ Graph Validator: Validating knowledge graph") G = state["graph"] validation_report = { "num_nodes": len(G.nodes), "num_edges": len(G.edges), "is_connected": nx.is_weakly_connected(G) if G.nodes else False, "has_cycles": not nx.is_directed_acyclic_graph(G) if G.nodes else False } state["validation"] = validation_report state["messages"].append(AIMessage(content=f"Validation report: {validation_report}")) print(f" Validation report: {validation_report}") state["current_agent"] = END return state The graph_validator function performs a basic health check on the constructed knowledge graph. It compiles a validation report containing the number of nodes and edges, whether the graph is weakly connected (i.e., every node is reachable if direction is ignored), and whether the graph contains cycles. This report is added to the state and logged as an AI message. Once validation is complete, the pipeline is marked as finished by setting the current_agent to END. def router(state: KGState) -> str: return state["current_agent"] def visualize_graph(graph): plt.figure(figsize=(10, 6)) pos = nx.spring_layout(graph) nx.draw(graph, pos, with_labels=True, node_color='skyblue', node_size=1500, font_size=10) edge_labels = nx.get_edge_attributes(graph, 'relation') nx.draw_networkx_edge_labels(graph, pos, edge_labels=edge_labels) plt.title("Knowledge Graph") plt.tight_layout() plt.show() The router function directs the pipeline to the next agent based on the current_agent field in the state. Meanwhile, the visualize_graph function uses matplotlib and networkx to display the final knowledge graph, showing nodes, edges, and labeled relationships for intuitive visual understanding. def build_kg_graph(): workflow = StateGraph(KGState) workflow.add_node("data_gatherer", data_gatherer) workflow.add_node("entity_extractor", entity_extractor) workflow.add_node("relation_extractor", relation_extractor) workflow.add_node("entity_resolver", entity_resolver) workflow.add_node("graph_integrator", graph_integrator) workflow.add_node("graph_validator", graph_validator) workflow.add_conditional_edges("data_gatherer", router, {"entity_extractor": "entity_extractor"}) workflow.add_conditional_edges("entity_extractor", router, {"relation_extractor": "relation_extractor"}) workflow.add_conditional_edges("relation_extractor", router, {"entity_resolver": "entity_resolver"}) workflow.add_conditional_edges("entity_resolver", router, {"graph_integrator": "graph_integrator"}) workflow.add_conditional_edges("graph_integrator", router, {"graph_validator": "graph_validator"}) workflow.add_conditional_edges("graph_validator", router, {END: END}) workflow.set_entry_point("data_gatherer") return workflow.compile() The build_kg_graph function defines the complete knowledge graph workflow using LangGraph. It sequentially adds each agent as a node, from data collection to graph validation, and connects them through conditional transitions based on the current agent. The entry point is set to data_gatherer, and the graph is compiled into an executable workflow that guides the automated pipeline from start to finish. def run_knowledge_graph_pipeline(topic): print(f"🚀 Starting knowledge graph pipeline for: {topic}") initial_state = { "topic": topic, "raw_text": "", "entities": [], "relations": [], "resolved_relations": [], "graph": None, "validation": {}, "messages": [HumanMessage(content=f"Build a knowledge graph about {topic}")], "current_agent": "data_gatherer" } kg_app = build_kg_graph() final_state = kg_app.invoke(initial_state) print(f"✨ Knowledge graph construction complete for: {topic}") return final_state The run_knowledge_graph_pipeline function initializes the pipeline by setting up an empty state dictionary with the provided topic. It builds the workflow using build_kg_graph(), then runs it by invoking the compiled graph with the initial state. As each agent processes the data, the state evolves, and the final result contains the complete knowledge graph, validated and ready for use. if __name__ == "__main__": topic = "Artificial Intelligence" result = run_knowledge_graph_pipeline(topic) visualize_graph(result["graph"]) Finally, this block serves as the script’s entry point. When executed directly, it triggers the knowledge graph pipeline for the topic “Artificial Intelligence,” runs through all agent stages, and finally visualizes the resulting graph using the visualize_graph() function. It provides an end-to-end demonstration of automated knowledge graph generation. Output Generated from Knowledge Graph Execution In conclusion, we have learned how to seamlessly integrate multiple specialized agents into a cohesive knowledge graph pipeline through this structured approach, leveraging LangGraph and NetworkX. This workflow automates entity and relation extraction processes and visualizes intricate relationships, offering a clear and actionable representation of gathered information. By adjusting and enhancing individual agents, such as employing more sophisticated entity recognition methods or integrating real-time data sources, this foundational framework can be scaled and customized for advanced knowledge graph construction tasks across various domains. Check out the Colab Notebook. All credit for this research goes to the researchers of this project. Also, feel free to follow us on Twitter and don’t forget to join our 90k+ ML SubReddit. Asif RazzaqWebsite |  + postsBioAsif Razzaq is the CEO of Marktechpost Media Inc.. As a visionary entrepreneur and engineer, Asif is committed to harnessing the potential of Artificial Intelligence for social good. His most recent endeavor is the launch of an Artificial Intelligence Media Platform, Marktechpost, which stands out for its in-depth coverage of machine learning and deep learning news that is both technically sound and easily understandable by a wide audience. The platform boasts of over 2 million monthly views, illustrating its popularity among audiences.Asif Razzaqhttps://www.marktechpost.com/author/6flvq/Google DeepMind Introduces AlphaEvolve: A Gemini-Powered Coding AI Agent for Algorithm Discovery and Scientific OptimizationAsif Razzaqhttps://www.marktechpost.com/author/6flvq/Rime Introduces Arcana and Rimecaster (Open Source): Practical Voice AI Tools Built on Real-World SpeechAsif Razzaqhttps://www.marktechpost.com/author/6flvq/A Step-by-Step Guide to Build a Fast Semantic Search and RAG QA Engine on Web-Scraped Data Using Together AI Embeddings, FAISS Retrieval, and LangChainAsif Razzaqhttps://www.marktechpost.com/author/6flvq/Agent-Based Debugging Gets a Cost-Effective Alternative: Salesforce AI Presents SWERank for Accurate and Scalable Software Issue Localization