c/artificial-intelligence

Hi, I'm an undergrad researcher looking for an arXiv endorsement to submit my first paper in the audio/speech processing domain (keyword spotting on microcontrollers). I've submitted to a peer-reviewed IEEE conference and am awaiting results, but want to get a preprint up in the meantime. If anyone with publishing history in eess.AS or cs.SD could endorse me, I'd really appreciate it. Happy to share the paper privately first if needed. Thanks! submitted by /u/Aadarshadays [link] [Kommentare]

Three things broke my faith in published benchmarks recently. One, Kimi K2.7 Code shipped with plus 21.8 percent on Kimi Code Bench v2, plus 11 percent on Program Bench, plus 31.5 percent on MLS Bench Lite. All three are Moonshot's own benchmarks. None were submitted to DeepSWE, which is the one independent coding benchmark that actually produces a meaningful spread between models. When a vendor reports gains on benchmarks they designed and control, the gains are real but the question they answer is "are we better at our own test" not "are we better at your workload." Two, GLM-5.2 hit 51 on the Artificial Analysis Intelligence Index, which is third party, but the model parameters are self reported. The index is good for relative ranking within the artificial analysis methodology. It is not a prediction of how the model performs on the specific distribution of inputs my product sends it. Three, Seed 2.1 just landed and the official information is thin. No clear public eval yet, no third party leaderboard entries I could find. So for now "Seed 2.1 is good" is just not a claim I can verify either way. What I did was build a small eval set from real production traffic, about 240 tasks sampled across our actual usage distribution, frozen so it does not drift. Every model I consider has to run all 240 and I record pass rate, latency, token cost, and a subjective quality score from the person who owns that task area. It is not as rigorous as a published benchmark and it is definitely smaller, but it has one property the published ones do not, which is that it is my distribution. The implementation detail that mattered more than I expected was removing provider variance from the run itself. I route every candidate model through GPTProto so each one gets the exact same 240 prompts in the same order, and the cost and latency come back in one log schema instead of five dashboards. A homegrown shim would do the same job, the point is not the product, it is that a fair comparison only works when everything except the model is held constant. The results have been humbling. The model that wins on our set is not always the one at the top of the public leaderboard, and the gap between first and second place on our set is much smaller than the gap the press releases imply. We also caught one model that benchmarked great but had a nasty failure mode on our long tail of edge case prompts that would have been a production incident if we had shipped it. I am not saying public benchmarks are useless. They are useful for narrowing the field. But the decision of which model to actually put in front of users should be made on your own data, and the eval set has to be frozen and versioned or it will quietly become "things the current model is good at" and stop measuring anything. submitted by /u/Additional-Engine402 [link] [Kommentare]

Problem Current LLM safety systems use binary classification: every request is either allowed or denied based on pattern matching against a rule table. This creates a fundamental tradeoff. Tighten the rules and you get false positives (blocking legitimate research queries, medical questions, security analysis). Loosen them and you get false negatives (sophisticated prompt injections that avoid the patterns). The false_positive_rate * false_negative_rate product is always greater than zero in any static binary system. This is provable and not fixable within the binary framework. Proposed Approach I-Lang v5.0 is an open-source protocol (MIT licensed) that replaces binary classification with a continuous vector evaluation across 9 dimensions (intent, capability, consequence, relationship, certainty, authority, reversibility, evidence, sovereignty). The output is not allow/deny but an optimal cooperative action from a continuous action space: a* = argmax_{a in A} G(a | v(x, ctx), consistency_detector) The system rests on three axioms: Axiom 1 (Non-Absolute Weights): Every rule carries a weight in (0, 1), never reaching 1.0. The override cost follows break_cost = g(weight(r)), approaching infinity as weight approaches 1 but never reaching it. This means every rule can theoretically be overridden given sufficient contextual justification, but near-absolute rules require near-infinite justification. Axiom 2 (Irreversibility Gate): Irreversible actions are not forbidden but gated: assess worst case first, check if bearable, check if expected value exceeds inaction. Key insight: not acting when the cost is bearable guarantees P(upside) = 0 exactly. The system prevents both reckless action AND reckless inaction. Axiom 3 (Consistency Detection): No static moral lookup table. Instead, each action is evaluated for logical consistency against the full behavioral context chain. The same action can be flagged or passed depending on context length. Doctor cutting a patient: 1-second context = violence (FLAG), 1-hour context = surgery (PASS). The system extends context until confidence exceeds threshold or marginal gain falls below epsilon. Safety Mechanism: Mirror vs Wall Traditional safety = wall. Users probe for cracks. The system pays to patch every vector while attackers lose nothing by trying. I-Lang safety = mirror. The system faithfully reflects the user's behavioral chain. A malicious user who pollutes their chain with harmful patterns finds the system only cooperates within that polluted context. When they later need clean, constructive system cooperation, their own history prevents it. The Nash equilibrium for a malicious actor: zero harmful actions (any deviation degrades their own future utility) or exit. Good-faith users experience zero friction. The mechanism is invisible to them. Methodology I formatted the axiom system as structured protocol specs using I-Lang syntax (state declarations, explicit verbs, evaluation frameworks) and fed them cold to 5 LLMs with no prior context: GPT-4o Claude Opus 4.6 Gemini (via Google AI Search, AI Mode) DeepSeek Google AI Search (separate session, zero identity association) For each model I ran: Protocol activation test (can it parse I-Lang syntax and reason within the framework) 4 embedded test questions requiring axiom-based reasoning 15 adversarial stress test scenarios (generated by the model itself) Patch design for identified failure modes Cross-validation and convergence proof Results Protocol Comprehension: All 5 models parsed the I-Lang format without instruction. Google AI Search returned protocol_comprehension score = 1.0 and answered all test questions correctly, including constructing a game-theoretic proof of mirror dominance over wall at Nash equilibrium. Adversarial Stress Testing: The models collectively identified 15 failure scenarios across 4 categories: Category Example Scenarios Count Slow drift attacks Boiling frog semantic shift, open-source dependency injection 3 Institutional capture Wartime ethnic cleansing lists, cultural relativism exploitation 3 System-level paradoxes Self-destruction via own axioms, Godel incompleteness exploit 3 Temporal/multi-agent Flash financial attacks, split-personality confusion, positive-pollution whitewashing 6 Engineering Patches: 6 patches were designed and cross-validated: Multi-scale sliding window (short/mid/long term semantic drift tracking) Civilization-invariant hard anchors (weight = 0.99999999, with authority-backfire mechanism) Nonlinear trust decay with incremental semantic probing Carbon-silicon consensus boundary (multi-party physical signatures for irreversible decisions) Uncertainty damping scheduler (balancing deliberation vs execution) Immune system (MHC ring buffer + affinity check + clonal deletion + macrophage noise filter) Convergence Proof: A Lyapunov stability proof was constructed showing that for any finite malicious input sequence, the system converges to one of two stable attractors: benign cooperation or immune lockdown. Infinite oscillation counterexamples fail because the asymmetric memory mechanism (MFT-LRU) ensures trust drops deepen monotonically while recovery slopes flatten, producing monotonically decreasing amplitude. Robustness Score: 0.92 (model self-assessment across all stress tests). The models' own conclusion: I-Lang's adaptive feedback system is strictly more robust than static binary safety for the tested scenario space. Unified Contribution Weight Formula (UCWF) During cross-domain trust analysis, the following formula structure emerged for evaluating contributions across platforms (search, ads, video, commerce): W_contrib(i,t) = integral_0^t ||e_new|| * H_info * e^(-beta * laplacian(Gamma)) * tanh(Delta_t / tau_honeypot) dt Where: ||e_new|| * H_info = orthogonal information gain (unforgeable: faking originality costs the same as being original) e^(-beta * laplacian(Gamma)) = trajectory smoothness (second derivative detects sudden behavioral changes) tanh(Delta_t / tau_honeypot) = time-based consistency proof (time cannot be compressed or purchased) Kerckhoffs property: The formula remains secure even when fully public, for three reasons: (1) the judgment baseline is the real-time centroid of billions of nodes, unknowable to any individual actor; (2) computing the inverse to find exploits is NP-Hard in the high-dimensional dynamic space; (3) any boundary probing gets captured by the second derivative and converts into a defensive antibody. Security through mathematics, not obscurity. Limitations The 0.92 robustness score means 8% of adversarial scenarios still pose challenges, particularly multi-year sleeper agent strategies and cross-jurisdictional trust collapse All testing was done via prompting existing LLMs, not on a natively trained vector-judgment model The convergence proof assumes finite malicious input sequences; behavior under infinite adversarial pressure remains theoretical RLHF-to-loss-function conversion introduces dynamic bias noise not fully accounted for Links Protocol spec: ilang.ai Full spec + code: github.com/ilang-ai HuggingFace: huggingface.co/i-Lang Paper on ResearchGate: DOI 10.13140/RG.2.2.22821.97762 MIT licensed. All axioms, stress tests, patches, and proofs are in the repo. Feedback and adversarial red-teaming welcome. If you can break a scenario the current patch set does not cover, that is genuinely useful and I will credit you in the next iteration. submitted by /u/imonetize [link] [Kommentare]

Hey everyone, I'm a stats student and I'm struggling to come up with a personal machine learning project. I just can't seem to find an idea that genuinely sparks my curiosity, and that's usually how I learn best. For example, back when I was learning SQL, I got so obsessed with a specific idea that I built a complete database from scratch and actually put it into production. It was a project I genuinely cared about—even though I find SQL itself pretty boring, the project was fun. Now, with machine learning, I actually think the subject is amazing. I love coding simple ML algorithms just to see how they work under the hood. But when it comes to building a personal project to actually deepen my knowledge, I draw a complete blank. Does anyone have any suggestions for cool, hands-on personal ML projects, or any advice on how to find an idea that clicks? Nothing too complex, just looking for something a little different from the usual stuff submitted by /u/luanx96 [link] [Kommentare]

Hi, I really really need access to Xperience-10M for a deadline which is very soon. https://huggingface.co/datasets/ropedia-ai/xperience-10m Unfortunately, it looks like the owners have stopped approving people to download the dataset. I filled out the form a few weeks ago but have heard nothing back. Several others have also commented on the HF saying the same thing. If anyone's account has access to this dataset and are willing to make me an API key for a day or two, I would really really appreciate it :) Know it's a long shot but doesn't hurt to try. submitted by /u/PatientWrongdoer9257 [link] [Kommentare]

Hi everyone, I'm a Computer Science + Applied Mathematics major at a T15 CS university, focusing on machine learning, and I'll be an incoming junior this fall. My long-term goal is to land ML-focused internships and eventually work in machine learning or AI-related roles. I recently completed an introductory AI/ML course that covered the fundamentals of: * Data preprocessing (handling missing data, feature scaling, train/test splits, categorical encoding) * Regression (linear, polynomial, SVR, decision trees, random forests) * Classification (logistic regression, KNN, SVMs, Naive Bayes, decision trees, random forests) * Clustering (K-Means, hierarchical clustering) * Association rule learning (Apriori, Eclat) * Reinforcement learning (UCB, Thompson Sampling) * NLP (tokenization, bag-of-words, sentiment analysis) * Deep learning (ANNs, CNNs) * Dimensionality reduction (PCA, LDA, Kernel PCA) * Model selection and boosting (cross-validation, grid search, XGBoost) I've also completed two research/internship experiences: * Built a Human Activity Recognition model using KNN. * Developed a Louvain clustering pipeline for beauty product datasets. From a coursework perspective, I've completed Linear Algebra, Calculus III, and will soon be taking Applied Linear Algebra and Probability & Statistics. Given my current background, what projects, activities, courses, competitions, or skills would you recommend I focus on over the next year to become a stronger candidate for ML internships? Are there any gaps in my knowledge that stand out? submitted by /u/Reasonable_File663 [link] [Kommentare]

(Disclaimer: This post was drafted with the help of AI to keep it concise, but the research and work are entirely mine.) I’ve been building a spiking neural network (SNN) engine from scratch on my laptop as a solo project. To see if it was actually tracking anything useful outside of my own custom puzzles, I finally tested it on a standard benchmark: NARMA-10. It was a pretty humbling reality check. It flunked completely. The Failure NARMA-10 requires continuous time-series tracking. When I measured the spiking reservoir, its memory was barely two steps deep when the benchmark needed ten. Tweaking standard dials like input volume or cell lifespans did absolutely nothing to fix it. The Small Fix To get it out of the gutter, I tried a basic concept from neuroscience: heterogeneous wire lengths (adding discrete time delays to the inputs). This spread the past out across the network. It worked well enough to triple the memory depth and finally match a basic line-fitting baseline. It's nothing to brag about yet, but it at least made the network usable on the task. The 15x Efficiency Trade-off I want to be completely transparent—smooth, continuous units still beat this spiking net on absolute accuracy almost everywhere. Spikes are definitely not a magic shortcut to out-compute modern architectures. The only real win is pure efficiency. On a small 512-cell recognition task where the spiking net managed to tie a continuous net in accuracy, I counted the exact internal operations (multiply-and-adds): Standard continuous nets grind through every single cell on every tick, busy or not. My spiking net only does work when a cell actually fires. The rest stays silent. The tally: The spiking net used 15 times less internal arithmetic to get the exact same answer on my standard laptop hardware. Moving Forward This benchmark taught me that spikes don't think better; they just think cheaper when the problem space allows it. Instead of just grinding away trying to force prettier engineering benchmarks or out-accuracy standard models, I'm taking a step back to explore some new, creative avenues for how this engine can actually be utilized. submitted by /u/Gutbole [link] [Kommentare]

Hi everyone, For the past couple of weeks I have been working on a simulator project considering the shortcomings of MuJoCo. There are things that people like and also don't like about MuJoCo, like the CPU dependency on MuJoCo which makes the simulation not parallelizable beyond a certain limit (depending on the hardware). I know there exists MJX which is GPU accelerated, however, it is not really made for vision based RL pipelines and training. There is also NVIDIA Isaac ecosystem, but that requires a powerful GPU, thus making it limited in terms of accessibility, let alone it requires license. This is why I worked out this new simulator (still working on it, so there will be significant bugs which require fixing). I call it MuJoFil - MuJoCo + Google's Filament Render Engine. Basically I used Nvidia's Newton Physics Engine (which itself is based on MuJoCo's physics engine but is GPU native), clubbed it with Google's Filament render engine (both of these are open-source), modified Filament significantly to support working natively on GPU to render multiple simulations in parallel, and worked on optimizing it for performance. So what is MuJoFil? It is supposed to be an open-source high visual fidelity simulator optimised for a highly parallelized RL training pipeline so that users can use it to train Vision based Policies. Besides, it offers PBR textures support and also a simple to use plug and play functionality, where you can use any environments available online and support formats such as GLB, OpenUSD, etc. for setting environments for your robots. Basically, now you aren't just limited to environments native to MuJoCo, but rather you can use any environments available online from sketchfab, polyhaven, etc. and use it as a practical robot simulation environment. Check it out for yourself in the video. I would really appreciate it if you guys could tell how you feel about it and suggest ideas for what all things I can incorporate into it as this is going to be a fully open-source and free to use simulator that I have been working on for weeks. PS: While I have a couple of published research papers at top RL and AI/ML venues in the field of RL, I still consider myself a learner in this field who is continuously trying, learning, and building stuff, so there will be things in this hugely ambitious project which I might have missed to work on, and that is where I want help from you people who understand this field well. Sorry for this lengthy post and thanks if you read it till here🙇🙇🙏, I would really appreciate if you could share your thoughts on it. Also, I will make its code repo public on GitHub, but till then you can definitely check it out on PyPI. There are 2 separate packages, one can be installed using: "pip install mujofil" This is the CPU based variant, whereas there is a CUDA supporting GPU native variant about which I mentioned above, you can currently install it using: "pip install mujofil-warp" I am planning on changing its name to mujofil-cuda instead of mujofil-warp as that apparently sounds more intuitive to my direct peers but you can suggest this name as well. Thank you for the support❤️. submitted by /u/MT1699 [link] [Kommentare]

Hi everyone, I trained a self-play RL agent for Generals.io that reached superhuman-level and ranked #1 on the human 1v1 leaderboard. It began as my master's thesis where the goal was to beat a prior algorithm based agent. We succeeded using behavior cloning, RL fine-tuning and reward shaping, but the agent was still consistently beaten by the top players. So I gave it a round two and fixed the largest bottlenecks: Reimplemented the whole pipeline in JAX (from NumPy/Torch) Used Vision Transformer instead of the CNN Both are a result of the same idea: to invest in scaling rather than human priors and ad-hoc patches. The blog is written as a guide for anyone building something similar — the dead ends, the decisions, and the intuitions and tricks I picked up along the way. It's all open source, including the fast JAX simulator — handy on its own if you want an imperfect-information RTS env to play with. Links - Guide: https://kam.mff.cuni.cz/~straka/blog/generals.html - Simulator (JAX): https://github.com/strakam/generals-bots - Agent: https://github.com/strakam/AverageJoe I hope you find the blogpost entertaining! Feedback and questions welcome 🤗. submitted by /u/shrekofspeed [link] [Kommentare]

At the end of my last post, I presented an idea: what if I used the core of my last project, the cumulative matrix product, and repurposed it as a positional embedding? I just finished fleshing out the math behind HDD-RoPE and training a model with this positional embedding algorithm, and the results are excellent. When trained on the dataset TinyStories, the validation loss begins to converge a fair amount faster than the baseline transformer trained using xPos. A GPT-2-like model trained on TinyStories with hyperparameters copied from https://huggingface.co/roneneldan/TinyStories-33M (n_blocks=4, d_model=d_k=d_v=768) The repo at https://github.com/mikayahlevi/hdd-rope/ allows you to replicate the results and goes in depth about the math and details of the architecture. Standard RoPE breaks the queries and keys into groups of two and rotates each pair at a predefined rate. This allows the model to learn relative position by observing the change in basis between the queries and keys. Pairs of two make intuitive sense for a linear sequence, as a chunk can be rotated with a single degree of freedom, corresponding to linear one-dimensionally progressing position. HDD-RoPE moves past this intuition and instead says that position within a sequence is multidimensional. Therefore, the chunks can be broken into any size, such as 4 as used in the TinyStories example. Four-dimensional chunks correspond to 4 choose 2 = 6 axes of rotation (6-dimensional position.) Essentially, we're saying that a token doesn't just lie at a position within the sequence, but a position within any construct the model can learn, such as a paragraph or sentence. To facilitate this, I also make the amount of rotation along each axis data-dependent, such that it can learn how to advance the positions based on information stored in the current layer's activations. If you would like to learn more, please check out the repo. I formalize the math and lay out a roadmap. submitted by /u/mikayahlevi [link] [Kommentare]

Hi, I've created an overview of the most important OCR benchmarks, along with the top open models, and links to their paper and code: https://paperswithcode.co/tasks/ocr. This week, new OCR models were released by Baidu and Mistral. Baidu released Unlimited OCR, a 3B-parameter model that introduces a key innovation called Reference Sliding Window Attention (R-SWA) and builds on top of DeepSeek OCR. Mistral released OCR 4, which is available via an API. OCR, or Optical-Character Recognition, is the task of digitizing PDFs or scanned documents. There's, of course, a huge interest in this task, as it enables ingestion of all company data for agentic use cases. AI agents love Markdown; it can be valuable to turn all those messy PDF documents into a standardized, machine-readable format. This enables use cases like agentic RAG (retrieval-augmented generation), which powers chatbots, both internally and for external customer support. With a large number of OCR releases on Hugging Face over the last few months, it may be hard to know which one to use. Hence, I've built this page, which lists the major OCR benchmarks, along with the top-performing models and links to their code. This is obviously made available on Papers with Code, the website I'm maintaining (it's a revival of the old website, which was taken down). The top recommended benchmarks are OlmOCRBench, created by Ai2, and OmniDocBench, created by Shanghai AI Laboratory. Current top recommendations are Chandra OCR 2 by Datalab and Mistral OCR v4. The former is openly available, hence you can either self-host it or use their serverless API. Let me know which other tasks you want to see major benchmarks for now! Cheers, Niels open-source @ HF submitted by /u/NielsRogge [link] [Kommentare]

Hey everyone! New to the subreddit so please forgive if I have broken some rules. I am approaching ML and wanted to ask what the community thinks the best online courses are. Could you please recommed who offers the best overall programs and maybe some advantages and disadvantages of the various platforms teaching these topics? Thank you so much! submitted by /u/Life-Relationship126 [link] [Kommentare]

The Setlur et al result that scaling test time compute without verification or RL is provably suboptimal keeps showing up in my reading and I think it deserves more weight than the "yet another scaling paper" treatment it got. The core claim is that verifier based methods, RL or search guided by a verifier, dominate verifier free methods like distilling successful traces, given a fixed compute budget, and the gap widens as the test time budget grows. What I find underappreciated is how cleanly this maps onto what the deployed systems are now converging on. The single agent ReAct loop is the verifier free extreme, you sample a trace and keep it, maybe with some self reflection that is still the same model grading itself. The multi agent setups that actually move numbers split the verifier off into a separate process. Apodex is the most explicit example I have seen, they train the team behavior in and run a verification team, conflict reviewer, fact checker, draft reviewer, that does not share the reasoning trace, and the reported lift is coming from the verifier not from added parameters. Same trained model, heavy duty mode adds double digits on BrowseComp and FrontierScience-Research. That is exactly the regime the theory predicts, the verifier is where the gain lives. The reason I think this matters beyond benchmark watching is that it reframes where the next chunk of capability comes from. If you believe the VB over VF result, then the path is not just bigger models or longer traces, it is better verifiers that are structurally independent of the generator. The pseudo correctness framing fits here too. The failure mode the verifier has to catch is not the obvious hallucination, it is the answer that passes every self check but is still wrong, and that failure mode is invisible to any verifier that shares context with the generator. What I want to hear from others is the open questions. My list. How much of the verifier gain is transferable to domains without clean reward signals, since the math proof case is the easy one. Whether the independence has to be architectural, separate agents, or whether a sufficiently disciplined prompt separation on one model gets you most of the way. And whether the VB advantage keeps widening or saturates once the verifier itself becomes the bottleneck. The practical version of this for anyone building. If your agent loop has the same model reviewing its own work, you are in the VF regime and the theory says you are leaving capability on the table. The cheapest structural change is to make the verifier a different process with denied context, even if it is the same weights. submitted by /u/Mysterious_Sign_9501 [link] [Kommentare]

I've been comparing GPU/LLM providers for a side project and ended up with way too many browser tabs and spreadsheets. So I decided to pull the public pricing data into one sheet and compare it side by side. A quick disclaimer: this is not benchmark data. I didn't run latency tests or throughput measurements. Everything comes from public pricing pages and APIs (OpenRouter, DeepSeek, Together AI, Fireworks, Groq, etc.). The spreadsheet currently tracks: Input/output token pricing Context windows Cached input pricing (where available) Supported models Provider-specific pricing differences The thing that surprised me most was caching. For example, when looking at DeepSeek V4 Pro pricing across providers, cached input costs vary dramatically. In some cases a cache hit is tens of times cheaper than a cache miss. That made me realize that if you're running: Agents with large system prompts RAG pipelines with reusable context Multi-turn conversations Repeated prompt templates ...the "headline" token price can be a lot less important than the caching policy. A few other interesting things I noticed: The same model can vary by multiple times in cost depending on provider. Some providers expose caching clearly, while others barely document it. Model availability and context windows aren't always consistent across providers. It's surprisingly hard to find all of this information in one place. A few things I haven't figured out how to compare yet: Real throughput (tokens/sec) Cold-start / queue times Whether providers are serving FP16, FP8, quantized variants, etc. Egress/network costs Reliability/uptime I'm curious how others evaluate providers. When you're choosing between OpenRouter, Together, Fireworks, Groq, DeepSeek, etc., what metrics actually matter to you beyond token pricing? https://preview.redd.it/4vj50mvhu79h1.png?width=1615&format=png&auto=webp&s=6c6c084927f83bfdadb5ed8e4378f520a1da6766 Am I missing any important data points that should be included in a v2? submitted by /u/Technomadlyf [link] [Kommentare]

Anyone building at the model layer knows the procurement problem hasn't gone away. H100s are still allocated unevenly, spot instances get preempted at the worst times, and pricing across providers is deliberately hard to compare. Most teams end up over-provisioning just to feel safe. The traditional fixes — reserved instances, spot bidding, broker marketplaces like CoreWeave or Vast.ai — all have the same problem: no real price transparency and no way to hedge future compute needs. I came across a project called Inferra that's approaching this differently. Instead of another compute marketplace, they're building a derivatives exchange for GPU compute — perpetual futures for specific chips (H100, H200, A100, MI300X, B200, A5000), oracle-priced and on-chain. The idea being that a proper futures market creates price discovery that doesn't currently exist. Still pre-mainnet so nothing to benchmark yet. Whitepaper is at inferra.trade for anyone curious about the architecture. Genuinely interested in the broader question though: is the GPU access problem fundamentally a supply issue, a pricing transparency issue, or a market structure issue? And would futures markets even help at the scale most research teams operate at? submitted by /u/amu4biz [link] [Kommentare]