run 了半小时了，也不知道是真在 run 还是卡死了
请教各位大佬，win10 下映射网络驱动器盘符用完了该怎么办？
RT 除了安装的物理硬盘之外，剩下的盘符全部被映射网络驱动器用完了，还想要新增有什么办法么？ 不想以文件夹形式存在，因为看不到剩余容量，很不直观。
我最近在学习 AI ，想本地搭建调试。我前段时间刚买了一台二手 m3max 128G 内存 1T 硬盘，不知道行不行？
五年工作经验, 两年全栈经验, 3 年后端(java)
后端: java 、node 前端|客户端: flutter 、react
轻度加班可以(8 点) 希望工作内容有意义点.. 不是都在爬流程...
或者什么小而美的公司?(
听说场外现在已经在炒 V2EX 的邀请码了 solana 上的代币被 livid 认证了，并且控了 75%的筹码，要是散出来给空投的话不是原地起飞了？
承认的链接是这个： https://www.sns.id/zh-Hans/domain/ca.v2ex
链接到了 pumpfun 的代币
💻 套餐配置：BIGGERBOX-PRO
LoginBWHCGLUKKB🛡️ 可靠保障
还可加$9.32 升级至NODESEEK-MEGABOX-PRO
从 iPhone 13PM 换到 Samsung S25 Ultra ，总共花费约 ￥ 5800 （含 2 年 Care+）
iPhone 13PM 流畅度依然很高，但对我来说痛点主要有：
预期中 Android 的缺点：
收获的 Android / Samsung OneUI 的优点：
预期外的缺点：
总结：
使用 SVHN 的数据集进行模型的训练，但是整个模型在训练集上的准确率是一直在上升的，但是到了测试集上就一直卡在 95%，都 3 天了，求各位大佬帮我看下有没有优化的方案！跪谢!
import torch
import torch.nn as nn
import torch.optim as optim
from torch.distributed.checkpoint import load_state_dict
from torch.hub import load_state_dict_from_url
from torch.nn.modules.loss import _Loss
from torch.optim import Optimizer
from torch.utils.data import Dataset, random_split, DataLoader
import torchvision
from torchvision.transforms import transforms
import torchvision.models as m
import matplotlib.pyplot as plt
import random
import gc # 用于垃圾回收
from torchinfo import summary
import numpy as np
import random
import gc
# 设置随机数种子
SEED = 420
random.seed(SEED)
np.random.seed(SEED)
torch.manual_seed(SEED)
torch.cuda.manual_seed(SEED)
torch.cuda.manual_seed_all(SEED)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
# 设置使用 gpu 还是 cpu 进行训练
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# 定义训练的论述
epochs = 100
lr = 0.0001
# 定义数据集需要的参数
batchSize = 64
# 加载训练集需要的数据转换器
trainT = transforms.Compose([
transforms.RandomCrop(28),
transforms.RandomRotation(degrees=[-15, 15]),
transforms.ToTensor(),
transforms.Normalize(mean = [0.4377, 0.4438, 0.4728], std = [0.1980, 0.2010, 0.1970])
])
# 加载测试集需要的数据转换器
testT = transforms.Compose([
transforms.CenterCrop(28),
transforms.ToTensor(),
transforms.Normalize(mean = [0.4377, 0.4438, 0.4728], std = [0.1980, 0.2010, 0.1970])
])
# 加载训练集数据
svhn_train = torchvision.datasets.SVHN(root='C:\\FashionMNIST'
, split="train"
, download=True
, transform=trainT
)
# 加载测试集数据
svhn_test = torchvision.datasets.SVHN(root='C:\\FashionMNIST'
, split="test"
, download=True
, transform=testT
)
# 定义神经网络，因为我们的图片的尺寸和样本数量都不是很大，所以选择从 ResNet18 和 Vgg16 中抽取层来构建网络
resnet18_ = m.resnet18()
class MyResNet(nn.Module): # 这个是基于 ResNet18 构建的网络
def __init__(self):
super(MyResNet, self).__init__()
self.block1 = nn.Sequential(
nn.Conv2d(3, 64, 3, 1, 1),
resnet18_.bn1,
resnet18_.relu
)
self.block2 = resnet18_.layer2 # 连权重都会复用过来，在 resnet18_ = m.resnet18() 这儿就已经初始化好了权重数据！
self.block3 = resnet18_.layer3
self.block4 = resnet18_.layer4 # 从 Resnet18 中哪 layer 新增到自己的模型中
self.avgpool = resnet18_.avgpool
self.fc = nn.Linear(512, 10, True)
def forward(self, x):
x = self.block1(x)
x = self.block2(x)
x = self.block3(x)
x = self.block4(x) # 这儿新增一条处理代码
x = self.avgpool(x)
x = x.view(-1, 512)
return self.fc(x)
vgg16_ = m.vgg16()
class MyVgg(nn.Module): # 这个是基于 Vgg16 构建的网络
def __init__(self):
super(MyVgg, self).__init__()
self.features = nn.Sequential(
*vgg16_.features[0:9],
# 使用*是 将 .features[0:9]提取出来的层，全部取出来，一个个放到当前的 Sequential 中，而不是组成一个 Sequential 放到当前的 Sequential 中！
nn.Conv2d(128, 128, 3, 1, 1),
nn.ReLU(inplace=True),
nn.MaxPool2d(2, 2, padding=0, dilation=1, ceil_mode=False)
)
self.avgpool = vgg16_.avgpool
self.fc = nn.Sequential(
nn.Linear(6272, 4096, True),
*vgg16_.classifier[1:6],
nn.Linear(4096, 10, True)
)
def forward(self, x):
x = self.features(x)
x = self.avgpool(x)
x = x.view(-1, 6272)
x = self.fc(x)
return x
# summary(MyVgg(), input_size=(10, 3, 28, 28)) # 一定要，实例化跑一下，看看有没有问题！
class earlyStopping():
def __init__(self, patience=5, tol=0.0005):
# 当连续 patience=5 次，本轮次的迭代的损失与历史最小的损失的差值大于 0.0005 这个阈值，就会停止训练
self.patience = patience
self.tol = tol
self.counter = 0 # 计数器
self.lowest_loss = None # 记录历史最小损失
self.early_stop = False # 需要返回是否需要提前停止
def __call__(self, val_loss): # val_loss 是记录测试集或训练集上一次 epoch 的损失
if self.lowest_loss is None:
self.lowest_loss = val_loss
elif self.lowest_loss - val_loss > self.tol:
self.lowest_loss = val_loss
self.counter = 0
elif self.lowest_loss - val_loss < self.tol:
self.counter += 1
print('Notice: Early stopping counter {} of {}'.format(self.counter, self.patience))
if self.counter >= self.patience:
print('Notice: Early stopping counter Active')
self.early_stop = True
return self.early_stop
# 定义训练函数
def fit(net: nn.Module, lossFunc: _Loss, op: Optimizer, trainData: DataLoader, testData: DataLoader, epochs: int):
transLost = [] # 用于收集每轮训练和测试的结果，用于后面画图表使用
trainCorrect = []
testLost = []
testCorrect = []
trainedSampleNum = 0
# 初始化 earlystopping 类
early_stopping = earlyStopping(patience=15, tol=0.00000005)
# 初始化测试集的历史最高准确率
test_highest_correct = None
test_lowest_loss = None
# 获取到整个训练集中的样本数量
trainTotalNum = trainData.dataset.__len__()
# 获取到整个测试集中的样本数量
testTotalNum = testData.dataset.__len__()
for epoch in range(epochs):
net.train()
train_loss = 0
train_correct = 0
for batch_index, (data, target) in enumerate(trainData):
data = data.to(device, non_blocking=True)
target = target.to(device, non_blocking=True).view(data.shape[0]) # 确保标签是 1 维的结构
trainRes = net(data) # 经过学习，这儿每个样本会输出 10 个特征结果对应的数据(如果模型中有 softmax ，就是概率)，可以用于后续计算准确率
loss = lossFunc(trainRes, target)
op.zero_grad() # 清空优化器上的梯度
loss.backward()
op.step()
# 开始计算准确数，并累加
yhat = torch.max(trainRes, 1)[1] # 从 trainRes 一个矩阵中，取出每个样本的最大值和最大值所在的索引，得到[1,2,1,4]这种类型的结果
correct_num = torch.sum(
yhat == target) # yhat 、target 都是一维张量，使用 == 会挨个对比张量中的元素是否相等，最终得到[False, True, Flase]这样的数据，然后使用 torch.sum 就可以得到一个数字，因为 True 为 1 ，False 为 0 。
train_correct += correct_num # 将准备数累加
# 计算损失，并累加
train_loss += loss.item() # 这儿需要得到所有样本的损失的和
trainedSampleNum += data.shape[0]
# print("本批次训练损失为：", loss.item() / data.shape[0])
if (batch_index + 1) % 125 == 0:
# 现在进行到了哪个 epoch 、总共要训练多少个样本、已经训练了多少个样本、已训练的样本的百分比
print("Epoch{}:{} / {} = ({:.0f}%)".format(
epoch + 1,
trainedSampleNum,
epochs * len(trainData) * batchSize,
100 * trainedSampleNum / (epochs * len(trainData) * batchSize)
))
print("-------------------------------")
avg_correct = (float(train_correct) / trainTotalNum) * 100
# print("本轮训练平均准确率：", avg_correct)
trainCorrect.append(avg_correct)
avg_loss = (float(train_loss) / trainTotalNum) * 100
# print("本轮训练平均损失率：", avg_loss)
transLost.append(avg_loss)
del data, target, train_loss, train_correct
gc.collect()
torch.cuda.empty_cache()
# 一轮训练结束，就使用测试集进行测试
net.eval()
test_loss = 0
test_correct = 0
for batch_index, (test_data, test_target) in enumerate(testData):
with torch.no_grad():
test_data = test_data.to(device, non_blocking=True)
test_target = test_target.to(device, non_blocking=True).view(test_data.shape[0]) # 确保标签是 1 维的结构
testRes = net(test_data)
loss = lossFunc(testRes, test_target)
# 计算损失，并累加
test_loss += loss.item()
# 计算准备数，并累加
yhat = torch.max(testRes, 1)[1] # 从 trainRes 一个矩阵中，取出每个样本的最大值和最大值所在的索引，得到[1,2,1,4]这种类型的结果
correct_num = torch.sum(
yhat == test_target) # yhat 、target 都是一维张量，使用 == 会挨个对比张量中的元素是否相等，最终得到[False, True, Flase]这样的数据，然后使用 torch.sum 就可以得到一个数字，因为 True 为 1 ，False 为 0 。
test_correct += correct_num # 将准备数累加
avg_test_correct = (float(test_correct) / testTotalNum) * 100
# print("本轮测试平均准确率：", avg_test_correct)
testCorrect.append(avg_test_correct)
avg_test_loss = (float(test_loss) / testTotalNum) * 100
# print("本轮测试平均损失率：", avg_test_loss)
testLost.append(avg_test_loss)
print("本轮训练平均准确率：{}, 本轮训练平均损失率: {}, 本轮测试平均准确率：{}, 本轮测试平均损失率：{}".format(
avg_correct, avg_loss, avg_test_correct, avg_test_loss))
del test_data, test_target, test_loss, test_correct
gc.collect()
torch.cuda.empty_cache()
# 如果测试集损失出现新低或者准确率出现新高，就保存在模型的权重，防止中途断电等原因需要从头再来
if test_highest_correct is None:
test_highest_correct = avg_test_correct
if test_highest_correct < avg_test_correct:
test_highest_correct = avg_test_correct
torch.save(net.state_dict(), './v6/model-' + str(epoch + 1) + '.pth')
print("model saved")
# 最好在测试集上使用提前停止，如果使用训练集无法预测过拟合这种情况
early_stop = early_stopping(avg_test_loss) # 这儿使用提前停止！
if early_stop:
break
print("mission completed")
return transLost, trainCorrect, testLost, testCorrect
model = MyResNet().to(device)
# model.load_state_dict(torch.load("./v4/model-49.pth"))
loss_func = nn.CrossEntropyLoss(reduction='sum') # 因为我们在训练函数中，在计算损失的时候是计算的每个样本的损失的和，所以这儿需要使用 reduction='sum'
opt = optim.RMSprop(model.parameters(), lr=lr, weight_decay=0.00005, momentum=0.0001)
train_data = DataLoader(svhn_train, batch_size=batchSize, shuffle=True, drop_last=False, pin_memory=True)
test_data = DataLoader(svhn_test, batch_size=batchSize, shuffle=False, drop_last=False, pin_memory=True)
# 开始训练
transLost, trainCorrect, testLost, testCorrect = fit(model, loss_func, opt, train_data, test_data, epochs)
# 训练结果可视化
plt.plot(transLost, label='train loss')
plt.plot(testLost, label='test loss')
plt.plot(trainCorrect, label='train correcct')
plt.plot(testCorrect, label='test correcct')
plt.xlabel('Epoch')
plt.ylabel('CrossEntropy Loss')
plt.title('Training Loss')
plt.legend()
plt.grid(True)
plt.show()美区超大杯，每个人 333G+所有苹果服务 游戏 音乐 tv 健身 新闻 自用的车已经开了 3 年了，现在有俩车友下车，招点新朋友 目前是半年二九零，感兴趣的请联系我
弱电箱（ 400x300x110 ）有四根超六类网线接到客厅以及三个房间，打算用 AP 面板组全屋 WIFI ，计划买 1000M 宽带，希望设备能跑满带宽无压力。
在快速发展的前端生态中，开发者们一直在寻找既能提高开发效率，又能保证代码质量和用户体验的解决方案。今天，我们很兴奋地向大家介绍 Metis UI —— 一个基于 Tailwind CSS 构建，继承 Ant Design 交互逻辑的现代 React 组件库。
在众多组件库中，Metis UI 独树一帜，它不是简单的重复造轮子，而是在继承优秀设计理念的基础上，带来了全新的开发体验：
Metis UI 基于 Ant Design 久经考验的组件逻辑构建，确保了交互模式的一致性和可靠性。同时，我们抛弃了传统的 CSS-in-JS 方案，全面拥抱 Tailwind CSS ，为开发者带来了前所未有的样式自由度。
import { Button, Input, Form } from 'metis-ui';
// 简洁的 API ，强大的功能
<Button
type="primary"
className="hover:scale-105 transition-transform"
>
自定义样式，轻而易举
</Button>
无需学习复杂的主题配置，直接使用 Tailwind 类名即可实现个性化定制。
interface ButtonProps {
type?: 'primary' | 'default' | 'dashed';
size?: 'small' | 'middle' | 'large';
loading?: boolean;
...
}
每个组件都提供完整的类型定义，让你的开发过程更加安全和高效。
<Button className="bg-gradient-to-r from-blue-500 to-purple-600 hover:from-blue-600 hover:to-purple-700">
渐变按钮
</Button>
利用 Tailwind 的强大功能，轻松实现复杂的样式效果。
# npm
npm install metis-ui
# pnpm (推荐)
pnpm add metis-ui
# yarn
yarn add metis-ui
向你的入口 CSS 文件添加一个 @plugin 以导入 Metis UI 。
@import 'tailwindcss';
@source './node_modules/metis-ui/es';
@plugin 'metis-ui/plugin';
import { Alert } from 'metis-ui';
const App = () => (
<div className="h-screen w-screen">
<Alert type="info" banner message="Hello" description="Welcome to metis-ui" />
</div>
);
export default App;
Metis UI 只针对颜色进行主题定制，默认提供了两套主题：light 和 dark。您还可以创建自己的自定义主题或修改内置主题。
您可以在 CSS 文件中的 @plugin "metis-ui/plugin" 后添加括号来管理主题，详细介绍。
我们提供了一套开箱即用的企业中后台系统模板，基于 React、react-router、TypeScript、Vite、TailwindCSS、Zustand、faker-js、MSW 等技术栈构建。它内置了开箱即用的数据流、国际化、菜单、模拟数据、权限管理、主题切换等功能，助力企业快速搭建高质量的中后台应用。
├── .husky # Husky 钩子配置目录
├── public # 公共静态资源目录
├── src # 源码目录
│ ├── apis # 服务端接口请求相关
│ ├── assets # 静态资源（图片、SVG 等）
│ ├── components # 通用组件
│ ├── hooks # 自定义 hooks
│ ├── layouts # 页面布局组件
│ ├── locale # 国际化资源
│ ├── mocks # Mock 数据与服务
│ ├── pages # 页面组件
│ ├── store # Zustand 状态管理
│ ├── types # TypeScript 类型定义
│ ├── utils # 工具函数与工具类
│ ├── loading.tsx # 全局 Loading 组件
│ ├── main.tsx # 应用入口文件
│ ├── routes.tsx # 路由和菜单配置
│ └── vite-env.d.ts # Vite 环境类型声明
├── .env # 环境变量配置文件
├── .lintstagedrc # lint-staged 配置文件
├── .prettierignore # Prettier 忽略文件配置
├── .prettierrc # Prettier 代码格式化配置
├── commitlint.config.js # 提交规范校验配置
├── eslint.config.js # ESLint 代码规范配置
├── index.html # 项目入口 HTML
├── package.json # 项目依赖与脚本配置
├── tailwind.css # TailwindCSS 全局样式入口
├── tsconfig.app.json # TS 应用配置
├── tsconfig.json # TS 根配置
├── tsconfig.node.json # TS Node 配
tips: 网站匀部属在 Github Pages, 访问可能需要梯子
hifini.com 访问不了了，应该是关了，请问大家还有什么别的下载音乐资源的地方吗
工作 6 年了, 有点自己的职场碎碎念, 随便写写走过的弯路
我的背景, 英国水硕(就是那个因为排名太高成为一个梗的), 4 年互联网, 2 年量化, 现量化边缘业务组
我的性格, ENFJ/ENFP 性格比较跳, 说难听点就是组里的刺头
TL;DR
一个情绪波动比较大的人, 总是会被日常一些别人的行为影响到情绪. 情绪乱了很多事情就不好做了 - 原本定好的完成进度会被影响 - 原本能沉下心写明白的算法写的漏洞百出 - 原本能好好说的话现在也无法好好表达了
我感觉性格是我最大的问题, 总觉得别人说一些话是在攻击我, 太敏感了, 我知道这是刻在我骨子里的有些东西就是很难改, 理由总有千万个什么早年经历原生家庭之类的, 现实情况是你不改那因为情绪化产生的各种问题就会一直折磨你. A 导致 B 你不改 A 那么 B 就会一直出现, 纵使你有千万个理由
因为敏感产生的并发症太多了, 总觉得别人攻击自己, 恶意揣测, 看不起自己给自己摆谱, 十分需要别人的肯定, 说到底本质还是因为对自己不够自信, 因为心底里并不真觉得自己能行, 所以容易会把所有事情都歪曲解读, 好像一个承重柱不稳的房子就很容易摇摇晃晃一样. 如果你是马云有那么多钱你还会很在意别人的看法吗?
有一次我真的绷不住了, 我跟我老板说他那样骂我我真的受不了, 我就骂了回去, 我老板给我看了他的平级在另一个人更多的大群里骂他的记录, 我没话了, 的确人不是一定要忍气吞声, 如果你真的所有事情都能做好那你确实没必要忍耐, 但在我们成长为有话语权的人之前, 忍耐一手也是不可或缺的, 一个小白的怒火是没有人会在意的.
逼着自己去做吧, 可能一开始会比较难受, 也许后面适应了就会好一点, 说着容易实际做起来就会阻碍重重. own 一个大项目的时候就需要做一个老妈子的角色, 方方面面都要安排明白, 成员可以找一万个理由 delay 不好意思但我不能, 出问题那就是骂你. 当完孙子回头还是要问其他人你现在是否遇到什么问题不理解的, 需要我帮忙的. 记得很清楚当时被老板骂的时候, 骂完我说: 你骂好了我现在来改. 我也觉得这很难受但, 我感觉这就是成长不可或缺的一个环节, 承载最大的压力与责任, 否则最多当好一个 IC
处理完一天的任务脑子已经一片混沌的时候, 有时候真的很难再集中精力告诉自己区分 A/B/C 类任务, 再识别出自己因为情绪问题导致的不理智行为, 这也是我要克服的, 道理大家都懂, 真落地的时候又有多少人能克服了自己性格上的问题, 做不到我也不怪自己无能, 每个周每个月能进步一点我也会觉得自己变得更厉害了
我不知道你们有没有观察过或者想过, 自己一个 Q, 一个周好像没做出来啥可圈可点的好玩意儿, 但是每天又忙的焦头烂额, 说到底还是 C(紧急不重要) D(不紧急不重要) 的事做太多了. 可圈可点的好玩意儿是 A 类任务, 需要一些较长周期的建设, 一些学习理解后做的出来.
每天周围会刷新一些 CD 类任务出来进你的栈, 按照直觉那就 LIFO, 谁找我我就处理谁: 好的我看下我看看之类的, CD 的刷新可能比你消耗的速度还要更快, 最后一整天都在看看都在 debug
我们都知道这样不好, 但现实是日常生活就是频繁刷 CD 任务出来, 这是铁一般的事实, A 类任务就是几乎不会刷出来, 尽管我们都知道 A 通关了能爆好东西, 那怎样减少 CD, 给我们腾出更多精力专心刷 A 这是一个要处理的棘手问题. 我的体感是, 建立一个完善的值班制度, 对应方向有(至少一个)负责的人, 最重要的是: 你得明白为什么你的生活里会如此频繁的刷垃圾任务出来. 你直接把刷怪笼打掉不就好了么?
理解, 理解问题吧, 找个本子找个笔, 记录最临近 100 个垃圾任务, 想想是不是我系统设计不到位打个补丁哪怕是塞个 if else 进去呢? 是不是我可以做个脚本让他们自己去修呢? 方法很多, 善于利用的聪明人就会给自己腾出更多精力. 我有时候真觉得不思考问题的本质 (这个词已经给说的有点臭了但还真的有效) 只会让自己愈发繁忙焦头烂额, 越焦头烂额越是没脑力去思考, 进步就会越慢, 有时候我逼自己慢下来, 不要着急回复, 不要着急处理, 不要着急键盘敲的噼里啪啦响, 实践几周后我发现真的有不少任务我想明白了, 似乎就没必要做了.
看来我们的问题还是思考的不够多, 而心急着手处理的太快. 最后业务说不明白成长为 0 即使跳槽也会发现自己好像啥也说不明白, 自然也没有 A 薪资的底气. 于是对内无法晋升, 向外就算跳槽也 A 不了太多薪资.
我不想让自己变成爹味很明显的说教, 我说的只是针对我自己性格我的感受, 而且我就算说了做了顿悟一般的思考我也不一定能做到. 总结一下也就两句话:
最近刚用上 Vue3, 我在写 Vue3 的时候总感觉代码非常的散, 稍微复杂的页面里, 就是一堆的 const ref, computed, 更不用说一堆的 xxxLoading, xxxVisible, showXXX, hideXXX, 感觉写 Vue2 的时候也没这么乱过, 如果说要提取所谓 Composiable 组件, 感觉又是一堆的 useXXX, 导出一堆的 xxx,xxx 好像也没好到哪里去, 是我写的姿势不对吗? 这方面的最佳实践到底是什么, 有没有哪个开源项目让我参考参考?
挑选机器时可参考一下，比如目前版瓦工正在发售的 BIGGERBOX 所在的 洛杉矶 DC1 机房监控：
https://smokeping.frytea.com/smokeping/?target=BandwagonHost.USCA_1
目前监控了数二百余机房，监控结果可作为网络稳定性的参考，需要更多可留言。
) 如有需要请尽快购买，预计 1 小时内售罄
线路特点：
中国电信 CN2GIA 中国联通 Premium (AS9929+CN2) 中国移动 CMIN2
服务器地点：
Los Angeles, DC1
配置信息：
SSD：20 GB RAID-10
RAM：1024 MB
CPU：1 x AMD
每月流量：1000 GB/mo
服务器带宽：2.5 Gigabit
IP 地址：1 个 IPv4 ，IPv6/64
售价：36.36 美元每年(使用优惠券)
优惠券：BWHCGLUKKB
即使 IP 被封也可以 30 日内全额退款，退款仅限新账户(新邮箱注册的账号)。
audio_string = ""
for chunk in completion:
if chunk.choices:
if hasattr(chunk.choices[0].delta, "audio"):
try:
audio_string += chunk.choices[0].delta.audio["data"]
except Exception as e:
print(chunk.choices[0].delta.audio["transcript"])
else:
print(chunk.usage)
wav_bytes = base64.b64decode(audio_string)
audio_np = np.frombuffer(wav_bytes, dtype=np.int16)
sf.write("audio_assistant_py.wav", audio_np, samplerate=24000)
第 7 、8 行：为什么把 print(chunk.choices[0].delta.audio["transcript"]) 放在 Exception 后面输出？
才注意到国内一台有可玩性的真正意义的跑车发布了, 就是小跑车 SC01.
看了下这个参数相当诱人啊:
钢管车架, 前后双叉臂加推杆式减震器, 镁合金轮毂, 锻造铝合金转向节, 双向可调竞赛级减震, 比 GT3 赛车还低的 380MM 超低重心, 前六后四卡钳, 前后刹车导风, 前后 Camber, Toe 角度可通过垫片, 连杆调整, 整备质量 1365kg, 后中置电池, 双电机四驱系统, 支持前驱 / 后驱 / 四驱 / 运动模式等多种驱动模式自主调节 综合功率 435 马力, 峰值扭矩 576NM,
整车售价 23 万.
就我所知, 1.3 吨多一点点的车重, 2500MM 轴距, 这是国内唯一一辆真正意义上的跑车了.
就上面这个参数配置, 除了电车没有手动挡, 直接把 86, BRZ, MX5 给秒了, 真的没想到国内还能造出可玩性这么高的车.
不过, 看 SC01 天马赛道动态, 使用标配前 265 后 295 的底盘设定, 好几个弯都有反打的情况, 如果前后 245 等宽轮胎, 那后轮就太不稳定了, 但是这个车可是四驱模式的啊, 所以这辆车可能对于驾驶水平一般般的人来说, 车尾有点过于灵活了, 说白了就是有点危险.
但是整体来说, 拥有这么多硬核配置, 极低重心, 非常理想车重的情况下, 只卖 23 万, 这辆车性价比也很高了.
不知道, V2EX 上有喜欢驾驶的驾驶者吗? 大家怎么看呢?
搬瓦工 BIGGERBOX-PRO 补货了, 三网优化
Limited availability
Refundable within 30 days even if IP is blocked by GFW
SSD: 20 GB RAID-10
RAM: 1024 MB
CPU: 1x AMD
Transfer: 1000 GB/mo
Link speed: 2.5 Gigabit
Location: Los Angeles, DC1
Direct Premium China connectivity (China Telecom CN2 GIA, CMIN2, China Unicom Premium)
Price: $36.36/year
与之前 MEGABOX-PRO 配置比较, 看看后期能不能升级到 MEGABOX-PRO 了, 按需购买
| 产品 | 年付价格 | 月流量 | 配置 |
|---|---|---|---|
| BIGGERBOX-PRO | $36.36 | 1000G | 1 核 1G 20G |
| MEGABOX-PRO | $45.68 | 2000G | 2 核 2G 40G |
购买链接 1
购买链接 2
Discount code: NODESEEK
Discount code: BWHCGLUKKB
吐槽下，心里很闷。
在某平台做应用，做了几个完全不同类的作品，第三个类小火了。
那之后有幸被领导指教，领导说，你现在要做的就是把这个小火的作品里的“可复用”的东西抽出来，
把它系统化，然后用来来做一个不同主题的作品，这样就能把这个成功经验尝试去复现了。
领导说这是很难得的能力，并且比较宝贵。
听完以后深受启发！ 开始为期 1 年的苦修，终于做成一套可复用系统。
第四个作品做好，是第三个项目的“换皮”，此刻才感受到那些游戏换皮并不简单，要想换皮，
要把各个系统抽象成概念，然后去加入新的元素进去。最后还要融合起来。（做的文字对话机器人玩法类的）
然后准备给第四个作品提交推荐，被驳回，得到理由：毫无创新。本质还是你的第三个作品。
顿时，心灰意冷。
