தொடங்குதல்¶

நிறுவல்¶

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

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

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

You will need to download Python on your local system to get started. Jupyter is recommended for interacting with Qiskit.

We recommend using Python virtual environments to cleanly separate Qiskit from other applications and improve your experience.

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

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

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

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

Note: if you are using Windows, use the following commands in PowerShell.

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

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

pip install qiskit

If the packages were installed correctly, you can run pip list to see the active packages in your virtual environment.

நீங்கள் 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 பதிப்பு இருந்தால், விரும்பியதை விடக் குறைவாக இருக்கும் உறுப்புகளின் பதிப்புகளை நிறுவுவதைத் தடுக்க, மூலத்திலிருந்து உறுப்புகளை நிறுவுவதற்கு பின்வரும் நிறுவல் வரிசை தேவைப்படுகிறது:

qiskit-terra
qiskit-aer
: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

Installing from source requires that you have the Rust compiler on your system. To install the Rust compiler the recommended path is to use rustup, which is a cross-platform Rust installer. To use rustup you can go to:

https://rustup.rs/

which will provide instructions for how to install rust on your platform. Besides rustup there are other installation methods available too.

Once the Rust compiler is installed, you are ready to install Qiskit Terra.

Terra களஞ்சியத்தை குளோன் செய்யவும்.
```
git clone https://github.com/Qiskit/qiskit-terra.git
```
களஞ்சியத்தை குளோனிங் செய்வது qiskit-terra எனப்படும் உள்ளூர் கோப்புறையை உருவாக்குகிறது.
```
cd qiskit-terra
```
நீங்கள் சோதனைகள் அல்லது லின்டிங் காசோலைகளை இயக்க விரும்பினால், டெவலப்பர் தேவைகளை நிறுவவும்.
```
pip install -r requirements-dev.txt
```
qiskit-terra ஐ நிறுவவும்.
```
pip install .
```

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

pip install -e .

Installing in editable mode will build the compiled extensions in debug mode without optimizations. This will affect the runtime performance of the compiled code. If you'd like to use editable mode and build the compiled code in release with optimizations enabled you can run:

python setup.py build_rust --release --inplace

after you run pip and that will rebuild the binary in release mode. If you are working on Rust code in Qiskit you will need to rebuild the extension code every time you make a local change. pip install -e . will only build the Rust extension when it's called, so any local changes you make to the Rust code after running pip will not be reflected in the installed package unless you rebuild the extension. You can leverage the above build_rust command to do this (with or without --release based on whether you want to build in debug mode or release mode).

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

Aer களஞ்சியத்தை குளோன் செய்யவும்.
```
git clone https://github.com/Qiskit/qiskit-aer
```

To install Aer depend on which operating system you are using. Since Aer is a compiled C++ program with a Python interface, there are non-Python dependencies for building the Aer binary which can't be installed universally depending on operating system.

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

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

qiskit-ibmq-provider களஞ்சியத்தை குளோன் செய்யவும்.
```
git clone https://github.com/Qiskit/qiskit-ibmq-provider.git
```
களஞ்சியத்தை குளோனிங் செய்வது qiskit-ibmq-provider எனப்படும் இடஞ்சார்ந்த கோப்பகத்தை உருவாக்குகிறது.
```
cd qiskit-ibmq-provider
```
நீங்கள் சோதனைகள் அல்லது லின்டிங் காசோலைகளை இயக்க விரும்பினால், டெவலப்பர் தேவைகளை நிறுவவும். மூலத்திலிருந்து நிறுவும்போது qiskit-ibmq-provider தொகுப்பை நிறுவ அல்லது பயன்படுத்த இது தேவையில்லை.
```
pip install -r requirements-dev.txt
```
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