首页
/ yfinance数据获取稳定性优化指南：从受限到流畅的全方位解决方案

yfinance数据获取稳定性优化指南：从受限到流畅的全方位解决方案

2026-03-10 05:16:19作者：秋阔奎Evelyn
yfinance
Download market data from Yahoo! Finance's API
项目地址：https://gitcode.com/GitHub_Trending/yf/yfinance

第一章：问题剖析：当数据获取遭遇瓶颈

在量化交易系统开发中，你是否曾遇到这样的场景：精心编写的市场数据分析程序在本地测试时运行流畅，但部署到生产环境后却频繁抛出"429 Too Many Requests"错误？或者当需要获取全球市场数据时，部分地区的数据源始终无法访问？这些问题的根源往往可以归结为yfinance在API访问控制与速率限制方面的挑战。

1.1 常见访问问题的表现形式

在实际开发中，yfinance用户最常遇到的访问问题主要有三类：

请求频率限制：当短时间内发送过多请求时，Yahoo服务器会返回429状态码，就像演唱会入场时遇到的限流措施，每个IP地址在单位时间内只能通过有限数量的请求。

地域访问限制：某些金融数据可能仅对特定地区开放，这类似于视频平台的区域版权限制，导致身处其他地区的用户无法获取完整数据。

网络连接问题：代理配置不当或网络波动会导致连接超时或重置，就像通话时遇到的信号中断，严重影响数据获取的稳定性。

1.2 问题背后的技术本质

yfinance作为一款开源的金融数据获取工具，其工作原理是通过模拟浏览器请求来获取Yahoo Finance的公开数据。这种工作方式虽然避免了使用正式API的授权流程，却也使得用户暴露在Yahoo的各种访问限制之下。

Yahoo Finance的反爬虫机制会监控异常的请求模式，包括：

  • 单位时间内的请求次数
  • 请求头信息的完整性
  • IP地址的历史行为记录
  • 数据访问的地域特征

这些监控措施共同构成了一道无形的"访问门槛"，需要我们通过技术手段巧妙应对。

第二章：核心原理：yfinance访问控制机制解析

当你需要构建一个稳定的金融数据 pipeline 时，理解yfinance的底层工作机制至关重要。就像驾驶汽车需要了解发动机原理一样，只有掌握了yfinance的内部运作方式，才能在遇到问题时迅速定位并解决。

2.1 yfinance的请求处理流程

yfinance请求处理流程示意图

yfinance的请求处理采用了分支式架构，主要包含以下几个关键环节：

  1. 配置层：处理全局设置，包括代理配置、缓存策略和日志级别
  2. 请求层：构造HTTP请求，处理请求头和参数
  3. 速率控制层：实现请求间隔管理，防止触发频率限制
  4. 响应处理层：解析服务器响应，处理错误和异常情况
  5. 数据缓存层：存储已获取数据，减少重复请求

这种分层架构使得yfinance能够灵活应对各种复杂的网络环境和访问限制。

2.2 速率限制的底层实现

在yfinance的源代码中，速率限制主要通过utils.py模块中的时间间隔计算函数实现：

def _interval_to_timedelta(interval):
    """将时间间隔字符串转换为相对时间差对象"""
    units = {
        'm': 'minutes', 'h': 'hours', 'd': 'days', 
        'wk': 'weeks', 'mo': 'months', 'y': 'years'
    }
    return relativedelta(**{
        units[interval[-2:]]: int(interval[:-2]) 
        if interval[-2:] in units else 
        units[interval[-1]]: int(interval[:-1])
    })

这段代码将用户指定的时间间隔（如"1d"、"1wk"）转换为实际的时间差，为后续的请求间隔控制提供基础。yfinance通过这种机制，确保在获取历史数据时能够自动调整请求频率。

2.3 缓存机制的工作原理

yfinance的缓存系统是减少请求频率的关键组件。其核心思想是将已获取的数据存储在本地，当再次请求相同数据时直接从本地读取，而不是重新发送网络请求。这就像我们日常生活中的冰箱，将需要频繁使用的食物（数据）存储起来，避免每次都去超市（API服务器）购买。

缓存机制在cache.py中实现，支持多种缓存策略和过期时间设置，能够根据数据类型自动调整缓存策略。

第三章：解决方案：突破访问限制的技术路线

面对yfinance的访问限制问题，我们有多种技术路线可以选择。每种方案都有其适用场景和优缺点，就像不同的交通工具适用于不同的出行需求。

3.1 方案一：本地代理配置方案

当你的应用部署在受限网络环境中时，配置代理服务器是最直接有效的解决方案。yfinance提供了灵活的代理配置接口：

import yfinance as yf

# 方式一：全局代理配置
yf.set_config(proxy={
    'http': 'http://proxy-server:port',
    'https': 'https://proxy-server:port'
})

# 方式二：环境变量配置
import os
os.environ['HTTP_PROXY'] = 'http://proxy-server:port'
os.environ['HTTPS_PROXY'] = 'https://proxy-server:port'

# 方式三：单次请求代理
ticker = yf.Ticker("AAPL")
data = ticker.history(period="1d", proxy="http://proxy-server:port")

适用场景：网络环境存在访问限制，需要通过特定代理才能访问Yahoo Finance。

优点：配置简单，对现有代码改动小。

缺点：依赖代理服务器的稳定性，可能增加网络延迟。

3.2 方案二：分布式请求策略

对于大规模数据获取需求，分布式请求策略是更高级的解决方案。这种方案通过将请求分散到多个IP地址，从根本上解决单一IP的速率限制问题。

import yfinance as yf
from concurrent.futures import ThreadPoolExecutor
import random

# 代理池
proxies = [
    "http://proxy1:port",
    "http://proxy2:port",
    "http://proxy3:port"
]

def fetch_data(ticker):
    # 随机选择一个代理
    proxy = random.choice(proxies)
    try:
        return {
            'ticker': ticker,
            'data': yf.Ticker(ticker).history(period="1d", proxy=proxy)
        }
    except Exception as e:
        return {
            'ticker': ticker,
            'error': str(e)
        }

# 要获取数据的股票列表
tickers = ["AAPL", "MSFT", "GOOG", "AMZN", "TSLA", "META", "BABA"]

# 使用线程池并发获取数据
with ThreadPoolExecutor(max_workers=3) as executor:
    results = list(executor.map(fetch_data, tickers))

# 处理结果
for result in results:
    if 'error' in result:
        print(f"获取 {result['ticker']} 数据失败: {result['error']}")
    else:
        print(f"成功获取 {result['ticker']} 数据，共 {len(result['data'])} 条记录")

适用场景：需要获取大量股票数据或高频数据的场景。

优点：能显著提高数据获取速度，有效规避单一IP的速率限制。

缺点：实现复杂度高，需要管理多个代理资源。

3.3 方案对比与选择建议

评估维度 本地代理配置 分布式请求策略
实现复杂度 低 高
资源需求 低 高
抗封锁能力 一般 强
适用规模 小规模 大规模
维护成本 低 高

🔑 核心策略：对于中小规模的数据获取需求，建议使用本地代理配置方案；对于需要大规模、高频次数据获取的场景，分布式请求策略是更好的选择。

第四章：实战优化：从问题诊断到性能调优

当你已经实现了基本的数据获取功能，如何进一步优化系统稳定性和性能？本节将通过实际案例展示完整的优化流程。

4.1 问题诊断与分析

在优化之前，我们需要先准确诊断问题所在。以下是一个完整的诊断流程：

  1. 启用调试日志：
import yfinance as yf
yf.enable_debug_mode()  # 启用详细日志输出
  1. 分析错误模式：通过日志识别错误类型和发生频率，建立错误统计表格：
错误类型 发生频率 可能原因
429 Too Many Requests 高频 请求频率过高
Connection Timeout 偶发 网络不稳定或代理问题
403 Forbidden 持续 IP被封禁或地域限制
  1. 定位瓶颈：根据错误模式确定是频率限制、网络问题还是地域限制。

4.2 性能优化实践

针对诊断结果，我们可以从以下几个方面进行优化：

1. 智能速率控制

import yfinance as yf
import time
from collections import defaultdict

class SmartRateLimiter:
    def __init__(self):
        self.request_timestamps = defaultdict(list)
        self.rate_limits = {
            'default': (5, 60),  # 5 requests per 60 seconds
            'history': (3, 60),  # 3 requests per 60 seconds for history data
            'info': (10, 60)     # 10 requests per 60 seconds for info data
        }
    
    def wait_if_needed(self, request_type='default'):
        """根据请求类型和历史记录决定是否需要等待"""
        now = time.time()
        limit, window = self.rate_limits[request_type]
        
        # 清除窗口外的时间戳
        self.request_timestamps[request_type] = [t for t in self.request_timestamps[request_type] if now - t < window]
        
        # 如果已达限制，计算需要等待的时间
        if len(self.request_timestamps[request_type]) >= limit:
            oldest = self.request_timestamps[request_type][0]
            wait_time = window - (now - oldest) + 1  # 额外加1秒保险
            time.sleep(wait_time)
        
        # 记录当前请求时间
        self.request_timestamps[request_type].append(time.time())

# 使用智能速率限制器
rate_limiter = SmartRateLimiter()
tickers = ["AAPL", "MSFT", "GOOG", "AMZN", "TSLA"]
results = {}

for ticker in tickers:
    rate_limiter.wait_if_needed('history')
    try:
        results[ticker] = yf.Ticker(ticker).history(period="1d")
        print(f"成功获取 {ticker} 数据")
    except Exception as e:
        print(f"获取 {ticker} 数据失败: {str(e)}")

2. 多级缓存策略

from functools import lru_cache
import yfinance as yf
import json
import os
from datetime import datetime, timedelta

class CachedYFinance:
    def __init__(self, cache_dir='yfinance_cache', ttl=3600):
        self.cache_dir = cache_dir
        self.ttl = ttl  # 缓存过期时间（秒）
        os.makedirs(cache_dir, exist_ok=True)
    
    def _get_cache_path(self, ticker, function, **kwargs):
        """生成缓存文件路径"""
        params_hash = hash(frozenset(kwargs.items()))
        return os.path.join(self.cache_dir, f"{ticker}_{function}_{params_hash}.json")
    
    def _is_cache_valid(self, cache_path):
        """检查缓存是否有效"""
        if not os.path.exists(cache_path):
            return False
        modified_time = os.path.getmtime(cache_path)
        return (datetime.now().timestamp() - modified_time) < self.ttl
    
    def _load_cache(self, cache_path):
        """加载缓存数据"""
        with open(cache_path, 'r') as f:
            return json.load(f)
    
    def _save_cache(self, cache_path, data):
        """保存数据到缓存"""
        with open(cache_path, 'w') as f:
            json.dump(data, f)
    
    def history(self, ticker, **kwargs):
        """带缓存的历史数据获取"""
        cache_path = self._get_cache_path(ticker, 'history', **kwargs)
        
        # 如果缓存有效，直接返回缓存数据
        if self._is_cache_valid(cache_path):
            return self._load_cache(cache_path)
        
        # 否则从API获取数据
        data = yf.Ticker(ticker).history(** kwargs).to_dict()
        self._save_cache(cache_path, data)
        return data

# 使用带缓存的yfinance客户端
cached_client = CachedYFinance(ttl=3600)  # 缓存1小时
data = cached_client.history("AAPL", period="1d")

4.3 失败案例分析与解决方案

案例一：高频请求导致的429错误

问题描述：在循环中连续获取20只股票的历史数据，前5只成功，后续全部返回429错误。

原因分析：未控制请求频率，超过了Yahoo的速率限制。

解决方案：实现动态速率控制，根据响应状态调整请求间隔：

import yfinance as yf
import time

tickers = ["AAPL", "MSFT", "GOOG", "AMZN", "TSLA", "META", "BABA", "PDD", "NFLX", "NVDA"]
results = {}
base_delay = 2  # 基础延迟时间（秒）
dynamic_delay = base_delay

for ticker in tickers:
    try:
        results[ticker] = yf.Ticker(ticker).history(period="1d")
        print(f"成功获取 {ticker} 数据")
        # 请求成功，逐渐降低延迟（但不低于基础延迟）
        dynamic_delay = max(base_delay, dynamic_delay * 0.9)
    except Exception as e:
        print(f"获取 {ticker} 数据失败: {str(e)}")
        # 如果是429错误，增加延迟
        if "429" in str(e):
            dynamic_delay *= 1.5
            print(f"检测到速率限制，增加延迟至 {dynamic_delay:.2f} 秒")
    
    # 等待下一次请求
    time.sleep(dynamic_delay)

案例二：代理服务器不稳定导致的连接中断

问题描述：使用单一代理服务器时，经常出现连接超时或重置。

解决方案：实现代理池和自动切换机制：

import yfinance as yf
import time
import random

# 代理池
proxies = [
    "http://proxy1:port",
    "http://proxy2:port",
    "http://proxy3:port"
]

# 代理可用性测试
def test_proxy(proxy):
    try:
        yf.Ticker("AAPL").info(proxy=proxy)
        return True
    except:
        return False

# 过滤可用代理
available_proxies = [p for p in proxies if test_proxy(p)]
if not available_proxies:
    raise Exception("没有可用的代理服务器")

tickers = ["AAPL", "MSFT", "GOOG"]
results = {}
current_proxy_index = 0

for ticker in tickers:
    max_retries = 3
    retry_count = 0
    
    while retry_count < max_retries:
        try:
            proxy = available_proxies[current_proxy_index]
            results[ticker] = yf.Ticker(ticker).history(period="1d", proxy=proxy)
            print(f"使用代理 {proxy} 成功获取 {ticker} 数据")
            break
        except Exception as e:
            retry_count += 1
            print(f"使用代理 {proxy} 获取 {ticker} 数据失败（{retry_count}/{max_retries}）: {str(e)}")
            
            if retry_count == max_retries:
                # 切换到下一个代理
                current_proxy_index = (current_proxy_index + 1) % len(available_proxies)
                print(f"切换到代理 {available_proxies[current_proxy_index]}")
                retry_count = 0
            time.sleep(2)

第五章：应急处理指南：常见故障排查流程

即使经过精心优化，在实际运行中仍然可能遇到各种问题。以下是五种常见故障的排查流程和解决方案。

5.1 429 Too Many Requests错误

排查流程：

  1. 检查请求频率是否超过Yahoo的限制
  2. 确认是否使用了缓存机制
  3. 检查是否有其他进程同时使用相同IP请求
  4. 验证代理IP是否被识别为异常流量源

解决方案：

  • 增加请求间隔时间
  • 实现指数退避算法（Exponential Backoff）
  • 切换代理IP
  • 优化缓存策略，减少重复请求

5.2 连接超时错误

排查流程：

  1. 检查网络连接是否正常
  2. 验证代理服务器是否可访问
  3. 测试目标服务器是否可达
  4. 检查防火墙设置是否阻止了请求

解决方案：

  • 增加超时时间设置
  • 实现请求重试机制
  • 切换到备用代理
  • 检查并调整网络配置

5.3 数据不完整或格式错误

排查流程：

  1. 检查请求参数是否正确
  2. 验证返回数据的完整性
  3. 查看日志了解详细错误信息
  4. 确认Yahoo Finance数据源是否有变化

解决方案：

  • 更新yfinance到最新版本
  • 调整请求参数
  • 实现数据校验和修复机制
  • 准备备用数据源

5.4 代理配置无效

排查流程：

  1. 验证代理服务器地址和端口是否正确
  2. 检查代理是否需要身份验证
  3. 测试代理是否能正常访问Yahoo Finance
  4. 确认代理配置是否被正确应用

解决方案：

  • 检查代理配置语法
  • 验证代理服务器状态
  • 尝试不同的代理协议（HTTP/HTTPS/SOCKS）
  • 检查环境变量是否覆盖了代理设置

5.5 缓存相关问题

排查流程：

  1. 检查缓存目录权限
  2. 验证缓存文件是否被正确创建
  3. 检查缓存过期时间设置是否合理
  4. 确认缓存是否被正确读取

解决方案：

  • 调整缓存目录权限
  • 清理损坏的缓存文件
  • 优化缓存过期策略
  • 实现缓存预热机制

第六章：实用工具与资源

为了帮助你更好地使用yfinance并解决访问限制问题，以下是一些实用工具和资源推荐。

6.1 配置模板

1. 基础配置模板

import yfinance as yf
import logging

# 基础配置
def setup_yfinance():
    # 配置代理
    yf.set_config(proxy={
        'http': 'http://proxy-server:port',
        'https': 'https://proxy-server:port'
    })
    
    # 配置日志
    logging.basicConfig(
        level=logging.INFO,
        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
        filename='yfinance.log'
    )
    
    # 启用调试模式（生产环境可注释）
    # yf.enable_debug_mode()
    
    # 配置缓存
    yf.set_config(cache_dir='./yfinance_cache', cache_ttl=3600)
    
    return yf

# 使用配置
yf = setup_yfinance()
data = yf.Ticker("AAPL").history(period="1d")

2. 高级配置模板

import yfinance as yf
import time
import random
from concurrent.futures import ThreadPoolExecutor, as_completed

class YFinanceManager:
    def __init__(self, proxies=None, cache_dir='./yfinance_cache', cache_ttl=3600):
        self.proxies = proxies or []
        self.available_proxies = []
        self.rate_limit_delay = 2  # 基础延迟（秒）
        
        # 配置yfinance
        yf.set_config(cache_dir=cache_dir, cache_ttl=cache_ttl)
        
        # 测试并过滤可用代理
        if self.proxies:
            self._test_proxies()
    
    def _test_proxies(self):
        """测试代理可用性"""
        print("正在测试代理可用性...")
        with ThreadPoolExecutor(max_workers=5) as executor:
            futures = {executor.submit(self._test_proxy, p): p for p in self.proxies}
            
            for future in as_completed(futures):
                proxy = futures[future]
                try:
                    if future.result():
                        self.available_proxies.append(proxy)
                        print(f"代理 {proxy} 可用")
                except Exception as e:
                    print(f"测试代理 {proxy} 时出错: {str(e)}")
        
        if not self.available_proxies:
            print("警告: 没有可用的代理服务器，将使用直接连接")
    
    def _test_proxy(self, proxy):
        """测试单个代理是否可用"""
        try:
            yf.Ticker("AAPL").info(proxy=proxy)
            return True
        except:
            return False
    
    def get_data(self, tickers, max_workers=3, period="1d"):
        """获取多个股票数据"""
        results = {}
        
        with ThreadPoolExecutor(max_workers=max_workers) as executor:
            futures = {}
            
            for ticker in tickers:
                # 选择代理（如果有可用代理）
                proxy = random.choice(self.available_proxies) if self.available_proxies else None
                futures[executor.submit(self._fetch_ticker_data, ticker, period, proxy)] = ticker
            
            for future in as_completed(futures):
                ticker = futures[future]
                try:
                    results[ticker] = future.result()
                    print(f"成功获取 {ticker} 数据")
                except Exception as e:
                    print(f"获取 {ticker} 数据失败: {str(e)}")
                    results[ticker] = None
                
                # 添加延迟以控制速率
                time.sleep(self.rate_limit_delay)
        
        return results
    
    def _fetch_ticker_data(self, ticker, period, proxy):
        """获取单个股票数据"""
        try:
            ticker_obj = yf.Ticker(ticker)
            return ticker_obj.history(period=period, proxy=proxy)
        except Exception as e:
            # 如果是速率限制错误，增加延迟
            if "429" in str(e):
                self.rate_limit_delay = min(10, self.rate_limit_delay * 1.5)
                print(f"检测到速率限制，增加延迟至 {self.rate_limit_delay:.2f} 秒")
            raise e

# 使用示例
proxies = [
    "http://proxy1:port",
    "http://proxy2:port",
    "http://proxy3:port"
]

manager = YFinanceManager(proxies=proxies)
tickers = ["AAPL", "MSFT", "GOOG", "AMZN", "TSLA"]
data = manager.get_data(tickers, max_workers=2, period="1d")

6.2 辅助工具推荐

  1. ProxyPool：开源代理池管理工具，能够自动抓取、验证和管理代理IP，提高代理的可用性。

  2. RequestLogger：HTTP请求日志分析工具，可以详细记录所有API请求和响应，帮助诊断网络问题。

  3. RateLimitTester：速率限制测试工具，能够自动探测API的速率限制阈值，为速率控制提供依据。

  4. CacheManager：高级缓存管理工具，支持多种缓存策略和过期规则，优化缓存使用效率。

  5. NetworkMonitor：网络监控工具，实时监控网络连接状态和响应时间，及时发现网络问题。

第七章：总结与最佳实践

通过本文的学习，你已经掌握了解决yfinance访问限制问题的核心技术和实践方法。总结起来，确保yfinance稳定运行的关键在于：

1.** 合理配置网络环境 **：根据实际需求选择合适的代理方案，确保网络连接的稳定性和可用性。

2.** 智能控制请求频率 **：实现动态速率限制机制，根据API响应调整请求间隔，避免触发速率限制。

3.** 优化缓存策略 **：充分利用yfinance的缓存功能，减少重复请求，提高数据获取效率。

4.** 完善错误处理 **：实现健壮的错误处理和重试机制，提高系统的容错能力。

5.** 持续监控与调整**：定期分析请求日志和错误模式，不断优化配置参数。

最后，需要强调的是，遵守Yahoo Finance的服务条款和使用政策是长期稳定使用yfinance的基础。合理使用API资源，不仅能够避免访问限制，也是作为开发者应尽的责任。

通过将本文介绍的技术方法与实际应用场景相结合，你一定能够构建一个稳定、高效的金融数据获取系统，为量化分析和交易决策提供可靠的数据支持。

yfinance
Download market data from Yahoo! Finance's API
项目地址：https://gitcode.com/GitHub_Trending/yf/yfinance
登录后查看全文

相关内容推荐

1 彻底解决yfinance API访问受限问题：权限控制与速率限制全攻略2 yfinance API访问控制完全指南：从受限到稳定的数据获取方案3 yfinance数据获取稳定性指南：从访问受限到流畅采集的全方位解决方案4 yfinance API访问控制完全指南：从限流规避到分布式请求优化5 yfinance API访问优化指南：从错误排查到稳定请求的完整解决方案6 3个核心步骤掌握yfinance，让股票数据分析效率提升50%7 解决yfinance数据获取难题：从诊断到优化的完整指南8 7个高效技巧：yfinance金融数据获取从入门到精通9 攻克yfinance数据获取难题：从错误排查到稳定运行的实战指南10 突破yfinance数据获取限制的5种实战方案
热门项目推荐
相关项目推荐

热门内容推荐

1 build-your-own-x 探索指南：从零构建编程技能体系2 技术实践新范式：build-your-own-x项目的系统构建与能力跃迁指南3 build-your-own-x 开源学习项目一站式指南4 【亲测免费】 开源项目 `build-your-own-x` 使用指南5 【亲测免费】 探索科技之旅：《Build Your Own X》项目详解6 GitHub_Trending/bu/build-your-own-x自动化：CI/CD流程在自制项目中的应用7 从零打造智能家居系统：用build-your-own-x实现家庭自动化

最新内容推荐

aliyunpan命令行工具全场景技术指南防撤回功能失效？开源工具3个技巧解决版本适配难题V-JEPA自监督视频表征学习：技术突破与行业实践指南OpenArm开源机械臂：重新定义协作机器人开发的开源硬件平台Zotero插件Ethereal Style：重塑学术研究的文献管理体验告别模组混乱：Wrye Bash让Bethesda游戏体验升级革新性AI开发辅助平台：Every-Marketplace效率倍增指南XposedRimetHelper：基于Hook技术的位置模拟实现与应用解析如何让Mac鼠标侧键重获新生？3步解锁高效导航体验知识网络：思维工具的新范式——开源笔记系统的知识组织深度指南

项目优选

收起
kernelkernel
deepin linux kernel
C
27
13
docsdocs
OpenHarmony documentation | OpenHarmony开发者文档
Dockerfile
626
4.13 K
RuoYi-Vue3RuoYi-Vue3
🎉 (RuoYi)官方仓库 基于SpringBoot，Spring Security，JWT，Vue3 & Vite、Element Plus 的前后端分离权限管理系统
Vue
1.5 K
850
ops-mathops-math
本项目是CANN提供的数学类基础计算算子库，实现网络在NPU上加速计算。
C++
930
806
flutter_flutterflutter_flutter
暂无简介
Dart
872
207
openHiTLSopenHiTLS
旨在打造算法先进、性能卓越、高效敏捷、安全可靠的密码套件，通过轻量级、可剪裁的软件技术架构满足各行业不同场景的多样化要求，让密码技术应用更简单，同时探索后量子等先进算法创新实践，构建密码前沿技术底座！
C
1.06 K
547
pytorchpytorch
Ascend Extension for PyTorch
Python
465
553
OpenBOATOpenBOAT
全称：Open Base Operator for Ascend Toolkit，哈尔滨工业大学AISS团队基于Ascend C打造的高性能昇腾算子库。
C++
45
47
cherry-studiocherry-studio
🍒 Cherry Studio 是一款支持多个 LLM 提供商的桌面客户端
TypeScript
1.25 K
100
MindSpeed-LLMMindSpeed-LLM
昇腾LLM分布式训练框架
Python
138
160