日本电子维修技术 显卡2080TI采购被批准了，买哪块比较好
努力了一翻之后可以买几块试试。
之前还没给学校采购过东西，用来训练模型可能会长期高负载运行。
求推荐售后省事，散热好的2080TI……
评论
公版？
评论
买公版。。。
评论
黑东公版呗。。。
评论
你看，三个人同时发帖，不约而同。。。
评论
肯定公版啊
评论
如果你能抢到的话。。
评论
黑东公版呗
评论
华硕顶级非公那款，你值得拥有
评论
国庆前都不用指望能买到
评论
什么学校 这么土豪
评论
我觉得微星的好看些···公版这个版本实在是欣赏不来···没有半点线条感觉
评论
为什么都说公版……公版散热不咋地呀
评论
你不是一直阿苏斯阿苏斯的。怎么叛变了
评论
这种使用场景需要考虑卡片密度啊，又不是摆桌上随便跑着玩的塔式工作战站三槽三风扇也能塞进去反正一个工作站也就一块卡
正经跑用的机器里都是二三四块各种泰坦皮啊就那么点空间，大点的卡直接不用想
接下来，此处我根本不知道啊苏斯有啥卡，公版肯定塞的进去的，于是
评论
感觉这代不需要买公版，2080ti听说公版散热有降频，还是买散热再给力点的三奶吧，买保修长热管多点的就行。
评论
EVGA的一体水冷看着不错
评论
买公版，一是这次的公版散热效果非常好，二是均热板PCB及电子元件温度也低，非公往往是核心温度低，PCB VRM供电之类温度很高
评论
楼主要多卡，你们给推荐公版？？？
不如直上Quadro RTX
评论
2080ti还是压不住 降频了 公版用料这次是良心了 但是只能说现在显卡是谁大谁牛逼啊
评论
公版只能买2080，能压住而且差价不大，2080ti不管改水还是不改，都不用考虑公版，贵1000不说还降频，信仰和小机箱除外
评论
那是原来的涡轮
现在公版双风扇开放式散热了
评论
多卡跑计算的话，开放式散热不如原来的涡轮
评论
看了几家评测公版烤机都会过热降频
评论
公家东西 买保修方便的
评论
你换其他家非公一样过热降频
评论
怪不得现在学费那么贵
评论
也可以买公版，然后用延长线把显卡分开就行了。不好看就是了。但如果学校只让采购公版那也没办法。
评论
看标题以为是老婆批准，进来一看原来是科研批准
评论
既然批准了，当然捡最贵的买啊。反正被批准的不花自己钱。
现在单位也就学校采购经费好了，其它的头疼
评论
asus 有个涡轮扇子的卡，但估计散热吃不消，其他形状又是2.5槽的，我这也塞不下……
评论
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <cuda_runtime.h>
#include <assert.h>
#include <cudnn.h>
#include <stddef.h>
#include <iostream>
#include <time.h>
#include<vector>
// Linux
#include <sys/time.h>
#include <boost/multi_array.hpp>
using namespace std;
#define checkCUDNN(expression) \
{ \
cudnnStatus_t status = (expression); \
if (status != CUDNN_STATUS_SUCCESS) { \
cerr << "Error on line " << __LINE__ << ": " \
<< cudnnGetErrorString(status) << endl; \
exit(EXIT_FAILURE); \
} \
}
double get_wall_time()
{
struct timeval time;
if (gettimeofday(&time,NULL)){
return 0;
}
return (double)time.tv_sec + (double)time.tv_usec * .000001;
}
cudnnHandle_t cudnn;
cudnnTensorDescriptor_t input_descriptor;
cudnnTensorDescriptor_t output_descriptor;
cudnnFilterDescriptor_t kernel_descriptor;
cudnnConvolutionDescriptor_t convolution_descriptor;
float workspace_bytes;
void* d_workspace{nullptr};
float* d_dummy_input{nullptr};
float* d_dummy_kernel{nullptr};
float* d_output{nullptr};
void post(){
cout << "version : CUDA runtime: " << cudnnGetVersion() << " | CuDNN: " << cudnnGetCudartVersion() << endl;
}
void initializeDescriptor(
int batch_size,
int input_channel,
int output_channel,
int input_height,
int input_width,
int output_height,
int output_width,
int kernel_height,
int kernel_width,
cudnnDataType_t dataType,
cudnnMathType_t mathType){
checkCUDNN(cudnnCreate(&cudnn));
//TODO 3 : Input, Filter and Output descriptors (xDesc, yDesc, wDesc, dxDesc, dyDesc and dwDesc as applicable) have dataType = CUDNN_DATA_HALF.
// INPUT
checkCUDNN(cudnnCreateTensorDescriptor(&input_descriptor));
checkCUDNN(cudnnSetTensor4dDescriptor(input_descriptor,
/*format=*/CUDNN_TENSOR_NHWC/*batch_size | height | width | channel*/,
/*dataType=*/dataType/*fp16*/,
/*batch_size=*/batch_size,
/*channels=*/input_channel,
/*image_height=*/input_height,
/*image_width=*/input_width));
// OUTPUT
checkCUDNN(cudnnCreateTensorDescriptor(&output_descriptor));
checkCUDNN(cudnnSetTensor4dDescriptor(output_descriptor,
/*format=*/CUDNN_TENSOR_NHWC,
/*dataType=*/dataType,
/*batch_size=*/batch_size,
/*channels=*/output_channel,
/*image_height=*/output_height,
/*image_width=*/output_width));
// KERNEL
checkCUDNN(cudnnCreateFilterDescriptor(&kernel_descriptor));
checkCUDNN(cudnnSetFilter4dDescriptor(kernel_descriptor,
/*dataType=*/dataType,
/*format=*/CUDNN_TENSOR_NCHW,
/*out_channels=*/output_channel,
/*in_channels=*/input_channel,
/*kernel_height=*/kernel_height,
/*kernel_width=*/kernel_width));
// CONVOLUTION
checkCUDNN(cudnnCreateConvolutionDescriptor(&convolution_descriptor));
checkCUDNN(cudnnSetConvolution2dDescriptor(convolution_descriptor,
/*pad_height=*/1/*zero-padding*/,
/*pad_width=*/1/*zero-padding*/,
/*vertical_stride=*/1,
/*horizontal_stride=*/1,
/*dilation_height=*/1/*holing, new kernel height = dilation_factor * ( original_height - 1 ) + 1*/,
/*dilation_width=*/1/*dilation_factor = 1 means no change*/,
/*mode=*/CUDNN_CROSS_CORRELATION,
/*computeType=*/CUDNN_DATA_FLOAT));
// TODO 1 : cudnnSetConvolutionMathType is called on the appropriate convolution descriptor setting mathType to CUDNN_TENSOR_OP_MATH.
cudnnSetConvolutionMathType(convolution_descriptor, mathType);
}
void createDeviceData(
int batch_size,
int input_channel,
int output_channel,
int input_height,
int input_width,
int output_height,
int output_width,
int kernel_height,
int kernel_width){
// use 10GB GPU memory for workspace
workspace_bytes = 10 * 1024.0f * 1024.0f * 1024.0f;
cudaMalloc(&d_workspace, workspace_bytes);
int dummy_input_bytes = batch_size * input_width * input_height * input_channel * sizeof(float);
int output_bytes = dummy_input_bytes;
// generate dummy input data
boost::multi_array<float, 4> h_dummy_input(boost::extents[batch_size][input_height][input_width][input_channel]);
for (int inner_batch_size = 0; inner_batch_size < batch_size; ++inner_batch_size) {
for (int inner_height = 0; inner_height < input_height; ++inner_height) {
for (int inner_width = 0; inner_width < input_width; ++inner_width) {
for (int inner_channel = 0; inner_channel < input_channel; ++inner_channel) {
h_dummy_input[inner_batch_size][inner_height][inner_width][inner_channel] = 0.12345f;
}
}
}
}
cudaMalloc(&d_dummy_input, dummy_input_bytes);
cudaMemcpy(d_dummy_input, h_dummy_input.data(), dummy_input_bytes, cudaMemcpyHostToDevice);
// output data
cudaMalloc(&d_output, output_bytes);
cudaMemset(d_output, 0, output_bytes);
// 3 by 3 dummy kernel
float kernel_template[kernel_width][kernel_height] = {
{1.1, 1.2, 1.3},
{1.4, -1.5, 1.6},
{1.7, 1.8, 1.9}
};
float h_dummy_kernel[input_channel][output_channel][kernel_width][kernel_height];
for (int kernel = 0; kernel < input_channel; ++kernel) {
for (int channel = 0; channel < output_channel; ++channel) {
for (int row = 0; row < kernel_width; ++row) {
for (int column = 0; column < kernel_height; ++column) {
h_dummy_kernel[kernel][channel][row][column] = kernel_template[row][column];
}
}
}
}
cudaMalloc(&d_dummy_kernel, sizeof(h_dummy_kernel));
cudaMemcpy(d_dummy_kernel, h_dummy_kernel, sizeof(h_dummy_kernel), cudaMemcpyHostToDevice);
}
void freeDeviceData(){
cudaFree(d_dummy_kernel);
cudaFree(d_dummy_input);
cudaFree(d_output);
cudaFree(d_workspace);
}
int main( int argc, char** argv )
{
post();
//TODO 4 : The number of Input and Output feature maps is a multiple of 8.
int batch_size_hparam[1] = {128};
int input_channel_hparam[1] = {8};
int input_height_hparam[14] = {32, 40, 48, 56, 64, 80, 96, 112, 128, 152, 176, 200, 224, 256};
int kernel_height = 3;
int kernel_width = kernel_height;
for(int x = 0; x < 1; x++){
int batch_size = batch_size_hparam[x];
for(int y = 0; y < 1; y++){
int input_channel = input_channel_hparam[y];
int output_channel = input_channel;
for(int z = 0; z < 14; z++){
int input_height = input_height_hparam[z];
int input_width = input_height;
int output_height = input_height;
int output_width = output_height;
// cout << "hyper-param: batch_size = " << batch_size << " | input_channel = " << input_channel << " | input_height = " << input_height << endl;
initializeDescriptor(
batch_size,
input_channel,
output_channel,
input_height,
input_width,
output_height,
output_width,
kernel_height,
kernel_width,
CUDNN_DATA_HALF,
CUDNN_DEFAULT_MATH);
createDeviceData(
batch_size,
input_channel,
output_channel,
input_height,
input_width,
output_height,
output_width,
kernel_height,
kernel_width);
double start_time = get_wall_time();
// execute
const float alpha = 1, beta = 0;
for(int i = 0; i < 10000; i++){
// TODO 2 : cudnnConvolutionForward is called using algo = CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_PRECOMP_GEMM.
checkCUDNN(cudnnConvolutionForward(cudnn,
&alpha,
input_descriptor,
d_dummy_input,
kernel_descriptor,
d_dummy_kernel,
convolution_descriptor,
CUDNN_CONVOLUTION_FWD_ALGO_WINOGRAD,
d_workspace,
workspace_bytes,
&beta,
output_descriptor,
d_output));
}
double end_time = get_wall_time();
// cout<<"time cost : "<< end_time - start_time <<"s." << endl;
cout<< end_time - start_time <<endl;
freeDeviceData();
}
}
}
cudnnDestroyTensorDescriptor(input_descriptor);
cudnnDestroyTensorDescriptor(output_descriptor);
cudnnDestroyFilterDescriptor(kernel_descriptor);
cudnnDestroyConvolutionDescriptor(convolution_descriptor);
cudnnDestroy(cudnn);
}复制代码测试代码。就等着你测了。
评论
用法：
https://www.chiphell.com/thread-1839986-1-1.html
具体不一样的地方：
无需来回调mathtype_t，设置为CUDNN_TENSOR_OP_MATH_ALLOW_CONVERSION即可。代码中的TODO 1。
tensor core现在可以与CUDNN_CONVOLUTION_FWD_ALGO_WINOGRAD_NONFUSED一起用了，不仅是CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_PRECOMP_GEMM。代码中的TODO 2。
评论
好的…卡到了我试试（学校采购要很久…… 电路 电子 维修 我现在把定影部分拆出来了。想换下滚，因为卡纸。但是我发现灯管挡住了。拆不了。不会拆。论坛里的高手拆解过吗？ 评论 认真看，认真瞧。果然有收 电路 电子 维修 求创维42c08RD电路图 评论 电视的图纸很少见 评论 电视的图纸很少见 评论 创维的图纸你要说 版号，不然无能为力 评论 板号5800-p42ALM-0050 168P-P42CLM-01
·日本留学生活 求个大阪合租
·日本留学生活 自家房招租求
·日本留学生活 东京地区出9成新lv钱包
·日本育儿教育 孩子从国内过来如何学习日语
·日本育儿教育 明年四月横滨招月嫂
·日本育儿教育 请问咋让娃突破识字关？感谢分享中文共读和学习经验的妈妈
·中文新闻 东区明星迈克尔·格列柯，53 岁，将在第一次出生两年后第二次
·中文新闻 《爱情岛》明星卡米拉·瑟洛和杰米·朱维特在透露即将迎来第三