YouZum

Uncategorized

AI, Committee, ニュース, Uncategorized

Hackers made death threats against this security researcher. Big mistake.

The threats started in spring.  In April 2024, a mysterious someone using the online handles “Waifu” and “Judische” began posting death threats on Telegram and Discord channels aimed at a cybersecurity researcher named Allison Nixon.  “Alison [sic] Nixon is gonna get necklaced with a tire filled with gasoline soon,” wrote Waifu/Judische, both of which are words with offensive connotations. “Decerebration is my fav type of brain death, thats whats gonna happen to alison Nixon.”  It wasn’t long before others piled on. Someone shared AI-generated nudes of Nixon. These anonymous personas targeted Nixon because she had become a formidable threat: As chief research officer at the cyber investigations firm Unit 221B, named after Sherlock Holmes’s apartment, she had built a career tracking cybercriminals and helping get them arrested. For years she had lurked quietly in online chat channels or used pseudonyms to engage with perpetrators directly while piecing together clues they’d carelessly drop about themselves and their crimes. This had helped her bring to justice a number of cybercriminals—especially members of a loosely affiliated subculture of anarchic hackers who call themselves the Com. But members of the Com aren’t just involved in hacking; some of them also engage in offline violence against researchers who track them. This includes bricking (throwing a brick through a victim’s window) and swatting (a dangerous type of hoax that involves reporting a false murder or hostage situation at someone’s home so SWAT teams will swarm it with guns drawn). Members of a Com offshoot known as 764 have been accused of even more violent acts—including animal torture, stabbings, and school shootings—or of inciting others in and outside the Com to commit these crimes. Nixon started tracking members of the community more than a decade ago, when other researchers and people in law enforcement were largely ignoring them because they were young—many in their teens. Her early attention allowed her to develop strategies for unmasking them. Ryan Brogan, a special agent with the FBI, says Nixon has helped him and colleagues identify and arrest more than two dozen members of the community since 2011, when he first began working with her, and that her skills in exposing them are unparalleled. “If you get on Allison’s and my radar, you’re going [down]. It’s just a matter of time,” he says. “No matter how much digital anonymity and tradecraft you try to apply, you’re done.” Though she’d done this work for more than a decade, Nixon couldn’t understand why the person behind the Waifu/Judische accounts was suddenly threatening her. She had given media interviews about the Com—most recently on 60 Minutes—but not about her work unmasking members to get them arrested, so the hostility seemed to come out of the blue. And although she had taken an interest in the Waifu persona in years past for crimes he boasted about committing, he hadn’t been on her radar for a while when the threats began, because she was tracking other targets.  Now Nixon resolved to unmask Waifu/Judische and others responsible for the death threats—and take them down for crimes they admitted to committing. “Prior to them death-threatening me, I had no reason to pay attention to them,” she says.  Com beginnings Most people have never heard of the Com, but its influence and threat are growing. It’s an online community comprising loosely affiliated groups of, primarily, teens and twentysomethings in North America and English-speaking parts of Europe who have become part of what some call a cybercrime youth movement.  International laws and norms, and fears of retaliation, prevent states from going all out in cyber operations. That doesn’t stop the anarchic Com. Over the last decade, its criminal activities have escalated from simple distributed denial-of-service (DDoS) attacks that disrupt websites to SIM-swapping hacks that hijack a victim’s phone service, as well as crypto theft, ransomware attacks, and corporate data theft. These crimes have affected AT&T, Microsoft, Uber, and others. Com members have also been involved in various forms of sextortion aimed at forcing victims to physically harm themselves or record themselves doing sexually explicit activities. The Com’s impact has also spread beyond the digital realm to kidnapping, beatings, and other violence.  One longtime cybercrime researcher, who asked to remain anonymous because of his work, says the Com is as big a threat in the cyber realm as Russia and China—for one unusual reason. “There’s only so far that China is willing to go; there’s only so far that Russia or North Korea is willing to go,” he says, referring to international laws and norms, and fears of retaliation, that prevent states from going all out in cyber operations. That doesn’t stop the anarchic Com, he says. FRANZISKA BARCZYK “It is a pretty significant threat, and people tend to … push it under the rug [because] it’s just a bunch of kids,” he says. “But look at the impact [they have].” Brogan says the amount of damage they do in terms of monetary losses “can become staggering very quickly.” There is no single site where Com members congregate; they spread across a number of web forums and Telegram and Discord channels. The group follows a long line of hacking and subculture communities that emerged online over the last two decades, gained notoriety, and then faded or vanished after prominent members were arrested or other factors caused their decline. They differed in motivation and activity, but all emerged from “the same primordial soup,” says Nixon. The Com’s roots can be traced to the Scene, which began as a community of various “warez” groups engaged in pirating computer games, music, and movies. When Nixon began looking at the Scene, in 2011, its members were hijacking gaming accounts, launching DDoS attacks, and running booter services. (DDoS attacks overwhelm a server or computer with traffic from bot-controlled machines, preventing legitimate traffic from getting through; booters are tools that anyone can rent to launch a DDoS attack against a target of choice.) While they made some money, their primary goal was notoriety. This changed around

Hackers made death threats against this security researcher. Big mistake. 投稿を読む »

AI, Committee, ニュース, Uncategorized

Meet ‘Kani-TTS-2’: A 400M Param Open Source Text-to-Speech Model that Runs in 3GB VRAM with Voice Cloning Support

The landscape of generative audio is shifting toward efficiency. A new open-source contender, Kani-TTS-2, has been released by the team at nineninesix.ai. This model marks a departure from heavy, compute-expensive TTS systems. Instead, it treats audio as a language, delivering high-fidelity speech synthesis with a remarkably small footprint. Kani-TTS-2 offers a lean, high-performance alternative to closed-source APIs. It is currently available on Hugging Face in both English (EN) and Portuguese (PT) versions. The Architecture: LFM2 and NanoCodec Kani-TTS-2 follows the ‘Audio-as-Language‘ philosophy. The model does not use traditional mel-spectrogram pipelines. Instead, it converts raw audio into discrete tokens using a neural codec. The system relies on a two-stage process: The Language Backbone: The model is built on LiquidAI’s LFM2 (350M) architecture. This backbone generates ‘audio intent’ by predicting the next audio tokens. Because LFM (Liquid Foundation Models) are designed for efficiency, they provide a faster alternative to standard transformers. The Neural Codec: It uses the NVIDIA NanoCodec to turn those tokens into 22kHz waveforms. By using this architecture, the model captures human-like prosody—the rhythm and intonation of speech—without the ‘robotic’ artifacts found in older TTS systems. Efficiency: 10,000 Hours in 6 Hours The training metrics for Kani-TTS-2 are a masterclass in optimization. The English model was trained on 10,000 hours of high-quality speech data. While that scale is impressive, the speed of training is the real story. The research team trained the model in only 6 hours using a cluster of 8 NVIDIA H100 GPUs. This proves that massive datasets no longer require weeks of compute time when paired with efficient architectures like LFM2. Zero-Shot Voice Cloning and Performance The standout feature for developers is zero-shot voice cloning. Unlike traditional models that require fine-tuning for new voices, Kani-TTS-2 uses speaker embeddings. How it works: You provide a short reference audio clip. The result: The model extracts the unique characteristics of that voice and applies them to the generated text instantly. From a deployment perspective, the model is highly accessible: Parameter Count: 400M (0.4B) parameters. Speed: It features a Real-Time Factor (RTF) of 0.2. This means it can generate 10 seconds of speech in roughly 2 seconds. Hardware: It requires only 3GB of VRAM, making it compatible with consumer-grade GPUs like the RTX 3060 or 4050. License: Released under the Apache 2.0 license, allowing for commercial use. Key Takeaways Efficient Architecture: The model uses a 400M parameter backbone based on LiquidAI’s LFM2 (350M). This ‘Audio-as-Language’ approach treats speech as discrete tokens, allowing for faster processing and more human-like intonation compared to traditional architectures. Rapid Training at Scale: Kani-TTS-2-EN was trained on 10,000 hours of high-quality speech data in just 6 hours using 8 NVIDIA H100 GPUs. Instant Zero-Shot Cloning: There is no need for fine-tuning to replicate a specific voice. By providing a short reference audio clip, the model uses speaker embeddings to instantly synthesize text in the target speaker’s voice. High Performance on Edge Hardware: With a Real-Time Factor (RTF) of 0.2, the model can generate 10 seconds of audio in approximately 2 seconds. It requires only 3GB of VRAM, making it fully functional on consumer-grade GPUs like the RTX 3060. Developer-Friendly Licensing: Released under the Apache 2.0 license, Kani-TTS-2 is ready for commercial integration. It offers a local-first, low-latency alternative to expensive closed-source TTS APIs. Check out the Model Weight. Also, feel free to follow us on Twitter and don’t forget to join our 100k+ ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well. The post Meet ‘Kani-TTS-2’: A 400M Param Open Source Text-to-Speech Model that Runs in 3GB VRAM with Voice Cloning Support appeared first on MarkTechPost.

Meet ‘Kani-TTS-2’: A 400M Param Open Source Text-to-Speech Model that Runs in 3GB VRAM with Voice Cloning Support 投稿を読む »

AI, Committee, ニュース, Uncategorized

How to Build a Self-Organizing Agent Memory System for Long-Term AI Reasoning 

In this tutorial, we build a self-organizing memory system for an agent that goes beyond storing raw conversation history and instead structures interactions into persistent, meaningful knowledge units. We design the system so that reasoning and memory management are clearly separated, allowing a dedicated component to extract, compress, and organize information. At the same time, the main agent focuses on responding to the user. We use structured storage with SQLite, scene-based grouping, and summary consolidation, and we show how an agent can maintain useful context over long horizons without relying on opaque vector-only retrieval. Copy CodeCopiedUse a different Browser import sqlite3 import json import re from datetime import datetime from typing import List, Dict from getpass import getpass from openai import OpenAI OPENAI_API_KEY = getpass(“Enter your OpenAI API key: “).strip() client = OpenAI(api_key=OPENAI_API_KEY) def llm(prompt, temperature=0.1, max_tokens=500): return client.chat.completions.create( model=”gpt-4o-mini”, messages=[{“role”: “user”, “content”: prompt}], temperature=temperature, max_tokens=max_tokens ).choices[0].message.content.strip() We set up the core runtime by importing all required libraries and securely collecting the API key at execution time. We initialize the language model client and define a single helper function that standardizes all model calls. We ensure that every downstream component relies on this shared interface for consistent generation behavior. Copy CodeCopiedUse a different Browser class MemoryDB: def __init__(self): self.db = sqlite3.connect(“:memory:”) self.db.row_factory = sqlite3.Row self._init_schema() def _init_schema(self): self.db.execute(“”” CREATE TABLE mem_cells ( id INTEGER PRIMARY KEY, scene TEXT, cell_type TEXT, salience REAL, content TEXT, created_at TEXT ) “””) self.db.execute(“”” CREATE TABLE mem_scenes ( scene TEXT PRIMARY KEY, summary TEXT, updated_at TEXT ) “””) self.db.execute(“”” CREATE VIRTUAL TABLE mem_cells_fts USING fts5(content, scene, cell_type) “””) def insert_cell(self, cell): self.db.execute( “INSERT INTO mem_cells VALUES(NULL,?,?,?,?,?)”, ( cell[“scene”], cell[“cell_type”], cell[“salience”], json.dumps(cell[“content”]), datetime.utcnow().isoformat() ) ) self.db.execute( “INSERT INTO mem_cells_fts VALUES(?,?,?)”, ( json.dumps(cell[“content”]), cell[“scene”], cell[“cell_type”] ) ) self.db.commit() We define a structured memory database that persists information across interactions. We create tables for atomic memory units, higher-level scenes, and a full-text search index to enable symbolic retrieval. We also implement the logic to insert new memory entries in a normalized and queryable form. Copy CodeCopiedUse a different Browser def get_scene(self, scene): return self.db.execute( “SELECT * FROM mem_scenes WHERE scene=?”, (scene,) ).fetchone() def upsert_scene(self, scene, summary): self.db.execute(“”” INSERT INTO mem_scenes VALUES(?,?,?) ON CONFLICT(scene) DO UPDATE SET summary=excluded.summary, updated_at=excluded.updated_at “””, (scene, summary, datetime.utcnow().isoformat())) self.db.commit() def retrieve_scene_context(self, query, limit=6): tokens = re.findall(r”[a-zA-Z0-9]+”, query) if not tokens: return [] fts_query = ” OR “.join(tokens) rows = self.db.execute(“”” SELECT scene, content FROM mem_cells_fts WHERE mem_cells_fts MATCH ? LIMIT ? “””, (fts_query, limit)).fetchall() if not rows: rows = self.db.execute(“”” SELECT scene, content FROM mem_cells ORDER BY salience DESC LIMIT ? “””, (limit,)).fetchall() return rows def retrieve_scene_summary(self, scene): row = self.get_scene(scene) return row[“summary”] if row else “” We focus on memory retrieval and scene maintenance logic. We implement safe full-text search by sanitizing user queries and adding a fallback strategy when no lexical matches are found. We also expose helper methods to fetch consolidated scene summaries for long-horizon context building. Copy CodeCopiedUse a different Browser class MemoryManager: def __init__(self, db: MemoryDB): self.db = db def extract_cells(self, user, assistant) -> List[Dict]: prompt = f””” Convert this interaction into structured memory cells. Return JSON array with objects containing: – scene – cell_type (fact, plan, preference, decision, task, risk) – salience (0-1) – content (compressed, factual) User: {user} Assistant: {assistant} “”” raw = llm(prompt) raw = re.sub(r”“`json|“`”, “”, raw) try: cells = json.loads(raw) return cells if isinstance(cells, list) else [] except Exception: return [] def consolidate_scene(self, scene): rows = self.db.db.execute( “SELECT content FROM mem_cells WHERE scene=? ORDER BY salience DESC”, (scene,) ).fetchall() if not rows: return cells = [json.loads(r[“content”]) for r in rows] prompt = f””” Summarize this memory scene in under 100 words. Keep it stable and reusable for future reasoning. Cells: {cells} “”” summary = llm(prompt, temperature=0.05) self.db.upsert_scene(scene, summary) def update(self, user, assistant): cells = self.extract_cells(user, assistant) for cell in cells: self.db.insert_cell(cell) for scene in set(c[“scene”] for c in cells): self.consolidate_scene(scene) We implement the dedicated memory management component responsible for structuring experience. We extract compact memory representations from interactions, store them, and periodically consolidate them into stable scene summaries. We ensure that memory evolves incrementally without interfering with the agent’s response flow. Copy CodeCopiedUse a different Browser class WorkerAgent: def __init__(self, db: MemoryDB, mem_manager: MemoryManager): self.db = db self.mem_manager = mem_manager def answer(self, user_input): recalled = self.db.retrieve_scene_context(user_input) scenes = set(r[“scene”] for r in recalled) summaries = “n”.join( f”[{scene}]n{self.db.retrieve_scene_summary(scene)}” for scene in scenes ) prompt = f””” You are an intelligent agent with long-term memory. Relevant memory: {summaries} User: {user_input} “”” assistant_reply = llm(prompt) self.mem_manager.update(user_input, assistant_reply) return assistant_reply db = MemoryDB() memory_manager = MemoryManager(db) agent = WorkerAgent(db, memory_manager) print(agent.answer(“We are building an agent that remembers projects long term.”)) print(agent.answer(“It should organize conversations into topics automatically.”)) print(agent.answer(“This memory system should support future reasoning.”)) for row in db.db.execute(“SELECT * FROM mem_scenes”): print(dict(row)) We define the worker agent that performs reasoning while remaining memory-aware. We retrieve relevant scenes, assemble contextual summaries, and generate responses grounded in long-term knowledge. We then close the loop by passing the interaction back to the memory manager so the system continuously improves over time. In this tutorial, we demonstrated how an agent can actively curate its own memory and turn past interactions into stable, reusable knowledge rather than ephemeral chat logs. We enabled memory to evolve through consolidation and selective recall, which supports more consistent and grounded reasoning across sessions. This approach provides a practical foundation for building long-lived agentic systems, and it can be naturally extended with mechanisms for forgetting, richer relational memory, or graph-based orchestration as the system grows in complexity. Check out the Full Codes. Also, feel free to follow us on Twitter and don’t forget to join our 100k+ ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well. The post How to Build a Self-Organizing Agent Memory System for Long-Term AI Reasoning  appeared first on MarkTechPost.

How to Build a Self-Organizing Agent Memory System for Long-Term AI Reasoning  投稿を読む »

AI, Committee, ニュース, Uncategorized

The Download: an exclusive chat with Jim O’Neill, and the surprising truth about heists

This is today’s edition of The Download, our weekday newsletter that provides a daily dose of what’s going on in the world of technology. US deputy health secretary: Vaccine guidelines are still subject to change Over the past year, Jim O’Neill has become one of the most powerful people in public health. As the US deputy health secretary, he holds two roles at the top of the country’s federal health and science agencies. He oversees a department with a budget of over a trillion dollars. And he signed the decision memorandum on the US’s deeply controversial new vaccine schedule. He’s also a longevity enthusiast. In an exclusive interview with MIT Technology Review earlier this month, O’Neill described his plans to increase human healthspan through longevity-focused research supported by ARPA-H, a federal agency dedicated to biomedical breakthroughs. Fellow longevity enthusiasts said they hope he will bring attention and funding to their cause. At the same time, O’Neill defended reducing the number of broadly recommended childhood vaccines, a move that has been widely criticized by experts in medicine and public health. Read the full story. —Jessica Hamzelou The myth of the high-tech heist Making a movie is a lot like pulling off a heist. That’s what Steven Soderbergh—director of the Ocean’s franchise, among other heist-y classics—said a few years ago. You come up with a creative angle, put together a team of specialists, figure out how to beat the technological challenges, rehearse, move with Swiss-watch precision, and—if you do it right—redistribute some wealth. But conversely, pulling off a heist isn’t much like the movies. Surveillance cameras, computer-controlled alarms, knockout gas, and lasers hardly ever feature in big-ticket crime. In reality, technical countermeasures are rarely a problem, and high-tech gadgets are rarely a solution. Read the full story. —Adam Rogers This story is from the next print issue of MIT Technology Review magazine, which is all about crime. If you haven’t already, subscribe now to receive future issues once they land.  RFK Jr. follows a carnivore diet. That doesn’t mean you should. Americans have a new set of diet guidelines. Robert F. Kennedy Jr. has taken an old-fashioned food pyramid, turned it upside down, and plonked a steak and a stick of butter in prime positions. Kennedy and his Make America Healthy Again mates have long been extolling the virtues of meat and whole-fat dairy, so it wasn’t too surprising to see those foods recommended alongside vegetables and whole grains (despite the well-established fact that too much saturated fat can be extremely bad for you). Some influencers have taken the meat trend to extremes, following a “carnivore diet.” A recent review of research into nutrition misinformation on social media found that a lot of shared diet information is nonsense. But what’s new is that some of this misinformation comes from the people who now lead America’s federal health agencies. Read the full story. —Jessica Hamzelou This article first appeared in The Checkup, MIT Technology Review’s weekly biotech newsletter. To receive it in your inbox every Thursday, and read articles like this first, sign up here. The must-reads I’ve combed the internet to find you today’s most fun/important/scary/fascinating stories about technology. 1 The Trump administration has revoked a landmark climate rulingIn its absence, it can erase the limits that restrict planet-warming emissions. (WP $)+ Environmentalists and Democrats have vowed to fight the reversal. (Politico)+ They’re seriously worried about how it will affect public health. (The Hill) 2 An unexplained wave of bot traffic is sweeping the webSites across the world are witnessing automated traffic that appears to originate from China. (Wired $) 3 Amazon’s Ring has axed its partnership with FlockLaw enforcement will no longer be able to request Ring doorbell footage from its users. (The Verge)+ Ring’s recent TV ad for a dog-finding feature riled viewers. (WSJ $)+ How Amazon Ring uses domestic violence to market doorbell cameras. (MIT Technology Review) 4 Americans are taking the hit for almost all of Trump’s tariffsConsumers and companies in the US, not overseas, are shouldering 90% of levies. (Reuters)+ Trump has long insisted that his tariffs costs will be borne by foreign exporters. (FT $)+ Sweeping tariffs could threaten the US manufacturing rebound. (MIT Technology Review) 5 Meta and Snap say Australia’s social media ban hasn’t affected businessThey’re still making plenty of money amid the country’s decision to ban under-16s from the platforms. (Bloomberg $)+ Does preventing teens from going online actually do any good? (Economist $) 6 AI workers are selling their shares before their firms go publicCashing out early used to be a major Silicon Valley taboo. (WSJ $) 7 Elon Musk posted about race almost every day last monthHis fixation on a white racial majority appears to be intensifying. (The Guardian)+ Race is a recurring theme in the Epstein emails, too. (The Atlantic $) 8 The man behind a viral warning about AI used AI to write itBut he stands behind its content.. (NY Mag $)+ How AI-generated text is poisoning the internet. (MIT Technology Review) 9 Influencers are embracing Chinese traditions ahead of the New Year On the internet, no one knows you’re actually from Wisconsin. (NYT $) 10 Australia’s farmers are using AI to count sheep No word on whether it’s helping them sleep easier, though. (FT $) Quote of the day “Ignoring warning signs will not stop the storm. It puts more Americans directly in its path.” —Former US secretary of state John Kerry takes aim at the US government’s decision to repeal the key rule that allows it to regulate climate-heating pollution, the Guardian reports. One more thing The Vera C. Rubin Observatory is ready to transform our understanding of the cosmos High atop Chile’s 2,700-meter Cerro Pachón, the air is clear and dry, leaving few clouds to block the beautiful view of the stars. It’s here that the Vera C. Rubin Observatory will soon use a car-size 3,200-megapixel digital camera—the largest ever built—to produce a new map of the entire night sky every three days. Findings from the observatory

The Download: an exclusive chat with Jim O’Neill, and the surprising truth about heists 投稿を読む »

AI, Committee, ニュース, Uncategorized

ALS stole this musician’s voice. AI let him sing again.

There are tears in the audience as Patrick Darling’s song begins to play. It’s a heartfelt song written for his great-grandfather, whom he never got the chance to meet. But this performance is emotional for another reason: It’s Darling’s first time on stage with his bandmates since he lost the ability to sing two years ago. The 32-year-old musician was diagnosed with amyotrophic lateral sclerosis (ALS) when he was 29 years old. Like other types of motor neuron disease (MND), it affects nerves that supply the body’s muscles. People with ALS eventually lose the ability to control their muscles, including those that allow them to move, speak, and breathe. Darling’s last stage performance was over two years ago. By that point, he had already lost the ability to stand and play his instruments and was struggling to sing or speak. But recently, he was able to re-create his lost voice using an AI tool trained on snippets of old audio recordings. Another AI tool has enabled him to use this “voice clone” to compose new songs. Darling is able to make music again. “Sadly, I have lost the ability to sing and play my instruments,” Darling said on stage at the event, which took place in London on Wednesday, using his voice clone. “Despite this, most of my time these days is spent still continuing to compose and produce my music. Doing so feels more important than ever to me now.” Losing a voice Darling says he’s been a musician and a composer since he was around 14 years old. “I learned to play bass guitar, acoustic guitar, piano, melodica, mandolin, and tenor banjo,” he said at the event. “My biggest love, though, was singing.” He met bandmate Nick Cocking over 10 years ago, while he was still a university student, says Cocking. Darling joined Cocking’s Irish folk outfit, the Ceili House Band, shortly afterwards, and their first gig together was in April 2014. Darling, who joined the band as a singer and guitarist, “elevated the musicianship of the band,” says Cocking. Patrick Darling (second from left) with his former bandmates, including Nick Cocking (far right).COURTESY OF NICK COCKING But a few years ago, Cocking and his other bandmates started noticing changes in Darling. He became clumsy, says Cocking. He recalls one night when the band had to walk across the city of Cardiff in the rain: “He just kept slipping and falling, tripping on paving slabs and things like that.”  He didn’t think too much of it at the time, but Darling’s symptoms continued to worsen. The disease affected his legs first, and in August 2023, he started needing to sit during performances. Then he started to lose the use of his hands. “Eventually he couldn’t play the guitar or the banjo anymore,” says Cocking. By April 2024, Darling was struggling to talk and breathe at the same time, says Cocking. For that performance, the band carried Darling on stage. “He called me the day after and said he couldn’t do it anymore,” Cocking says, his voice breaking. “By June 2024, it was done.” It was the last time the band played together. Re-creating a voice Darling was put in touch with a speech therapist, who raised the possibility of “banking” his voice. People who are losing the ability to speak can opt to record themselves speaking and use those recordings to create speech sounds that can then be activated with typed text, whether by hand or perhaps using a device controlled by eye movements. Some users have found these tools to be robotic sounding. But Darling had another issue. “By that stage, my voice had already changed,” he said at the event. “It felt like we were saving the wrong voice.” Then another speech therapist introduced him to a different technology. Richard Cave is a speech and language therapist and a researcher at University College London. He is also a consultant for ElevenLabs, an AI company that develops agents and audio, speech, video, and music tools. One of these tools can create “voice clones”—realistic mimics of real voices that can be generated from minutes, or even seconds, of a person’s recorded voice. Last year, ElevenLabs launched an impact program with a promise to provide free licenses to these tools for people who have lost their voices to ALS or other diseases, like head and neck cancer or stroke.  The tool is already helping some of those users. “We’re not really improving how quickly they’re able to communicate, or all of the difficulties that individuals with MND are going through physically, with eating and breathing,” says Gabi Leibowitz, a speech therapist who leads the program. “But what we are doing is giving them a way … to create again, to thrive.” Users are able to stay in their jobs longer and “continue to do the things that make them feel like human beings,” she says. Cave worked with Darling to use the tool to re-create his lost speaking voice from older recordings. “The first time I heard the voice, I thought it was amazing,” Darling said at the event, using the voice clone. “It sounded exactly like I had before, and you literally wouldn’t be able to tell the difference,” he said. “I will not say what the first word I made my new voice say, but I can tell you that it began with ‘f’ and ended in ‘k.’” COURTESY OF PATRICK DARLING Re-creating his singing voice wasn’t as easy. The tool typically requires around 10 minutes of clear audio to generate a clone. “I had no high-quality recordings of myself singing,” Darling said. “We had to use audio from videos on people’s phones, shot in noisy pubs, and a couple of recordings of me singing in my kitchen.” Still, those snippets were enough to create a “synthetic version of [Darling’s] singing voice,” says Cave. In the recordings, Darling sounded a little raspy and “was a bit off” on some of the notes, says Cave. The voice

ALS stole this musician’s voice. AI let him sing again. 投稿を読む »

AI, Committee, ニュース, Uncategorized

[In-Depth Guide] The Complete CTGAN + SDV Pipeline for High-Fidelity Synthetic Data

In this tutorial, we build a complete, production-grade synthetic data pipeline using CTGAN and the SDV ecosystem. We start from raw mixed-type tabular data and progressively move toward constrained generation, conditional sampling, statistical validation, and downstream utility testing. Rather than stopping at sample generation, we focus on understanding how well synthetic data preserves structure, distributions, and predictive signal. This tutorial demonstrates how CTGAN can be used responsibly and rigorously in real-world data science workflows. Copy CodeCopiedUse a different Browser !pip -q install “ctgan” “sdv” “sdmetrics” “scikit-learn” “pandas” “numpy” “matplotlib” import numpy as np import pandas as pd import warnings warnings.filterwarnings(“ignore”) import ctgan, sdv, sdmetrics from ctgan import load_demo, CTGAN from sdv.metadata import SingleTableMetadata from sdv.single_table import CTGANSynthesizer from sdv.cag import Inequality, FixedCombinations from sdv.sampling import Condition from sdmetrics.reports.single_table import DiagnosticReport, QualityReport from sklearn.model_selection import train_test_split from sklearn.metrics import roc_auc_score from sklearn.linear_model import LogisticRegression from sklearn.preprocessing import OneHotEncoder from sklearn.compose import ColumnTransformer from sklearn.pipeline import Pipeline import matplotlib.pyplot as plt print(“Versions:”) print(“ctgan:”, ctgan.__version__) print(“sdv:”, sdv.__version__) print(“sdmetrics:”, sdmetrics.__version__) We set up the environment by installing all required libraries and importing the full dependency stack. We explicitly load CTGAN, SDV, SDMetrics, and downstream ML tooling to ensure compatibility across the pipeline. We also surface library versions to make the experiment reproducible and debuggable. Copy CodeCopiedUse a different Browser real = load_demo().copy() real.columns = [c.strip().replace(” “, “_”) for c in real.columns] target_col = “income” real[target_col] = real[target_col].astype(str) categorical_cols = real.select_dtypes(include=[“object”]).columns.tolist() numerical_cols = [c for c in real.columns if c not in categorical_cols] print(“Rows:”, len(real), “Cols:”, len(real.columns)) print(“Categorical:”, len(categorical_cols), “Numerical:”, len(numerical_cols)) display(real.head()) ctgan_model = CTGAN( epochs=30, batch_size=500, verbose=True ) ctgan_model.fit(real, discrete_columns=categorical_cols) synthetic_ctgan = ctgan_model.sample(5000) print(“Standalone CTGAN sample:”) display(synthetic_ctgan.head()) We load the CTGAN Adult demo dataset and perform minimal normalization on column names and data types. We explicitly identify categorical and numerical columns, which is critical for both CTGAN training and evaluation. We then train a baseline standalone CTGAN model and generate synthetic samples for comparison. Copy CodeCopiedUse a different Browser metadata = SingleTableMetadata() metadata.detect_from_dataframe(data=real) metadata.update_column(column_name=target_col, sdtype=”categorical”) constraints = [] if len(numerical_cols) >= 2: col_lo, col_hi = numerical_cols[0], numerical_cols[1] constraints.append(Inequality(low_column_name=col_lo, high_column_name=col_hi)) print(f”Added Inequality constraint: {col_hi} > {col_lo}”) if len(categorical_cols) >= 2: c1, c2 = categorical_cols[0], categorical_cols[1] constraints.append(FixedCombinations(column_names=[c1, c2])) print(f”Added FixedCombinations constraint on: [{c1}, {c2}]”) synth = CTGANSynthesizer( metadata=metadata, epochs=30, batch_size=500 ) if constraints: synth.add_constraints(constraints) synth.fit(real) synthetic_sdv = synth.sample(num_rows=5000) print(“SDV CTGANSynthesizer sample:”) display(synthetic_sdv.head()) We construct a formal metadata object and attach explicit semantic types to the dataset. We introduce structural constraints using SDV’s constraint graph system, enforcing numeric inequalities and validity of categorical combinations. We then train a CTGAN-based SDV synthesizer that respects these constraints during generation. Copy CodeCopiedUse a different Browser loss_df = synth.get_loss_values() display(loss_df.tail()) x_candidates = [“epoch”, “step”, “steps”, “iteration”, “iter”, “batch”, “update”] xcol = next((c for c in x_candidates if c in loss_df.columns), None) g_candidates = [“generator_loss”, “gen_loss”, “g_loss”] d_candidates = [“discriminator_loss”, “disc_loss”, “d_loss”] gcol = next((c for c in g_candidates if c in loss_df.columns), None) dcol = next((c for c in d_candidates if c in loss_df.columns), None) plt.figure(figsize=(10,4)) if xcol is None: x = np.arange(len(loss_df)) else: x = loss_df[xcol].to_numpy() if gcol is not None: plt.plot(x, loss_df[gcol].to_numpy(), label=gcol) if dcol is not None: plt.plot(x, loss_df[dcol].to_numpy(), label=dcol) plt.xlabel(xcol if xcol is not None else “index”) plt.ylabel(“loss”) plt.legend() plt.title(“CTGAN training losses (SDV wrapper)”) plt.show() cond_col = categorical_cols[0] common_value = real[cond_col].value_counts().index[0] conditions = [Condition({cond_col: common_value}, num_rows=2000)] synthetic_cond = synth.sample_from_conditions( conditions=conditions, max_tries_per_batch=200, batch_size=5000 ) print(“Conditional sampling requested:”, 2000, “got:”, len(synthetic_cond)) print(“Conditional sample distribution (top 5):”) print(synthetic_cond[cond_col].value_counts().head(5)) display(synthetic_cond.head()) We extract and visualize the dynamics of generator and discriminator losses using a version-robust plotting strategy. We perform conditional sampling to generate data under specific attribute constraints and verify that the conditions are satisfied. This demonstrates how CTGAN behaves under guided generation scenarios. Copy CodeCopiedUse a different Browser metadata_dict = metadata.to_dict() diagnostic = DiagnosticReport() diagnostic.generate(real_data=real, synthetic_data=synthetic_sdv, metadata=metadata_dict, verbose=True) print(“Diagnostic score:”, diagnostic.get_score()) quality = QualityReport() quality.generate(real_data=real, synthetic_data=synthetic_sdv, metadata=metadata_dict, verbose=True) print(“Quality score:”, quality.get_score()) def show_report_details(report, title): print(f”n===== {title} details =====”) props = report.get_properties() for p in props: print(f”n— {p} —“) details = report.get_details(property_name=p) try: display(details.head(10)) except Exception: display(details) show_report_details(diagnostic, “DiagnosticReport”) show_report_details(quality, “QualityReport”) train_real, test_real = train_test_split( real, test_size=0.25, random_state=42, stratify=real[target_col] ) def make_pipeline(cat_cols, num_cols): pre = ColumnTransformer( transformers=[ (“cat”, OneHotEncoder(handle_unknown=”ignore”), cat_cols), (“num”, “passthrough”, num_cols), ], remainder=”drop” ) clf = LogisticRegression(max_iter=200) return Pipeline([(“pre”, pre), (“clf”, clf)]) pipe_syn = make_pipeline(categorical_cols, numerical_cols) pipe_syn.fit(synthetic_sdv.drop(columns=[target_col]), synthetic_sdv[target_col]) proba_syn = pipe_syn.predict_proba(test_real.drop(columns=[target_col]))[:, 1] y_true = (test_real[target_col].astype(str).str.contains(“>”)).astype(int) auc_syn = roc_auc_score(y_true, proba_syn) print(“Synthetic-train -> Real-test AUC:”, auc_syn) pipe_real = make_pipeline(categorical_cols, numerical_cols) pipe_real.fit(train_real.drop(columns=[target_col]), train_real[target_col]) proba_real = pipe_real.predict_proba(test_real.drop(columns=[target_col]))[:, 1] auc_real = roc_auc_score(y_true, proba_real) print(“Real-train -> Real-test AUC:”, auc_real) model_path = “ctgan_sdv_synth.pkl” synth.save(model_path) print(“Saved synthesizer to:”, model_path) from sdv.utils import load_synthesizer synth_loaded = load_synthesizer(model_path) synthetic_loaded = synth_loaded.sample(1000) print(“Loaded synthesizer sample:”) display(synthetic_loaded.head()) We evaluate synthetic data using SDMetrics diagnostic and quality reports and a property-level inspection. We validate downstream usefulness by training a classifier on synthetic data and testing it on real data. Finally, we serialize the trained synthesizer and confirm that it can be reloaded and sampled reliably. In conclusion, we demonstrated that synthetic data generation with CTGAN becomes significantly more powerful when paired with metadata, constraints, and rigorous evaluation. By validating both statistical similarity and downstream task performance, we ensured that the synthetic data is not only realistic but also useful. This pipeline serves as a strong foundation for privacy-preserving analytics, data sharing, and simulation workflows. With careful configuration and evaluation, CTGAN can be safely deployed in real-world data science systems. Check out the Full Codes here. Also, feel free to follow us on Twitter and don’t forget to join our 100k+ ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well. The post [In-Depth Guide] The Complete CTGAN + SDV Pipeline for High-Fidelity Synthetic Data appeared first on MarkTechPost.

[In-Depth Guide] The Complete CTGAN + SDV Pipeline for High-Fidelity Synthetic Data 投稿を読む »

AI, Committee, ニュース, Uncategorized

Kyutai Releases Hibiki-Zero: A3B Parameter Simultaneous Speech-to-Speech Translation Model Using GRPO Reinforcement Learning Without Any Word-Level Aligned Data

Kyutai has released Hibiki-Zero, a new model for simultaneous speech-to-speech translation (S2ST) and speech-to-text translation (S2TT). The system translates source speech into a target language in real-time. It handles non-monotonic word dependencies during the process. Unlike previous models, Hibiki-Zero does not require word-level aligned data for training. This eliminates a major bottleneck in scaling AI translation to more languages. Traditional approaches rely on supervised training with word-level alignments. These alignments are difficult to collect at scale. Developers usually depend on synthetic alignments and language-specific heuristics. Hibiki-Zero removes this complexity by using a novel reinforcement learning (RL) strategy to optimize latency. https://kyutai.org/blog/2026-02-12-hibiki-zero A Multistream Architecture Hibiki-Zero is a decoder-only model. It uses a multistream architecture to model sequences of tokens jointly. The model handles 3 specific streams: Source Stream: Audio tokens from the input speech. Target Stream: Generated audio tokens for the translated speech. Inner Monologue: A stream of padded text tokens that match the target audio. The system uses the Mimi neural audio codec. Mimi is a causal and streaming codec that encodes waveforms into discrete tokens. It operates at a framerate of 12.5 Hz. The model uses an RQ-Transformer to model these audio streams. The architectural specs include: Total Parameters: 3B. Temporal Transformer: 28 layers with a latent dimension of 2048. Depth Transformer: 6 layers per codebook with a latent dimension of 1024. Context Window: 4min. Audio Codebooks: 16 levels for high-quality speech. Training Without Human Interpretation Data Hibiki-Zero is trained in 2 main stages: Coarse Alignment Training: The model first trains on sentence-level aligned data. This data ensures that the ith sentence in the target is a translation of the ith sentence in the source. The research team use a technique to insert artificial silence in the target speech to delay its content relative to the source. Reinforcement Learning (RL): The model uses Group Relative Policy Optimization (GRPO) to refine its policy. This stage reduces translation latency while preserving quality. The RL process uses process rewards based only on the BLEU score. It computes intermediate rewards at multiple points during translation. A hyperparameter ⍺ balances the trade-off between speed and accuracy. A lower ⍺ reduces latency but may slightly decrease quality. Scaling to Italian in Record Time The researchers demonstrated how easily Hibiki-Zero adapts to new languages. They added Italian as an input language using less than 1000h of speech data. They performed supervised fine-tuning followed by the GRPO process. The model reached a quality and latency trade-off similar to Meta’s Seamless model. It surpassed Seamless in speaker similarity by over 30 points. Performance and Results Hibiki-Zero achieves state-of-the-art results across 5 X-to-English tasks. It was tested on the Audio-NTREX-4L long-form benchmark, which includes 15h of speech per TTS system. Metric Hibiki-Zero (French) Seamless (French) ASR-BLEU (↑) 28.7 23.9 Speaker Similarity (↑) 61.3 44.4 Average Lag (LAAL) (↓) 2.3 6.2 In short-form tasks (Europarl-ST), Hibiki-Zero reached an ASR-BLEU of 34.6 with a lag of 2.8 seconds. Human raters also scored the model significantly higher than baselines for speech naturalness and voice transfer. https://kyutai.org/blog/2026-02-12-hibiki-zero Key Takeaways Zero Aligned Data Requirement: Hibiki-Zero eliminates the need for expensive, hand-crafted word-level alignments between source and target speech, which were previously the biggest bottleneck in scaling simultaneous translation to new languages. GRPO-Driven Latency Optimization: The model uses Group Relative Policy Optimization (GRPO) and a simple reward system based only on BLEU scores to automatically learn an efficient translation policy, balancing high translation quality with low latency. Coarse-to-Fine Training Strategy: The training pipeline starts with sentence-level aligned data to teach the model base translation at high latency, followed by a reinforcement learning phase that “teaches” the model when to speak and when to listen. Superior Voice and Naturalness: In benchmarking against previous state-of-the-art systems like Seamless, Hibiki-Zero achieved a 30-point lead in speaker similarity and significantly higher scores in speech naturalness and audio quality across five language tasks. Rapid New Language Adaptation: The architecture is highly portable; researchers demonstrated that Hibiki-Zero could be adapted to a new input language (Italian) with less than 1,000 hours of speech data while maintaining its original performance on other languages. Check out the Paper, Technical details, Repo and Samples. Also, feel free to follow us on Twitter and don’t forget to join our 100k+ ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well. The post Kyutai Releases Hibiki-Zero: A3B Parameter Simultaneous Speech-to-Speech Translation Model Using GRPO Reinforcement Learning Without Any Word-Level Aligned Data appeared first on MarkTechPost.

Kyutai Releases Hibiki-Zero: A3B Parameter Simultaneous Speech-to-Speech Translation Model Using GRPO Reinforcement Learning Without Any Word-Level Aligned Data 投稿を読む »

AI, Committee, ニュース, Uncategorized

Exa AI Introduces Exa Instant: A Sub-200ms Neural Search Engine Designed to Eliminate Bottlenecks for Real-Time Agentic Workflows

In the world of Large Language Models (LLMs), speed is the only feature that matters once accuracy is solved. For a human, waiting 1 second for a search result is fine. For an AI agent performing 10 sequential searches to solve a complex task, a 1-second delay per search creates a 10-second lag. This latency kills the user experience. Exa, the search engine startup formerly known as Metaphor, just released Exa Instant. It is a search model designed to provide the world’s web data to AI agents in under 200ms. For software engineers and data scientists building Retrieval-Augmented Generation (RAG) pipelines, this removes the biggest bottleneck in agentic workflows. https://exa.ai/blog/exa-instant Why Latency is the Enemy of RAG When you build a RAG application, your system follows a loop: the user asks a question, your system searches the web for context, and the LLM processes that context. If the search step takes 700ms to 1000ms, the total ‘time to first token’ becomes sluggish. Exa Instant delivers results with a latency between 100ms and 200ms. In tests conducted from the us-west-1 (northern california) region, the network latency was roughly 50ms. This speed allows agents to perform multiple searches in a single ‘thought’ process without the user feeling a delay. No More ‘Wrapping’ Google Most search APIs available today are ‘wrappers.’ They send a query to a traditional search engine like Google or Bing, scrape the results, and send them back to you. This adds layers of overhead. Exa Instant is different. It is built on a proprietary, end-to-end neural search and retrieval stack. Instead of matching keywords, Exa uses embeddings and transformers to understand the meaning of a query. This neural approach ensures the results are relevant to the AI’s intent, not just the specific words used. By owning the entire stack from the crawler to the inference engine, Exa can optimize for speed in ways that ‘wrapper’ APIs cannot. Benchmarking the Speed The Exa team benchmarked Exa Instant against other popular options like Tavily Ultra Fast and Brave. To ensure the tests were fair and avoided ‘cached’ results, the team used the SealQA query dataset. They also added random words generated by GPT-5 to each query to force the engine to perform a fresh search every time. The results showed that Exa Instant is up to 15x faster than competitors. While Exa offers other models like Exa Fast and Exa Auto for higher-quality reasoning, Exa Instant is the clear choice for real-time applications where every millisecond counts. Pricing and Developer Integration The transition to Exa Instant is simple. The API is accessible through the dashboard.exa.ai platform. Cost: Exa Instant is priced at $5 per 1,000 requests. Capacity: It searches the same massive index of the web as Exa’s more powerful models. Accuracy: While designed for speed, it maintains high relevance. For specialized entity searches, Exa’s Websets product remains the gold standard, proving to be 20x more correct than Google for complex queries. The API returns clean content ready for LLMs, removing the need for developers to write custom scraping or HTML cleaning code. Key Takeaways Sub-200ms Latency for Real-Time Agents: Exa Instant is optimized for ‘agentic’ workflows where speed is a bottleneck. By delivering results in under 200ms (and network latency as low as 50ms), it allows AI agents to perform multi-step reasoning and parallel searches without the lag associated with traditional search engines. Proprietary Neural Stack vs. ‘Wrappers‘: Unlike many search APIs that simply ‘wrap’ Google or Bing (adding 700ms+ of overhead), Exa Instant is built on a proprietary, end-to-end neural search engine. It uses a custom transformer-based architecture to index and retrieve web data, offering up to 15x faster performance than existing alternatives like Tavily or Brave. Cost-Efficient Scaling: The model is designed to make search a ‘primitive’ rather than an expensive luxury. It is priced at $5 per 1,000 requests, allowing developers to integrate real-time web lookups at every step of an agent’s thought process without breaking the budget. Semantic Intent over Keywords: Exa Instant leverages embeddings to prioritize the ‘meaning’ of a query rather than exact word matches. This is particularly effective for RAG (Retrieval-Augmented Generation) applications, where finding ‘link-worthy’ content that fits an LLM’s context is more valuable than simple keyword hits. Optimized for LLM Consumption: The API provides more than just URLs; it offers clean, parsed HTML, Markdown, and token-efficient highlights. This reduces the need for custom scraping scripts and minimizes the number of tokens the LLM needs to process, further speeding up the entire pipeline. Check out the Technical details. Also, feel free to follow us on Twitter and don’t forget to join our 100k+ ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well. The post Exa AI Introduces Exa Instant: A Sub-200ms Neural Search Engine Designed to Eliminate Bottlenecks for Real-Time Agentic Workflows appeared first on MarkTechPost.

Exa AI Introduces Exa Instant: A Sub-200ms Neural Search Engine Designed to Eliminate Bottlenecks for Real-Time Agentic Workflows 投稿を読む »

AI, Committee, ニュース, Uncategorized

Kyutai Releases Hibiki-Zero: A3B Parameter Simultaneous Speech-to-Speech Translation Model Using GRPO Reinforcement Learning Without Any Word-Level Aligned Data

Kyutai has released Hibiki-Zero, a new model for simultaneous speech-to-speech translation (S2ST) and speech-to-text translation (S2TT). The system translates source speech into a target language in real-time. It handles non-monotonic word dependencies during the process. Unlike previous models, Hibiki-Zero does not require word-level aligned data for training. This eliminates a major bottleneck in scaling AI translation to more languages. Traditional approaches rely on supervised training with word-level alignments. These alignments are difficult to collect at scale. Developers usually depend on synthetic alignments and language-specific heuristics. Hibiki-Zero removes this complexity by using a novel reinforcement learning (RL) strategy to optimize latency. https://kyutai.org/blog/2026-02-12-hibiki-zero A Multistream Architecture Hibiki-Zero is a decoder-only model. It uses a multistream architecture to model sequences of tokens jointly. The model handles 3 specific streams: Source Stream: Audio tokens from the input speech. Target Stream: Generated audio tokens for the translated speech. Inner Monologue: A stream of padded text tokens that match the target audio. The system uses the Mimi neural audio codec. Mimi is a causal and streaming codec that encodes waveforms into discrete tokens. It operates at a framerate of 12.5 Hz. The model uses an RQ-Transformer to model these audio streams. The architectural specs include: Total Parameters: 3B. Temporal Transformer: 28 layers with a latent dimension of 2048. Depth Transformer: 6 layers per codebook with a latent dimension of 1024. Context Window: 4min. Audio Codebooks: 16 levels for high-quality speech. Training Without Human Interpretation Data Hibiki-Zero is trained in 2 main stages: Coarse Alignment Training: The model first trains on sentence-level aligned data. This data ensures that the ith sentence in the target is a translation of the ith sentence in the source. The research team use a technique to insert artificial silence in the target speech to delay its content relative to the source. Reinforcement Learning (RL): The model uses Group Relative Policy Optimization (GRPO) to refine its policy. This stage reduces translation latency while preserving quality. The RL process uses process rewards based only on the BLEU score. It computes intermediate rewards at multiple points during translation. A hyperparameter ⍺ balances the trade-off between speed and accuracy. A lower ⍺ reduces latency but may slightly decrease quality. Scaling to Italian in Record Time The researchers demonstrated how easily Hibiki-Zero adapts to new languages. They added Italian as an input language using less than 1000h of speech data. They performed supervised fine-tuning followed by the GRPO process. The model reached a quality and latency trade-off similar to Meta’s Seamless model. It surpassed Seamless in speaker similarity by over 30 points. Performance and Results Hibiki-Zero achieves state-of-the-art results across 5 X-to-English tasks. It was tested on the Audio-NTREX-4L long-form benchmark, which includes 15h of speech per TTS system. Metric Hibiki-Zero (French) Seamless (French) ASR-BLEU (↑) 28.7 23.9 Speaker Similarity (↑) 61.3 44.4 Average Lag (LAAL) (↓) 2.3 6.2 In short-form tasks (Europarl-ST), Hibiki-Zero reached an ASR-BLEU of 34.6 with a lag of 2.8 seconds. Human raters also scored the model significantly higher than baselines for speech naturalness and voice transfer. https://kyutai.org/blog/2026-02-12-hibiki-zero Key Takeaways Zero Aligned Data Requirement: Hibiki-Zero eliminates the need for expensive, hand-crafted word-level alignments between source and target speech, which were previously the biggest bottleneck in scaling simultaneous translation to new languages. GRPO-Driven Latency Optimization: The model uses Group Relative Policy Optimization (GRPO) and a simple reward system based only on BLEU scores to automatically learn an efficient translation policy, balancing high translation quality with low latency. Coarse-to-Fine Training Strategy: The training pipeline starts with sentence-level aligned data to teach the model base translation at high latency, followed by a reinforcement learning phase that “teaches” the model when to speak and when to listen. Superior Voice and Naturalness: In benchmarking against previous state-of-the-art systems like Seamless, Hibiki-Zero achieved a 30-point lead in speaker similarity and significantly higher scores in speech naturalness and audio quality across five language tasks. Rapid New Language Adaptation: The architecture is highly portable; researchers demonstrated that Hibiki-Zero could be adapted to a new input language (Italian) with less than 1,000 hours of speech data while maintaining its original performance on other languages. Check out the Paper, Technical details, Repo and Samples. Also, feel free to follow us on Twitter and don’t forget to join our 100k+ ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well. The post Kyutai Releases Hibiki-Zero: A3B Parameter Simultaneous Speech-to-Speech Translation Model Using GRPO Reinforcement Learning Without Any Word-Level Aligned Data appeared first on MarkTechPost.

Kyutai Releases Hibiki-Zero: A3B Parameter Simultaneous Speech-to-Speech Translation Model Using GRPO Reinforcement Learning Without Any Word-Level Aligned Data 投稿を読む »

We use cookies to improve your experience and performance on our website. You can learn more at プライバシーポリシー and manage your privacy settings by clicking Settings.

Privacy Preferences

You can choose your cookie settings by turning on/off each type of cookie as you wish, except for essential cookies.

Allow All
Manage Consent Preferences
  • Always Active

Save
ja