복잡한 텐서에 대한 선택적 지원을 추가하는 데 관심이 있다고 생각합니다. 가장 좋은 방법은 torch/lib 의 C 라이브러리를 포크하고 작업하는 것입니다. 이것은 마스터와 충돌이 없어야 하므로 오랫동안 이 작업을 수행할 수 있습니다. 라이브러리를 사용 가능한 상태로 만들면 바인딩 작성을 시작할 수 있으며 여기에서 충돌을 피하는 방법에 대한 지침을 제공할 수 있습니다.

복잡한 유형을 컴파일하는 TH가 있습니다. Python 통합을 위해 무엇을 추가해야 합니까?

@PhilippPelz 는 https://github.com/facebook/ztorch/tree/master/lib/THZ 를 의미합니까? 아니면 복잡한 유형을 가능하게 하는 자체 TH 포크를 구축했습니까?

@killeent 는 TH가 Python에 바인딩되는 방법에 대한 몇 가지 메모를 가지고 있으며 공유할 수 있습니다.

일반적으로 복잡한 Tensor를 가져오려면 테스트 등이 있으므로 THZ를 선호합니다.

복잡한 Tensor를 위한 CUDA 백엔드를 구축하는 것은 상당히 힘든 일이지만 아직 시작도 하지 않았습니다.

나는 얼마 전에 z-cutorch( https://github.com/PhilippPelz/z-cutorch )를 작성했습니다. CudaHalfTensor에 대한 리팩토링 이전의 포크 오프 컷입니다(아직 하드웨어가 없음).

이것은 훌륭합니다. 그런 방향으로 이미 많은 노력을 했다고 생각합니다 :)

@soumith 나는 복잡한 유형으로 TH를 포크했습니다. 기본적으로 THGenerateComplexTypes.h + 추가된 BLAS + LAPACK 루틴 나머지는 거의 무료였습니다. THZ의 어떤 부분이 호환되는지 확인한 다음 복사하여 붙여넣는 것보다 훨씬 덜 수월해 보였습니다.

저는 지금 THPP를 컴파일하는 데 어려움을 겪고 있으며 다음과 같은 컴파일러 메시지를 파악하고 있습니다.

/home/philipp/projects/pytorch/torch/lib/tmp_install/include/TH/generic/THBlas.h:6:40: 오류: '*' 토큰 앞에 ',' 또는 '...'가 있어야 합니다.
TH_API 무효 THBlas_(swap)(long n, real *, long incx, real *, long incy);

조금 까다롭습니다.

파이썬 통합을 활성화하는 방법에 대한 도움을 주시면 감사하겠습니다. CUDA 백엔드는 대부분 z-cutorch에서 복사 붙여넣기여야 합니다.

@PhilippPelz 는 PyTorch 랩 TH에 대한 몇 가지 참고 사항입니다. https://gist.github.com/killeent/4675635b40b61a45cac2f95a285ce3c0

@killent 감사합니다, 매우 유용해 보입니다. lib/build_all.sh가 이제 컴파일 중입니다. csrc 디렉토리를 볼 수 있을 것 같습니다.

이제 다음이 실행됩니다.

토치를 th로 가져오기
numpy를 np로 가져오기

a = np.array([1+1j,2+2j])
b = np.array([3+3j,4+4j])
ath = th.from_numpy(a)
bth = th.from_numpy(b)
ath_cuda = ath.cuda()
ath_cuda += bth.cuda()
ath = ath_cuda.cpu()
인쇄(ath.numpy())

아웃: [ 4.+4.j 6.+6.j]

대부분의 수학 함수와 함께
나는 다음 주에 편의 기능과 fft를 추가할 것입니다. 이것을 병합하기 전에 모든 것에 대한 테스트가 필요하다고 생각합니다. 복잡한 텐서에 관심이 있고 테스트 작성에 기꺼이 기여할 수 있는 사람을 알고 있다면 정말 좋을 것입니다. 이 논문이 떠오릅니다: Deep Complex Networks , 아마도 그 사람들이 관심을 가질 것입니다.
혼자서 모든 테스트를 작성할 시간이 없습니다.

@PhilippPelz 귀하의 의견에 감사드립니다. 귀하의 구현을 확인하고 있습니다. 그리고 먼저 ger 구현에 대해 잘 모르겠습니다. 생성 헤더에서 GER를 zger_ 및 cger_ 로 정의한 것처럼 일부 복잡한 blas 함수는 THBlas.c에 포함되어 있지 않지만 일반/THBlas.c에는 cger_가 있는 blas 함수가 없습니다. . 하지만 gemv 및 기타 기능을 사용할 수 있습니다. 그리고 IMO는 .gitignore에 .gch를 추가해야 할까요? 모든 확장을 포크로 푸시했습니까? 먼저 구현에 따라 마스터에게 풀 요청을 할 수 있습니다.

그리고 DOT 의 경우 복잡한 벡터의 경우 점에 대한 dotc 루틴이 더 일반적이라고 생각합니다.

그리고 예, real 를 사용하는 것이 구현에 더 쉬울 것이라면 real 가 실제로 복잡할 때 이상한 느낌이 들었습니다.

그리고 테스트의 경우 TH에 대한 이전 테스트를 보지 못했습니다. 그 테스트는 어디에 작성해야 합니까? 또는 우리는 약간의 파이썬 테스트를 작성합니다.

예, 죄송합니다. 필요한 모든 것을 푸시하지 못한 것 같습니다. 월요일에 다시 확인하겠습니다. 일부 선언이 누락되었습니다. zger와 cger

DOT의 경우 cdotc 및 zdotc를 사용하고 있는데 누락된 것 같습니다. 다음 주에 업데이트하겠습니다.

실제로 선호하는 이름을 pytorch 유지 관리자에게 확인하십시오. 나는 당신의 버전을 더 좋아하지만 아직 노력을 기울이지 않았습니다.

예, 파이썬은 수학 문제를 테스트합니다. compelx 번호 검사도 포함하도록 대부분의 기능에 대해 쉽게 변경되어야 합니다.

멋진 당신도 이것에 대해 찾고 있습니다!

알겠습니다. 몇 가지 변경 사항을 푸시했습니다. TH blas 루틴은 이제 복잡한

@PhilippPelz 방금 귀하의 리포지토리에 pull 요청을 했습니다. 복잡한 선형 레이어 및 기타 연산자의 경우. 많은 hermitian 연산이 있을 수 있습니다(복잡한 선형 레이어의 경우 bp와 같은). 텐서에 기능을 추가할까요? THNN 부분은 확인하셨나요?

예, hermitian이 유용합니다. cuda fft가 지금 작동 중입니다. cpu fft는 numpy에서 래핑될 수 있습니다. 나는 아직 THNN이나 THCUNN을 만지지 않았다.

@PhilippPelz PR에 간단한 은둔자를 추가했습니다. 그리고 그것을 검토할 수 있습니다. 따라서 이러한 변경 사항이 적합한지 확인하고 다음 단계로 이동할 수 있습니다. 감사 해요! 추신. 일부 헤더를 놓친 것 같습니다. 해당 헤더와 기타 경고도 수정합니다. 실제 출력이 있는 복잡한 함수의 경우 복소수 텐서가 아닌 실제 텐서를 반환해야 합니까? 나는 복합형과 실제형 사이에 복사 방법을 구현했으니 가능하다.

검토 후 모든 커밋을 리베이스하겠습니다.

@PhilippPelz 안녕하세요, 구현한 THPP 부분에 대해 상당히 혼란스럽습니다. Traits.hpp 의 추력에 의존하는 이유는 무엇입니까? cuda 없이 컴파일할 때 오류가 발생합니다. 처럼만 사용이 가능한가요?또는Traits.hpp ? 나는 그것을 알아내지 못했다. 몇 가지 단서를 제공할 수 있습니까?

@Roger-luo 예, 다른 곳에서도 문제가 있습니다. 우리가 사용하는 복합 유형은 complex.h 또는 std::complex 중 하나여야 합니다. THPP는 C++ 래퍼이므로 std::complex가 더 적절할 수 있습니다. 바꿔주실 수 있나요?

Thrust는 cffi 확장을 구축할 때와 똑같은 이유로 문제를 일으키기도 합니다. 지금은 해결 방법을 수행하고 있지만 적절한 방법은 THC에서 복합 유형을 cuFloatComplex/cuDoubleComplex로 변경하는 것입니다. cffi 컴파일러가 불평하지 않도록. 지금 바로 연구를 진행하고 싶은데 시간이 너무 많이 걸리네요 :( . 시간이 되시면 해주세요.

또한 사용자 정의 커널 호출로 cffi 확장을 구축하는 것은 매우 번거로운 일입니다. 왜냐하면 항상 nvcc로 컴파일된 추가 라이브러리를 생성해야 하기 때문입니다. 이 라이브러리는 cffi 래퍼에 연결됩니다. 다른 방법은 없는 것 같아요. ABI 모드에서 cffi를 사용할 수 있지만 웹 사이트에는 "대신 API 모드는 대상 함수를 직접 호출하는 CPython C 래퍼를 컴파일합니다. 상대적으로 훨씬 빠르며 libffi보다 더 잘 작동합니다."라고 말합니다.

@PhilippPelz 아마도 reinterpret_cast 이 해결책이 될 수 있습니까? cuComplex 로 변경하고 THPP에서 reinterpret_cast 를 사용해야 한다고 생각합니다. 내가 먼저 해볼게...

예, cuda가 설치되지 않은 상태에서도 THPP를 빌드하려면 reinterpret_cast 외에는 다른 방법이 없다고 생각합니다.

@PhilippPelz 도와드리고 싶습니다. 할 일 목록이 어디에 있습니까?

복합 유형에 대해 THNN 및 THCUNN을 활성화해야 합니다. @roger-luo와 협력할 수 있습니까? 또한 마스터와의 통합을 목표로 한다면 모든 복잡한 메소드에 대해 단위 테스트를 작성해야 합니다.

@elbamos THNN 의 대부분의 작업은 존재하는 각 레이어에 대해 새롭고 복잡한 역전파 방법을 구현하는 것입니다. Philipp의 포크에 WIP PR이 있습니다. 나는 몇 가지 참조를 나열했습니다.

@apaszke @sumith @PhilippPelz 그리고 두 가지 질문이 있습니다.

• THS 에 다른 GenerateXXXTypes.h 파일이 있는 이유를 아는 사람이 있습니까? TH 에 있는 것과 동일하게 보입니다.

• byte_order.cpp 의 다음 코드는 무엇입니까?

void THP_decodeFloatBuffer(float* dst, const uint8_t* src, THPByteOrder order, size_t len)
{
  for (size_t i = 0; i < len; i++) {
    union { uint32_t x; float f; };
    x = (order == THP_BIG_ENDIAN ? decodeUInt32BE(src) : decodeUInt32LE(src));
    dst[i] = f;
    src += sizeof(float);
  }
}

void THP_decodeDoubleBuffer(double* dst, const uint8_t* src, THPByteOrder order, size_t len)
{
  for (size_t i = 0; i < len; i++) {
    union { uint64_t x; double d; };
    x = (order == THP_BIG_ENDIAN ? decodeUInt64BE(src) : decodeUInt64LE(src));
    dst[i] = d;
    src += sizeof(double);
  }
}

관련 복합 버전 구현에 대한 제안 사항이 있습니까? 다음 구현이 올바른지 확실하지 않습니다...

void THP_decodeZFloatBuffer(std::complex<float>* dst, const uint8_t* src, THPByteOrder order, size_t len)
{
  for (size_t i = 0; i < len; i++) {
    union { uint64_t x; std::complex<float> cf;};
    x = (order == THP_BIG_ENDIAN ? decodeUInt64BE(src) : decodeUInt64LE(src));
    dst[i] = cf;
    src += sizeof(std::complex<float>);
  }
}

void THP_decodeDoubleBuffer(std::complex<double>* dst, const uint8_t* src, THPByteOrder order, size_t len)
{
  for (size_t i = 0; i < len; i++) {
    union { uint128_t x; std::complex<double> df;};
    x = (order == THP_BIG_ENDIAN ? decodeUInt128BE(src) : decodeUInt128LE(src));
    dst[i] = df;
    src += sizeof(std::complex<double>);
  }
}

이전 decodeUInt128XE 는 다음과 같이 선언됩니다.

static inline uint128_t decodeUInt128LE(const uint8_t *data) {
  return (((uint128_t)data[ 0])<<  0) | (((uint128_t)data[ 1])<<  8)|
         (((uint128_t)data[ 2])<< 16) | (((uint128_t)data[ 3])<< 24)|
         (((uint128_t)data[ 4])<< 32) | (((uint128_t)data[ 5])<< 40)|
         (((uint128_t)data[ 6])<< 48) | (((uint128_t)data[ 7])<< 56)|
         (((uint128_t)data[ 8])<< 64) | (((uint128_t)data[ 9])<< 72)|
         (((uint128_t)data[10])<< 80) | (((uint128_t)data[11])<< 88)|
         (((uint128_t)data[12])<< 96) | (((uint128_t)data[13])<<104)|
         (((uint128_t)data[14])<<112) | (((uint128_t)data[15])<<120);
}

static inline uint128_t decodeUInt128BE(const uint8_t *data) {
  return (((uint128_t)data[15])<<  0) | (((uint128_t)data[14])<<  8)|
         (((uint128_t)data[13])<< 16) | (((uint128_t)data[12])<< 24)|
         (((uint128_t)data[11])<< 32) | (((uint128_t)data[10])<< 40)|
         (((uint128_t)data[ 9])<< 48) | (((uint128_t)data[ 8])<< 56)|
         (((uint128_t)data[ 7])<< 64) | (((uint128_t)data[ 6])<< 72)|
         (((uint128_t)data[ 5])<< 80) | (((uint128_t)data[ 4])<< 88)|
         (((uint128_t)data[ 3])<< 96) | (((uint128_t)data[ 2])<<104)|
         (((uint128_t)data[ 1])<<112) | (((uint128_t)data[ 0])<<120);
}

저는 현재 THPP T _Complex std::complex<T> 를 사용하고 있습니다. 이것이 아직 Python에서 사용할 수 있는지 확실하지 않습니다. 또는 C 유형 T _Complex python에 사용할 수 있습니다. 따라서 여기서 dst 유형은 std::complex<T> 입니다.

그리고 이 구현이 맞다면 아마도 https://github.com/calccrypto/uint128_t 와 같은 uint128_t 구현이 필요할 것입니다. 모든 컴파일러가 128비트 정수를 지원하는 것은 아닌 것 같기 때문에(gcc에는 int128_t 및 uint128_t가 있습니다).

@PhilippPelz 귀하의 포크에 문제가 활성화되어 있지 않은 것으로 나타났습니다. 귀하의 프로젝트 상태는 어떻습니까? 복잡한 텐서가 pytorch의 로드맵에 없다는 것이 조금 아쉽습니다.

@el3ment 나는 CPU에 복잡한 백엔드를 추가했습니다 https://github.com/pytorch/pytorch/pull/4899 하지만 아직 검토되지 않았습니다... 그리고 내 PR에 대한 의견을 받지 못했기 때문에 사용하기 시작했습니다. Julia 프로그래밍 언어는 최근...

지난번에 @PhilippPelz 에게 이메일을 보냈습니다. 그의 repo는 아직 v0.1 미만이고 그는 9월까지 논문을 위해 바쁩니까? 그리고 v0.3의 새로운 CUDA 백엔드 작업을 하고 있었지만 이 모든 바인딩을 혼자 완료할 시간이 없습니다. map/reduce 함수는 일부 최적화가 있는 v0.1과 다르지만 복소수를 지원하도록 간단하게 변환할 수 없습니다. 도와주실 분이 계시다면 기쁠텐데...

기꺼이 도와드리겠습니다.

2018년 4월 10일 오후 10시 52분에 Rogerluo [email protected] 이 다음과 같이 썼습니다.

@el3ment CPU #4899에 복잡한 백엔드를 추가했습니다.

지난번에 @PhilippPelz 에게 이메일을 보냈습니다. 그의 repo는 아직 v0.1 미만이고 그는 9월까지 논문을 위해 바쁩니까? 그리고 v0.3의 새로운 CUDA 백엔드 작업을 하고 있었지만 이 모든 바인딩을 혼자 완료할 시간이 없습니다. map/reduce 함수는 일부 최적화가 있는 v0.1과 다르지만 복소수를 지원하도록 간단하게 변환할 수 없습니다. 도와주실 분이 계시다면 기쁠텐데...

—
당신이 언급되었기 때문에 이것을 받는 것입니다.
이 이메일에 직접 답장하거나 GitHub에서 보거나 스레드를 음소거하세요.

@elbamos 쿨, pytorch 팀은 별도의 구현을 선호하는 것 같습니다. 나중에 다른 부분에 대해 포크를 업데이트하겠습니다. 그러나 나는 정말로 이것에 대한 시간이 없고, 이것이 pytorch의 큰 확장이 될 것이기 때문에 pytorch 팀에서 계획이 있을 때 작업을 시작해야 한다고 생각합니다.

안녕하세요, 제 코드는 v0.2 이후에 커밋되었습니다.

나는 모든 텐서 코드를 Aten으로 옮기는 꽤 큰 리팩터가 있는 것을 보았습니다. 이것은 내 포크를 현재 버전에 쉽게 병합할 수 없으며 더 많은 작업이 포함될 수 있음을 의미합니다.

아직 박사 과정을 작성 중이지만 Variable과 Tensor의 병합이 릴리스될 때까지 어쨌든 0.4를 기다릴 계획이었습니다. 더 일찍 리팩토링을 하면 따라잡기 위해 너무 많은 리팩토링이 진행되지 않을까 걱정됩니다.

@elbamos 원하는 경우 내 포크에 항목을 추가할 수 있습니다. 병합하겠습니다. 대신 수행 중인 프로젝트에 필요한 것을 구현하겠습니다. TH(CU)NN은 꽤 큰 인터페이스이며 엄청난 워크로드가 될 것입니다.

@el3ment 다른 사람의 문제를 처리할 시간이 없습니다. 그러나 거기에 없는 것을 구현해야 하는 경우 항목을 병합할 것입니다.

기본적으로 복소수로 작동하는 것을 원한다면 tensorflow를 적극 권장합니다.

컴파일 문제가 있는 경우에도 도움을 드리겠습니다.

포스트닥을 계속하면 이 모든 것을 어느 시점에서 현재 버전으로 이식할 것입니다. 페이스북이 이를 지원하지 않는다는 점은 정말 안타깝습니다. :((

@PhilippPelz 동의합니다. 정말 슬프고 실제로 tensorflow가 양자 물리학의 모든 연산자를 지원하지 않습니다... Julia를 사용하기 시작하고 파이썬을 포기했습니다.

@Roger-luo 흥미롭습니다. 특정 julia 패키지를 사용하고 있습니까 아니면 모두 자체 작성 코드입니까?

@PhilippPelz 저는 Julia에서 양자 다체 툴킷을 개발 중입니다(PyTorch PR 이후). 여기에는 복잡한 신경망에 대한 이전 논문을 기반으로 한 복잡한/실제 신경망 구현이 포함되어 있으며 Julia의 메타프로그래밍. 나는 현재 그것을 QMTK.jl 에 넣었고, 여전히 진행 중이며 내가 원하는 모든 것을 끝내지 못했습니다. PyTorch는 정말 많은 영감을 주지만 복잡한 지원에 대해 정말 죄송합니다...

하지만 앞으로 신경망 단일 패키지로 분리할 계획이 있습니다(지금은 여러 저장소를 유지하고 싶지 않습니다). 그리고 CAS(Institute of Physics, CAS)의 개발에 더 많은 사람들이 참여할 것입니다. 첫 번째 태그가 지정된 버전(몇 주 내) 이후에 PR을 수락하겠습니다.

개발에 관심이 있다면 볼 수 있습니다.

PyTorch 팀이 미래에 복잡한 지원에 대한 계획을 가지고 있다면 기꺼이 도울 것입니다.

쿨, 지켜볼게!

안녕하세요 여러분, 이 문제가 시작된 이후로 이에 대해 답변을 드리지 못해 죄송합니다.

다음은 두 가지 사실입니다.

1. 우리는 PyTorch가 복잡한 지원을 필요로 한다는 데 절대적으로 동의합니다.
2. 모든 복잡한 작업에 필요한 롱테일을 적절하게 채울 인력이 없습니다. (이에 대한 증거로 마스터에 있고 절뚝거리고 있는 희소 지원을 살펴보세요.)

이 문제가 2017년에 열린 이후로 복잡한 지원 구현을 좀 더 간단하게 만들 수 있는 몇 가지 중요한 사항이 변경되었습니다. 첫 번째는 이제 텐서를 조작하기 위한 인체공학적 C++ 라이브러리인 ATen이 있다는 것입니다. 이것은 TH/THC 코드의 거대한 부분을 복사하여 붙여넣을 필요 가 없고 모든 수동 refcounting을 올바르게 했으면 하는 것을 의미합니다. C++ 코드를 마치 Python인 것처럼 작성할 수 있고 빠르게 실행할 수 있습니다. 두 번째는 우리가 C10이라고 하는 새 버전의 Aten을 개발 중이라는 것입니다. 이 버전은 Aten(닫힌 것)보다 개방형 백엔드를 갖는 것에 대해 훨씬 더 진지합니다. t는 실제로 PyTorch를 분기하여 코드의 새 디렉토리를 추가하는 것을 수반합니다.

따라서 @Roger-luo 및 @PhilippPelz , 우리는 복잡한 백엔드를 현실로 만드는 데 여러분의 도움을 받고 싶지만 미래에도 이를 지속 가능하게 유지하는 데 도움이 되는 방법을 찾고 싶습니다. 당신의 생각을 알려주세요.

@ezyang 인력이 부족하면 앞으로 복잡한 텐서 부분을 유지하려고 노력할 수 있습니다. 나는 방금 박사 학위를 시작했습니다. 적어도 최근 몇 년. 하지만 pytorch 팀의 피드백 없이는 계속 기여할 수 없습니다. 이 큰 확장에 대한 로드맵 이 있어야 한다고 생각합니다. 그리고 복잡한 지원을 원활하게 추가할 수 있으므로 귀하의 사람들이 대규모 PR을 검토할 필요가 없고 마스터 브랜치를 추적하는 개발자의 노력을 쉽게 할 수 있습니다.

첫째, 복잡한 지원에 대한 주요 문제는 CUDA 부분이 될 것이라고 생각합니다. Aten이나 다른 라이브러리로 CPU 부분을 지원하는 것은 매우 쉽습니다. 피드백이 있으면 며칠 만에 CPU 부분을 다시 작성할 수 있습니다. CUDA 부분에 대해 우려할 수 있는 몇 가지 문제가 있으며 이것이 두 가지 다른 접근 방식으로 이어질 수 있다고 생각합니다.

1. float2 등을 사용하여 CUDA 부분에서 cuComplex 와 같은 단일 복합 값을 시뮬레이션합니다.
2. 기존 FloatTensor 및 DoubleTensor 를 사용하여 Aten의 C++ 부분에서 복잡한 텐서를 시뮬레이션합니다.

두 번째 접근 방식의 이유는 THC 에서 pytorch가 몇 가지 트릭을 사용하여 맵/리듀스 작업을 가속화하고 cuComplex 가 실제로 float2 이기 때문에 사소한 cuComplex 에 적합하지 않기 때문입니다. float2 하지만 __shfl_xxx 함수는 기본적으로 float2 를 지원하지 않습니다. 현재로서는 float2 에 대해 이러한 기능을 효율적으로 시뮬레이션하는 방법을 모르겠습니다.

두 번째 접근 방식은 이제 하드웨어에 대해 신경 쓸 필요가 없기 때문에 더 쉬울 것이며 이전 장치에서 새로운 복잡한 확장 작업을 훨씬 쉽게 만들 수 있습니다. 그러나 인접 메모리 주소로 인해 약간의 오버헤드가 발생할 수 있습니다.

게다가, 나는 복소수를 Aten에 통합하려면 하드웨어에서 실제로 동일한 네 가지 유형을 처리해야 할 수도 있다는 것을 발견했습니다. std::complex , thrust::complex , cuComplex , float2 때때로 위험할 수 있습니다. (사실 저는 작년에 이 문제를 만났고 reinterpreter_cast 가 해결책이었습니다).

나는 개인적으로 모든 것을 더 네이티브로 쓰는 것을 선호합니다.

그리고 우리는 아마도 일정이나 로드맵이 필요할 것이라고 생각합니다. 그리고 우리는 각각의 작은 부분을 선택하고 함께 작업할 수 있으므로 완전히 불가능한 마스터를 직접 추적할 필요가 없습니다...

CPU 백엔드를 구현하려고 할 때 ChangeLog 가 있었고 로그의 복소수에 대해 함수를 수정해야 한다고 분류했습니다. 이 로그를 기반으로 로드맵을 작성할 수 있습니다.

게다가 (호주에서) 내 비자가 방금 거부되었으므로 갭 이어를 시작해야합니다. 계속 일할 사람이 필요하면 인턴쉽을 신청할 수 있습니다.

나는 지난 하루 동안 이것에 대해 많은 생각을 했다. 로저의 노력을 그대로 담아내지 못해서 조금 아쉽지만 속으로 생각했다

"낮은 유지 관리 오버헤드를 유지하면서 어떻게 복잡한 Tensor 지원을 구축할 수 있습니까?"

이것은 위의 목표에서 효과적인 계획으로 제시하는 것입니다.

• 복잡한 텐서는 sparse 텐서와 같은 근본적이고 새로운 텐서 유형이 되어서는 안 됩니다. 기본 유형을 추가하면 많은 유지 관리 오버헤드와 교차 변경이 발생합니다. 유지 관리 오버헤드는 "복잡한 비트를 누가 유지 관리합니까?"에 관한 것이 아니라 "이제 모든 핵심 개발자는 근본적인 변경, Aten 변경 등을 수행할 때 이 복잡한 유형을 인식해야 합니다."
  
  
  
  • 대신 항상 [Tensor Shape x 2] 또는 [2 x TensorShape]여야 합니다. 즉, Tensor에는 크기가 2인 추가 차원이 하나 있어야 합니다.
  
  
• 복잡한 Tensor는 Aten Tensor API 위에 구축된 ~2k 라인의 간단한 C++로 구성된 작은 파일/폴더여야 합니다.
  
  
  
  • 예를 들어 https://github.com/pytorch/pytorch/issues/6514 에서 제안하는 것처럼 복잡한 곱셈은 torch.stack([real1 * real2 - imag1 * imag2, real1 * imag2 + imag1 * real2], dim = -1) 로 구현되어야 합니다. 여기서 real1 = input1[:, :, :, ..., 0]
  
  
  • 이것은 성능을 저하시킵니다. 예, 우리는 모든 것을 인라인하는 것처럼 많은 성능을 얻지 못할 것입니다. 그러나 질문은 "얼마나?"입니다. 나는 우리가 건강하고 완전한 기능과 유지되는 복잡한 지원에 대한 대가로 20% 더 낮은 성능을 목표로 해야 한다고 생각합니다.
  
  
  • 가장 많이 사용되는 복잡한 기능은 전용 커널을 가져오기 시작할 수 있으므로 자주 사용하는 기능에서 성능이 20% 이상 떨어지는 경우 우리가 개입합니다.
  
  

BLAS, cublas 및 MAGMA는 모두 float2와 바이트 호환되는 자체 복합 유형을 기대하기 때문에 [Tensor Shape x 2]여야 합니다. 또한 blas, cublas 및 magma 호출은 Python 수준에서 처리할 수 없습니다.
복잡한 곱셈의 경우 20% 밖에 되지 않을 것이라고 생각합니다. 실제 부분과 이미지 부분에 대한 계산 위에 4개의 전체 복사 작업이 있지 않습니까?
어쨌든 계속해서 마스터의 변경 사항을 병합하지 않아도 된다면 다행입니다.

@PhilippPelz 에 동의합니다. BLAS, cublas 및 MAGMA의 복잡한 지원을 잃게 되므로 많은 성능을 잃을 수 있습니다. 하지만 잘 모르겠습니다. 그러나 분명히 복잡한 Tensor는 희소 텐서와 완전히 다릅니다 scipy.sparse 와 같은 대부분의 라이브러리와 Julia의 SparseArrays 는 희소 배열을 기본적인 다차원 배열의 구성으로 취급합니다. 그러나 아무도 두 개의 실제 배열을 합성하여 복합 유형의 다차원 배열을 취급하지 않습니다... (여기서 아무도 tensorflow, arrayfire, numpy 및 Julia를 의미하지 않습니다). MXNet에서 FFT는 실제로 두 개의 실제 텐서의 구성으로 이루어지지만 복잡한 것을 지원하지 않습니다... tensorflow는 complex64 및 complex128 를 포함한 다른 넷 유형에 대한 래퍼로 DataType을 구현한 것 같습니다. types.proto 참조

성능 손실에 대해

첫째, 요소별 함수(함수가 map/reduce를 호출함)는 성능 손실이 크지 않습니다(적어도 이러한 작업을 위한 메모리는 연속적임). 하지만 먼저 몇 가지 BLAS 기능을 벤치마킹하여 FloatTensor 의 구성이 GPU에서 Complex64Tensor 와 유사한 성능을 보이는지, 다음과 같은 초안 구현:

• gemm
• gemv

복합 복합 텐서는 다음과 같습니다(또는 shared_ptr 사용).

class ComplexTensor {
    FloatTensor *real;
    FloatTensor *imag;
};

그러나 첫 번째 접근 방식의 단점에서 언급했듯이 __shfl_xxx 와 같은 함수도 이 작업을 더 기본적으로 수행하려는 경우 장애물처럼 보입니다.

현재 torch.fft 는 [dim1, ..., dimN, 2] 모양의 단일 float 텐서를 반환합니다.

@ezyang C10 출시 일정은 어떻게 되나요? 마스터 브랜치에서 컴플렉스 지원을 시작하기에 매우 합리적인 시점인 것 같습니다.

@PhilippPelz 확실히 0.4용이 아닙니다. 우리는 내부적으로 6월을 목표로 하고 있습니다. 너무 오래 기다리지 않기를 바랍니다.

6월에 언급한 @ezyang , PyTorch에 복소수 지원을 추가할 수 있었나요?

나는 그가 복잡한 지원이 아니라 C10을 의미했다고 생각합니다. C10은 복잡한 추가를 더 쉽게 만들 것입니다. 그렇게 이해했습니다.

예, C10은 Tensor 유형과 기능을 모두 공개 등록합니다. 따라서 복잡한 유형을 별도의 패키지로 추가하는 것이 훨씬 쉬울 것입니다.

복소수에 ETA가 있습니까? "훨씬 더 쉽다"는 것은 "아마도 빨리 끝날 것이다"를 의미합니까?

@themightyoarfish 훨씬 쉽게, 우리가 pytorch 마스터에 푸시할 수 있는 것에 대해 차단되지 않을 것임을 의미합니다. ETA를 설정하지 않았습니다. PyTorch에 공개 등록되면 작업 범위를 지정하겠습니다.

@sumith 여전히 이 작업을 수행할 사람이 필요합니까(복소수)? PyTorch 팀이 복소수를 지원합니까? QuCumber 를 유지 관리할 것이기 때문에 9월에 원하는 경우 이 작업에 시간을 할애할 수 있습니다(복소수를 많이 사용함)

@Roger-luo 네. PyTorch 백엔드에서 공개 등록이 가능해지면 연락을 드리고 세부 사항을 해결할 수 있습니다.
@ezyang 9월까지 오픈형 등록 되나요?

@sumith Cool, 귀하의 서비스에.

우리는 그것을 실현할 수 있습니다. (우리는 "완전한" 새로운 시스템을 갖추지는 않겠지만, 리팩토링이 가능하도록 설정하는 한 새로운 개발이 발생하면 계속 진행할 수 있습니다. 이는 새로운 오픈에 대한 좋은 테스트 사례가 될 것입니다. 등록할 수 있습니다.

@ezyang 지금까지 메모가 있습니까? 작업하기 전에 읽을 수 있었습니다. 지난번과 많이 달라진 것 같습니다.

@Roger-luo @PhilippPelz 또한 복잡한 텐서의 구현을 도와드리고 싶습니다. 박사과정 연구에도 필요합니다..

@alexgomezalanis 여유 시간에 대해 토론할 수 있는 채널이 있을 수 있습니다. 방금 #complex-numbers 채널 호출을 만들었습니다. 하지만 9월까지는 작업을 시작하지 않을 것입니다(여전히 Julia 코드 중 일부를 작업해야 합니다...)

BTW, 지난번에 비해 많이 변한 것 같습니다. 손에 닿기 전에 시간을 내서 따라잡겠습니다.

@alexgomezalanis 할 수 없습니다. 먼저 slack에서 pytorch의 작업 공간에 가입해야 합니다. 나는 너를 찾을 수 없어. 초대장을 받으려면 [email protected] 로 이메일을 보내주십시오.

@Roger-luo @alexgomezalanis 복잡한 텐서 문제에 대한 삶을 다시 보게 되어 기쁩니다. 저도 참여하겠다고 제안할 수 있지만 현실적으로 9월 말/10월 초까지는 이런 일이 일어나지 않을 것입니다. 이 문제에 대한 꽤 많은 논평자들은 복잡한 텐서 지원이 제 박사 프로젝트에 매우 도움이 될 것입니다.

나는 또한 작년에 내 연구를 저장하려고 노력했습니다 😏 ... 그러나 이제는 이전 1w + loc 코드를 다시 되돌리고 싶습니다. 🤣 슬랙에서 채팅하자!

:) 예, 슬랙에서 채팅합시다. 메일 폴더에서 초대장을 찾았습니다.

작업 진행 중인 플러그인(단기 CPU 전용)은 https://github.com/Roger-luo/pytorch-complex 입니다.

저에게 이슈와 PR을 주시기 바랍니다.

이 문제의 맨 위에 복잡한 구현이 수행되는 방법에 대한 메모를 게시했습니다.

저는 최근에 PyTorch를 사용하기 시작했고 정말 좋아합니다. TensorFlow보다 사용하기가 훨씬 좋습니다. 그러나 복잡한 텐서 지원은 내 연구(광 신경망)에 매우 중요합니다. 아직 활발히 진행되고 있나요? 그렇다면 복잡한 텐서 지원에 대한 (느슨한) 기간을 아는 사람이 있습니까?

제가 할 수 있는 곳에서 이 작업을 돕게 되어 기쁩니다. 하지만 저는 PyTorch를 처음 접하기 때문에 이 기능이 얼마나 큰 일인지 아직 잘 모릅니다. 내 연구실 동료 중 일부는 복잡한 텐서 지원에 깊은 관심을 표명했으며(물리학에서 이를 추가하면 Torch가 거의 NumPy에 대한 GPU 가속 대체품이 될 수 있음) 가까운 미래.

안녕하세요 @bencbartlett

나는 여전히 천천히 작업하려고 노력하고 있습니다.... 하지만 저는 현재 학생이기도 합니다(매우 불안정한 상황에 있음). 즉, 이 풀타임 작업은 할 수 없고 여가 시간에만 작업할 수 있습니다. (저는 작년부터 Julia에서 연구 관련 코드를 구현했습니다. 이는 기존 패키지에만 토치의 더 나은 복소수 지원이 필요하다는 것을 의미합니다.)

복소수가 중요하고 횃불을 켜는 것이 긴급한 경우 다음을 시도하는 것이 좋습니다.

https://github.com/PIQuIL/QuCumber/blob/master/qucumber/utils/cplx.py

그것은 매우 느리지만 ... 적어도 작동합니다. 또는 이전 TH 스타일의 C 버전이 있었습니다.

이것은 며칠 만에 끝낼 수 있는 작은 프로젝트가 아닙니다. 따라서 CPU 또는 CUDA에 대한 복잡한 값으로 완전한 기능 지원을 위한 특정 시간 프레임을 보장할 수 없습니다.

그러나 이 문제에 대해 저와 함께 작업하는 데 도움이 되었으면 합니다. 확장 리포지토리에 게시한 문제를 해결하는 것으로 시작하는 것이 좋습니다. 그리고 질문이 있는 경우 slack이나 이메일 또는 이슈를 통해 자유롭게 질문하세요(아직 문서가 많지 않기 때문에).

불행히도 아직 PyTorch Slack에 액세스할 수 없습니다. (초대를 요청하는 이메일을 두 번이나 보냈지만 답장을 받지 못했습니다.) 누군가 저를 초대할 수 있습니까? ([email protected])

@Roger-luo 확실히 귀하의 포크를 살펴보겠지만 많은 도움이 될 것이라고 장담할 수는 없습니다. 제 C++가 녹슬고 지적하신 대로 학생. QuCumber 유틸리티는 훌륭하지만 불행히도 나에게는 별로 도움이 되지 않습니다. 복잡한 텐서가 GPU 지원되거나 autograd 및 torch.nn에서 지원될 때까지는 NumPy가 제공할 수 있는 것보다 많은 유틸리티를 제공하지 않습니다.

@soumith @ezyang PyTorch 팀에서 이에 대해 더 많은 관심을 가져주시면 좋겠습니다! 복합 지원은 일반 텐서 라이브러리가 갖추어야 할 중요한 기능인 것 같습니다. 이는 물리학에서 사실상 필수적이며 특히 지난 몇 년 동안 ML 내에서 복소수 값 모델에 대한 관심이 급격히 증가했습니다.

@bencbartlett QuCumber의 접근 방식은 AD가 있는 GPU에서 사용할 수 있습니다... 그것은 단지 매우 느립니다... 제 말은 당신이 그 AD를 원하면 사용할 수 있을 것입니다.

예, 솔직히 말해서 https://github.com/FluxML/Flux.jl 의 약간 수정된 버전과 연구를 위해 Julia에서 자체 패키지를 사용하고 있습니다(어떤 상황에서는 텐서가 있는 GPU의 복잡한 AD도 필요합니다. ). source2source AD ​​패키지 Zygote.jl은 복잡한 텐서에서 AD를 수행할 수 있지만 세그먼트 오류가 있을 수 있는 초기 단계입니다. 생태계는 아직 토치에 비해 안정적이지 않고 자체 사용을 위해 이러한 구현을 약간 해킹해야 하는 경우가 있습니다. 하지만 기본적으로는 양자 물리학 연구에 필요한 것입니다. GPU에서도 복잡한 텐서를 가질 수 있습니다.

torch.nn 에 대한 복잡한 값 지원이 필요하지 않다고 생각합니다. 복잡한 텐서가 작동하면 autograd 에 대한 몇 가지 정의를 추가해야 할 수도 있습니다. 선형 레이어와 같은 것이 동일하게 유지될 수 있기 때문입니다. . 그리고 일부 활성화 기능은 Hilbert 공간에서 표준 확장이 없을 수 있습니다... (내 협력자 @GiggleLiu 의 블로그 게시물을 확인할 수 있습니다)

pytorch-complex 확장의 경우 GPU에서 AD에 대한 완전한 지원을 언제 받을 수 있는지 잘 모르겠습니다... 이것은 여전히 ​​나에게 꽤 먼 것 같습니다. CPU 구현은 메인 트리에서 패치가 필요한 일정 기간(예: 유형 승격, simd 지원 등)을 거쳐야 한다고 말하고 싶습니다. 이것은 C++의 다가오는 Aten 구현과 관련이 있고 TH 등을 제거하는 것과도 관련이 있을 수 있습니다. 그러면 복잡한 텐서에 대한 연산자를 더 빠르게 추가할 수 있습니다.

나는 봄에 인턴쉽을 신청할 수 있습니다(방금 @ezyang 에게 물어봤습니다). 그래서 박사 과정을 시작하기 몇 달 전에 풀타임으로 이 일을 할 수 있을지도 모릅니다. 봅시다.

그 동안 나는 복잡한 곱셈의 내 자신의 버전을 구현했습니다. 그러나 프로파일링할 때 상당한 시간이 소요됩니다. torch._C_._cuda_isDriverSufficient

이유가 뭔지 아세요? 복잡한 곱셈의 더 나은 구현을 알고 있다면 알려주십시오. 여하튼, 내 버전(곱셈 수에 최적화되어 있음: 4 대신 3)은 상대적으로 느린 것 같습니다. 예를 들어 out 텐서의 irfft는 요소별 곱셈보다 10배 빠릅니다. PyTorch의 C++ 수준에서 복소수 곱셈이 지원됩니까?

def complex_mul(x, y, out):
    uavc = x[..., 0] * (y[..., 0] + y[..., 1])
    out[..., 0] = uavc - (x[..., 0] + x[..., 1]) * y[..., 1]
    out[..., 1] = (x[..., 1] - x[..., 0]) * y[..., 0] + uavc

def test_complex_mul_out_tensor(self):
        N, C, H, W, I = 128, 3, 32, 32, 2
        K = 16  # number of filter banks
        repetitions = 1000
        dtype = torch.float
        if torch.cuda.is_available():
            device = torch.device("cuda")
        else:
            device = torch.device("cpu")
        x = torch.randn(N, 1, C, H, W, I, dtype=dtype, device=device)
        y = torch.randn(K, C, H, W, I, dtype=dtype, device=device)
        start_mul_time = time.time()
        out = torch.empty(N, K, C, H, W, I, dtype=dtype, device=device)
        for _ in range(repetitions):
            complex_mul(x, y, out)
        print("multiplication time: ", time.time() - start_mul_time)

우리는 C++에서 그것을 지원하려고 노력하고 있습니다. 상단의 게시물을 참조하십시오. 확장을 컴파일할 수 있다면 적어도 현재로서는 스칼라 곱셈에서 작동해야 합니다....

구현은 QuCumber에 있는 것과 유사합니다. 복소수에 대해 올바른 cuda 커널을 호출하지 않으면 더 많은 GPU 스레드를 호출할 수 있습니다. Python에서 지원하는 C++ 백엔드가 없으면 SIMD를 잃을 수 있습니다.

자세한 내용을 보려면 nvprof 를 실행하는 것이 좋습니다.

@Roger-luo @apaszke @soumith 이 스레드에 감사드립니다. btw. 나는 토치.텐서를 서브클래싱하여 함께 해킹된 기본 복합 텐서를 구현했습니다.

나는 전반부를 실제로, 후반부를 허수사로 취급하고 내 자신의 기본 산술 연산과 내 연구에 필요한 일부 다른 연산을 구현합니다.

Tensorflow 및 numpy에 대해 확인했습니다. 내가 구현한 그라디언트와 모든 작업은 출력과 일치합니다!

PT가 복잡한 텐서를 완전히 지원할 때까지 보류로 사용하기 위한 것입니다.

특징:

1. 테스트가 구현되었습니다.
2. Pypi 지원(예: pip 설치)

pip install pytorch-complex-tensor

https://github.com/williamFalcon/pytorch-complex-tensor

@williamFalcon 감사합니다!

업데이트 하나? 복잡한 유형 지원을 pytorch에 통합할 계획이 있는지 궁금합니다.

안녕하세요, @whmrtm

@ezyang 은 https://github.com/Roger-luo/pytorch-complex/issues/4 에서 작업 중입니다. 또는 이에 관심이 있는 사람은 누구나 실행할 수 있도록 도와줄 수 있습니다. 이 문제는 일부 기본적인 방송 문제를 해결합니다(이 문제가 해결된 후 많은 기능을 사용할 수 있음). 자유롭게 PR을 하거나 저에게 당신을 협력자로 추가해달라고 요청하십시오.

나는 여름까지 아무것도 할 수 없을 것이고, 우리 자신의 패키지를 위한 새로운 릴리스를 끝내야 합니다.

안녕하세요, @whmrtm

@ezyang 은 Roger-luo/pytorch-complex#4 에 대해 작업 중입니다. 또는 이에 관심이 있는 사람은 누구나 실행할 수 있도록 도와줄 수 있습니다. 이 문제는 일부 기본적인 방송 문제를 해결합니다(이 문제가 해결된 후 많은 기능을 사용할 수 있음). 자유롭게 PR을 하거나 저에게 당신을 협력자로 추가해달라고 요청하십시오.

나는 여름까지 아무것도 할 수 없을 것이고, 우리 자신의 패키지를 위한 새로운 릴리스를 끝내야 합니다.

업데이트 감사합니다. 제가 할 수 있는 일을 알아보겠습니다.

안녕하세요 @Roger-luo

복잡한 텐서 지원 주제([email protected])와 관련된 slack 채널에 액세스할 수 있나요? 초대장을 이메일로 보냈지만 아직 아무 일도 일어나지 않았습니다. 지금 저는 이 문제에 기여하기 시작할 지점을 파악하려고 노력하고 있습니다. https://github.com/Roger-luo/pytorch-complex/issues/4 가 현재 진입점인 것 같은데요?

@beconstant 예, 그것이 시작점입니다. 이것은 일부 브로드캐스트 기능을 작동하게 해야 하지만 cuda에서 유형 승격 오류가 발생하는 이유를 모르겠습니다. CPU에서 작동하고 있었습니다. (처음부터 cuda를 지원할 생각은 없지만 빌드 실패의 원인이 됩니다.)

초대 이메일을 보낼 수 없습니다(액세스 권한이 없습니다). slack에 가입하려면 pytorch 공식 가이드를 따라야 한다고 생각합니다. 그러나 우리는 항상 이슈/PR에서 논의할 수 있습니다.

@Roger-luo 알겠습니다. :)

도움이 필요하면 알려주세요. 지정된 pytorch 버전을 빌드하는 것으로 시작하겠습니다. pytorch-complex/issues/4 에 대한 진행 상황이 있습니까?

도움이 필요하면 알려주세요. 지정된 pytorch 버전을 빌드하는 것으로 시작하겠습니다. pytorch-complex/issues/4 에 대한 진행 상황이 있습니까?

@dylanbespalko 안녕하세요, Complex-valued 버전으로 구현된 pytorch가 시급히 필요합니다.
귀하의 기여에 진심으로 감사드립니다.

친애하는,
젤라르209

안녕하세요 @Zellar209 ,

@ezyang 이 더 큰 문제( pytorch-complex/issues/4 ) 중 하나에서 열심히 일하고 있다는 느낌을 받고 있습니다. 현재 AMD 시스템이 있고 3주 후에 GPU 지원을 강화하는 데 사용할 수 있는 Nvidia 시스템이 있습니다.

문제는 원래 유형 승격 변경이 CUDA를 중단하는 것뿐인 것 같습니다. 해당 PR이 해결되는 한 최소한 일부 운영자가 CPU에서 작동하도록 하고 아직 CUDA를 지원하지 않습니다...

IMHO 나는 우리가 CPU에 집중하고 일을 먼저 만들고 GPU를 나중에 고려해야 한다고 생각합니다.

CPU만 지원하면 괜찮습니다. 이 유형 승격 문제( pytorch-complex/issues/4 가 fb에서 내부적으로 처리됩니까? 외부에서 작업해도 괜찮습니까?

안녕하세요 @dylanbespalko; 나는 @Roger-luo에게 내가 그것을 조사할 것이라고 말했지만(왜냐하면 내가 아마도 문제가 무엇인지 파악하는 것이 가장 좋은 위치에 있기 때문입니다), 아직 그것을 볼 시간이 없었습니다. 문제를 해결하는 방법을 찾아보고 싶다면 기꺼이 조언해 드리겠습니다.

안녕하세요 @Zellar209 ,

@ezyang 이 더 큰 문제( pytorch-complex/issues/4 ) 중 하나에서 열심히 일하고 있다는 느낌을 받고 있습니다. 현재 AMD 시스템이 있고 3주 후에 GPU 지원을 강화하는 데 사용할 수 있는 Nvidia 시스템이 있습니다.

예, 지금은 GPU가 필요하지 않습니다. 저는 MAC 시스템을 사용하고 있습니다. 하지만 이 프로젝트를 빌드할 때 몇 가지 오류가 있었습니다.

안녕하세요 @Zellar209님 , pytorch-complex의 문제에서 얻은 내용을 게시할 수 있습니까? Mac의 새로운 Xcode에 문제가 있는 것 같아서 빌드하기가 어렵습니다. 그러나 사람들은 그 이유를 알아내기 위해 더 많은 오류 메시지가 필요할 것입니다.

OS랑 에러메세지 물어봤는데 답이없네...

안녕하세요 @dylanbespalko; 나는 @Roger-luo에게 내가 그것을 조사할 것이라고 말했지만(왜냐하면 내가 아마도 문제가 무엇인지 파악하는 것이 가장 좋은 위치에 있기 때문입니다), 아직 그것을 볼 시간이 없었습니다. 문제를 해결하는 방법을 찾아보고 싶다면 기꺼이 조언해 드리겠습니다.

빠른 답변 감사합니다.

1. gcc(기본값)를 사용하여 "python setup.py install"을 실행하면 다음과 같은 오류가 발생합니다.

건물 'torch_complex.cpp' 확장
gcc -Wno-unused-result -Wsign-compare -Wunreachable-code -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -I/anaconda3/include -arch x86_64 -I/anaconda3/include -arch x86_64 -I/ anaconda3/lib/python3.6/site-packages/torch/include -I/anaconda3/lib/python3.6/site-packages/torch/include/torch/csrc/api/include -I/anaconda3/lib/python3. 6/site-packages/torch/include/TH -I/anaconda3/lib/python3.6/site-packages/torch/include/THC -I/anaconda3/include/python3.6m -c src/module.cpp -o 빌드/temp.macosx-10.7-x86_64-3.6/src/module.o -g -stdlib=libc++ -std=c++11 -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=cpp
gcc: 오류: 인식할 수 없는 명령줄 옵션 '-stdlib=libc++'

오류: 'gcc' 명령이 종료 상태 1로 실패했습니다.

2. clang을 사용하여 컴파일할 때 오류는 다음과 같습니다.

src/module에 포함된 파일에 있습니다. cpp:2 :
src/CPUComplexType.h:60에 포함된 파일:
src/CPUComplexTypeImpl.h:102:105: 경고: 'IntList'는 더 이상 사용되지 않습니다. [-Wdeprecated-declarations]
Tensor & CPUComplexType::set_(Tensor & self, Storage 소스, int64_t storage_offset, IntList 크기, IntList strides) const {
^^
/anaconda3/lib/python3.6/site-packages/torch/include/c10/util/ArrayRef.h:273:7: 참고: 'IntList'는 여기서 더 이상 사용되지 않는 것으로 명시적으로 표시되었습니다.
IntList 사용 C10_DEPRECATED_USING = ArrayRef;
^^
src/module에 포함된 파일에 있습니다. cpp:2 :
src/CPUComplexType.h:60에 포함된 파일:
src/CPUComplexTypeImpl.h:105:76: 오류: 'at' 네임스페이스에 'scalarTypeToDataType'이라는 멤버가 없습니다.
자동 소스_ = checked_storage(소스,"소스",2, DeviceType::CPU, at::scalarTypeToDataType(CPUComplexTypeInfo::scalar_type));
~~~~^
7개의 경고와 2개의 오류가 생성되었습니다.

오류: 'clang' 명령이 종료 상태 1과 함께 실패했습니다.

나는 그것을 고칠 수 없습니다. 나는 당신이 나를 도울 수 있기를 정말로 바랍니다!

얘들 아,

의견을 보내주셔서 감사합니다. 나는 이것을 조사하는 데 일주일을 보낼 수 있다고 생각합니다. 지금까지 다음과 같이 @Roger-luo의 pytorch-complex를 컴파일했습니다.

@Zellar209 : macOS 10.13에서 실행되는 환경 변수를 첨부했습니다.

1. 다음과 같이 기존 pytorch 배포를 삭제합니다.
   콘다 제거 파이토치
   핍 제거 토치
   pip uninstall torch # 이 명령을 두 번 실행
   파이썬 setup.py 청소
   python site-packages 폴더가 있는 경우 토치 폴더를 삭제합니다.
   이전 pytorch 소스 폴더의 이름을 변경(또는 삭제)합니다.

2. PyTorch 개정판 6cb593b88cb0c411690b4957850058329526d87b를 설치합니다.

    git clone [email protected]:pytorch/pytorch.git
    git checkout 6cb593b88cb0c411690b4957850058329526d87b
    git submodule update --init —recursive
    export CMAKE_PREFIX_PATH=${CONDA_PREFIX:-"$(dirname $(which conda))/../“}
    MACOSX_DEPLOYMENT_TARGET=10.13 CC=clang CXX=clang++ python setup.py develop
    python

>>> import torch

1. pytorch-complex 설치

    python setup.py install
    python setup.py build
    python setup.py test
    # ERROR: test (unittest.loader._FailedTest)
    # ERROR: test_scalar_binary_op (tests.test_tensor.TestComplexTensor)

1. 복잡한 텐서 만들기

   from torch_complex import torch
   a = torch.ones(3, dtype=torch.complex128)
   a*a  
   RuntimeError: promoteTypes with complex numbers is not handled yet; figure out what the correct rules should be

@ezyang , @Roger-luo:

텐서 작업을 위한 유형 승격을 위한 모든 것은 c10/core/ScalarType.h 에서 수행되는 것 같습니다.
AT_ERROR("promoteTypes with complex numbers is not handled yet; figure out what the correct rules should be”); 오류를 찾았습니다.
이 테이블 안에 c8 및 c16에 대한 항목을 추가해야 하는 것 같습니다.
이것이 9515 와 관련이 있습니까? 나는 이것이 numpy 함수를 호출하기위한 것이라고 생각합니다.
시작하기에 좋은 곳인가요?

9515는 관련이 없습니다. 그러나 ScalarType.h에서 이 코드 경로를 수정하는 것부터 시작하는 것이 좋습니다.

ScalarType.h에서 코드 경로를 수정했습니다.
BinaryOps(add, sub, mul, div)가 작동하지만 두 인수가 모두 Tensor인 경우에만 가능합니다.
다른 이상한 문제도 있지만 좀 더 살펴봐야 합니다.

@dylanbespalko 여기에 유형 프로모션을 추가했습니다: https://github.com/pytorch/pytorch/pull/11641

그냥 복사할 수도 있지만 문제는 이것이 어떻게든 CUDA를 손상시킨다는 것입니다.

IIRC, gcc 버전으로 인해 와이어 버그가 있었습니다. 거기에 몇 가지 해결 방법이 있었습니다.

아, 감사합니다 @Roger-luo. #11641 의 댓글을 보고 있었습니다. 내일 코드 복사를 더 잘하겠습니다.

CUDA 장치가 없을 때 CUDA가 고장났는지 어떻게 알 수 있습니까? CI가 알려줄 거라고 생각합니까?

예, PR을 제출하면 어느 것이 고장났는지 알려줍니다. 모든 것이 통과하면 이를 병합하고 작업을 수행할 수 있습니다.

알겠습니다. 그러면 PR 제출을 시작하여 언제 발생하는지 알 수 있습니다.

@dylanbespalko 안녕하세요, 여전히 환경에 오류가 있는 것 같습니까?
당신이 그것을 고친다면, 우리와 공유하십시오. 정말 감사합니다.

얘들 아,

@Roger-luo의 커밋 몇 개를 복사한 후 여러 PR을 시도했습니다. 불행히도 지금은 CUDA GPU가 없고 CUDA가 있는 CI 시스템이 초기화되지 않습니다. 지금은 CUDA 테스트 실패를 재현할 수 없으므로 몇 주 후에 해당 GPU에서 로컬로 실행할 수 있게 되면 다시 언급하겠습니다. 적어도 유망해 보입니다.

@ezyang , @Roger-luo

나는 Roger의 PR #11641 을 살펴보았다.

• 내 CUDA 9.0 시스템에서 빌드 및 실행됩니다.
• CUDA 9.0을 실행하는 CI 시스템에서 빌드하지 못합니다.

또한 최근 PyTorch 개발 중 일부를 살펴보았습니다.

• 사용자 정의 device/layout/dtype 을 정의할 수 있는 C++/CUDA 확장을 작성하는 방법을 설명하는 @ezyang 의 프레젠테이션 입니다.
  
  
  
  • " ComplexHooksInterface를 제거"하지만 pytorch/test/cpp_extensions/complex_registration_extension.cpp에 있는 복소수 C++ 확장을 정의하는 최신 PR #21964
  
  

새로운 "out-of-tree" 확장 기능이 개발되고 있어 나머지 pytorch를 손상시키지 않고 복소수 지원을 조사할 수 있습니다. 내 목표는 다음과 같습니다.

1. AVX 없이 복잡한 CPU 지원을 정의하십시오.
2. Thrust를 사용하여 복잡한 CUDA 지원을 정의합니다.

@ezyang
당신이 제시한 이 out-of-tree device/layout/dtype 확장에 대한 예상 타임라인을 제공할 수 있습니까? 앞으로 3개월 이내에 이 기능을 기대할 수 있습니까?

@ezyang

AVX/SSE 지원 없이 CPU에서 복소수 지원을 병합할 수 있습니까? 별도의 병합 요청으로 다음을 제출할 계획입니다.

• [ ] CPU BinaryOp 커널의 복잡한 지원 추가
• [ ] CPU TensorFactories의 복잡한 지원 추가
• [ ] CPU FillKernels의 복잡한 지원 추가
• [ ] CPU 범위 커널의 복잡한 지원 추가
• [ ] CPU 단항 커널의 복잡한 지원 추가
• [ ] CPU 비교 커널의 복잡한 지원 추가
• [ ] CPU TensorCompare 커널의 복잡한 지원 추가
• [ ] CPU ReduceOp 커널의 복잡한 지원 추가
• [ ] CPU PointwiseOps 커널의 복잡한 지원 추가
• [ ] CPU learpOps 커널의 복잡한 지원 추가
• [ ] CPU LinearAlgebraOps 커널의 복잡한 지원 추가
• [ ] CPU SpectralOps 커널의 복잡한 지원 추가

앞으로 며칠 안에 Intel/arm CPU 전체에서 이것을 테스트할 계획입니다.

@ezyang ,

저는 fft() 및 var() $ 와 같은 연산을 찾고 있습니다. 여기서 복소수 구현은 텐서 데이터를 (complex_shape, 2) 모양의 이중 텐서로 변환해야 합니다. 이것은 기존 텐서 메서드에서는 작동하지 않습니다.

1. 'tensor.to(torch.float64): 실수 부분만 유지하고 동일한 모양의 텐서를 반환합니다.
2. 'tensor.view(new_shape): 새로운 모양은 같은 수의 요소를 가져야 합니다.

분명히 나는 ​​다음과 같이 비효율적인 일을 할 수 있습니다.

def to_float(tensor):
    return th.stack((tensor.real().type(th.float64), tensor.imag().type(th.float64)), -1)

def to_complex(tensor):
    tensor = tensor.type(th.complex128) 
    return tensor[..., 0] + 1j*tensor[..., 1]

분명히 그것은 복사본을 만드는 것입니다. 필요한 것은 static_cast<double> 이고 텐서의 모양을 (old_shape, 2) 로 변경하는 것입니다. 이 작업을 수행하는 방법에 대한 제안 사항이 있습니까?

또한 numpy에는 다음과 같은 작업을 수행할 수 있는 해킹이 있습니다.

a = np.array([1 + 1j], dtype=np.complex128)
a.dtype = np.float64  ## This works

a = torch.tensor([1 + 1j], dtype=torch.complex128)
a.dtype = torch.float64  ## This does not work

dtype을 설정하는 기능은 이 상황에서 실제로 작동하지만 예측할 수 없습니다.

복소수를 실수의 길이 2 배열로 해석하는 것과 관련된 몇 가지 추가 정보입니다. 다음은 C++11에서 유효합니다.

복소수 p의 배열 요소에 대한 포인터와 유효한 배열 인덱스 i의 경우 reinterpret_cast(p)[2 i]는 복소수 p[i]의 실수부이고 reinterpret_cast(p)[2 i + 1]은 복소수 p[i]의 허수부입니다. (C++11부터)

이것은 complex_tensor를 모양(complex_shape, 2)을 가진 real_tensor로 변환한 다음 새 메모리를 할당한 real() 및 imag() 를 호출하지 않고 작업을 수행할 수 있음을 의미한다고 생각합니다.

@dylanbespalko 나는 당신이 이것에 대해 물을 때를 두려워했습니다 :) std::complex 보증은 데이터 포인터 std::complex<float>* 가 있으면 float* 로 안전하게 캐스트할 수 있음을 의미합니다 (엄격한 앨리어싱 중얼거림) 그런 다음 사용 중인 fft 항목에 전달합니다. 이 낮은 수준의 담당자를 전달할 수 있는 fft/var만 구현해야 하는 경우 가장 쉽습니다.

그러나 복잡한 텐서를 float 텐서로 문자 그대로 재검토해야 하는 경우 오늘날 PyTorch에 이에 대한 전례가 없기 때문에 약간의 난관에 봉착하게 됩니다. Storage dtype은 항상 Tensor dtype과 동의했습니다. 그래서 복잡한 창고를 만든다면 플로트 창고로 검토할 방법이 없습니다.

내가 가진 한 가지 생각은 우리가 이 불변량을 완화해야 한다는 것입니다. 아이디어는 다음과 같습니다.

1. 우리는 항상 스토리지를 문제의 "벡터화되지 않은" 유형으로 할당합니다. 그래서 콤플렉스의 경우float 텐서를 할당합니다.
2. Tensor dtype은 스토리지 dtype과 동의하지 않을 수 있지만 기본 유형의 벡터화된 변형으로만 허용됩니다.

하지만 이 불변성을 발생시키려면 얼마나 많은 코드를 변경해야 하는지 잘 모르겠습니다.

@ezyang ,

그래 이건 어쩔 수 없었다...

이 낮은 수준의 담당자를 전달할 수 있는 fft/var만 구현해야 하는 경우 가장 쉽습니다.

예, 많은 경우에 가능합니다. 텐서 데이터를 std::vector로 해석하는 방법에 대한 코드 스니펫을 제공할 수 있습니까?

그러나 복잡한 텐서를 말 그대로 float 텐서로 다시 봐야 한다면....

다른 dtype을 사용하여 텐서를 보는 것은 드뭅니다. Tensor set_dtype() 메서드를 구현했지만 몇 가지 오류가 발생했습니다. 또한 모양의 변화를 반영하기 위해 보폭을 업데이트하지 않았습니다. dtype 설정이 numpy에서 작동하는 이유는 확실하지 않지만(우연인가요?) 데이터를 DAC(디지털-아날로그 변환기)에 업로드할 때 종종 실제/허수 데이터가 인터리브될 것으로 예상합니다. 아마도 그것은 당신이 제안한 것처럼 스토리지 dtype에서 텐서 dtype을 분리해야 할 필요성에 동기를 부여할 것입니다.

당분간은 이 일을 피하겠습니다. 나에게 다른 성능 병목 현상이 있다고 확신합니다.

예, 많은 경우에 가능합니다. 텐서 데이터를 std::vector로 해석하는 방법에 대한 코드 스니펫을 제공할 수 있습니까?

정확히 std::vector는 아니지만 다음과 같이 상상하고 있습니다.

Tensor complex_tensor;
assert(complex_tensor.is_contiguous());
std::complex<float>* cp = complex_tensor.data_ptr<std::complex<float>>();
float* fp = reinterpret_cast<float*>(cp);
auto num_floats = complex_tensor.numel() * 2;

Tensor용 set_dtype() 메서드를 구현했지만 몇 가지 오류가 발생했습니다. 또한 모양의 변화를 반영하기 위해 보폭을 업데이트하지 않았습니다.

예, 보폭도 수정하지 않으면 이것은 아마도 나쁜 생각일 것입니다. 또한 저는 다른 dtype으로 변환하는 텐서의 열렬한 팬이 아닙니다. 모든 것을 제자리에서 수행하는 것이 좋습니다. :)

그러나 DAC(디지털-아날로그 변환기)에 데이터를 업로드할 때 종종 실제/허수 데이터가 인터리브될 것으로 예상합니다. 아마도 그것은 당신이 제안한 것처럼 스토리지 dtype에서 텐서 dtype을 분리해야 할 필요성에 동기를 부여할 것입니다.

예, 궁극적으로 이것이 올바른 일이지만 지금은 하지 않는 것이 더 쉽다는 데 동의합니다.

@ezyang ,

복소수 CUDA 지원을 엉망으로 만들기 시작했습니다.

두 가지 바이너리 호환 옵션이 있습니다.

1. cuComplex : 매우 기본적인 add, sub, mul, div, real, imag 지원.
2. Thrust::complex : 호스트 및 장치 메모리 할당을 지원하는 std::complex 에 대한 교체가 중단되었습니다.

추진력::복잡한 컨테이너가 가야 할 길인 것 같습니다. Thrust::Complex API 는 thrust::complex<T> 컨테이너가 호스트 및 장치 메모리에 할당될 수 있는 반면 std::complex<T> 는 호스트 메모리에만 할당될 수 있다고 제안합니다.

__host__ __device__     thrust::complex< T >::complex (const complex< T > &z)  //thrust container
__host__    thrust::complex< T >::complex (const std::complex< T > &z) //stl container.

1. 이것은 AT_DISPATCH_COMPLEX_TYPES가 using scalar_t = std::complex<double> using scalar_t = thrust::complex<double> 를 설정해야 함을 의미합니까?

2. Pytorch는 실제 데이터 유형에 대해 std::log 에 해당하는 CUDA를 어떻게 자동으로 호출합니까? 수학 커널에 해당하는 CUDA가 있는지 어떻게 알 수 있습니까?

1. CPU와 CUDA에 대해 보편적으로 thrust::complex<double> 를 사용하는 것의 어려움은 CPU 전용 빌드를 수행하는 경우 실제로 추력에 대해 빌드하지 않는다는 것입니다. 나는 많은 옵션이 있다고 생각합니다. 우리는 우리 자신의 복잡한 유형을 굴릴 수 있습니다(우리가 우리 자신의 하프 유형을 굴리는 방법과 유사). 또는 std::complex<> 가 특정 바이너리 레이아웃을 갖도록 정의되어 있기 때문에 캐스트를 재해석하여 승리할 수 있습니다. 그것은 당신에게 달려 있지만, 지금은 유형 간의 캐스팅을 재해석하는 것이 더 쉬워 보입니다.
2. THCNumerics.cuh에 수학 오버로드가 있습니다. 질문에 대한 답변입니까?

@iotamudelta 는 #29547에서 C++11 규정 준수 문제를 제기했습니다.

std::real은 C++14의 constexpr일 뿐입니다.

내가 올바르게 이해한다면 std::real() 는 constexpr 이어야 hcc 컴파일러가 __device__ 에 대한 명령을 컴파일할 수 있습니다.

가능한 해결책:

1. complex<double> 를 double 로 변환하는 다른 방법이나 함수를 찾으십시오.
   
   
   
   • abs 도 작동하지 않습니다. 템플릿T abs(상수 복합& x) ;
   
   

1. 함수를 래핑하는 방법을 찾으십시오.

   • std::real 에 대한 대부분의 호출은 aten/src/ATen/native/cpu/zmath.h 에서 이루어집니다. 예: inline constexpr :

     inline VALUE_TYPE real_impl (SCALAR_TYPE z) ->
     constexpr VALUE_TYPE real_impl (SCALAR_TYPE z)

     inline std::complex<float> real_impl <std::complex<float>> (std::complex<float> z) -> constexpr std::complex<float> real_impl <std::complex<float>> (std::complex<float> z)

     inline std::complex<float> real_impl <std::complex<double>> (std::complex<float> z) -> constexpr std::complex<float> real_impl <std::complex<double>> (std::complex<float> z)

constexpr 가 아닌 std::real() 에 대한 중첩 호출이 여전히 있기 때문에 컴파일되지 않습니다.

3. std::complex를 사용하는 경우::real() 대신 std::real() 이것은 C++11과 호환되는 것 같습니다.

1. 내가 무엇을 하든 C++14까지는 이 코드가 UB라는 말을 하는 것 같습니다. std::complex<double> 를 double 로 변환할 수 있는 다른 방법이 있습니까?

@iotamudelta , @bddppq , @ezyang ,

CUDA thrust::complex API에 복잡한 UnaryOps 및 BinaryOps에 대한 지원을 추가했지만 제출하기 전에 몇 가지 질문을 해야 합니다.

나는 복소수를 다룰 때 thrust::complex 데이터 유형을 사용할 수 있도록 하는 템플릿 함수를 정의했습니다.
aten/src/ATen/native/cuda/zmath.cuh

#pragma once

#include <complex>
#include <thrust/complex.h>

namespace at { namespace native {
namespace {

template <typename TYPE>
struct ztype_cuda {
  using value_t = TYPE; // Complex template type
  using thrust_t = TYPE; // Equivalent thrust type
};

template <>
struct ztype_cuda<std::complex<float>> {
  using value_t = float;
  using thrust_t = thrust::complex<float>;
};

template <>
struct ztype_cuda<std::complex<double>> {
  using value_t = double;
  using thrust_t = thrust::complex<double>;
};

} // end namespace
}} //end at::native

그런 다음 aten/src/ATen/native/cuda/BinaryOpsKernel.cu 에서
바꾸다:

void add_kernel_cuda(TensorIterator& iter, Scalar alpha_scalar) {
  AT_DISPATCH_ALL_TYPES_AND2(kHalf, kBool, iter.common_dtype(), "add_cuda/sub_cuda", [&]() {
    auto alpha = alpha_scalar.to<scalar_t>();
    gpu_kernel_with_scalars(iter, [alpha]GPU_LAMBDA(scalar_t a, scalar_t b) -> scalar_t {
      return a + alpha * b;
    });
  });
}

와 함께:

void add_kernel_cuda(TensorIterator& iter, Scalar alpha_scalar) {
  AT_DISPATCH_ALL_TYPES_AND_COMPLEX_AND2(kHalf, kBool, iter.dtype(), "add_cuda/sub_cuda", [&]() {
    using thrust_t = typename ztype_cuda<scalar_t>::thrust_t;
    auto alpha = thrust_t(alpha_scalar.to<scalar_t>());
    gpu_kernel_with_scalars(iter, [alpha]GPU_LAMBDA(thrust_t a, thrust_t b) -> thrust_t {
      return a + alpha * b;
    });
  });
}

질문

1. @ezyang : 복소수가 아닌 경우 scalar_t 및 thrust_t는 동일한 유형입니다. 변수 이름 thrust_t 를 scalar_t_c 와 같이 복소수가 아닌 숫자에 더 친숙한 이름으로 바꿀 수 있습니까?
2. 추력 라이브러리는 코드에서 널리 참조되는 것으로 보입니다.
   a) @bddppq : thrust::complex cuComplex 를 사용해야 하는 이유가 있습니까?
   b) @iotamudelta : ROCm2.7에서 엉덩이 추력이 제거되었습니다. 대신 hip_complex 를 사용해야 합니까?
   Thrust::complex는 cuComplex 보다 더 많은 기능을 지원하는 것 같습니다.

어떻게 생각하는지 알려주세요.

@iotamudelta

std::real()에 대한 토론을 업데이트했습니다. std::complex를 확인할 수 있습니까?::real()은 문제를 해결합니다.

안녕하세요 @dylanbespalko ,

@iotamudelta 가 불평하는 것은 복잡한 유형에 대한 cast_and_store 에 C10_HOST_DEVICE 이 누락되어 해당 코드 경로가 GPU에서 실행되는 경우 UB가 될 것입니다.

현재 이 동적 캐스팅 유틸리티는 GPU TensorIterator에서만 사용되며 유형 승격이 있는 경우에만 사용됩니다. 현재 GPU에서 complex가 지원되지 않았기 때문에 현재 complex type에 대한 cast_and_store 에는 C10_HOST_DEVICE 한정자가 없으며 호스트에 대해 완전히 괜찮은 std::real 를 사용합니다. 유일한 기능. 여기에 UB는 사용되지 않고 걱정할 필요가 없기 때문에 없습니다.

하지만 복잡한 지원을 GPU에 추가하고 싶기 때문에 https://github.com/pytorch/pytorch/blob/master/c10/core/ScalarType.h#L398 에서 볼 수 있듯이 복합물은 유형 승격에 의해 지원됩니다. L420, 이 코드 경로에 대해 매우 주의해야 하며 작동하려면 몇 가지 수정이 필요할 수 있습니다.

물론 https://github.com/pytorch/pytorch/pull/29547 에서 @iotamudelta 가 하는 대로 C10_HOST_DEVICE 를 추가해야 하지만 단순히 C10_HOST_DEVICE 를 추가하기 때문에 충분하지 않습니다. @iotamudelta 가 언급한 것처럼 다른 변경 사항이 없으면 여전히 C++11의 UB입니다. 좋은 솔루션은 귀하가 언급한 것일 수 있습니다. std::real std::complex::real() 를 사용하십시오.

하지만 그 외에도 https://github.com/pytorch/pytorch/blob/master/c10/util/TypeCast.h 파일을 보면 fetch_and_cast 내부에 다음과 같은 내용이 있습니다.

#ifndef C10_HOST_DEVICE
    AT_FORALL_COMPLEX_TYPES(FETCH_AND_CAST_COMPLEX_CASE)
#endif

이 코드 경로는 GPU에서 비활성화되어 있습니다. 활성화하고 작동하도록 해야 합니다.

또한 fetch_and_cast 및 cast_and_store $ 내에서 $ complex<float> 와 complex<double> 사이의 변환을 보지 못했습니다. 이를 위해 변환을 추가해야 할 수도 있습니다. 모든 dtypes의 이러한 기능 범위를 철저히 테스트하십시오.

참조: @ezyang 및 @bddppq

또한 @dylanbespalko , PR에서 TypeCast.h 을 변경하는 경우 저를 참조하십시오.

알겠습니다. ARM에서 torch.real() 및 torch.imag() 로 수정해야 할 몇 가지 작은 사항이 있으므로 TypeCast.h 및 기타 몇 가지를 수정하는 동안 수정하겠습니다. PR에서 참조하겠습니다.

댓글로 드라이브: @smessmer 는 우리를 C++14로 옮기고 있으며, 그 시점에서는 UB가 아닙니다. 이것이 곧 나올 것이기 때문에 UB가 실제 문제를 일으키지 않는다면 나는 그것에 대해 너무 걱정하지 않을 것입니다.

@ezyang : 반갑습니다. Eigen과 같은 타사 제품의 대부분은 여전히 std::real() 매우 자유롭게 호출합니다.

복소수가 아닌 숫자의 경우 scalar_t 및 thrust_t는 동일한 유형입니다. 아마도 내가 변수 이름 thrust_t를 scalar_t_c와 같은 비복소수에 더 친숙한 것으로 바꿀 수 있습니까?

확실하지 않지만 scalar_t_c 는 thrust_t 보다 약간 덜 명확해 보입니다( c 는 어쨌든 무엇을 의미합니까?) 여기서 문제의 유형은 상당히 구체적으로 보입니다 그래서 의도를 직접적으로 말하는 이름을 사용하는 것이 좋을 것 같습니다.

알겠습니다. thrust_t 를 계속 사용하겠습니다. 누구든지 ztype_cuda<>() 에 뛰어들면 scalar_t 가 복잡하지 않은 유형의 경우 thrust_t 임을 즉시 알아차려야 합니다.

https://github.com/pytorch/pytorch/pull/29612 를 참조하세요.

안녕하세요 여러분! pytorch에 복잡한 지원을 추가하는 방향으로 좋은 진전이 있는 것 같습니다! 이에 대한 주도권을 잡고 CUDA 지원도 추가해 주신 @dylanbespalko 에게 감사드립니다! 높은 수준에서 복잡한 지원의 현재 진행 상황을 알고 싶습니다. 저는 주로 복잡한 텐서(이진 연산)를 추가하고 곱하기 위한 CUDA 지원을 위한 대략적인 타임라인에 관심이 있습니다. 감사합니다!

안녕하세요 @sunilkpai 입니다 .

CUDA: #30295에서 이진 및 단항 연산을 지원해야 하는 공개 PR이 있습니다.

또 다른 문제는 역전파와 관련된 것입니다. 복소수 abs() 의 도함수는 실수와 다르게 정의된다고 생각합니다. 그것에 대해 무엇을해야할지 모르겠지만 파생 상품은 tools/autograd/derivatives.yaml 에 정의되어 있습니다.

나는 복소수 /dz abs(z) = z/abs(z) 에 대해 생각합니다. 이것은 실수에도 사용할 수 있지만 sgn(z) 보다 느릴 것입니다.

@dylanbespalko 내 보고서 https://arxiv.org/pdf/1701.00392.pdf 의 표 4.1, 4.2 및 4.3이 파생 상품을 정의하는 데 도움이 될 수 있습니다.

복잡한 도함수(wirtinger calculus)의 경우 두 가지 옵션이 있습니다.
미분 wrt z 또는 z 켤레 계산.
저는 개인적으로 wrt z conjugate 도함수를 더 좋아합니다.
행렬 연산에 더 자연스럽게 느껴지고 그라디언트 업데이트에 켤레가 필요하지 않습니다.
이들의 정의는 다음과 같습니다.

• z = x + jy #$에 대한 파생 상품 z $: dJ/dz = dJ/dx -j dJ/dy
• z = x + jy에 대한 파생 상품 z.conj z = x + jy : dJ/dz.conj = dJ/dx + j dJ/dy

귀하의 의견에서 내 가정은 현재 z 파생 상품을 계산한다는 것입니다.
이 경우 파생 상품은 d abs(z) / d z = z.conj / abs(z) 입니다. 다른 정의를 사용하면 @Randl 제안을 따를 수 있습니다.

더 설명해야 하는 경우 알려주세요. 복잡한 파생 상품에 대한 몇 가지 numpy 구현도 있습니다.

유용할 또 다른 연산(특히 복소수 지원이 필요한 물리 공간의 프로젝트에 대해)은 exp() 연산자에 대한 처리기입니다. tensorflow에는 tf.exp(x + iy) = tf.exp(x) * (tf.cos(y) + 1j * tf.sin(y)) 가 있습니다. pytorch에서도 구현하기가 간단합니까?

@sunilkpai , @boeddeker , @Randl ,

복잡한 파생 상품에 대한 보고서에 감사드립니다. 나는 그것을 따르려고 노력할 것이고 나는 다음 주에 이것을 다시 할 것이다. 여기에 몇 가지 링크를 추가하고 프로젝트 상태를 설명해야 한다고 생각했습니다.

복소수의 상태는 비공식적으로 지원되며 PyTorch 확장을 통해 추가해야 합니다.

• pytorch-cpu-strided-complex
• pytorch-cuda-strided-complex

각 확장에는 다음 두 가지가 포함됩니다.

• 필요한 수학 커널 등록이 포함된 .cpp .
• pytorch 테스트 스크립트의 매우 단순화된 버전이 포함된 test/ 폴더.
  테스트 스크립트에서 지원되는 커널과 지원하지 않는 커널을 확인하십시오.

복잡한 텐서를 콘솔에 인쇄할 수 없는 이유는 무엇입니까?

• Tensor python 객체에는 지원되지 않는 일부 기능을 호출하는 예쁜 인쇄 형식이 있습니다.
  
  
  
  • tensor.py 의 내용을 수정하여 인쇄 형식을 무시할 수 있습니다.
  
  
  • 또는 간단히 Pytorch 텐서를 Numpy 배열로 변환한 다음 인쇄할 수 있습니다.
  
  

현재 프로젝트 상태:

• CPU 커버리지가 상당히 좋습니다.
  
  
  
  • 커널은 'aten/src/ATen/native/cpu/ </li> <li>Complex number specific code is under 'aten/src/ATen/native/cpu/zmath.h 아래 PyTorch 내부에서 구현됩니다.
  
  
  • Intel AVX256 가속은 'aten/src/ATen/cpu/vec256/' 아래에 있습니다.
    
    
    
    
    
    • @sunilkpai : exp 최적화를 몰랐습니다. 추가한 폴더입니다.
    
    
    
    • 변경하는 것이 편하신지 알려주세요.
    
    
    
  
  
• GPU 적용 범위는 이진 및 단항 연산으로 제한됩니다.
  
  
  
  • 커널은 'aten/src/ATen/native/cuda/* </li> <li>Complex number specific code is under 'aten/src/ATen/native/cuda/zmath.cuh 아래 PyTorch 내부에서 구현됩니다.
  
  
  • thrust::complex<T> 데이터 유형이 사용되며 여기에는 최적화된 커널이 포함됩니다.
  
  

현재 개발:

• C 기반 TH 커널이 C++ Aten 폴더로 이식되기를 기다리고 있습니다.
  
  
  
  • rand() 함수는 테스트 케이스를 pytorch의 내부 테스트로 이식하는 데 필요합니다.
  
  
  • 일부 인덱싱 작업은 현재 이식되지 않습니다.
  
  
  • 현재 TH에서 ATen으로 이식해야 하는 168/1300 수학 커널(10월 230에서 감소)이 있습니다.
  
  
• 이러한 커널을 ATen에서 사용할 수 있게 되면 복소수 지원을 추가하려고 합니다.

--

참고로 복잡한 파생 상품과 관련하여 Julia에서 긴 논의가 있었고 이제 ChainRules ( http://www.juliadiff.org/ChainRules.jl/dev/api.html#ChainRulesCore.Wirtinger 참조) 및 Zygote 에서 구현이 완료되었습니다. . 일반적으로 사람들에게 필요한 것은
\partial L/\partial adjoint(z) 그라디언트(정의상 가장 빠른 감소 방향)로 사용되지만 도함수는 \partial L/\partial z 와 다르며 복소수 AD를 완벽하게 지원하려면 추가 인터페이스를 추가해야 합니다. . 자세한 규칙은 ChainRules 또는 Zygote/lib 에 구현된 것을 확인할 수 있습니다(일반 규칙만 있기 때문에 대부분의 연산자에 대한 복소수에 대한 별도의 규칙이 없습니다. matmul 는 일반 정의로 작성됩니다(예: adjoint(A) * B ).

복잡한 텐서를 콘솔에 인쇄할 수 없는 이유는 무엇입니까?
Tensor python 객체에는 지원되지 않는 일부 기능을 호출하는 예쁜 인쇄 형식이 있습니다.
tensor.py의 내용을 수정하여 인쇄 형식을 무시할 수 있습니다.
또는 간단히 Pytorch 텐서를 Numpy 배열로 변환한 다음 인쇄할 수 있습니다.

나는 디버깅 등을 위해 https://github.com/Roger-luo/pytorch-complex 에서 인쇄의 적어도 일부를 수정했다고 생각합니다. 처음에는 마스터가 과거에 많이 변경되었기 때문에 이것이 도움이 될지 확실하지 않습니다. 년도. 도움이 되는 경우 가져갈 수 있습니다. 더 이상 이 작업을 수행하지 않겠습니다.

@dylanbespalko 저는 배우기 시작했지만 pytorch 내부에 상대적으로 경험이 없습니다! aten/src/ATen/cpu/vec256/* 에서 본 것을 기반으로 하면 이 변경을 시도할 수도 있지만 std::exp(std::complex) 의 기본 동작이 내가 언급한 것과 정확히 일치한다는 점을 감안할 때 이것이 필요한지 확실하지 않습니다. 내 이전 의견에서 : https://en.cppreference.com/w/cpp/numeric/complex/exp 의 메모를 참조하십시오. 또한 이것이 CUDA에서 이러한 작업을 구현하는 것으로 어떻게 해석되는지 잘 모르겠습니다(현재 실제, imag, conj 및 각도로 제한되어 있는 것처럼 보입니까?).

@sunilkpai ,

제공된 방정식을 사용하여 exp() 에 대한 AVX 지원을 추가했습니다.

또한 PyTorch의 최근 변경 사항으로 인해 몇 가지 문제가 발생했음을 알았습니다. #30871에서 수정했습니다.

@dylanbespalko

TH에서 ATen으로 이식하는 일정이 있습니까?
내가 pytorch의 내부 작동에 정통하지 않다는 사실을 감안할 때 기여할 수 있는 방법이 있습니까?

나는 arxiv 에서 복잡한 svd의 역전파를 위한 공식을 찾았고 그것을 구현할 수 있습니다.

작업해주셔서 감사합니다!

@야콥-언프리드

https://github.com/pytorch/pytorch/wiki/TH-to-ATen-porting-guide

TH 커널은 C로 구현되며 고유한 참조 카운팅 문제로 인해 복잡한 지원을 추가하는 데 거의 관심이 없습니다. 각 커널이 등록된 aten/src/ATen/native/native_functions.yaml 에서 진행 상황을 추적할 수 있습니다.

legacy::cpu::_th 를 검색하고 해당 숫자를 3으로 나누어 이전 TH 커널 수로 나눕니다.
legacy::cpu::_thnn 를 검색하고 이전 TH 신경망 커널의 수로 해당 숫자를 3으로 나눕니다.

각 커널은 일반적으로 3가지 다른 방법으로 등록됩니다.
1. 일반 커널 y = add(a, b)
2. 인플레이스 커널 a = add_(a, b)
3. 출력 커널 add_out(a, b, out=y)
실제 구현은 항상 출력 커널에 있고 다른 2개는 해당 함수를 호출합니다.

nn 커널은 종속 커널이 더 적기 때문에 이식하기 쉬운 경향이 있습니다. 따라서 커널을 구현한 방법의 역순으로 커널을 이식할 수 있다면 전체 작업을 덜 수행하게 됩니다.

포팅 추적 문제 확인 https://github.com/pytorch/pytorch/issues/24507 , @VitalyFedyunin 도 참조

다음은 #32437에서 요청한 복소수 지원에 대한 상태 업데이트입니다. 저는 오늘 CPU 관련 지원을 위해 다시 일하고 있습니다.

오토그라드 지원

• 나는 이것을 할 시간이 많지 않았다.
• angle() , real() , imag() , conj() 모두 구현되었습니다.
• abs() 는 복소수에 대해 별도의 구현이 필요합니다. (위의 @boeddeker 및 @Randl 의 메모 참조)

하드웨어 지원

복소수 지원은 현재 트리 외부에서 구현됩니다. 이것이 의미하는 바는 다음과 같습니다.

인트리 코드

• 수학 연산은 실제로 트리 내(PyTorch 소스 코드 내)에서 구현됩니다 .
• 트리 내 Pytorch 테스트 중 어떤 것도 복소수 지원을 검증하지 않습니다(그래서 문제가 발생하는 경향이 있음).
• PyTorch가 TH에서 ATen으로 마이그레이션 중입니다(#24507).
  - TH에서 구현된 수학 커널은 복소수를 지원하지 않습니다.
  - ATen에서 구현된 커널만 복소수를 지원할 수 있습니다.
• 복잡한 dtype을 활성화하려면 PyTorch 확장을 설치해야 합니다.

트리 외부 코드

• 여러 PyTorch 확장이 구현되었으며 향후 쉽게 내부화할 수 있습니다.
• 각 확장에는 4개의 중요한 파일이 있습니다.
  
  
  
  • setup.py: pytorch 확장을 빌드하고 설치합니다.
  
  
  • [CPU/CUDA/FPGA]ComplexType.cpp: CPUType.cpp 또는 CUDAType.cpp와 유사한 수학 커널 등록
  
  
  • test/test_torch.py: Aten 지원에 의해 제한되는 작동 중인 커널을 나타내는 매우 보기 흉한 테스트 케이스입니다.
  
  
  • test/test_autograd.py: autograd 기능 테스트.
  
  

트리 외부 PyTorch 확장

1. cpu_strided_complex
   - [x] 카피 커널
   - [ ] 텐서팩토리(th_random, th_uniform, th_normal)
   - [x] RangeFactories
   - [x] BinaryOpKernal
   - [x] UnaryOpKernels
   - [x]CompareOpKernels
   - [x] PowerKernels
   - [x] ReduceOpKernels(th_min, th_max, 일부 규범은 복소수 켤레를 계산하지 않음)
   - [ ] IndexOpKernels(th_masked_select_bool, th_set, th_gather, th_cat)
   - [x] PointwiseOps
   - [x] Lerp Ops
   - [ ] BlasOps(th_mv, th_mm, th_fmod, th_eig)
   - [ ] LinpackOps(Blas 사용)
   - [ ] SpectralOps(지원되지만 작업이 필요함)
   
   
   
   1. cuda_strided_complex
      
      
      
      
      
      • [x] 카피 커널
      
      
      
      • [ ] TensorFactories(cpu 문제 참조)
      
      
      
      • [x] BinaryOpKernal
      
      
      
      • [x] UnaryOpKernels(Todo: 각도, 실수, 이미지, 결합 추가)
      
      
      
      • [ ] OpKernel 비교(Todo)
      
      
      
      • [ ] ReduceOpKernels(WARP_SIZE 관련 오류 메시지)
      
      
      
      • GPU는 point-wise 계산 이상으로 어려워지지만 추가 기능이 지원될 수 있습니다.
      
      
      
   
   
2. vitis_strided_complex
   
   
   
   • Xilinx Vitis는 서버 및 임베디드 장치를 지원하는 FPGA 고수준 합성 플랫폼입니다.
   
   
   • 2019년 10월에 출시되었습니다(기기에 대한 지원이 제한적일 수 있음).
   
   
   • SDAccel(서버)과 VIvado HLS(임베디드)를 결합합니다.
   
   
   • [ ] BinaryOpKernals(1월 말)
   
   
   • [ ] UnaryOpKernels(1월 말)
   
   
   • [ ] ReduceOpKernels(2월 말).
   
   
   • FPGA는 최근 Vec256 PyTorch 템플릿 클래스와 유사한 벡터화된 객체를 추가했습니다.
   
   
   • Vec256은 CPU에 복잡한 지원이 추가되었고 $C$ 또는 $R^N$ 텐서 공간을 구현하는 더 자연스러운 방법인 것 같습니다.
   
   

이 문제에 대한 추가 업데이트: https://github.com/pytorch/pytorch/issues/33152

이것은 별도의 문제가 될 수도 있고 아닐 수도 있지만, 현재 문서에 '현재 pytorch가 복소수와 함께 작동하는 방식'을 설명하는 내용을 포함하는 것이 실질적으로 더 중요하다고 생각합니다. 일명 덧셈, 곱셈, 일종의 규범을 할 수 있고 복잡한 가중치를 가질 수 없습니다. 이 모든 것은 상위 수준에서 의도한 현재 동작을 설명하는 몇 줄의 문서로 요약될 수 있습니다.

이것은 별도의 문제가 될 수도 있고 아닐 수도 있지만, 현재 문서에 '현재 pytorch가 복소수와 함께 작동하는 방식'을 설명하는 내용을 포함하는 것이 실질적으로 더 중요하다고 생각합니다. 일명 덧셈, 곱셈, 일종의 규범을 할 수 있고 복잡한 가중치를 가질 수 없습니다. 이 모든 것은 상위 수준에서 의도한 현재 동작을 설명하는 몇 줄의 문서로 요약될 수 있습니다.

안녕하세요 @redwrasse 피드백 주셔서 감사합니다! 현재 마스터의 복잡한 텐서에 대해 지원되는 일부 토치 기본 및 복잡한 기능에 대해 이야기하는 복소수에 대한 메모가 있습니다.
(대부분은 1.6 릴리스에 포함됨) https://pytorch.org/docs/master/complex_numbers.html?highlight=complex. 다른 어떤 기능에 관심이 있는지 공유할 수 있습니까? 현재 지원 및 향후 릴리스에 대한 계획에 대해 더 이야기하게 되어 기쁩니다.

이것은 별도의 문제가 될 수도 있고 아닐 수도 있지만, 현재 문서에 '현재 pytorch가 복소수와 함께 작동하는 방식'을 설명하는 내용을 포함하는 것이 실질적으로 더 중요하다고 생각합니다. 일명 덧셈, 곱셈, 일종의 규범을 할 수 있고 복잡한 가중치를 가질 수 없습니다. 이 모든 것은 상위 수준에서 의도한 현재 동작을 설명하는 몇 줄의 문서로 요약될 수 있습니다.

안녕하세요 @redwrasse 피드백 주셔서 감사합니다! 현재 마스터의 복잡한 텐서에 대해 지원되는 일부 토치 기본 및 복잡한 기능에 대해 이야기하는 복소수에 대한 메모가 있습니다.
(대부분은 1.6 릴리스에 포함됨) https://pytorch.org/docs/master/complex_numbers.html?highlight=complex. 다른 어떤 기능에 관심이 있는지 공유할 수 있습니까? 현재 지원 및 향후 릴리스에 대한 계획에 대해 더 이야기하게 되어 기쁩니다.

@anjali411 감사합니다. 이 문서를 보니 반갑습니다. 이전에는 몰랐습니다. 필요한 것은 '복잡한 신경망에 대한 현재 지원 상태'의 몇 줄 앞과 중앙에 있는 것 같지만 ...

복잡한 autograd에 관심이 있는 사람들은 https://github.com/pytorch/pytorch/issues/41857 에서 PyTorch가 따를 규칙(JAX 또는 TF)에 대해 설명합니다.