# ML மாடலை பயன்படுத்த ஒரு வலை பயன்பாட்டை உருவாக்குதல்

இந்த பாடத்தில், நீங்கள் ஒரு வினோதமான தரவுத்தொகுப்பில் ML மாடலை பயிற்றுவிக்கப் போகிறீர்கள்: _கடந்த நூற்றாண்டில் UFO காட்சிகள்_, NUFORC தரவுத்தொகுப்பிலிருந்து பெறப்பட்டது.

நீங்கள் கற்றுக்கொள்வீர்கள்:

- பயிற்று மாடலை 'pickle' செய்வது எப்படி
- Flask பயன்பாட்டில் அந்த மாடலை பயன்படுத்துவது எப்படி

நாம் தரவுகளை சுத்தம் செய்யவும், மாடலை பயிற்றுவிக்கவும் நோட்புக் பயன்படுத்துவதை தொடர்கிறோம், ஆனால் நீங்கள் இந்த செயல்முறையை மேலும் ஒரு படி முன்னேறி, ஒரு வலை பயன்பாட்டில் மாடலை 'வெளியில்' பயன்படுத்துவது எப்படி என்பதை ஆராயலாம்.

இதற்காக, Flask பயன்படுத்தி ஒரு வலை பயன்பாட்டை உருவாக்க வேண்டும்.

## [பாடத்திற்கு முன் கேள்வி](https://ff-quizzes.netlify.app/en/ml/)

## ஒரு பயன்பாட்டை உருவாக்குதல்

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

### கருத்துக்கள்

நீங்கள் பல கேள்விகளை கேட்க வேண்டும்:

- **இது ஒரு வலை பயன்பாடா அல்லது மொபைல் பயன்பாடா?** நீங்கள் ஒரு மொபைல் பயன்பாட்டை உருவாக்குகிறீர்கள் அல்லது IoT சூழலில் மாடலை பயன்படுத்த வேண்டும் என்றால், [TensorFlow Lite](https://www.tensorflow.org/lite/) பயன்படுத்தி Android அல்லது iOS பயன்பாட்டில் மாடலை பயன்படுத்தலாம்.
- **மாடல் எங்கு இருக்கும்?** மேகத்தில் அல்லது உள்ளூரிலா?
- **ஆஃப்லைன் ஆதரவு.** பயன்பாடு ஆஃப்லைனில் வேலை செய்ய வேண்டுமா?
- **மாடலை பயிற்றுவிக்க எந்த தொழில்நுட்பம் பயன்படுத்தப்பட்டது?** தேர்ந்தெடுக்கப்பட்ட தொழில்நுட்பம் நீங்கள் பயன்படுத்த வேண்டிய கருவிகளை பாதிக்கலாம்.
    - **TensorFlow பயன்படுத்துதல்.** உதாரணமாக, TensorFlow பயன்படுத்தி மாடலை பயிற்றுவிக்கிறீர்கள் என்றால், [TensorFlow.js](https://www.tensorflow.org/js/) மூலம் வலை பயன்பாட்டில் பயன்படுத்த TensorFlow மாடலை மாற்றும் திறனை அந்த சூழல் வழங்குகிறது.
    - **PyTorch பயன்படுத்துதல்.** [PyTorch](https://pytorch.org/) போன்ற நூலகத்தைப் பயன்படுத்தி மாடலை உருவாக்குகிறீர்கள் என்றால், [ONNX](https://onnx.ai/) (Open Neural Network Exchange) வடிவத்தில் அதை ஏற்றுமதி செய்யும் விருப்பம் உங்களுக்கு உள்ளது, இது [Onnx Runtime](https://www.onnxruntime.ai/) பயன்படுத்தும் JavaScript வலை பயன்பாடுகளில் பயன்படுத்தலாம். இந்த விருப்பத்தை Scikit-learn பயிற்றுவிக்கப்பட்ட மாடலுக்கான எதிர்கால பாடத்தில் ஆராயப்படும்.
    - **Lobe.ai அல்லது Azure Custom Vision பயன்படுத்துதல்.** [Lobe.ai](https://lobe.ai/) அல்லது [Azure Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77952-leestott) போன்ற ML SaaS (Software as a Service) அமைப்பை பயன்படுத்தி மாடலை பயிற்றுவிக்கிறீர்கள் என்றால், இந்த வகை மென்பொருள் பல தளங்களுக்கு மாடலை ஏற்றுமதி செய்யும் வழிகளை வழங்குகிறது, அதில் உங்கள் ஆன்லைன் பயன்பாட்டால் மேகத்தில் கேட்கப்படும் தனிப்பயன் API உருவாக்கும் திறனும் அடங்கும்.

நீங்கள் ஒரு முழுமையான Flask வலை பயன்பாட்டை உருவாக்கும் வாய்ப்பும் உங்களுக்கு உள்ளது, இது வலை உலாவியில் மாடலை தானாகவே பயிற்றுவிக்கும். இது JavaScript சூழலில் TensorFlow.js பயன்படுத்தி செய்யலாம்.

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

## கருவி

இந்த பணிக்காக, Flask மற்றும் Pickle ஆகிய இரண்டு கருவிகள் தேவை, இரண்டும் Python-இல் இயங்குகின்றன.

✅ [Flask](https://palletsprojects.com/p/flask/) என்ன? அதன் உருவாக்குநர்களால் 'micro-framework' என வரையறுக்கப்பட்ட Flask, Python மற்றும் ஒரு டெம்ப்ளேட்டிங் என்ஜினை பயன்படுத்தி வலை பக்கங்களை உருவாக்க வலை கட்டமைப்புகளின் அடிப்படை அம்சங்களை வழங்குகிறது. Flask-ஐப் பயன்படுத்தி உருவாக்க பயிற்சி பெற [இந்த Learn module](https://docs.microsoft.com/learn/modules/python-flask-build-ai-web-app?WT.mc_id=academic-77952-leestott) பார்க்கவும்.

✅ [Pickle](https://docs.python.org/3/library/pickle.html) என்ன? Pickle 🥒 என்பது Python மாடுல் ஆகும், இது Python பொருள் அமைப்பை சீரியல் மற்றும் டி-சீரியல் செய்கிறது. நீங்கள் ஒரு மாடலை 'pickle' செய்யும்போது, அதன் அமைப்பை flatten செய்து வலை பயன்பாட்டில் பயன்படுத்த serialize செய்கிறீர்கள். கவனமாக இருங்கள்: pickle இயல்பாக பாதுகாப்பானது அல்ல, எனவே ஒரு கோப்பை 'un-pickle' செய்யுமாறு கேட்டால் கவனமாக இருங்கள். Pickled கோப்பின் suffix `.pkl` ஆகும்.

## பயிற்சி - உங்கள் தரவுகளை சுத்தம் செய்யுங்கள்

இந்த பாடத்தில் நீங்கள் [NUFORC](https://nuforc.org) (The National UFO Reporting Center) மூலம் சேகரிக்கப்பட்ட 80,000 UFO காட்சிகளின் தரவுகளைப் பயன்படுத்துவீர்கள். இந்த தரவுகளில் சில சுவாரஸ்யமான UFO காட்சிகளின் விளக்கங்கள் உள்ளன, உதாரணமாக:

- **நீண்ட விளக்க உதாரணம்.** "ஒரு மனிதன் இரவில் புல்வெளியில் ஒளிரும் ஒளிக்கதிரில் இருந்து வெளிவந்து Texas Instruments பார்க்கிங் லாட்டிற்கு ஓடுகிறார்".
- **குறுகிய விளக்க உதாரணம்.** "ஒளிகள் எங்களைத் தொடர்ந்து வந்தன".

[ufos.csv](../../../../3-Web-App/1-Web-App/data/ufos.csv) ஸ்பிரெட்ஷீட்டில் `city`, `state` மற்றும் `country` ஆகியவை காட்சிகள் நிகழ்ந்த இடம், பொர object's `shape` மற்றும் அதன் `latitude` மற்றும் `longitude` ஆகியவை பற்றிய பத்திகள் உள்ளன.

இந்த பாடத்தில் உள்ள [notebook](notebook.ipynb) வெற்றிடத்தில்:

1. `pandas`, `matplotlib`, மற்றும் `numpy` ஆகியவற்றை முந்தைய பாடங்களில் செய்தது போல இறக்குமதி செய்து, ufos ஸ்பிரெட்ஷீட்டை இறக்குமதி செய்யுங்கள். நீங்கள் ஒரு மாதிரி தரவுத்தொகுப்பைப் பார்க்கலாம்:

    ```python
    import pandas as pd
    import numpy as np
    
    ufos = pd.read_csv('./data/ufos.csv')
    ufos.head()
    ```

1. ufos தரவுகளை புதிய தலைப்புகளுடன் ஒரு சிறிய dataframe-ஆக மாற்றுங்கள். `Country` புலத்தில் உள்ள தனித்துவமான மதிப்புகளைச் சரிபாருங்கள்.

    ```python
    ufos = pd.DataFrame({'Seconds': ufos['duration (seconds)'], 'Country': ufos['country'],'Latitude': ufos['latitude'],'Longitude': ufos['longitude']})
    
    ufos.Country.unique()
    ```

1. இப்போது, நாம் கையாள வேண்டிய தரவின் அளவை குறைக்க, எந்த null மதிப்புகளையும் நீக்கி, 1-60 விநாடிகளுக்குள் உள்ள காட்சிகளை மட்டும் இறக்குமதி செய்யலாம்:

    ```python
    ufos.dropna(inplace=True)
    
    ufos = ufos[(ufos['Seconds'] >= 1) & (ufos['Seconds'] <= 60)]
    
    ufos.info()
    ```

1. Scikit-learn இன் `LabelEncoder` நூலகத்தை இறக்குமதி செய்து, நாடுகளுக்கான உரை மதிப்புகளை எண்ணாக மாற்றுங்கள்:

    ✅ LabelEncoder தரவுகளை அகரவரிசையாக encode செய்கிறது

    ```python
    from sklearn.preprocessing import LabelEncoder
    
    ufos['Country'] = LabelEncoder().fit_transform(ufos['Country'])
    
    ufos.head()
    ```

    உங்கள் தரவுகள் இவ்வாறு தோன்ற வேண்டும்:

    ```output
    	Seconds	Country	Latitude	Longitude
    2	20.0	3		53.200000	-2.916667
    3	20.0	4		28.978333	-96.645833
    14	30.0	4		35.823889	-80.253611
    23	60.0	4		45.582778	-122.352222
    24	3.0		3		51.783333	-0.783333
    ```

## பயிற்சி - உங்கள் மாடலை உருவாக்குங்கள்

இப்போது, தரவுகளை பயிற்சி மற்றும் சோதனை குழுவாகப் பிரித்து, மாடலை பயிற்றுவிக்க தயாராக இருக்கலாம்.

1. உங்கள் X வெக்டராக பயிற்சி செய்ய நீங்கள் தேர்ந்தெடுக்க விரும்பும் மூன்று அம்சங்களைத் தேர்ந்தெடுக்கவும், y வெக்டர் `Country` ஆக இருக்கும். நீங்கள் `Seconds`, `Latitude` மற்றும் `Longitude` ஐ உள்ளீடாகக் கொண்டு ஒரு நாடு ஐடியைத் திருப்ப விரும்புகிறீர்கள்.

    ```python
    from sklearn.model_selection import train_test_split
    
    Selected_features = ['Seconds','Latitude','Longitude']
    
    X = ufos[Selected_features]
    y = ufos['Country']
    
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
    ```

1. உங்கள் மாடலை logistic regression பயன்படுத்தி பயிற்றுவிக்கவும்:

    ```python
    from sklearn.metrics import accuracy_score, classification_report
    from sklearn.linear_model import LogisticRegression
    model = LogisticRegression()
    model.fit(X_train, y_train)
    predictions = model.predict(X_test)
    
    print(classification_report(y_test, predictions))
    print('Predicted labels: ', predictions)
    print('Accuracy: ', accuracy_score(y_test, predictions))
    ```

துல்லியம் **(சுமார் 95%)** மோசமாக இல்லை, ஆச்சரியமில்லை, ஏனெனில் `Country` மற்றும் `Latitude/Longitude` தொடர்புடையவை.

நீங்கள் உருவாக்கிய மாடல் மிகவும் புரட்சிகரமானது அல்ல, ஏனெனில் `Latitude` மற்றும் `Longitude` மூலம் ஒரு `Country` ஐ infer செய்ய முடியும், ஆனால் இது சுத்தம் செய்யப்பட்ட மூல தரவிலிருந்து பயிற்சி செய்ய முயற்சிக்க ஒரு நல்ல பயிற்சியாகும், அதை ஏற்றுமதி செய்து, பின்னர் இந்த மாடலை ஒரு வலை பயன்பாட்டில் பயன்படுத்துங்கள்.

## பயிற்சி - உங்கள் மாடலை 'pickle' செய்யுங்கள்

இப்போது, உங்கள் மாடலை _pickle_ செய்ய நேரம்! நீங்கள் அதை சில கோடுகளில் செய்யலாம். ஒரு முறை _pickled_, உங்கள் pickled மாடலை ஏற்றவும், மற்றும் seconds, latitude மற்றும் longitude மதிப்புகளை உள்ளடக்கிய மாதிரி தரவுத்தொகுப்புக்கு எதிராக அதை சோதிக்கவும்,

```python
import pickle
model_filename = 'ufo-model.pkl'
pickle.dump(model, open(model_filename,'wb'))

model = pickle.load(open('ufo-model.pkl','rb'))
print(model.predict([[50,44,-12]]))
```

மாடல் **'3'** ஐ திருப்புகிறது, இது UK-க்கான நாடு குறியீடு. வினோதம்! 👽

## பயிற்சி - Flask பயன்பாட்டை உருவாக்குங்கள்

இப்போது, உங்கள் மாடலை அழைக்கவும், அதே போன்ற முடிவுகளை திருப்பவும், ஆனால் பார்ப்பதற்கு அழகான முறையில் ஒரு Flask பயன்பாட்டை உருவாக்கலாம்.

1. உங்கள் _notebook.ipynb_ கோப்பின் அருகில் **web-app** என்ற ஒரு கோப்புறையை உருவாக்கவும், அங்கு உங்கள் _ufo-model.pkl_ கோப்பு உள்ளது.

1. அந்த கோப்புறையில் மேலும் மூன்று கோப்புறைகளை உருவாக்கவும்: **static**, அதன் உள்ளே **css** கோப்புறை, மற்றும் **templates**. நீங்கள் தற்போது பின்வரும் கோப்புகள் மற்றும் கோப்புறைகளை வைத்திருக்க வேண்டும்:

    ```output
    web-app/
      static/
        css/
      templates/
    notebook.ipynb
    ufo-model.pkl
    ```

    ✅ முடிக்கப்பட்ட பயன்பாட்டின் காட்சியைப் பார்க்க தீர்வு கோப்புறையைப் பார்க்கவும்

1. _web-app_ கோப்புறையில் உருவாக்க வேண்டிய முதல் கோப்பு **requirements.txt** கோப்பு. JavaScript பயன்பாட்டில் உள்ள _package.json_ போல, இந்த கோப்பு பயன்பாட்டிற்கு தேவையான சார்புகளை பட்டியலிடுகிறது. **requirements.txt**-இல் பின்வரும் வரிகளைச் சேர்க்கவும்:

    ```text
    scikit-learn
    pandas
    numpy
    flask
    ```

1. இப்போது, _web-app_ கோப்புறைக்கு சென்று இந்த கோப்பை இயக்கவும்:

    ```bash
    cd web-app
    ```

1. உங்கள் டெர்மினலில் `pip install` என টাইப் செய்து, _requirements.txt_ இல் பட்டியலிடப்பட்ட நூலகங்களை நிறுவவும்:

    ```bash
    pip install -r requirements.txt
    ```

1. இப்போது, பயன்பாட்டை முடிக்க மேலும் மூன்று கோப்புகளை உருவாக்க தயாராக இருக்கிறீர்கள்:

    1. **app.py** ஐ root-இல் உருவாக்கவும்.
    2. _templates_ கோப்புறையில் **index.html** ஐ உருவாக்கவும்.
    3. _static/css_ கோப்புறையில் **styles.css** ஐ உருவாக்கவும்.

1. _styles.css_ கோப்பை சில பாணிகளுடன் உருவாக்கவும்:

    ```css
    body {
    	width: 100%;
    	height: 100%;
    	font-family: 'Helvetica';
    	background: black;
    	color: #fff;
    	text-align: center;
    	letter-spacing: 1.4px;
    	font-size: 30px;
    }
    
    input {
    	min-width: 150px;
    }
    
    .grid {
    	width: 300px;
    	border: 1px solid #2d2d2d;
    	display: grid;
    	justify-content: center;
    	margin: 20px auto;
    }
    
    .box {
    	color: #fff;
    	background: #2d2d2d;
    	padding: 12px;
    	display: inline-block;
    }
    ```

1. அடுத்ததாக, _index.html_ கோப்பை உருவாக்கவும்:

    ```html
    <!DOCTYPE html>
    <html>
      <head>
        <meta charset="UTF-8">
        <title>🛸 UFO Appearance Prediction! 👽</title>
        <link rel="stylesheet" href="{{ url_for('static', filename='css/styles.css') }}">
      </head>
    
      <body>
        <div class="grid">
    
          <div class="box">
    
            <p>According to the number of seconds, latitude and longitude, which country is likely to have reported seeing a UFO?</p>
    
            <form action="{{ url_for('predict')}}" method="post">
              <input type="number" name="seconds" placeholder="Seconds" required="required" min="0" max="60" />
              <input type="text" name="latitude" placeholder="Latitude" required="required" />
              <input type="text" name="longitude" placeholder="Longitude" required="required" />
              <button type="submit" class="btn">Predict country where the UFO is seen</button>
            </form>
    
            <p>{{ prediction_text }}</p>
    
          </div>
    
        </div>
    
      </body>
    </html>
    ```

    இந்த கோப்பில் உள்ள டெம்ப்ளேட்டிங்கை கவனிக்கவும். பயன்பாட்டால் வழங்கப்படும் மாறிகள், உதாரணமாக prediction உரை: `{{}}`. மேலும், `/predict` வழியில் ஒரு முன்னறிவிப்பு பதிவிடும் ஒரு படிவம் உள்ளது.

    இறுதியாக, மாடலைப் பயன்படுத்தவும், முன்னறிவிப்புகளை காட்சிப்படுத்தவும் இயக்கும் Python கோப்பை உருவாக்க தயாராக இருக்கிறீர்கள்:

1. `app.py`-இல் சேர்க்கவும்:

    ```python
    import numpy as np
    from flask import Flask, request, render_template
    import pickle
    
    app = Flask(__name__)
    
    model = pickle.load(open("./ufo-model.pkl", "rb"))
    
    
    @app.route("/")
    def home():
        return render_template("index.html")
    
    
    @app.route("/predict", methods=["POST"])
    def predict():
    
        int_features = [int(x) for x in request.form.values()]
        final_features = [np.array(int_features)]
        prediction = model.predict(final_features)
    
        output = prediction[0]
    
        countries = ["Australia", "Canada", "Germany", "UK", "US"]
    
        return render_template(
            "index.html", prediction_text="Likely country: {}".format(countries[output])
        )
    
    
    if __name__ == "__main__":
        app.run(debug=True)
    ```

    > 💡 குறிப்புகள்: Flask பயன்படுத்தி வலை பயன்பாட்டை இயக்கும்போது [`debug=True`](https://www.askpython.com/python-modules/flask/flask-debug-mode) சேர்க்கும்போது, உங்கள் பயன்பாட்டில் நீங்கள் செய்யும் எந்த மாற்றங்களும் உடனடியாக பிரதிபலிக்கப்படும், சர்வரை மீண்டும் தொடங்க தேவையில்லை. கவனமாக இருங்கள்! உற்பத்தி பயன்பாட்டில் இந்த முறையை இயக்க வேண்டாம்.

நீங்கள் `python app.py` அல்லது `python3 app.py` இயக்கினால் - உங்கள் வலை சர்வர் உள்ளூரில் தொடங்குகிறது, மேலும் UFO காட்சிகள் எங்கு நிகழ்ந்தன என்பதைப் பற்றிய உங்கள் burning கேள்விக்கு பதில் பெற ஒரு குறுகிய படிவத்தை நிரப்பலாம்!

அதைச் செய்யும் முன், `app.py`-இன் பகுதிகளைப் பாருங்கள்:

1. முதலில், சார்புகள் ஏற்றப்பட்டு பயன்பாடு தொடங்குகிறது.
1. பின்னர், மாடல் இறக்குமதி செய்யப்படுகிறது.
1. பின்னர், index.html முகப்புப் பாதையில் ரெண்டர் செய்யப்படுகிறது.

`/predict` பாதையில், படிவம் பதிவிடப்பட்டபோது பல விஷயங்கள் நடக்கின்றன:

1. படிவ மாறிகள் சேகரிக்கப்பட்டு numpy array ஆக மாற்றப்படுகின்றன. பின்னர் அவை மாடலுக்கு அனுப்பப்பட்டு ஒரு முன்னறிவிப்பு திருப்பப்படுகிறது.
2. நாம் காட்சிப்படுத்த விரும்பும் நாடுகள், அவற்றின் முன்னறிவிக்கப்பட்ட நாடு குறியீட்டிலிருந்து வாசிக்கக்கூடிய உரையாக மீண்டும் ரெண்டர் செய்யப்படுகின்றன, மேலும் அந்த மதிப்பு index.html-க்கு திருப்பி டெம்ப்ளேட்டில் ரெண்டர் செய்யப்படுகிறது.

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

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

---

## 🚀 சவால்

நோட்புக்கில் வேலை செய்து, Flask பயன்பாட்டில் மாடலை இறக்குமதி செய்வதற்குப் பதிலாக, Flask பயன்பாட்டின் உள்ளே மாடலை நேரடியாக பயிற்றுவிக்கலாம்! உங்கள் Python கோடுகளை நோட்புக்கில் இருந்து மாற்ற முயற்சிக்கவும், உங்கள் தரவுகள் சுத்தம் செய்யப்பட்ட பிறகு, `train` எனப்படும் ஒரு பாதையில் பயன்பாட்டின் உள்ளே மாடலை பயிற்றுவிக்க. இந்த முறையை பின்பற்றுவதன் நன்மைகள் மற்றும் தீமைகள் என்ன?

## [பாடத்திற்குப் பின் கேள்வி](https://ff-quizzes.netlify.app/en/ml/)

## மதிப்பீடு & சுயபடிப்பு

ML மாடல்களைப் பயன்படுத்த வலை பயன்பாட்டை உருவாக்க பல வழிகள் உள்ளன. JavaScript அல்லது Python பயன்படுத்தி ML-ஐ பயன்படுத்த வலை பயன்பாட்டை உருவாக்க நீங்கள் பயன்படுத்தக்கூடிய வழிகளை பட்டியலிடுங்கள். கட்டமைப்பை கருத்தில் கொள்ளுங்கள்: மாடல் பயன்பாட்டில் இருக்க வேண்டுமா அல்லது மேகத்தில் வாழ வேண்டுமா? இரண்டாவது வழியில், அதை எப்படி அணுகுவீர்கள்? ML வலை தீர்வுக்கான ஒரு கட்டமைப்பு மாதிரியை வரைந்து பாருங்கள்.

## பணிக்கட்டளை

[வேறு மாடலை முயற்சிக்கவும்](assignment.md)

---

**குறிப்பு**:  
இந்த ஆவணம் [Co-op Translator](https://github.com/Azure/co-op-translator) என்ற AI மொழிபெயர்ப்பு சேவையைப் பயன்படுத்தி மொழிபெயர்க்கப்பட்டுள்ளது. நாங்கள் துல்லியத்திற்காக முயற்சிக்கின்றோம், ஆனால் தானியங்கி மொழிபெயர்ப்புகளில் பிழைகள் அல்லது தவறான தகவல்கள் இருக்கக்கூடும் என்பதை தயவுசெய்து கவனத்தில் கொள்ளவும். அதன் தாய்மொழியில் உள்ள மூல ஆவணம் அதிகாரப்பூர்வ ஆதாரமாக கருதப்பட வேண்டும். முக்கியமான தகவல்களுக்கு, தொழில்முறை மனித மொழிபெயர்ப்பு பரிந்துரைக்கப்படுகிறது. இந்த மொழிபெயர்ப்பைப் பயன்படுத்துவதால் ஏற்படும் எந்தவொரு தவறான புரிதல்கள் அல்லது தவறான விளக்கங்களுக்கு நாங்கள் பொறுப்பல்ல.