టెన్సర్ ఫ్లో బేసిక్స్: టెన్సర్, షేప్, టైప్, సెషన్స్ & ఆపరేటర్లు

టెన్సర్ అంటే ఏమిటి?

టెన్సర్‌ఫ్లో పేరు నేరుగా దాని ప్రధాన ఫ్రేమ్‌వర్క్ నుండి తీసుకోబడింది: టెన్సర్. టెన్సర్‌ఫ్లో, అన్ని గణనలలో టెన్సర్‌లు ఉంటాయి. టెన్సర్ అనేది అన్ని రకాల డేటాను సూచించే n- డైమెన్షన్‌ల వెక్టర్ లేదా మాతృక. టెన్సర్‌లోని అన్ని విలువలు తెలిసిన (లేదా పాక్షికంగా తెలిసిన) ఆకారంతో ఒకే రకమైన డేటా రకాన్ని కలిగి ఉంటాయి. డేటా ఆకృతి మాతృక లేదా శ్రేణి యొక్క డైమెన్షియాలిటీ.

ఒక టెన్సర్ ఇన్‌పుట్ డేటా లేదా గణన ఫలితం నుండి ఉద్భవించవచ్చు. టెన్సర్‌ఫ్లో, అన్ని కార్యకలాపాలు గ్రాఫ్ లోపల నిర్వహించబడతాయి. గ్రాఫ్ అనేది వరుసగా జరిగే గణన సమితి. ప్రతి ఆపరేషన్‌ను ఓప్ నోడ్ అంటారు మరియు ఒకదానితో ఒకటి కనెక్ట్ చేయబడతాయి.

గ్రాఫ్ నోడ్స్ మధ్య ఆప్స్ మరియు కనెక్షన్‌లను వివరిస్తుంది. అయితే, అది విలువలను ప్రదర్శించదు. నోడ్‌ల అంచు టెన్సర్, అనగా, డేటాతో ఆపరేషన్‌ని జనసాంద్రత చేయడానికి ఒక మార్గం.

మెషిన్ లెర్నింగ్‌లో, ఫీచర్ వెక్టర్స్ అని పిలువబడే వస్తువుల జాబితాతో నమూనాలు ఫీడ్ చేయబడతాయి. ఫీచర్ వెక్టర్ ఏదైనా డేటా రకం కావచ్చు. ఫీచర్ వెక్టర్ సాధారణంగా టెన్సర్‌ను జనసాంద్రత చేయడానికి ప్రాథమిక ఇన్‌పుట్‌గా ఉంటుంది. ఈ విలువలు టెన్సర్ ద్వారా ఒక op నోడ్‌లోకి ప్రవహిస్తాయి మరియు ఈ ఆపరేషన్/గణన ఫలితం కొత్త టెన్సర్‌ని సృష్టిస్తుంది, ఇది కొత్త ఆపరేషన్‌లో ఉపయోగించబడుతుంది. ఈ కార్యకలాపాలన్నీ గ్రాఫ్‌లో చూడవచ్చు.

ఈ ట్యుటోరియల్‌లో, మీరు TensorFlow ప్రాథమికాలను నేర్చుకుంటారు-

టెన్సర్ యొక్క ప్రాతినిధ్యం

టెన్సర్‌ఫ్లో, టెన్సర్ అనేది ఎన్-డైమెన్షన్‌ల ఫీచర్ వెక్టర్స్ (అనగా శ్రేణి) యొక్క సమాహారం. ఉదాహరణకు, మనకు 1 నుండి 6 వరకు విలువలు కలిగిన 2x3 మాతృక ఉంటే, మేము వ్రాస్తాము:

టెన్సర్ యొక్క ప్రాతినిధ్యం

TensorFlow ఈ మాతృకను సూచిస్తుంది: | _+_ |

మేము 1 నుండి 8 వరకు విలువలతో త్రిమితీయ మాతృకను సృష్టిస్తే, మనకు ఇవి ఉంటాయి:

TensorFlow ఈ మాతృకను సూచిస్తుంది: | _+_ |

గమనిక: టెన్సర్‌ను స్కేలార్‌తో సూచించవచ్చు లేదా మూడు కోణాల కంటే ఎక్కువ ఆకారాన్ని కలిగి ఉండవచ్చు. అధిక పరిమాణ స్థాయిని దృశ్యమానం చేయడం మరింత క్లిష్టంగా ఉంటుంది.

టెన్సర్ రకాలు

టెన్సర్‌ఫ్లో, అన్ని గణనలు ఒకటి లేదా అంతకంటే ఎక్కువ టెన్సర్‌ల గుండా వెళతాయి. Tf.tensor అనేది మూడు లక్షణాలతో కూడిన వస్తువు:

  • ప్రత్యేకమైన లేబుల్ (పేరు)
  • పరిమాణం (ఆకారం)
  • డేటా రకం (dtype)

టెన్సర్‌ఫ్లోతో మీరు చేసే ప్రతి ఆపరేషన్‌లో టెన్సర్ యొక్క తారుమారు ఉంటుంది. మీరు సృష్టించగల నాలుగు ప్రధాన టెన్సర్ రకాలు ఉన్నాయి:

  • tf. వేరియబుల్
  • tf. కాన్స్టాంట్
  • tf.placeholder
  • tf.SparseTensor

ఈ ట్యుటోరియల్‌లో, మీరు tf.constant మరియు tf. వేరియబుల్ ఎలా సృష్టించాలో నేర్చుకుంటారు.

మేము ట్యుటోరియల్‌కి వెళ్లే ముందు, మీరు టెన్సర్‌ఫ్లోతో కాండా వాతావరణాన్ని సక్రియం చేశారని నిర్ధారించుకోండి. మేము ఈ పర్యావరణానికి హలో-టిఎఫ్ అని పేరు పెట్టాము.

MacOS వినియోగదారు కోసం:

[[1, 2, 3], [4, 5, 6]] 

విండోస్ యూజర్ కోసం:

[ [[1, 2], [[3, 4], [[5, 6], [[7,8] ] 

మీరు దాన్ని పూర్తి చేసిన తర్వాత, మీరు టెన్సర్‌ఫ్లోను దిగుమతి చేయడానికి సిద్ధంగా ఉన్నారు | _+_ |

N- డైమెన్షన్ యొక్క టెన్సర్‌ని సృష్టించండి

మీరు ఒక పరిమాణంతో ఒక టెన్సర్‌ని సృష్టించడం ద్వారా ప్రారంభించండి, అవి స్కేలార్.

ఒక టెన్సర్‌ని సృష్టించడానికి, మీరు క్రింద ఉన్న TensorFlow టెన్సర్ ఆకార ఉదాహరణలో చూపిన విధంగా tf.constant () ని ఉపయోగించవచ్చు: | _+_ |

పరిమాణం 0 యొక్క టెన్సర్‌ను సృష్టించడానికి, కింది కోడ్‌ని అమలు చేయండి | _+_ |

అవుట్‌పుట్

source activate hello-tf 

activate hello-tf 

అవుట్‌పుట్

 # Import tf import tensorflow as tf 

ప్రతి టెన్సర్ టెన్సర్ పేరుతో ప్రదర్శించబడుతుంది. ప్రతి టెన్సర్ వస్తువు ప్రత్యేకమైన లేబుల్ (పేరు), డైమెన్షన్ (ఆకారం) మరియు టెన్సర్‌ఫ్లో డేటా రకాలు (dtype) వంటి టెన్సర్ లక్షణాలతో నిర్వచించబడింది.

డేటా రకాన్ని మార్చడం ద్వారా మీరు టెన్సర్‌ని దశాంశ విలువలతో లేదా స్ట్రింగ్‌తో నిర్వచించవచ్చు. | _+_ |

అవుట్‌పుట్

tf.constant(value, dtype, name = '') arguments - `value`: Value of n dimension to define the tensor. Optional - `dtype`: Define the type of data: - `tf.string`: String variable - `tf.float32`: Float variable - `tf.int16`: Integer variable - 'name': Name of the tensor. Optional. By default, `Const_1:0` 

డైమెన్షన్ 1 యొక్క టెన్సర్‌ను ఈ క్రింది విధంగా సృష్టించవచ్చు: | _+_ |

అవుట్‌పుట్

## rank 0 # Default name r1 = tf.constant(1, tf.int16) print(r1) 

TensorFlow ఆకారం కేవలం 1 కాలమ్‌తో కూడి ఉందని మీరు గమనించవచ్చు.

2 టెన్సర్ పరిమాణాల శ్రేణిని సృష్టించడానికి, ప్రతి అడ్డు వరుస తర్వాత మీరు బ్రాకెట్‌లను మూసివేయాలి. దిగువ కేరాస్ టెన్సర్ ఆకార ఉదాహరణను చూడండి | _+_ |

అవుట్‌పుట్

Tensor('Const:0', shape=(), dtype=int16) 

మాతృకలో 1, 2, 3, 4 విలువలతో నిండిన 2 వరుసలు మరియు 2 నిలువు వరుసలు ఉన్నాయి.

బ్రాకెట్‌లతో మరొక స్థాయిని జోడించడం ద్వారా 3 కొలతలు కలిగిన మాతృక నిర్మించబడింది. | _+_ |

అవుట్‌పుట్

 # Named my_scalar r2 = tf.constant(1, tf.int16, name = 'my_scalar') print(r2) 

మ్యాట్రిక్స్ చిత్రం రెండు కనిపిస్తుంది.

టెన్సర్ ఆకారం

మీరు టెన్సర్‌ను ముద్రించినప్పుడు, టెన్సర్‌ఫ్లో ఆకారాన్ని అంచనా వేస్తుంది. అయితే, మీరు టెన్సర్‌ఫ్లో ఆకార ఆస్తితో టెన్సర్ ఆకారాన్ని పొందవచ్చు.

క్రింద, మీరు 10 నుండి 15 వరకు సంఖ్యతో నిండిన మాతృకను నిర్మించారు మరియు మీరు m_shape | _+_ | ఆకారాన్ని తనిఖీ చేస్తారు.

అవుట్‌పుట్

Tensor('my_scalar:0', shape=(), dtype=int16) 

మాతృకలో 3 వరుసలు మరియు 2 నిలువు వరుసలు ఉన్నాయి.

టెన్సర్‌ఫ్లో 0 లేదా 1 నిండిన వెక్టర్ లేదా మాతృకను సృష్టించడానికి ఉపయోగకరమైన ఆదేశాలను కలిగి ఉంది, ఉదాహరణకు, మీరు 1 యొక్క నిర్దిష్ట ఆకారంతో 1-D టెన్సర్‌ను సృష్టించాలనుకుంటే, 0 తో నిండి, మీరు దిగువ కోడ్‌ని అమలు చేయవచ్చు: | _ +_ |

అవుట్‌పుట్

 # Decimal r1_decimal = tf.constant(1.12345, tf.float32) print(r1_decimal) # String r1_string = tf.constant('Guru99', tf.string) print(r1_string) 

ఆస్తి మాతృక కోసం కూడా పనిచేస్తుంది. ఇక్కడ, మీరు 1 | _+_ | తో నిండిన 10x10 మాతృకను సృష్టిస్తారు

అవుట్‌పుట్

Tensor('Const_1:0', shape=(), dtype=float32) Tensor('Const_2:0', shape=(), dtype=string) 

వెక్టర్‌ని తయారు చేయడానికి మీరు ఇచ్చిన మాతృక ఆకారాన్ని ఉపయోగించవచ్చు. మాతృక m_ ఆకారం 3x2 కొలతలు. మీరు క్రింది కోడ్‌తో నిండిన 3 వరుసలతో ఒక టెన్సర్‌ను సృష్టించవచ్చు: | _+_ |

అవుట్‌పుట్

## Rank 1r1_vector = tf.constant([1,3,5], tf.int16) print(r1_vector) r2_boolean = tf.constant([True, True, False], tf.bool) print(r2_boolean) 

మీరు విలువ 1 ను బ్రాకెట్‌లోకి పాస్ చేస్తే, మీరు మాతృక m_shape లోని నిలువు వరుసల సంఖ్యకు సమానమైన వాటి యొక్క వెక్టర్‌ను నిర్మించవచ్చు. | _+_ |

అవుట్‌పుట్

Tensor('Const_3:0', shape=(3,), dtype=int16) Tensor('Const_4:0', shape=(3,), dtype=bool) 

చివరగా, మీరు మాత్రిక 3x2 ను ఒకదానితో మాత్రమే సృష్టించవచ్చు | _+_ |

అవుట్‌పుట్

## Rank 2 r2_matrix = tf.constant([ [1, 2], [3, 4] ],tf.int16) print(r2_matrix) 

డేటా రకం

టెన్సర్ యొక్క రెండవ ఆస్తి డేటా రకం. ఒక టెన్సర్ ఒక సమయంలో ఒక రకమైన డేటాను మాత్రమే కలిగి ఉంటుంది. ఒక టెన్సర్ ఒక రకమైన డేటాను మాత్రమే కలిగి ఉంటుంది. మీరు ఆస్తి dtype తో రకాన్ని తిరిగి ఇవ్వవచ్చు. | _+_ |

అవుట్‌పుట్

Tensor('Const_5:0', shape=(2, 2), dtype=int16) 

కొన్ని సందర్భాల్లో, మీరు డేటా రకాన్ని మార్చాలనుకుంటున్నారు. TensorFlow లో, tf.cast పద్ధతిలో ఇది సాధ్యమవుతుంది.

ఉదాహరణ

క్రింద, మీరు పద్ధతి తారాగణాన్ని ఉపయోగించి ఫ్లోట్ టెన్సర్ పూర్ణాంకానికి మార్చబడుతుంది. | _+_ |

అవుట్‌పుట్

## Rank 3 r3_matrix = tf.constant([ [[1, 2], [3, 4], [5, 6]] ], tf.int16) print(r3_matrix) 

టెన్సర్ సృష్టి సమయంలో వాదన పేర్కొనబడనప్పుడు TensorFlow డేటా రకాన్ని స్వయంచాలకంగా ఎంచుకుంటుంది. TensorFlow డేటా యొక్క అత్యంత సాధ్యమయ్యే రకాలు ఏమిటో అంచనా వేస్తుంది. ఉదాహరణకు, మీరు ఒక టెక్స్ట్ పాస్ చేస్తే, అది స్ట్రింగ్ అని ఊహించి స్ట్రింగ్‌గా మార్చేస్తుంది.

ఆపరేటర్‌ను సృష్టిస్తోంది

కొన్ని ఉపయోగకరమైన TensorFlow ఆపరేటర్లు

టెన్సర్‌ఫ్లోతో టెన్సర్‌ని ఎలా సృష్టించాలో మీకు తెలుసు. గణిత కార్యకలాపాలను ఎలా నిర్వహించాలో తెలుసుకోవడానికి ఇది సమయం.

TensorFlow అన్ని ప్రాథమిక కార్యకలాపాలను కలిగి ఉంది. మీరు సరళమైన వాటితో ప్రారంభించవచ్చు. మీరు సంఖ్య యొక్క చతురస్రాన్ని లెక్కించడానికి TensorFlow పద్ధతిని ఉపయోగిస్తారు. ఈ ఆపరేషన్ సూటిగా ఉంటుంది ఎందుకంటే టెన్సర్‌ను నిర్మించడానికి ఒకే ఒక్క వాదన అవసరం.

ఒక సంఖ్య యొక్క చతురస్రం tf.sqrt (x) తో x ఒక ఫ్లోటింగ్ సంఖ్యగా నిర్మించబడింది. | _+_ |

అవుట్‌పుట్

Tensor('Const_6:0', shape=(1, 3, 2), dtype=int16) 

గమనిక: అవుట్‌పుట్ ఒక టెన్సర్ ఆబ్జెక్ట్‌ను అందించింది మరియు స్క్వేర్ 2. యొక్క ఫలితం కాదు. ఉదాహరణలో, మీరు టెన్సర్ యొక్క నిర్వచనాన్ని ప్రింట్ చేస్తారు మరియు ఆపరేషన్ యొక్క వాస్తవ మూల్యాంకనం కాదు. తదుపరి విభాగంలో, టెన్సర్‌ఫ్లో కార్యకలాపాలను అమలు చేయడానికి ఎలా పని చేస్తుందో మీరు నేర్చుకుంటారు.

కిందివి సాధారణంగా ఉపయోగించే కార్యకలాపాల జాబితా. ఆలోచన ఒకటే. ప్రతి ఆపరేషన్‌కు ఒకటి లేదా అంతకంటే ఎక్కువ వాదనలు అవసరం.

  • tf.add (a, b)
  • tf. సబ్‌స్ట్రాక్ట్ (a, b)
  • tf.multiply (a, b)
  • tf.div (a, b)
  • tf.pow (a, b)
  • tf.exp (a)
  • tf.sqrt (a)

ఉదాహరణ

# Shape of tensor m_shape = tf.constant([ [10, 11], [12, 13], [14, 15] ] ) m_shape.shape 

అవుట్‌పుట్

TensorShape([Dimension(3), Dimension(2)]) 

కోడ్ వివరణ

రెండు టెన్సర్‌లను సృష్టించండి:

  • 1 మరియు 2 తో ఒక టెన్సర్
  • 3 మరియు 4 తో ఒక టెన్సర్

మీరు రెండు టెన్సర్‌లను జోడించండి.

నోటీసు : రెండు టెన్సర్‌లు ఒకే ఆకారాన్ని కలిగి ఉండాలి. మీరు రెండు టెన్సర్‌లపై గుణకారం అమలు చేయవచ్చు. | _+_ |

అవుట్‌పుట్

# Create a vector of 0 print(tf.zeros(10)) 

వేరియబుల్స్

ఇప్పటివరకు, మీరు స్థిరమైన టెన్సర్‌లను మాత్రమే సృష్టించారు. ఇది పెద్దగా ఉపయోగం లేదు. డేటా ఎల్లప్పుడూ విభిన్న విలువలతో వస్తుంది, దీనిని సంగ్రహించడానికి, మీరు వేరియబుల్ క్లాస్‌ని ఉపయోగించవచ్చు. ఇది విలువలు ఎల్లప్పుడూ మారే నోడ్‌ని సూచిస్తుంది.

వేరియబుల్ సృష్టించడానికి, మీరు tf.get_ variable () పద్ధతిని ఉపయోగించవచ్చు | _+_ |

ఉదాహరణకు, దిగువ కోడ్ రెండు యాదృచ్ఛిక విలువలతో రెండు డైమెన్షనల్ వేరియబుల్‌ను సృష్టిస్తుంది. డిఫాల్ట్‌గా, TensorFlow యాదృచ్ఛిక విలువను అందిస్తుంది. మీరు వేరియబుల్ var | _+_ | అని పేరు పెట్టండి

అవుట్‌పుట్

Tensor('zeros:0', shape=(10,), dtype=float32) 

రెండవ ఉదాహరణలో, మీరు ఒక వరుస మరియు రెండు నిలువు వరుసలతో వేరియబుల్‌ని సృష్టిస్తారు. వేరియబుల్ యొక్క పరిమాణాన్ని సృష్టించడానికి మీరు [1,2] ను ఉపయోగించాలి

ఈ టెన్సర్ యొక్క ప్రారంభ విలువలు సున్నా. ఉదాహరణకు, మీరు ఒక మోడల్‌కి శిక్షణ ఇచ్చినప్పుడు, ఫీచర్‌ల బరువును లెక్కించడానికి మీరు ప్రాథమిక విలువలను కలిగి ఉండాలి. క్రింద, మీరు ఈ ప్రారంభ విలువను సున్నాకి సెట్ చేసారు. | _+_ |

అవుట్‌పుట్

# Create a vector of 1 print(tf.ones([10, 10])) 

మీరు స్థిరమైన టెన్సర్ విలువలను వేరియబుల్‌లో పాస్ చేయవచ్చు. మీరు tf.constant () పద్ధతితో స్థిరమైన టెన్సర్‌ని సృష్టించండి. వేరియబుల్‌ను ప్రారంభించడానికి మీరు ఈ టెన్సర్‌ని ఉపయోగించండి.

వేరియబుల్ యొక్క మొదటి విలువలు 10, 20, 30 మరియు 40. కొత్త టెన్సర్ 2x2 ఆకారాన్ని కలిగి ఉంటుంది. | _+_ |

అవుట్‌పుట్

Tensor('ones:0', shape=(10, 10), dtype=float32) 

ప్లేస్‌హోల్డర్

ఒక ప్లేస్‌హోల్డర్‌కు టెన్సర్‌కు ఆహారం అందించే ఉద్దేశ్యం ఉంది. టెన్సర్‌ల లోపల డేటాను ప్రారంభించడానికి ప్లేస్‌హోల్డర్ ఉపయోగించబడుతుంది. ప్లేస్‌హోల్డర్‌ని సరఫరా చేయడానికి, మీరు ఫీడ్_డిక్ట్ పద్ధతిని ఉపయోగించాలి. సెషన్‌లో మాత్రమే ప్లేస్‌హోల్డర్‌కు ఆహారం అందించబడుతుంది.

తదుపరి ఉదాహరణలో, tf.placeholder పద్ధతితో ప్లేస్‌హోల్డర్‌ని ఎలా సృష్టించాలో మీరు చూస్తారు. తదుపరి సెషన్‌లో, మీరు అసలు టెన్సర్ విలువతో ఒక ప్లేస్‌హోల్డర్‌ని పోషించడం నేర్చుకుంటారు.

వాక్యనిర్మాణం: | _+_ |

అవుట్‌పుట్

# Create a vector of ones with the same number of rows as m_shape print(tf.ones(m_shape.shape[0])) 

సెషన్

TensorFlow 3 ప్రధాన భాగాల చుట్టూ పనిచేస్తుంది:

  • గ్రాఫ్
  • టెన్సర్
  • సెషన్
భాగాలువివరణ

గ్రాఫ్

టెన్సర్‌ఫ్లో గ్రాఫ్ ప్రాథమికమైనది. అన్ని గణిత కార్యకలాపాలు (ops) గ్రాఫ్ లోపల నిర్వహించబడతాయి. ప్రతి ఆపరేషన్ పూర్తయ్యే ప్రాజెక్ట్‌గా మీరు గ్రాఫ్‌ను ఊహించవచ్చు. నోడ్స్ ఈ ఆప్‌లను సూచిస్తాయి, అవి కొత్త టెన్సర్‌లను గ్రహించగలవు లేదా సృష్టించగలవు.

టెన్సర్

ఒక టెన్సర్ కార్యకలాపాల మధ్య పురోగమిస్తున్న డేటాను సూచిస్తుంది. టెన్సర్‌ని ఎలా ప్రారంభించాలో మీరు ఇంతకు ముందు చూసారు. స్థిరమైన మరియు వేరియబుల్ మధ్య వ్యత్యాసం అనేది వేరియబుల్ యొక్క ప్రారంభ విలువలు కాలక్రమేణా మారుతుంది.

సెషన్

సెషన్ గ్రాఫ్ నుండి ఆపరేషన్‌ను అమలు చేస్తుంది. టెన్సర్ విలువలతో గ్రాఫ్‌ను ఫీడ్ చేయడానికి, మీరు సెషన్‌ను తెరవాలి. సెషన్ లోపల, అవుట్‌పుట్‌ను సృష్టించడానికి మీరు తప్పనిసరిగా ఆపరేటర్‌ను అమలు చేయాలి.

గ్రాఫ్‌లు మరియు సెషన్‌లు స్వతంత్రంగా ఉంటాయి. మీరు సెషన్‌ను అమలు చేయవచ్చు మరియు తదుపరి గణనల కోసం తర్వాత ఉపయోగించడానికి విలువలను పొందవచ్చు.

దిగువ ఉదాహరణలో, మీరు:

  • రెండు టెన్సర్‌లను సృష్టించండి
  • ఒక ఆపరేషన్ సృష్టించండి
  • సెషన్‌ని తెరవండి
  • ఫలితాన్ని ముద్రించండి

దశ 1) మీరు x మరియు y | _+_ | అనే రెండు టెన్సర్‌లను సృష్టిస్తారు

దశ 2) మీరు x మరియు y | _+_ | గుణించడం ద్వారా ఆపరేటర్‌ను సృష్టించండి

దశ 3) మీరు సెషన్‌ని తెరవండి. సెషన్‌లో అన్ని గణనలు జరుగుతాయి. మీరు పూర్తి చేసిన తర్వాత, మీరు సెషన్‌ను మూసివేయాలి. | _+_ |

అవుట్‌పుట్

Tensor('ones_1:0', shape=(3,), dtype=float32) 

కోడ్ వివరణ

  • tf.Session (): ఒక సెషన్‌ను తెరవండి. అన్ని కార్యకలాపాలు సెషన్లలో ప్రవహిస్తాయి
  • రన్ (గుణకారం): దశ 2 లో సృష్టించబడిన ఆపరేషన్‌ను అమలు చేయండి.
  • print (result_1): చివరగా, మీరు ఫలితాన్ని ముద్రించవచ్చు
  • మూసివేయి (): సెషన్‌ను మూసివేయండి

ఫలితం 8 ని చూపుతుంది, ఇది x మరియు y యొక్క గుణకారం.

సెషన్‌ను సృష్టించడానికి మరొక మార్గం బ్లాక్ లోపల ఉంది. ప్రయోజనం ఏమిటంటే ఇది సెషన్‌ను స్వయంచాలకంగా మూసివేస్తుంది. | _+_ |

అవుట్‌పుట్

# Create a vector of ones with the same number of column as m_shape print(tf.ones(m_shape.shape[1])) 

సెషన్ సందర్భంలో, మీరు ఆపరేషన్‌ను అమలు చేయడానికి eval () పద్ధతిని ఉపయోగించవచ్చు. ఇది అమలు చేయడానికి సమానం (). ఇది కోడ్‌ని మరింత చదవగలిగేలా చేస్తుంది.

మీరు సెషన్‌ను సృష్టించవచ్చు మరియు మీరు ఇప్పటివరకు సృష్టించిన టెన్సర్‌ల లోపల విలువలను చూడవచ్చు. | _+_ |

అవుట్‌పుట్

Tensor('ones_2:0', shape=(2,), dtype=float32) 

మీరు టెన్సర్‌ను సృష్టించిన తర్వాత కూడా వేరియబుల్స్ డిఫాల్ట్‌గా ఖాళీగా ఉంటాయి. మీరు వేరియబుల్ ఉపయోగించాలనుకుంటే మీరు వేరియబుల్‌ను ప్రారంభించాలి. వేరియబుల్ విలువలను ప్రారంభించడానికి ఆబ్జెక్ట్ tf.global_variables_initializer () ని పిలవాలి. ఈ వస్తువు అన్ని వేరియబుల్స్‌ని స్పష్టంగా ప్రారంభిస్తుంది. మీరు మోడల్‌కు శిక్షణ ఇచ్చే ముందు ఇది ఉపయోగపడుతుంది.

మీరు ఇంతకు ముందు సృష్టించిన వేరియబుల్స్ విలువలను తనిఖీ చేయవచ్చు. టెన్సర్‌ని అంచనా వేయడానికి మీరు రన్‌ని ఉపయోగించాల్సిన అవసరం ఉందని గమనించండి | _+_ |

అవుట్‌పుట్

print(tf.ones(m_shape.shape)) 

మీరు ఇంతకు ముందు సృష్టించిన ప్లేస్‌హోల్డర్‌ని ఉపయోగించవచ్చు మరియు వాస్తవ విలువతో ఫీడ్ చేయవచ్చు. మీరు ఫీడ్_డిక్ట్ పద్ధతిలో డేటాను పాస్ చేయాలి.

ఉదాహరణకు, మీరు ప్లేస్‌హోల్డర్ డేటా_ ప్లేస్‌హోల్డర్_ఎలో 2 పవర్‌ను తీసుకుంటారు. | _+_ |

కోడ్ వివరణ

  • np గా నంపీని దిగుమతి చేయండి: డేటాను సృష్టించడానికి నంపి లైబ్రరీని దిగుమతి చేయండి
  • tf.pow (data_placeholder_a, 2): ops ని సృష్టించండి
  • np.random.rand (1, 10): యాదృచ్ఛిక డేటా శ్రేణిని సృష్టించండి
  • feed_dict = {data_placeholder_a: data}: డేటాతో ప్లేస్‌హోల్డర్‌కి ఫీడ్ చేయండి

అవుట్‌పుట్

Tensor('ones_3:0', shape=(3, 2), dtype=float32) 

గ్రాఫ్

TensorFlow ఆపరేషన్ అందించడానికి ఒక మేధావి విధానంపై ఆధారపడి ఉంటుంది. అన్ని గణనలు డేటాఫ్లో పథకంతో సూచించబడతాయి. వ్యక్తిగత ఆపరేషన్ మధ్య డేటా డిపెండెన్సీలను చూడటానికి డేటాఫ్లో గ్రాఫ్ అభివృద్ధి చేయబడింది. గణిత సూత్రం లేదా అల్గోరిథం అనేక వరుస కార్యకలాపాలతో రూపొందించబడింది. గణనలు ఎలా సమన్వయం చేయబడ్డాయో ఊహించడానికి గ్రాఫ్ ఒక అనుకూలమైన మార్గం.

గ్రాఫ్ a చూపిస్తుంది నోడ్ మరియు ఒక అంచు . నోడ్ అనేది ఆపరేషన్ యొక్క ప్రాతినిధ్యం, అనగా గణన యూనిట్. అంచు టెన్సర్, ఇది కొత్త టెన్సర్‌ని ఉత్పత్తి చేయగలదు లేదా ఇన్‌పుట్ డేటాను వినియోగించగలదు. ఇది వ్యక్తిగత ఆపరేషన్ మధ్య డిపెండెన్సీలపై ఆధారపడి ఉంటుంది.

గ్రాఫ్ యొక్క నిర్మాణం ఆపరేషన్లను (అంటే నోడ్స్) మరియు అవి ఎలా పనిచేస్తాయో ఫీడ్‌ని కలుపుతుంది. కార్యకలాపాల అవుట్‌పుట్‌ను గ్రాఫ్ ప్రదర్శించదని గమనించండి, ఇది వ్యక్తిగత కార్యకలాపాల మధ్య కనెక్షన్‌ని దృశ్యమానం చేయడానికి మాత్రమే సహాయపడుతుంది.

ఒక ఉదాహరణ చూద్దాం.

మీరు ఈ క్రింది ఫంక్షన్‌ను విశ్లేషించాలనుకుంటున్నట్లు ఊహించుకోండి:

ఫంక్షన్‌ను అమలు చేయడానికి టెన్సర్‌ఫ్లో గ్రాఫ్‌ను సృష్టిస్తుంది. గ్రాఫ్ ఇలా కనిపిస్తుంది:

టెన్సర్ ఫ్లో గ్రాఫ్ ఉదాహరణ

తుది గమ్యాన్ని చేరుకోవడానికి టెన్సర్‌లు తీసుకునే మార్గాన్ని మీరు సులభంగా చూడవచ్చు.

ఉదాహరణకు, ఆపరేషన్ యాడ్ ముందు చేయలేమని మీరు చూడవచ్చు మరియు. గ్రాఫ్ వివరిస్తుంది:

  1. గణన మరియు:
  2. 1) కలపండి
  3. 2 కి జోడించండి)
  4. 3) జోడించండి
print(m_shape.dtype) 

కోడ్ వివరణ

  • x: 5 అనే స్థిరమైన విలువతో x అనే వేరియబుల్‌ని ప్రారంభించండి
  • z: 6 అనే స్థిరమైన విలువతో z అనే వేరియబుల్‌ను ప్రారంభించండి
  • సి: 5 యొక్క స్థిరమైన విలువతో సి అని పిలువబడే స్థిరమైన టెన్సర్‌ని ప్రారంభించండి
  • స్క్వేర్: స్క్వేర్ అని పిలువబడే స్థిరమైన టెన్సర్‌ను 2 యొక్క స్థిరమైన విలువతో ప్రారంభించండి
  • f: ఆపరేటర్‌ను నిర్మించండి

ఈ ఉదాహరణలో, వేరియబుల్స్ విలువలను స్థిరంగా ఉంచడానికి మేము ఎంచుకుంటాము. మేము సి అని పిలువబడే స్థిరమైన టెన్సర్‌ను కూడా సృష్టించాము, ఇది ఫంక్షన్‌లో స్థిరమైన పరామితి. ఇది ఒక స్థిర విలువను తీసుకుంటుంది 5. గ్రాఫ్‌లో, మీరు ఈ పరామితిని స్థిరాంకం అని పిలవబడే టెన్సర్‌లో చూడవచ్చు.

మేము ఆపరేటర్ tf.pow () లో పవర్ కోసం స్థిరమైన టెన్సర్‌ను కూడా నిర్మించాము. అవసరం లేదు. మీరు గ్రాఫ్‌లో టెన్సర్ పేరును చూడగలిగేలా చేశాము. ఇది చతురస్రం అని పిలువబడే వృత్తం.

గ్రాఫ్ నుండి, టెన్సర్‌ల వల్ల ఏమి జరుగుతుందో మరియు అది 66 యొక్క అవుట్‌పుట్‌ను ఎలా తిరిగి ఇవ్వగలదో మీరు అర్థం చేసుకోవచ్చు.

దిగువ కోడ్ ఒక సెషన్‌లో ఫంక్షన్‌ను అంచనా వేస్తుంది. | _+_ |

అవుట్‌పుట్

 

సారాంశం

TensorFlow చుట్టూ పనిచేస్తుంది:

  • గ్రాఫ్ : కార్యకలాపాలు మరియు టెన్సర్‌లను కలిగి ఉన్న గణన వాతావరణం
  • టెన్సర్లు : గ్రాఫ్‌లో ప్రవహించే డేటాను (లేదా విలువ) సూచిస్తుంది. ఇది గ్రాఫ్‌లోని అంచు
  • సెషన్‌లు : కార్యకలాపాల అమలును అనుమతించండి

స్థిరమైన టెన్సర్‌ని సృష్టించండి

స్థిరమైనవస్తువు

డి 0

tf. కాన్స్టాంట్ (1, tf.int16)

డి 1

tf. కాన్స్టాంట్ ([1,3,5], tf.int16)

D2

tf. కాన్స్టాంట్ ([[1, 2], [3, 4]], tf.int16)

D3

tf. కాన్స్టాంట్ ([[[1, 2], [3, 4], [5, 6]]], tf.int16)

ఒక ఆపరేటర్‌ను సృష్టించండి

ఒక ఆపరేటర్‌ను సృష్టించండివస్తువు

a+b

tf.add (a, b)

a*b

tf.multiply (a, b)

వేరియబుల్ టెన్సర్‌ని సృష్టించండి

వేరియబుల్ సృష్టించండి

వస్తువు

యాదృచ్ఛిక విలువ

tf.get_ variable ('var', [1, 2])

ప్రారంభించిన మొదటి విలువ

tf.get_ variable ('var_init_2', dtype = tf.int32, initializer = [[1, 2], [3, 4]])

సెషన్‌ని తెరవండి

సెషన్వస్తువు

ఒక సెషన్‌ను సృష్టించండి

tf.Session ()

ఒక సెషన్‌ని అమలు చేయండి

tf.Session.run ()

ఒక టెన్సర్‌ని అంచనా వేయండి

variable_name.eval ()

సెషన్‌ను మూసివేయండి

sess.close ()

బ్లాక్ ద్వారా సెషన్

tf.Session () తో సెస్: