தொடங்குதல்

நிறுவல்

கிஸ்கிட்டைப் பயன்படுத்தத் தொடங்குவோம்! முதலில் செய்ய வேண்டியது, தொகுப்புகளை எவ்வாறு இயக்குவது மற்றும் நிறுவுவது என்பதைத் தேர்வுசெய்ய வேண்டும். இதைச் செய்ய மூன்று முக்கிய வழிகள் உள்ளன:

குறிப்பிட்ட இடத்தில் தொடங்கவும்

Qiskit Python 3.7 அல்லது அதற்குப் பிறகு ஆதரிக்கிறது. இருப்பினும், Python மற்றும் Qiskit இரண்டும் உருவாகி வரும் சுற்றுச்சூழல் அமைப்புகளாகும், சில சமயங்களில் ஒன்று அல்லது மற்றொன்றில் புதிய வெளியீடுகள் ஏற்படும்போது, ​​இணக்கத்தன்மையில் சிக்கல்கள் இருக்கலாம்.

தொடங்குவதற்கு, உங்கள் அந்த இடத்திற்குறிய கணினியில் பைத்தானை பதிவிறக்கம் செய்ய வேண்டும். Jupyter Qiskit உடன் தொடர்புகொள்வதற்கு பரிந்துரைக்கப்படுகிறது.

Qiskit ஐ பிற பயன்பாடுகளிலிருந்து சுத்தமாகப் பிரித்து உங்கள் அனுபவத்தை மேம்படுத்த, Python virtual சூழல்களை பயன்படுத்தப் பரிந்துரைக்கிறோம்.

பைதான் மட்டும் நிறுவப்பட்ட குறைந்தபட்ச சூழலை உருவாக்கவும்.

python3 -m venv /path/to/virtual/environment

உங்கள் புதிய சூழலைச் செயல்படுத்தவும்.

source /path/to/virtual/environment/bin/activate

குறிப்பு: நீங்கள் விண்டோஸ் பயன்படுத்தினால், PowerShell இல் பின்வரும் கட்டளைகளைப் பயன்படுத்தவும்.

python3 -m venv c:\path\to\virtual\environment
c:\path\to\virtual\environment\Scripts\Activate.ps1

அடுத்து, கிஸ்கிட் தொகுப்பை நிறுவவும்.

pip install qiskit

தொகுப்புகள் சரியாக நிறுவப்பட்டிருந்தால், உங்கள் மெய்நிகர் சூழலில் செயலில் உள்ள தொகுப்புகளைக் காண pip list ஐ இயக்கலாம்.

நீங்கள் visualisation செயல்பாடு அல்லது Jupyter notebooks-களைப் பயன்படுத்த விரும்பினால், கூடுதல் `` காட்சி `` ஆதரவுடன் Qiskit ஐ நிறுவப் பரிந்துரைக்கப்படுகிறது:

pip install qiskit[visualization]

நீங்கள் zsh பயனராக இருந்தால் (இது MacOS இன் புதிய பதிப்புகளில் இயல்புநிலை ஷெல் ஆகும்), மேற்கோள்களில் qiskit[visualization] என்பதை நீங்கள் quotes-களில் குறிப்பிட வேண்டும்:

pip install 'qiskit[visualization]'

Cloud-டில் தொடங்கவும்

பின்வரும் cloud விற்பனையாளர்கள் தங்கள் சூழலில் Qiskit-டை முன்பே நிறுவியுள்ளனர்:

---

IBM Quantum Lab

Build quantum applications and experiments with Qiskit in a cloud programming environment.

Strangeworks

A platform that enables users and organizations to easily apply quantum computing to their most pressing problems and research.

மூலத்திலிருந்து நிறுவவும்

மூலத்திலிருந்து உறுப்புகளை நிறுவுவது, Python Package Index (PyPI) களஞ்சியத்தில் உள்ள பதிப்பைப் பயன்படுத்துவதற்குப் பதிலாக, Qiskit இன் மிகச் சமீபத்தில் புதுப்பிக்கப்பட்ட பதிப்பை அணுக உங்களை அனுமதிக்கிறது. இது Qiskit குறியீட்டின் சமீபத்திய பதிப்பை மிகவும் திறமையாக ஆய்வு செய்து நீட்டிக்கும் திறனை உங்களுக்கு வழங்கும்.

மூலத்திலிருந்து உறுப்புகள் மற்றும் கூறுகளை நிறுவும் போது, இயல்புநிலையாக அவற்றின் மேம்பாடு பதிப்பு (மாஸ்டர் கிட் கிளைக்கு ஒத்திருக்கும்) நிலையான பதிப்பிற்கு எதிராகப் பயன்படுத்தப்படும் (அதையே கொண்டுள்ளது கோட்பேஸ் வெளியிடப்பட்ட பிப் தொகுப்புகளாக). ஒரு உறுப்பு அல்லது கூறுகளின் மேம்பாடு பதிப்புகள் பொதுவாக புதிய அம்சங்களையும் மாற்றங்களையும் உள்ளடக்கியிருப்பதால், அவை பொதுவாக மற்ற உருப்படிகளின் மேம்பாட்டு பதிப்பைப் பயன்படுத்த வேண்டும்.

Terra மற்றும் Aer தொகுப்புகள் இரண்டிற்கும் நீங்கள் நிறுவும் முன் மூலத்திலிருந்து உருவாக்க ஒரு கம்பைலர் தேவைப்படுகிறது. Ignis, Aqua மற்றும் IBM Quantum Provider பின்தளத்திற்கு கம்பைலர் தேவையில்லை.

மூலப் பதிப்புகளுக்குப் பின்னால் pip பதிப்பு இருந்தால், விரும்பியதை விடக் குறைவாக இருக்கும் உறுப்புகளின் பதிப்புகளை நிறுவுவதைத் தடுக்க, மூலத்திலிருந்து உறுப்புகளை நிறுவுவதற்கு பின்வரும் நிறுவல் வரிசை தேவைப்படுகிறது:

1. qiskit-terra

2. qiskit-aer

3. :ref:`qiskit-ibmq-provider <install-qiskit-ibmq-provider>`(நீங்கள் IBM Quantum சாதனங்கள் அல்லது ஆன்லைன் simulator-உடன் இணைக்க விரும்பினால்)

பல கூறுகள் மற்றும் உறுப்புகளுடன் ஒரே நேரத்தில் வேலை செய்ய, ஒவ்வொரு உறுப்புக்கும் பின்வரும் படிகளைப் பயன்படுத்தவும்.

Note

பைத்தானில் நேம்ஸ்பேஸ் பேக்கேஜிங் பயன்படுத்தப்படுவதால், நீங்கள் தொகுப்புகளை எவ்வாறு நிறுவுகிறீர்கள் என்பதில் கவனமாக இருக்க வேண்டும். மூலத்திலிருந்து ஏதேனும் உறுப்பை நிறுவ நீங்கள் திட்டமிட்டால், qiskit மெட்டா பேக்கேஜைப் பயன்படுத்த வேண்டாம். மேலும், இந்த வழிகாட்டியைப் பின்பற்றி, மேம்பாட்டிற்காக ஒரு தனி மெய்நிகர் சூழலைப் பயன்படுத்தவும். உங்கள் மேம்பாட்டுடன் ஏற்கனவே உள்ள நிறுவலைக் கலக்க நீங்கள் தேர்வுசெய்தால், ஒன்றாகச் செயல்படும் நிறுவல் முறைகளின் தொகுப்புக்கு https://github.com/pypa/sample-namespace-packages/blob/master/table.md ஐப் பார்க்கவும்.

Set up the Virtual Development Environment

python3 -m venv QiskitDevenv
source QiskitDevenv/bin/activate

Installing Terra from Source

மூலத்திலிருந்து நிறுவுவதற்கு உங்கள் கணினியில் ரஸ்ட் கம்பைலர் இருக்க வேண்டும். ரஸ்ட் கம்பைலரை நிறுவ, பரிந்துரைக்கப்பட்ட பாதை ரஸ்டப்பைப் பயன்படுத்துவதாகும், இது குறுக்கு-தளம் ரஸ்ட் நிறுவி ஆகும். rustup ஐப் பயன்படுத்த நீங்கள் செல்லலாம்:

https://rustup.rs/

இது உங்கள் மேடையில் துருவை எவ்வாறு நிறுவுவது என்பதற்கான வழிமுறைகளை வழங்கும். rustup தவிர பிற நிறுவல் முறைகள் உள்ளன.

ரஸ்ட் கம்பைலர் நிறுவப்பட்டதும், கிஸ்கிட் டெர்ராவை நிறுவ நீங்கள் தயாராக உள்ளீர்கள்.

1. Terra களஞ்சியத்தை குளோன் செய்யவும்.

   git clone https://github.com/Qiskit/qiskit-terra.git
   

2. களஞ்சியத்தை குளோனிங் செய்வது qiskit-terra எனப்படும் உள்ளூர் கோப்புறையை உருவாக்குகிறது.

   cd qiskit-terra
   

3. நீங்கள் சோதனைகள் அல்லது லின்டிங் காசோலைகளை இயக்க விரும்பினால், டெவலப்பர் தேவைகளை நிறுவவும்.

   pip install -r requirements-dev.txt
   

4. qiskit-terra ஐ நிறுவவும்.

   pip install .
   

நீங்கள் அதை எடிட் செய்யக்கூடிய பயன்முறையில் நிறுவ விரும்பினால், திட்டத்தில் குறியீடு மாற்றங்களுக்கு மீண்டும் நிறுவல் தேவையில்லை, நீங்கள் இதைச் செய்யலாம்:

pip install -e .

திருத்தக்கூடிய பயன்முறையில் நிறுவுவது, மேம்படுத்தல்கள் இல்லாமல் பிழைத்திருத்த பயன்முறையில் தொகுக்கப்பட்ட நீட்டிப்புகளை உருவாக்கும். இது தொகுக்கப்பட்ட குறியீட்டின் இயக்க நேரத்தை பாதிக்கும். நீங்கள் எடிட் செய்யக்கூடிய பயன்முறையைப் பயன்படுத்தவும், தொகுக்கப்பட்ட குறியீட்டை வெளியீட்டில் மேம்படுத்துதல்களை இயக்கவும் விரும்பினால், நீங்கள் இயக்கலாம்:

python setup.py build_rust --release --inplace

நீங்கள் பிப்பை இயக்கிய பிறகு, அது பைனரியை வெளியீட்டு பயன்முறையில் மீண்டும் உருவாக்குகிறது. நீங்கள் Qiskit இல் ரஸ்ட் குறியீட்டில் பணிபுரிந்தால், ஒவ்வொரு முறையும் நீங்கள் உள்ளூர் மாற்றத்தைச் செய்யும் போது நீட்டிப்புக் குறியீட்டை மீண்டும் உருவாக்க வேண்டும். pip install -e . Rust நீட்டிப்பு என்று அழைக்கப்படும் போது மட்டுமே அதை உருவாக்கும், எனவே pip ஐ இயக்கிய பிறகு Rust குறியீட்டில் நீங்கள் செய்யும் எந்த உள்ளூர் மாற்றங்களும் நீங்கள் நீட்டிப்பை மீண்டும் உருவாக்காத வரை நிறுவப்பட்ட தொகுப்பில் பிரதிபலிக்காது. இதைச் செய்ய, மேலே உள்ள build_rust கட்டளையை நீங்கள் பயன்படுத்தலாம் (நீங்கள் பிழைத்திருத்த பயன்முறையில் அல்லது வெளியீட்டு பயன்முறையில் உருவாக்க விரும்புகிறீர்களா என்பதைப் பொறுத்து --release உடன் அல்லது இல்லாமல்).

Terra-வை நிறுவியபின் குறியீடு உதாரணங்களை இயக்கலாம். பின்வரும் கட்டளையுடன் நீங்கள் உதாரணத்தை இயக்கலாம்.

python examples/python/using_qiskit_terra_level_0.py

Note

நீங்கள் வேறு எந்த கூறுகளையும் நிறுவ விரும்பவில்லை என்றால், qiskit-terra, qiskit-aer மற்றும் qiskit-ibmq-provider ஆகிய இரண்டும் நிறுவப்படவில்லை என்ற RuntimeWarning எச்சரிக்கையை வெளியிடும். பயனர்கள் பொதுவாக கூடுதல் கூறுகளைப் பயன்படுத்த விரும்புவதால் இது செய்யப்படுகிறது, ஆனால் அவை நிறுவப்படவில்லை என்பதை உணரவில்லை, அல்லது Aer அல்லது IBM Quantum வழங்குநரின் நிறுவல் சில காரணங்களால் தோல்வியடைந்தது. இந்த எச்சரிக்கைகளை நீங்கள் அடக்க விரும்பினால், இவற்றை சேர்க்கவும்:

import warnings
warnings.filterwarnings('ignore', category=RuntimeWarning,
                        module='qiskit')

உங்கள் குறியீட்டில் ஏதேனும் ``qiskit` இறக்குமதி செய்வதற்கு முன். இது விடுபட்ட qiskit-aer மற்றும் qiskit-ibmq-provider பற்றிய எச்சரிக்கையை அடக்கும், ஆனால் qiskit அல்லது பிற தொகுப்புகளிலிருந்து வேறு ஏதேனும் எச்சரிக்கைகளைத் தொடர்ந்து காண்பிக்கும்.

Installing Aer from Source

1. Aer களஞ்சியத்தை குளோன் செய்யவும்.

   git clone https://github.com/Qiskit/qiskit-aer
   

Aer ஐ நிறுவ நீங்கள் எந்த இயக்க முறைமையைப் பயன்படுத்துகிறீர்கள் என்பதைப் பொறுத்தது. ஏர் என்பது பைதான் இடைமுகத்துடன் தொகுக்கப்பட்ட சி++ நிரல் என்பதால், ஏர் பைனரியை உருவாக்குவதற்கு பைதான் அல்லாத சார்புகள் உள்ளன, அவை இயக்க முறைமையைப் பொறுத்து உலகளாவிய அளவில் நிறுவ முடியாது.

லினக்ஸ்

2. தொகுப்பி தேவைகளை நிறுவவும்.

   ஏரை உருவாக்குவதற்கு சி++ கம்பைலர் மற்றும் டெவலப்மெண்ட் ஹெடர்கள் தேவை.

   நீங்கள் Fedora அல்லது அதற்குச் சமமான Linux விநியோகத்தைப் பயன்படுத்தினால், இதைப் பயன்படுத்தி நிறுவவும்:

   dnf install @development-tools
   

   உபுண்டு/டெபியனுக்கு இதைப் பயன்படுத்தி நிறுவவும்:

   apt-get install build-essential
   

3. OpenBLAS மேம்பாட்டு தலைப்புகளை நிறுவவும்.

   நீங்கள் Fedora அல்லது அதற்குச் சமமான Linux விநியோகத்தைப் பயன்படுத்தினால், இதைப் பயன்படுத்தி நிறுவவும்:

   dnf install openblas-devel
   

   உபுண்டு/டெபியனுக்கு இதைப் பயன்படுத்தி நிறுவவும்:

   apt-get install libopenblas-dev
   

macOS

2. சார்புகளை நிறுவவும்.

   MacOS இல் Clang கம்பைலரைப் பயன்படுத்த, OpenMP ஐ ஆதரிக்கக் கூடுதல் நூலகத்தை நிறுவ வேண்டும். இதையும் பிற சார்புகளையும் நிறுவ ப்ரூ ஐப் பயன்படுத்தலாம்.

   brew install libomp
   

3. பின்னர் BLAS செயல்படுத்தலை நிறுவவும்; OpenBLAS என்பது இயல்புநிலை தேர்வாகும்.

   brew install openblas
   

   அடுத்து, Xcode Command Line Tools ஐ நிறுவவும்.

   xcode-select --install
   

Windows

2. மேலே நிறுவப்பட்ட விஷுவல் சி++ கம்பைலரின் ஒரு பகுதியாக அனைத்து சார்புகளும் சேர்க்கப்படுகின்றன, எனவே கூடுதல் அமைவு தேவையில்லை.

Qiskit Aer என்பது குவாண்டம் சர்க்யூட்களுக்கான உயர் செயல்திறன் சிமுலேட்டர் கட்டமைப்பாகும். வெவ்வேறு உருவகப்படுத்துதல் இலக்குகளை அடைய இது பல பின்தளங்களை வழங்குகிறது.

4. qiskit-aer ஐ நேரடியாக உருவாக்கி நிறுவவும்

   உங்களிடம் pip <19.0.0 நிறுவப்பட்டிருந்தால் மற்றும் உங்கள் சூழலுக்குத் தனிப்பயன் உருவாக்கம் தேவையில்லை என்றால், இயக்கவும்:

   cd qiskit-aer
   pip install .
   

   இது பைனரிகளை உருவாக்கி Aer-ரை நிறுவும்.

   மாற்றாக, உங்களிடம் ஒரு புதிய பைப் நிறுவப்பட்டிருந்தால் அல்லது சில தனிப்பயன் தேவைகள் இருந்தால், நீங்கள் கைமுறையாக பைதான் சக்கரத்தை உருவாக்கலாம்.

   cd qiskit-aer
   python ./setup.py bdist_wheel
   

   வீல் கட்டும்போது தனிப்பயன் விருப்பத்தை அமைக்க வேண்டும் என்றால், aer_wheel_build_options ஐப் பார்க்கவும்.

   நீங்கள் பைதான் சக்கரத்தை உருவாக்கிய பிறகு, அது ஏர் களஞ்சியத்தில் dist/ dir இல் சேமிக்கப்படும். சரியான பதிப்பு சார்ந்தது

   cd dist
   pip install qiskit_aer-*.whl
   

   வெளியீட்டு சக்கரக் கோப்பின் சரியான கோப்புப் பெயர், உருவாக்கத்தில் இருக்கும் Aer இன் தற்போதைய பதிப்பைப் பொறுத்தது.

Custom options

Aer பில்ட் சிஸ்டம், பைதான் இடைமுகத்துடன் அதை உருவாக்கும்போது தொகுப்பை இயக்க scikit-build ஐப் பயன்படுத்துகிறது. CMake ஐ அழைப்பதற்கும் உங்கள் உள்ளூர் அமைப்பிற்கான பைனரிகளைத் தொகுப்பதற்கும் இது setuptools இன் இடைமுகமாகச் செயல்படுகிறது.

பைனரிகளை தொகுப்பதில் உள்ள சிக்கலான தன்மை காரணமாக, நீங்கள் உருவாக்கச் செயல்முறையின் ஒரு குறிப்பிட்ட பகுதிக்கு விருப்பங்களை அனுப்ப வேண்டியிருக்கும். மாறிகளைக் கடந்து செல்லும் வழி:

python setup.py bdist_wheel [skbuild_opts] [-- [cmake_opts] [-- build_tool_opts]]

சதுர அடைப்புக்குறிக்குள் உள்ள உறுப்புகள் [] விருப்பத்திற்குரியவை, மேலும் skbuild_opts, cmake_opts, ``build_tool_opts` ஆகியவை உங்கள் விருப்பப்படி கொடிகளால் மாற்றப்பட வேண்டும். CMake விருப்பங்களின் பட்டியல் இங்கே கிடைக்கிறது: https://cmake.org/cmake/help/v3.6/manual/cmake.1.html#options. உதாரணமாக, நீங்கள் இதைப் போன்ற ஒன்றை இயக்கலாம்:

python setup.py bdist_wheel -- -- -j8

இது -j8 என்ற கொடியை அடிப்படை உருவாக்க அமைப்புக்கு அனுப்புகிறது (இந்த விஷயத்தில் ஆட்டோமேக்), நீங்கள் உருவாக்க விரும்புகிறீர்கள் என்று கூறுகிறது. 8 செயல்முறைகளைப் பயன்படுத்தி இணையாக.

எடுத்துக்காட்டாக, Linux-ஸில் இந்தக் கொடிகளுக்கான பொதுவான பயன்பாடு C++ கம்பைலரின் குறிப்பிட்ட பதிப்பைக் குறிப்பிடுவது (பொதுவாக இயல்புநிலை மிகவும் பழையதாக இருந்தால்):

python setup.py bdist_wheel -- -DCMAKE_CXX_COMPILER=g++-7

இது Aer ஐ தொகுக்கும்போது இயல்புநிலை g++ க்குப் பதிலாக g++-7 கட்டளையைப் பயன்படுத்த CMake ஐச் சொல்லும்.

இதற்கான மற்றொரு பொதுவான பயன்பாடு, உங்கள் சூழலைப் பொறுத்து, உங்கள் இயங்குதளப் பெயரைக் குறிப்பிட்டு நிலையான இணைப்பை முடக்க வேண்டியிருக்கும்.

python setup.py bdist_wheel --plat-name macosx-10.9-x86_64 \
-- -DSTATIC_LINKING=False -- -j8

இங்கே --plat-name செட்டப்டூல்களுக்கான கொடி, தொகுப்பு மெட்டாடேட்டாவில் பயன்படுத்துவதற்கான பிளாட்ஃபார்ம் பெயரைக் குறிப்பிடவும், ``-DSTATIC_LINKING` என்பது CMakeஐப் பயன்படுத்தி நிலையான இணைப்பு முடக்குவதற்கான கொடி மற்றும் ``-j8 `` என்பது தொகுக்க 8 செயல்முறைகளைப் பயன்படுத்த ஆட்டோமேக்கைப் பயன்படுத்துவதற்கான கொடியாகும்.

தளத்தைப் பொறுத்து பொதுவான விருப்பங்களின் பட்டியல்:

பணித்தளம்	கருவி	விருப்பம்	யூஸ் கேஸ்
அனைத்தும்	தானாகவே	-j	ஒரு எண்ணைத் தொடர்ந்து, தொகுக்கப் பயன்படுத்த வேண்டிய செயல்முறைகளின் எண்ணிக்கையை அமைக்கிறது.
லினக்ஸ்	CMake	-DCMAKE_CXX_COMPILER	ஒரு குறிப்பிட்ட C++ கம்பைலரைக் குறிப்பிடப் பயன்படுகிறது; உங்கள் இயல்புநிலை g++ மிகவும் பழையதாக இருந்தால் இது அடிக்கடி தேவைப்படும்.
OSX	அமைப்புகருவிகள்	-- plat-name	வெளியீட்டு Python தொகுப்பில் இயங்குதளப் பெயரைக் குறிப்பிடப் பயன்படுகிறது.
OSX	CMake	-DSTATIC_LINKING	Static linking பயன்படுத்தப்பட வேண்டுமா இல்லையா என்பதைக் குறிப்பிடப் பயன்படுகிறது.

Note

இந்த விருப்பங்களில் சில இயங்குதளம் சார்ந்தவை அல்ல. இந்தக் குறிப்பிட்ட தளங்கள் பட்டியலிடப்பட்டுள்ளன, ஏனெனில் அவை பொதுவாகச் சூழலில் பயன்படுத்தப்படுகின்றன. மேலும் தகவலுக்குக் கருவி ஆவணங்களைப் பார்க்கவும்.

Installing IBM Quantum Provider from Source

1. qiskit-ibmq-provider களஞ்சியத்தை குளோன் செய்யவும்.

   git clone https://github.com/Qiskit/qiskit-ibmq-provider.git
   

2. களஞ்சியத்தை குளோனிங் செய்வது qiskit-ibmq-provider எனப்படும் இடஞ்சார்ந்த கோப்பகத்தை உருவாக்குகிறது.

   cd qiskit-ibmq-provider
   

3. நீங்கள் சோதனைகள் அல்லது லின்டிங் காசோலைகளை இயக்க விரும்பினால், டெவலப்பர் தேவைகளை நிறுவவும். மூலத்திலிருந்து நிறுவும்போது qiskit-ibmq-provider தொகுப்பை நிறுவ அல்லது பயன்படுத்த இது தேவையில்லை.

   pip install -r requirements-dev.txt
   

4. qiskit-ibmq-provider ஐ நிறுவவும்.

   pip install .
   

நீங்கள் அதைத் தொகுத்து செய்யக்கூடிய பயன்முறையில் நிறுவ விரும்பினால், திட்டத்தில் குறியீடு மாற்றங்களுக்கு மீண்டும் நிறுவல் தேவையில்லை:

pip install -e .

இயங்குதள ஆதரவு

Qiskit முடிந்தவரை பல இயங்குதளங்களை ஆதரிக்க முயற்சிக்கிறது, ஆனால் கிடைக்கக்கூடிய சோதனை ஆதாரங்கள் மற்றும் இயங்குதளம் கிடைப்பதில் உள்ள வரம்புகள் காரணமாக, எல்லா இயங்குதளங்களையும் ஆதரிக்க முடியாது. Qiskit-க்கான இயங்குதள ஆதரவு ஒவ்வொரு அடுக்குக்கும் வெவ்வேறு நிலைகளில் ஆதரவுடன் 3 அடுக்குகளாக பிரிக்கப்பட்டுள்ளது. இவற்றுக்கு வெளியே உள்ள இயங்குதளங்களுக்கு, Qiskit இன்னும் நிறுவக்கூடியதாக இருக்கலாம், ஆனால் அது சோதிக்கப்படவில்லை மேலும் நீங்கள் Qiskit (மற்றும் Qiskit-இன் சார்புகளை) மூலத்திலிருந்து உருவாக்க வேண்டும்.

கூடுதலாக, Qiskit CPython ஐ மட்டுமே ஆதரிக்கிறது. பிற Python மொழிபெயர்ப்பாளர்களுடன் இயங்குவது தற்போது ஆதரிக்கப்படவில்லை.

அடுக்கு 1

எந்த முன்மொழியப்பட்ட மாற்றமும் சரியாகச் செயல்படுவதை உறுதிசெய்ய, டெவலப்மெண்ட் செயல்முறைகளின் ஒரு பகுதியாக, அடுக்கு 1 ஆதரிக்கப்படும் இயங்குதளங்கள் முழுவதுமாக அப்ஸ்ட்ரீமில் சோதிக்கப்படுகின்றன. முன்-தொகுக்கப்பட்ட பைனரிகள் கட்டமைக்கப்பட்டு, சோதனை செய்யப்பட்டு, வெளியீட்டுச் செயல்பாட்டின் ஒரு பகுதியாக PyPI இல் வெளியிடப்படுகின்றன. இந்த இயங்குதளங்களில் அனைத்து சார்புகளும் இருப்பதால், செயல்பாட்டில் உள்ள Python சுற்றுசூழலுடன் இந்த இயங்குதளங்கள் நிறுவப்படும் என எதிர்பார்க்கப்படுகிறது.

தற்போது உள்ள அடுக்கு 1 இயங்குதளங்கள்:

• Linux x86_64 (manylinux 2010 பேக்கேஜிங் விவரக்குறிப்புடன் இணக்கமான விநியோகங்கள்).

• macOS x86_64 (10.9 அல்லது புதியது)

• Windows 64 bit

அடுக்கு 2

அடுக்கு 2 இயங்குதளங்கள் மேம்பாட்டின் ஒரு பகுதியாக அப்ஸ்ட்ரீமில் சோதனை செய்யப்படவில்லை. இருப்பினும், முன்-தொகுக்கப்பட்ட பைனரிகள் கட்டமைக்கப்பட்டு, சோதனை செய்யப்பட்டு, வெளியீட்டு செயல்முறையின் ஒரு பகுதியாக PyPI இல் வெளியிடப்படுகின்றன, மேலும் இந்த தொகுப்புகள் செயல்பாட்டில் உள்ள Python சுற்றுசூழலுடன் நிறுவப்படும் என்று எதிர்பார்க்கலாம்.

தற்போது உள்ள அடுக்கு 2 இயங்குதளங்கள்:

• Linux i686 (manylinux 2014 பேக்கேஜிங் விவரக்குறிப்புடன் இணக்கமான விநியோகங்கள்) for Python >= 3.10

• Windows 32 bit for Python < 3.10

• Linux aarch64 (manylinux 2014 பேக்கேஜிங் விவரக்குறிப்புடன் இணக்கமான விநியோகங்கள்)

அடுக்கு 3

டெவலப்மென்ட் செயல்பாட்டின் ஒரு பகுதியாக அடுக்கு 3 இயங்குதளங்கள் அப்ஸ்ட்ரீமில் சோதிக்கப்படவில்லை. முன்-தொகுக்கப்பட்ட பைனரிகள் எந்த சோதனையும் இல்லாமல், வெளியீட்டு செயல்முறையின் ஒரு பகுதியாக PyPI இல் கட்டமைக்கப்பட்டு வெளியிடப்படுகின்றன. அவை செயல்பாட்டில் உள்ள Python சுற்றுசூழலில் மட்டுமே நிறுவப்பட முடியாமல் இருக்கலாம் மற்றும் நிறுவல் செயல்முறையின் ஒரு பகுதியாக மூலத்திலிருந்து சார்புகளை உருவாக்குவதற்கு C/C++ கம்பைலர் அல்லது கூடுதல் நிரல்கள் தேவைப்படலாம். இந்த இயங்குதளங்களுக்கான ஆதரவு சிறந்த முயற்சி மட்டுமே.

தற்போது உள்ள அடுக்கு 3 இயங்குதளங்கள்:

• Linux ppc64le (manylinux 2014 பேக்கேஜிங் விவரக்குறிப்புக்கு இணக்கமான விநியோகங்கள்)

• Linux s390x (manylinux 2014 பேக்கேஜிங் விவரக்குறிப்புக்கு இணக்கமான விநியோகங்கள்)

• macOS arm64 (10.15 அல்லது புதியது)

• Linux i686 (manylinux 2014 பேக்கேஜிங் விவரக்குறிப்புடன் இணக்கமான விநியோகங்கள்) for Python >= 3.10

• Windows 32bit for Python >= 3.10

செல்ல தயாரா?...

Qiskit from the ground up

Learn how to build, execute, and post-process quantum circuits with Qiskit.

Start learning Qiskit

Dive into the tutorials

Find out how to leverage Qiskit for everything from single-circuits to full quantum application development.

Qiskit tutorials