Rate this Page

★★★★★

Struct IValue #

Defined inFile ivalue.h

Nested Relationships#

Nested Types#

Struct Documentation#

structIValue#

IValue (Interpreter Value) is a tagged union over the types supported by the TorchScript interpreter.

IValues contain their values as anIValue::Payload, which holds primitive types (int64_t,bool,double,Device) andTensor as values, and all other types as ac10::intrusive_ptr. In order to optimize performance of the destructor and related operations by making theTensor andc10::intrusive_ptr paths generate the same code, we represent a nullc10::intrusive_ptr asUndefinedTensorImpl::singleton(),notnullptr.

IValues are used as inputs to and outputs from the TorchScript interpreter. To retrieve the value contained within anIValue, use the.toX() methods, whereX is the type you are trying to get. Note that neither the.toX() methods nor the templated.to<T> functions do any kind of casting, they only unwrap the contained value. For example:

// Make the IValuetorch::IValuemy_ivalue(26);std::cout<<my_ivalue<<"\n";// Unwrap the IValueint64_tmy_int=my_ivalue.toInt();std::cout<<my_int<<"\n";// This will throw an error!// `my_ivalue` is tagged as an int and cannot be used as another typetorch::Tensormy_tensor=my_ivalue.toTensor();

Public Types

template<classT> usingenable_if_ivalue_constructible=std::enable_if_t<std::is_constructible_v<IValue,T>,std::nullptr_t>#

template<classT> usingenable_if_list_is_ivalue_constructible=std::enable_if_t<std::is_constructible_v<IValue,T>&&!std::is_same_v<T,c10::SymInt>,std::nullptr_t>#

template<classT> usingenable_if_symint=std::enable_if_t<std::is_same_v<T,c10::SymInt>,std::nullptr_t>#

template<classT> usingenable_if_ilist_is_ivalue_constructible=std::enable_if_t<std::is_constructible_v<IValue,T>&&std::is_constructible_v<IValue,typenameIListRef<T>::boxed_type>&&!std::is_same_v<T,c10::SymInt>,std::nullptr_t>#

usingHashAliasedIValues=std::unordered_set<IValue,HashAliasedIValue,CompAliasedIValues>#

usingHashAliasedIValueMap=std::unordered_map<IValue,IValue,HashAliasedIValue,CompAliasedIValues>#

usingHashIdentityIValues=std::unordered_set<IValue,HashIdentityIValue,CompIdentityIValues>#

usingHashIdentityIValueMap=std::unordered_map<IValue,IValue,HashIdentityIValue,CompIdentityIValues>#

Public Functions

inlineIValue(constIValue&rhs)#

inlineIValue(IValue&&rhs)noexcept#

inlineIValue&operator=(IValue&&rhs)&noexcept#

inlineIValue&operator=(IValueconst&rhs)&#

voiddump()const#

IValueequals(constIValue&rhs)const#

Equality comparison.

The semantics are the same as Python’s==:

Numerical types are compared by value.
Tensors compute element-wise equality, returning a BoolTensor (see:torch.eq())
Strings are compared by value.
Sequence types (list, tuple) are compared lexicographically by comparing their elements. Different sequence types never compare equal.
Mappings (dict) must have equal (key, value) pairs.
If not listed above, the default behavior for is to test identity equality (e.g. pointer equality).

Why does this return anIValue instead of a bool? Because in PyTorch,tensor1==tensor2 returns aBoolTensor, not a bool.

NOTE: we (like Python) assume that identity equality implies value equality for efficiency. TODO: need to support customizing equality

boolis(constIValue&rhs)const#

Identity comparison.

Checks ifthis is the same object asrhs. The semantics are the same as Python’sis operator.

NOTE: Like in Python, this operation is poorly defined for primitive types like numbers and strings. Prefer to use== unless you really want to check identity equality.

inlineIValuehash()const#

Hashing for IValues.

Returns an IValue-boxed int.

Some notes:

Like eager, Tensors are hashed by looking at the pointer. This is not strictly correct because two value-equal tensors with different tensor pointers will hash differently, but we choose to reproduce the eager semantics.
Hashing is not defined on all built-inIValue types (e.g. list and dict), following Python. Callinghash() on these types will throw.

inlineIValue(at::TensorBaset)#

inlineboolisTensor()const#

at::TensortoTensor()&&#

at::Tensor&toTensor()&#

constat::Tensor&toTensor()const&#

inlineat::TensorImpl*unsafeToTensorImpl()const#

inlineIValue(at::Storages)#

inlineboolisStorage()const#

c10::StoragetoStorage()&&#

c10::StoragetoStorage()const&#

inlineconstIValue&toIValue()const#

inlineIValue&toIValue()#

inlineboolisCapsule()const#

c10::intrusive_ptr<torch::CustomClassHolder>toCapsule()&&#

c10::intrusive_ptr<torch::CustomClassHolder>toCapsule()const&#

template<typenameT,std::enable_if_t<std::is_base_of_v<torch::CustomClassHolder,T>,int>=0> IValue(intrusive_ptr<T>custom_class)#

boolisCustomClass()const#

template<typenameT> c10::intrusive_ptr<T>toCustomClass()&&#

template<typenameT> c10::intrusive_ptr<T>toCustomClass()const&#

IValue(c10::intrusive_ptr<ivalue::Tuple>v)#

template<typename...Args,std::enable_if_t<!std::disjunction_v<std::is_lvalue_reference<Args>...,std::negation<std::is_constructible<IValue,Args>>...>,std::nullptr_t>=nullptr> IValue(conststd::tuple<Args...>&t)#

template<typename...Args,std::enable_if_t<!std::disjunction_v<std::is_lvalue_reference<Args>...,std::negation<std::is_constructible<IValue,Args>>...>,std::nullptr_t>=nullptr> IValue(std::tuple<Args...>&&t)#

inlineboolisTuple()const#

c10::intrusive_ptr<ivalue::Tuple>toTuple()&&#

c10::intrusive_ptr<ivalue::Tuple>toTuple()const&#

ivalue::Tuple&toTupleRef()const#

inlineIValue(doubled)#

inlineboolisDouble()const#

inlinedoubletoDouble()const#

template<typenameT> IValue(c10::complex<T>c)#

inlineboolisComplexDouble()const#

c10::complex<double>toComplexDouble()const#

IValue(c10::intrusive_ptr<ivalue::Future>v)#

inlineboolisFuture()const#

c10::intrusive_ptr<ivalue::Future>toFuture()&&#

c10::intrusive_ptr<ivalue::Future>toFuture()const&#

IValue(c10::intrusive_ptr<ivalue::Await>v)#

inlineboolisAwait()const#

c10::intrusive_ptr<ivalue::Await>toAwait()&&#

c10::intrusive_ptr<ivalue::Await>toAwait()const&#

IValue(c10::intrusive_ptr<c10::RRefInterface>v)#

inlineboolisRRef()const#

c10::intrusive_ptr<c10::RRefInterface>toRRef()&&#

c10::intrusive_ptr<c10::RRefInterface>toRRef()const&#

IValue(c10::intrusive_ptr<at::Quantizer>v)#

inlineboolisQuantizer()const#

c10::intrusive_ptr<at::Quantizer>toQuantizer()&&#

c10::intrusive_ptr<at::Quantizer>toQuantizer()const&#

inlineIValue(int64_ti)#

inlineIValue(constc10::SymInt&i)#

inlineboolisSymInt()const#

c10::SymInttoSymInt()&&#

c10::SymInttoSymInt()const&#

inlineIValue(constc10::SymFloat&i)#

inlineboolisSymFloat()const#

c10::SymFloattoSymFloat()&&#

c10::SymFloattoSymFloat()const&#

inlineIValue(constc10::SymBool&i)#

inlineboolisSymBool()const#

c10::SymBooltoSymBool()&&#

c10::SymBooltoSymBool()const&#

inlineIValue(int32_ti)#

inlineboolisInt()const#

inlineint64_ttoInt()const#

inlineIValue(uint64_tu)#

inlineboolisUnsigned()const#

inlineuint64_ttoUInt()const#

inlineIValue(boolb)#

inlineboolisBool()const#

inlinebooltoBool()const#

boolisIntList()const#

boolisSymIntList()const#

c10::List<int64_t>toIntList()&&#

c10::List<int64_t>toIntList()const&#

std::vector<int64_t>toIntVector()const#

c10::List<c10::SymInt>toSymIntList()&&#

c10::List<c10::SymInt>toSymIntList()const&#

std::vector<c10::SymInt>toSymIntVector()const#

at::DimVectortoDimVector()const#

IValue(c10::intrusive_ptr<ivalue::ConstantString>v)#

IValue(std::stringv)#

inlineIValue(constchar*v)#

inlineIValue(std::string_viewv)#

inlineboolisString()const#

c10::intrusive_ptr<ivalue::ConstantString>toString()&&#

c10::intrusive_ptr<ivalue::ConstantString>toString()const&#

conststd::string&toStringRef()const#

std::optional<std::reference_wrapper<conststd::string>>toOptionalStringRef()const#

std::string_viewtoStringView()const#

boolisDoubleList()const#

c10::List<double>toDoubleList()&&#

c10::List<double>toDoubleList()const&#

std::vector<double>toDoubleVector()const#

boolisComplexDoubleList()const#

c10::List<c10::complex<double>>toComplexDoubleList()&&#

c10::List<c10::complex<double>>toComplexDoubleList()const&#

std::vector<c10::complex<double>>toComplexDoubleVector()const#

boolisBoolList()const#

c10::List<bool>toBoolList()&&#

c10::List<bool>toBoolList()const&#

boolisTensorList()const#

c10::List<at::Tensor>toTensorList()&&#

c10::List<at::Tensor>toTensorList()const&#

std::vector<at::Tensor>toTensorVector()const#

boolisOptionalTensorList()const#

c10::List<std::optional<at::Tensor>>toOptionalTensorList()&&#

c10::List<std::optional<at::Tensor>>toOptionalTensorList()const&#

std::vector<std::optional<at::Tensor>>toOptionalTensorVector()const#

IValue(c10::List<IValue>v)#

inlineboolisList()const#

c10::List<IValue>toList()&&#

c10::List<IValue>toList()const&#

c10::ArrayRef<IValue>toListRef()const#

template<classT,enable_if_list_is_ivalue_constructible<T>=nullptr> IValue(c10::List<T>&&v)#

template<classT,enable_if_list_is_ivalue_constructible<T>=nullptr> IValue(constc10::List<T>&v)#

template<classT,enable_if_list_is_ivalue_constructible<T>=nullptr> IValue(at::ArrayRef<T>v)#

template<classT,enable_if_list_is_ivalue_constructible<T>=nullptr> IValue(conststd::vector<T>&v)#

template<classT,enable_if_list_is_ivalue_constructible<T>=nullptr> IValue(std::vector<T>&&v)#

template<classT,size_tN> IValue(std::array<T,N>v)#

template<classT,enable_if_symint<T>=nullptr> IValue(at::ArrayRef<T>v)#

template<classT,enable_if_symint<T>=nullptr> IValue(at::OptionalArrayRef<T>v)#

template<classT,enable_if_symint<T>=nullptr> IValue(conststd::vector<T>&v)#

template<classT,enable_if_symint<T>=nullptr> IValue(std::vector<T>&&v)#

template<classT,enable_if_ilist_is_ivalue_constructible<T>=nullptr> IValue(c10::IListRef<T>v)#

IValue(c10::Dict<IValue,IValue>v)#

inlineboolisGenericDict()const#

c10::Dict<IValue,IValue>toGenericDict()&&#

c10::Dict<IValue,IValue>toGenericDict()const&#

template<classKey,classValue> IValue(c10::Dict<Key,Value>v)#

template<classKey,classValue> IValue(std::unordered_map<Key,Value>v)#

template<classT,enable_if_ivalue_constructible<T>=nullptr> IValue(std::optional<T>v)#

template<classT,enable_if_list_is_ivalue_constructible<T>=nullptr> IValue(c10::OptionalArrayRef<T>v)#

IValue(std::nullopt_t)#

IValue(c10::intrusive_ptr<ivalue::Object>v)#

inlineboolisObject()const#

c10::intrusive_ptr<ivalue::Object>toObject()&&#

c10::intrusive_ptr<ivalue::Object>toObject()const&#

ivalue::Object&toObjectRef()const#

torch::jit::ModuletoModule()const#

boolisModule()const#

IValue(c10::intrusive_ptr<ivalue::PyObjectHolder>v)#

inlineboolisPyObject()const#

c10::intrusive_ptr<ivalue::PyObjectHolder>toPyObjectHolder()&&#

c10::intrusive_ptr<ivalue::PyObjectHolder>toPyObjectHolder()const&#

PyObject*toPyObject()const#

explicitIValue(c10::intrusive_ptr<ivalue::EnumHolder>v)#

inlineboolisEnum()const#

c10::intrusive_ptr<ivalue::EnumHolder>toEnumHolder()&&#

c10::intrusive_ptr<ivalue::EnumHolder>toEnumHolder()const&#

IValue()=default#

inlineboolisNone()const#

inlinestd::stringtoNone()const#

inlineIValue(constat::Scalar&s)#

inlineboolisScalar()const#

inlineat::ScalartoScalar()const#

inlineIValue(c10::Deviced)#

inlineboolisDevice()const#

inlinec10::DevicetoDevice()const#

inlineIValue(c10::Streams)#

c10::StreamtoStream()&&#

c10::StreamtoStream()const&#

inlineboolisStream()const#

inlineIValue(ScalarTypet)#

inlineat::ScalarTypetoScalarType()const#

inlineIValue(Layoutl)#

inlineat::LayouttoLayout()const#

inlineIValue(MemoryFormatm)#

inlineat::MemoryFormattoMemoryFormat()const#

inlineIValue(at::QSchemeqscheme)#

inlineat::QSchemetoQScheme()const#

inlineIValue(at::Dimnamedimname)#

inlineat::DimnametoDimname()const#

inlineIValue(at::Generatorg)#

inlineboolisGenerator()const#

at::GeneratortoGenerator()&&#

at::GeneratortoGenerator()const&#

inlinestd::stringtagKind()const#

template<typenameT> Tto()&&#

template<typenameT> c10::detail::ivalue_to_const_ref_overload_return<T>::typeto()const&#

template<typenameT> std::optional<T>toOptional()#

template<typenameT> std::optional<T>toOptional()const#

std::ostream&repr(std::ostream&stream,std::function<bool(std::ostream&,constIValue&v)>customFormatter)const#

inlineboolisPtrType()const#

template<typenameT=c10::PlatformType> TypePtrtype()const#

booloverlaps(constIValue&rhs)const#

voidgetSubValues(HashAliasedIValues&subValues)const#

voidvisit(conststd::function<bool(constIValue&)>&visitor)const#

IValuedeepcopy(std::optional<at::Device>device=std::nullopt)const#

IValuedeepcopy(HashIdentityIValueMap&memo,std::optional<at::Device>device=std::nullopt)const#

inlineboolisIntrusivePtr()const#

inlineboolisIntrusivePtrLegacyBehavior()const#

inlineIValue(constPayload&p,Tagt)#

Public Members

friendMaybeOwnedTraits<IValue>

Payloadpayload#

Tagtag={IValue::Tag::None}#

Public Static Functions

staticsize_thash(constIValue&iv)#

staticinlineIValuemake_capsule(intrusive_ptr<torch::CustomClassHolder>blob)#

staticinlineIValueuninitialized()#

Friends

friendstructWeakIValue

friendbooloperator==(constIValue&lhs,constIValue&rhs)#

This implements the same semantics asbool(lhs==rhs) in Python.

which is the same asequals() except for Tensor types.

friendbooloperator!=(constIValue&lhs,constIValue&rhs)#

friendstd::ostream&operator<<(std::ostream&out,constIValue&v)#

structCompAliasedIValues#

Public Functions

inlinebooloperator()(constIValue&lhs,constIValue&rhs)const#

structCompIdentityIValues#

Public Functions

inlinebooloperator()(constIValue&lhs,constIValue&rhs)const#

structHashAliasedIValue#

Public Functions

inlinesize_thashTensor(constat::Tensor&ten)const#

inlinesize_toperator()(constIValue&val)const#

structHashIdentityIValue#

Public Functions

inlinesize_toperator()(constIValue&val)const#

unionPayload#

Public Functions

inlinePayload()#

Payload(constPayload&)=delete#

Payload(Payload&&)=delete#

Payload&operator=(constPayload&)=delete#

Payload&operator=(Payload&&)=delete#

inline~Payload()#

Public Members

unionc10::IValue::Payload::TriviallyCopyablePayloadu#

at::Tensoras_tensor#

unionTriviallyCopyablePayload#

Public Functions

inlineTriviallyCopyablePayload()#

Public Members

int64_tas_int#

uint64_tas_uint#

doubleas_double#

boolas_bool#

c10::intrusive_ptr_target*as_intrusive_ptr#

c10::DeviceTypetype#

DeviceIndexindex#

structc10::IValue::Payload::TriviallyCopyablePayload::[anonymous]as_device#

template<typenameT> structTagType#

On this page

Show Source

PyTorch Libraries

Movatterモバイル変換

Struct IValue #

Nested Relationships#

Nested Types#

Struct Documentation#

Docs

Tutorials

Resources

Movatterモバイル変換

Struct IValue#

Nested Relationships#

Nested Types#

Struct Documentation#

Docs

Tutorials

Resources

Struct IValue #