Öğretici: bir görüntü sınıflandırma modelini örnekle eğitme Jupyter Notebook

Bu öğreticide, bir makine öğrenimi modelini uzaktan işlem kaynaklarında eğitebilirsiniz. Azure Machine Learning için eğitim ve dağıtım iş akışını bir Python Jupyter Notebook kullanacaksınız. Ardından not defterini şablon olarak kullanıp kendi verilerinizle kendi makine öğrenmesi modelinizi eğitebilirsiniz. Bu öğretici, iki bölümden oluşan bir öğretici serisinin birinci bölümüdür.

Bu öğreticide, Mnist veri kümesini ve scikit 'i kullanarak basit bir Lojistik gerileme yapılır. Azure Machine Learning hakkında bilgi edinin . MNIST, 70.000 gri tonlamalı resimden oluşan popüler bir veri kümesidir. Her görüntü, sıfır ile dokuz arasında bir sayıyı temsil eden 28 x 28 piksellik bir sayının el ile yazılmış bir rakamdır. Amaç, belirli bir resim temsil ettiği rakamı tanımlamak için çok sınıflı bir sınıflandırıcı oluşturmaktır.

Aşağıdaki eylemleri nasıl gerçekleştireceğinizi öğrenin:

Bir modelin nasıl seçeceğinizi ve Bu öğreticinin ikinci bölümündenasıl dağıtılacağını öğreneceksiniz.

Azure aboneliğiniz yoksa başlamadan önce ücretsiz bir hesap oluşturun. Azure Machine Learning ücretsiz veya ücretli sürümünü bugün deneyin.

Önkoşullar

• hızlı başlangıcı doldurun: Azure Machine Learning kullanmaya başlayın:
  • Çalışma alanı oluşturma.
  • Geliştirme ortamınız için kullanmak üzere bulut tabanlı bir işlem örneği oluşturun.
  • Modelinize eğitim için kullanmak üzere bulut tabanlı bir işlem kümesi oluşturun.

Çalışma alanınızdan bir not defteri çalıştırma

Azure Machine Learning, bir yüklemesi ücretsiz ve önceden yapılandırılmış bir deneyim için çalışma alanınızda bir bulut not defteri sunucusu içerir. Ortamınız, paketler ve bağımlılıklarınız üzerinde denetim sahibi olmayı tercih ediyorsanız kendi ortamınızı kullanın.

Bu videoyla birlikte izleyin veya eğitim Not defterini kopyalayıp çalışma alanınızdan çalıştırmak için ayrıntılı adımları kullanın.

Not defteri klasörünü Kopyala

aşağıdaki deneme kurulumunu tamamlayıp Azure Machine Learning studio 'da adımları çalıştırın. Bu birleştirilmiş arabirim, tüm beceri seviyeleri için veri bilimi senaryolarına yönelik veri bilimi senaryoları gerçekleştirmeye yönelik makine öğrenimi araçlarını içerir.

1. Azure Machine Learning studio'da oturum açın.

2. Aboneliğinizi ve oluşturduğunuz çalışma alanını seçin.

3. Sol tarafta, Not defterleri' ni seçin.

4. En üstteki örnekler sekmesini seçin.

5. Python klasörünü açın.

6. Klasörü üzerinde bir sürüm numarasıyla açın. Bu sayı, Python SDK 'sının geçerli sürümünü temsil eder.

7. Öğreticiler klasörünün sağ tarafındaki ... düğmesini seçin ve ardından Kopyala' yı seçin.

   

8. Klasörlerin listesi, çalışma alanına erişen her kullanıcıyı gösterir. Öğreticiler klasörünü kopyalamak için klasörünüzü seçin.

Kopyalanmış Not defterini açın

1. Kullanıcı dosyaları bölümüne kopyalanmış öğreticiler klasörünü açın.

   Önemli

   Not defterlerini örnekler klasöründe görüntüleyebilirsiniz, ancak buradan bir not defteri çalıştıramazsınız. Bir not defteri çalıştırmak için, Kullanıcı dosyaları bölümünde Not defterinin kopyalanmış sürümünü çalıştırdığınızdan emin olun.

2. Öğreticiler/Image-Classification-mnist-Data klasörünüzdeki img-Classification-part1-eğitim. ipynb dosyasını seçin.

   

3. Üst kısımdaki çubukta, Not defterini çalıştırmak için kullanılacak işlem örneğinizi seçin.

öğretici ve eşlik eden utils.py dosyası, kendi yerel ortamınızdakullanmak istiyorsanız GitHub de mevcuttur. İşlem örneğini kullanmıyorsanız, pip install azureml-sdk[notebooks] azureml-opendatasets matplotlib Bu öğreticinin bağımlılıklarını yüklemek için ' yi çalıştırın.

Geliştirme ortamınızı kurma

Geliştirme çalışmanızdaki tüm kurulum bir Python not defterinde gerçekleştirilebilir. Kurulum aşağıdaki eylemleri içerir:

• Python paketlerini içeri aktarın.
• yerel bilgisayarınızın uzak kaynaklarla iletişim kurabilmesi için bir çalışma alanına Bağlan.
• Tüm çalıştırmalarınızı izlemek için bir deneme oluşturun.
• Eğitim için kullanmak üzere bir uzak işlem hedefi oluşturun.

Paketleri içeri aktarma

Bu oturumda ihtiyacınız olan Python paketlerini içeri aktarın. Azure Machine Learning SDK sürümünü de görüntüle:

%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt

import azureml.core
from azureml.core import Workspace

# check core SDK version number
print("Azure ML SDK Version: ", azureml.core.VERSION)

çalışma alanına Bağlan

Mevcut çalışma alanından bir çalışma alanı nesnesi oluşturun. Workspace.from_config(), config.json dosyasını okur ve ayrıntıları ws adlı nesneye yükler. İşlem örneği, bu dosyanın kök dizininde kaydedilen bir kopyasına sahiptir. Kodu başka bir yerde çalıştırırsanız, dosyayı oluşturmanızgerekecektir.

# load workspace configuration from the config.json file in the current folder.
ws = Workspace.from_config()
print(ws.name, ws.location, ws.resource_group, sep='\t')

Deneme oluşturma

Çalışma alanınızdaki çalıştırmaları izleyecek bir deneme oluşturun. Bir çalışma alanı birden çok denemeleri içerebilir:

from azureml.core import Experiment
experiment_name = 'Tutorial-sklearn-mnist'

exp = Experiment(workspace=ws, name=experiment_name)

Mevcut bir işlem hedefi oluşturun veya ekleyin

yönetilen bir hizmet olan Azure Machine Learning işlem kullanarak, veri bilimcileri, Azure sanal makinelerinin kümelerinde makine öğrenimi modellerini eğitebilir. Örnek olarak GPU desteği olan VM 'Ler sayılabilir. bu öğreticide eğitim ortamınız olarak Azure Machine Learning işlem oluşturursunuz. Bu VM 'de daha sonra öğreticide çalıştırılacak Python kodunu gönderebilirsiniz.

Aşağıdaki kod, çalışma alanınızda zaten mevcut değilse sizin için işlem kümelerini oluşturur. Kullanımda olmadığında 0 ' a ölçeklenebilen bir küme ayarlar ve en fazla 4 düğüme ölçeklendirebilir.

İşlem hedefinin oluşturulması yaklaşık beş dakika sürer. İşlem kaynağı zaten çalışma alanında ise, kod onu kullanır ve oluşturma işlemini atlar.

from azureml.core.compute import AmlCompute
from azureml.core.compute import ComputeTarget
import os

# choose a name for your cluster
compute_name = os.environ.get("AML_COMPUTE_CLUSTER_NAME", "cpu-cluster")
compute_min_nodes = os.environ.get("AML_COMPUTE_CLUSTER_MIN_NODES", 0)
compute_max_nodes = os.environ.get("AML_COMPUTE_CLUSTER_MAX_NODES", 4)

# This example uses CPU VM. For using GPU VM, set SKU to STANDARD_NC6
vm_size = os.environ.get("AML_COMPUTE_CLUSTER_SKU", "STANDARD_D2_V2")


if compute_name in ws.compute_targets:
    compute_target = ws.compute_targets[compute_name]
    if compute_target and type(compute_target) is AmlCompute:
        print('found compute target. just use it. ' + compute_name)
else:
    print('creating a new compute target...')
    provisioning_config = AmlCompute.provisioning_configuration(vm_size=vm_size,
                                                                min_nodes=compute_min_nodes,
                                                                max_nodes=compute_max_nodes)

    # create the cluster
    compute_target = ComputeTarget.create(
        ws, compute_name, provisioning_config)

    # can poll for a minimum number of nodes and for a specific timeout.
    # if no min node count is provided it will use the scale settings for the cluster
    compute_target.wait_for_completion(
        show_output=True, min_node_count=None, timeout_in_minutes=20)

    # For a more detailed view of current AmlCompute status, use get_status()
    print(compute_target.get_status().serialize())

Artık bulutta bir modeli eğitmek için gerekli paketleriniz ve işlem kaynaklarınız vardır.

Verileri inceleme

Bir modeli eğitmadan önce, bunu eğitebilmek için kullandığınız verileri anlamanız gerekir. Bu bölümde şunları nasıl yapabileceğinizi öğrenirsiniz:

• MNIST veri kümesini indirin.
• Örnek görüntüleri görüntüleyin.

MNIST veri kümesini indirme

Ham veri dosyalarını almak için Azure açık veri kümelerini kullanın. Azure açık veri kümeleri, daha doğru modeller için makine öğrenimi çözümlerine senaryoya özgü özellikler eklemek için kullanabileceğiniz, seçkin ortak veri kümeleridir. Her veri kümesi, MNIST Bu durumda, verileri farklı yollarla almak için karşılık gelen bir sınıfa sahiptir.

Bu kod, bir alt sınıfı olan bir nesne olarak verileri alır FileDataset Dataset . Bir FileDataset veri deposu veya genel URL'leri herhangi bir biçimde tek veya birden çok dosya başvurur. sınıfı, veri kaynağı konumu için bir başvuru oluşturarak dosyaları indirmenize veya işleminize bağlamanıza yardımcı olur. Buna ek olarak, eğitim sırasında kolayca alınması için Veri Kümesi'nin çalışma alanınıza kaydolması gerekir.

Veri kümeleri ve SDK'daki kullanımları hakkında daha fazla bilgi edinmek için nasıl kullanılır? yönergelerini izleyin.

from azureml.core import Dataset
from azureml.opendatasets import MNIST

data_folder = os.path.join(os.getcwd(), 'data')
os.makedirs(data_folder, exist_ok=True)

mnist_file_dataset = MNIST.get_file_dataset()
mnist_file_dataset.download(data_folder, overwrite=True)

mnist_file_dataset = mnist_file_dataset.register(workspace=ws,
                                                 name='mnist_opendataset',
                                                 description='training and test dataset',
                                                 create_new_version=True)

Bazı örnek görüntüleri gösterme

Sıkıştırılmış dosyaları numpy dizilerine yükleyin. Ardından matplotlib kullanarak, üst kısımlarında etiketleriyle veri kümesinden 30 rastgele görüntü çizin. Bu adım, load_data bir dosyaya dahil edilen bir işlev utils.py gerektirir. Bu dosya örnek klasöründe bulunur. Bu not defteriyle aynı klasöre yerleştiril olduğundan emin olun. işlevi load_data sıkıştırılmış dosyaları numpy dizilerine ayrıştırır.

# make sure utils.py is in the same directory as this code
from utils import load_data
import glob


# note we also shrink the intensity values (X) from 0-255 to 0-1. This helps the model converge faster.
X_train = load_data(glob.glob(os.path.join(data_folder,"**/train-images-idx3-ubyte.gz"), recursive=True)[0], False) / 255.0
X_test = load_data(glob.glob(os.path.join(data_folder,"**/t10k-images-idx3-ubyte.gz"), recursive=True)[0], False) / 255.0
y_train = load_data(glob.glob(os.path.join(data_folder,"**/train-labels-idx1-ubyte.gz"), recursive=True)[0], True).reshape(-1)
y_test = load_data(glob.glob(os.path.join(data_folder,"**/t10k-labels-idx1-ubyte.gz"), recursive=True)[0], True).reshape(-1)


# now let's show some randomly chosen images from the traininng set.
count = 0
sample_size = 30
plt.figure(figsize=(16, 6))
for i in np.random.permutation(X_train.shape[0])[:sample_size]:
    count = count + 1
    plt.subplot(1, sample_size, count)
    plt.axhline('')
    plt.axvline('')
    plt.text(x=10, y=-10, s=y_train[i], fontsize=18)
    plt.imshow(X_train[i].reshape(28, 28), cmap=plt.cm.Greys)
plt.show()

Rastgele görüntü örnekleri gösterilir:

Artık bu görüntülerin nasıl göründüğü ve beklenen tahmin sonucu hakkında bir fikriniz oldu.

Uzak kümede eğitme

Bu görev için, daha önce ayar gönderdiğiniz uzak eğitim kümesinde çalıştıracak işi gönderin. İş göndermek için şunları yaparsınız:

• Dizin oluşturma
• Eğitim betiği oluşturma
• Betik çalıştırma yapılandırması oluşturma
• İşi gönderme

Dizin oluşturma

Gerekli kodu bilgisayarınızdan uzak kaynağa teslim etmek için bir dizin oluşturun.

import os
script_folder = os.path.join(os.getcwd(), "sklearn-mnist")
os.makedirs(script_folder, exist_ok=True)

Eğitim betiği oluşturma

İşi kümeye göndermek için, önce bir eğitim betiği oluşturun. Aşağıdaki kodu çalıştırarak, az önce oluşturduğunuz dizinde train.py adlı eğitim betiğini oluşturun.

%%writefile $script_folder/train.py

import argparse
import os
import numpy as np
import glob

from sklearn.linear_model import LogisticRegression
import joblib

from azureml.core import Run
from utils import load_data

# let user feed in 2 parameters, the dataset to mount or download, and the regularization rate of the logistic regression model
parser = argparse.ArgumentParser()
parser.add_argument('--data-folder', type=str, dest='data_folder', help='data folder mounting point')
parser.add_argument('--regularization', type=float, dest='reg', default=0.01, help='regularization rate')
args = parser.parse_args()

data_folder = args.data_folder
print('Data folder:', data_folder)

# load train and test set into numpy arrays
# note we scale the pixel intensity values to 0-1 (by dividing it with 255.0) so the model can converge faster.
X_train = load_data(glob.glob(os.path.join(data_folder, '**/train-images-idx3-ubyte.gz'), recursive=True)[0], False) / 255.0
X_test = load_data(glob.glob(os.path.join(data_folder, '**/t10k-images-idx3-ubyte.gz'), recursive=True)[0], False) / 255.0
y_train = load_data(glob.glob(os.path.join(data_folder, '**/train-labels-idx1-ubyte.gz'), recursive=True)[0], True).reshape(-1)
y_test = load_data(glob.glob(os.path.join(data_folder, '**/t10k-labels-idx1-ubyte.gz'), recursive=True)[0], True).reshape(-1)

print(X_train.shape, y_train.shape, X_test.shape, y_test.shape, sep = '\n')

# get hold of the current run
run = Run.get_context()

print('Train a logistic regression model with regularization rate of', args.reg)
clf = LogisticRegression(C=1.0/args.reg, solver="liblinear", multi_class="auto", random_state=42)
clf.fit(X_train, y_train)

print('Predict the test set')
y_hat = clf.predict(X_test)

# calculate accuracy on the prediction
acc = np.average(y_hat == y_test)
print('Accuracy is', acc)

run.log('regularization rate', np.float(args.reg))
run.log('accuracy', np.float(acc))

os.makedirs('outputs', exist_ok=True)
# note file saved in the outputs folder is automatically uploaded into experiment record
joblib.dump(value=clf, filename='outputs/sklearn_mnist_model.pkl')

Betiğin verileri nasıl aldığına ve modelleri nasıl kaydettiğine dikkat edin:

• Eğitim betiği, verileri içeren dizini bulmak için bir bağımsız değişkeni okur. Daha sonra işi gönderdiğinizde, bu bağımsız değişken için veri deposuna işaret edersiniz:

  parser.add_argument('--data-folder', type=str, dest='data_folder', help='data directory mounting point')

• Eğitim betiği, modelinizi outputs adlı bir dizine kaydeder. Bu dizine yazılan her şey otomatik olarak çalışma alanınıza yüklenir. Modelinize öğreticinin sonraki adımlarında bu dizinden erişebilirsiniz. joblib.dump(value=clf, filename='outputs/sklearn_mnist_model.pkl')

• Eğitim betiği, dosyanın utils.py veri kümesine doğru şekilde yüklemesi gerekir. Aşağıdaki kod içine utils.py script_folder kopyalanır, böylece dosyaya uzak kaynakta eğitim betiğiyle birlikte erişilebilir.

  import shutil
  shutil.copy('utils.py', script_folder)
  

Eğitim işini yapılandırma

Eğitim betiğiniz, kullanmak için ortam ve üzerinde çalıştıracak işlem hedefi dahil olmak üzere eğitim iş yapılandırma ayrıntılarını belirtmek için bir ScriptRunConfig nesnesi oluşturun. ScriptRunConfig'i yapılandırmak için şunları belirtin:

• Betiklerinizi içeren dizin. Bu dizindeki dosyaların tümü yürütülmek üzere küme düğümlerine yüklenir.
• Bilgi işlem hedefi. Bu örnekte oluşturduğunuz Azure Machine Learning işlem kümesini kullanacaksınız.
• Eğitim betiği adı, train.py.
• Betiği çalıştırmak için gereken kitaplıkları içeren ortam.
• Eğitim betiğinden gereken bağımsız değişkenler.

Bu öğreticide bu hedef AmlCompute'tir. Betik klasöründeki tüm dosyalar, çalıştır için küme düğümlerine karşıya yükler. --data_folder, veri kümesi kullanmak üzere ayarlanır.

İlk olarak şu ortamı oluşturun: scikit-learn kitaplığı, veri kümesine erişmek için gereken azureml-dataset-runtime ve ölçümleri günlüğe kaydetme bağımlılıklarını içeren azureml-defaults. azureml-defaults ayrıca öğreticinin 2. bölümünde modeli web hizmeti olarak dağıtmak için gereken bağımlılıkları içerir.

Ortam tanımlandıktan sonra, öğreticinin 2. bölümünde yeniden kullanmak için çalışma alanına kaydetmeniz gerekir.

from azureml.core.environment import Environment
from azureml.core.conda_dependencies import CondaDependencies

# to install required packages
env = Environment('tutorial-env')
cd = CondaDependencies.create(pip_packages=['azureml-dataset-runtime[pandas,fuse]', 'azureml-defaults'], conda_packages=['scikit-learn==0.22.1'])

env.python.conda_dependencies = cd

# Register environment to re-use later
env.register(workspace=ws)

Ardından eğitim betiği, işlem hedefi ve ortamı belirterek ScriptRunConfig'i oluşturun.

from azureml.core import ScriptRunConfig

args = ['--data-folder', mnist_file_dataset.as_mount(), '--regularization', 0.5]

src = ScriptRunConfig(source_directory=script_folder,
                      script='train.py', 
                      arguments=args,
                      compute_target=compute_target,
                      environment=env)

İşi kümeye gönderme

ScriptRunConfig nesnesini göndererek denemeyi çalıştırın:

run = exp.submit(config=src)
run

Çağrı zaman uyumsuz olduğundan, iş başlatıldı hemen hazırlık veya Çalışıyor durumu döndürür.

Uzaktan çalıştırmayı izleme

Toplamda ilk çalıştırma yaklaşık 10 dakika sürer. Ancak sonraki çalıştırmalarda betik bağımlılıkları değişmese de aynı görüntü yeniden kullanılır. Bu nedenle kapsayıcı başlatma süresi çok daha hızlıdır.

Siz beklerken ne olur?

• Görüntü oluşturma: Azure depolama ortamı tarafından belirtilen Python ortamıyla eşleşen bir Docker ML oluşturulur. Görüntü, çalışma alanına yüklenir. Görüntü oluşturma ve karşıya yükleme işlemi yaklaşık beş dakika sürer.

  Kapsayıcı sonraki çalıştırmalar için önbelleğe alınmış olduğundan bu aşama her Python ortamı için bir kez gerçekleşir. Görüntü oluşturma sırasında, günlükler çalıştırma geçmişine aktarılır. Bu günlükleri kullanarak görüntü oluşturma ilerleme durumunu izleyebilirsiniz.

• Ölçeklendirme: Uzak kümenin şu anda kullanılabilir durumdan daha fazla çalıştırmayı yapmak için daha fazla düğüme ihtiyacı varsa, otomatik olarak ek düğümler eklenir. Ölçeklendirme genellikle yaklaşık beş dakika sürer.

• Çalıştırma: Bu aşamada gerekli betikler ve dosyalar işlem hedefine gönderilir. Ardından veri deposu bağlı veya kopyalanır. Ardından, entry_script çalıştırın. İş çalışırken stdout ve ./logs dizini çalıştırma geçmişine akışla akışı yapılan bir dizindir. Bu günlükleri kullanarak çalıştırmanın ilerleme durumunu izleyebilirsiniz.

• İşlem sonrası: Çalıştırmanın ./outputs dizini çalışma alanınız içinde çalıştırma geçmişine kopyalanır, böylece bu sonuçlara erişebilirsiniz.

Çalışan bir işin ilerlemesini çeşitli yollarla kontrol edin. Bu öğreticide Jupyter pencere öğesi ve yöntemi wait_for_completion 2.

Jupyter pencere öğesi

Jupyter pencere öğesiyle çalıştırmanın ilerlemesini izleyin. Çalıştırma gönderimi gibi pencere öğesi de zaman uyumsuz olur ve iş bitene kadar her 10-15 saniyede bir canlı güncelleştirmeler sağlar:

from azureml.widgets import RunDetails
RunDetails(run).show()

Pencere öğesi, eğitimin sonunda aşağıdakine benzer:

Bir çalıştırmayı iptal etmeniz gerekirse bu yönergeleri takip edebilirsiniz.

Tamamlandıktan sonra günlük sonuçlarını alma

Model eğitimi ve izlemesi arka planda yapılır. Daha fazla kod çalıştırmadan önce modelin eğitimi tamamlana kadar bekleyin. Model wait_for_completion eğitiminin ne zaman tamam olduğunu göstermek için kullanın:

run.wait_for_completion(show_output=False)  # specify True for a verbose log

Çalıştırma sonuçlarını görüntüleme

Artık uzak düğümde eğitilmiş bir modeliniz vardır. Modelin doğruluğunu alın:

print(run.get_metrics())

Çıkış, uzak modelin 0,9204 doğruluk oranına sahip olduğunu gösterir:

{'regularization rate': 0.8, 'accuracy': 0.9204}

Sonraki öğreticide bu modeli daha ayrıntılı bir şekilde keşfedersiniz.

Modeli kaydetme

Eğitim betiğinde son adım, işi çalıştıracak kümenin VM'sinde adlı outputs/sklearn_mnist_model.pkl outputs bir dizinde dosyayı yazdı. outputs , bu dizinde yer alan tüm içeriklerin çalışma alanınıza otomatik olarak yüklensin diye özel bir dizindir. Bu içerik çalışma alanınızın altında yer alan denemedeki çalıştırma kaydında gösterilir. Bu nedenle model dosyası artık çalışma alanınız içinde de kullanılabilir.

Bu çalıştırmayla ilişkili dosyaları görebilir:

print(run.get_file_names())

Modeli çalışma alanına kaydedebilirsiniz; böylece siz veya diğer ortak çalışanlar bu modeli daha sonra sorgular, inceler ve dağıtabilirsiniz:

# register model
model = run.register_model(model_name='sklearn_mnist',
                           model_path='outputs/sklearn_mnist_model.pkl')
print(model.name, model.id, model.version, sep='\t')

Kaynakları temizleme

Oluşturduğunuz kaynakları kullanmayı planlamıyorsanız, herhangi bir ücret ödemeden bu şekilde silin:

1. Azure portalının en sol tarafındaki Kaynak gruplarını seçin.

2. Listeden oluşturduğunuz kaynak grubunu seçin.

3. Kaynak grubunu sil'i seçin.

   

4. Kaynak grubu adını girin. Ardından Sil’i seçin.

Ayrıca yalnızca İşlem kümesi Azure Machine Learning silebilirsiniz. Ancak, otomatik ölçeklendirme açık ve küme minimum değeri sıfırdır. Bu nedenle, bu belirli kaynak kullanımda olmadığında ek işlem ücretleri oluşturmaz:

# Optionally, delete the Azure Machine Learning Compute cluster
compute_target.delete()

Sonraki adımlar

bu Azure Machine Learning öğreticide, aşağıdaki görevler için Python kullandınız:

Bu kayıtlı modeli, öğretici serisinin sonraki bölümündeki yönergeleri kullanarak dağıtmaya hazırsınız: