Satura pārskats iestatīšana Lejupielādēt datus Datu priekšapstrāde Loģistikas regresija Loģistikas regresijas pamatprincipi Log zaudējumu funkcija Gradientu lejupslīdes atjaunināšanas noteikums Vilciens ar modeli Darbības novērtējums Saglabājiet modeli Secinājums Šajā rokasgrāmatā parādīts, kā izmantot TensorFlow Core zema līmeņa API, lai veiktu bināro klasifikāciju ar loģistikas regresiju. audzēja klasifikācija. Wisconsin krūts vēža datu kopums ir viens no populārākajiem algoritmiem binārajai klasifikācijai. Ņemot vērā piemēru kopumu ar iezīmēm, loģistikas regresijas mērķis ir iegūt vērtības starp 0 un 1, ko var interpretēt kā katra piemēra varbūtības, kas pieder pie konkrētas klases. Loģistikas regresija iestatīšana Šis tutoriāls izmanto Lai izlasītu CSV failu a , lai izveidotu attiecības datu kopā, lai aprēķinātu neskaidrību matricu, un Lai izveidotu vizualizāciju. Pandas Datu sistēma Jūrmala Mācīšanās Matplotlib pip install -q seaborn import tensorflow as tf import pandas as pd import matplotlib from matplotlib import pyplot as plt import seaborn as sns import sklearn.metrics as sk_metrics import tempfile import os # Preset matplotlib figure sizes. matplotlib.rcParams['figure.figsize'] = [9, 6] print(tf.__version__) # To make the results reproducible, set the random seed value. tf.random.set_seed(22) 2024-08-15 02:45:41.468739: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered 2024-08-15 02:45:41.489749: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered 2024-08-15 02:45:41.496228: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered 2.17.0 Lejupielādēt datus Tālāk, ielādējiet No tā Šis datu kopums satur dažādas iezīmes, piemēram, audzēja rādiusu, tekstūru un konkavitāti. Wisconsin krūts vēža datu kopums UCI mašīntulkošanas repozitorijs url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/wdbc.data' features = ['radius', 'texture', 'perimeter', 'area', 'smoothness', 'compactness', 'concavity', 'concave_poinits', 'symmetry', 'fractal_dimension'] column_names = ['id', 'diagnosis'] for attr in ['mean', 'ste', 'largest']: for feature in features: column_names.append(feature + "_" + attr) Lasīt datu kopu panda Izmantojot : Datu sistēma pandas.read_csv dataset = pd.read_csv(url, names=column_names) dataset.info() <class 'pandas.core.frame.DataFrame'> RangeIndex: 569 entries, 0 to 568 Data columns (total 32 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 id 569 non-null int64 1 diagnosis 569 non-null object 2 radius_mean 569 non-null float64 3 texture_mean 569 non-null float64 4 perimeter_mean 569 non-null float64 5 area_mean 569 non-null float64 6 smoothness_mean 569 non-null float64 7 compactness_mean 569 non-null float64 8 concavity_mean 569 non-null float64 9 concave_poinits_mean 569 non-null float64 10 symmetry_mean 569 non-null float64 11 fractal_dimension_mean 569 non-null float64 12 radius_ste 569 non-null float64 13 texture_ste 569 non-null float64 14 perimeter_ste 569 non-null float64 15 area_ste 569 non-null float64 16 smoothness_ste 569 non-null float64 17 compactness_ste 569 non-null float64 18 concavity_ste 569 non-null float64 19 concave_poinits_ste 569 non-null float64 20 symmetry_ste 569 non-null float64 21 fractal_dimension_ste 569 non-null float64 22 radius_largest 569 non-null float64 23 texture_largest 569 non-null float64 24 perimeter_largest 569 non-null float64 25 area_largest 569 non-null float64 26 smoothness_largest 569 non-null float64 27 compactness_largest 569 non-null float64 28 concavity_largest 569 non-null float64 29 concave_poinits_largest 569 non-null float64 30 symmetry_largest 569 non-null float64 31 fractal_dimension_largest 569 non-null float64 dtypes: float64(30), int64(1), object(1) memory usage: 142.4+ KB Rādīt pirmās piecas rindas: dataset.head() id diagnosis radius_mean texture_mean perimeter_mean area_mean smoothness_mean compactness_mean concavity_mean concave_poinits_mean ... radius_largest texture_largest perimeter_largest area_largest smoothness_largest compactness_largest concavity_largest concave_poinits_largest symmetry_largest fractal_dimension_largest Tātad, ja jūs vēlaties iegādāties šo produktu, jums vajadzētu būt uzmanīgiem un rūpīgi jāpārliecinās par to, vai tas ir piemērots jūsu mājās, vai tas ir piemērots jūsu mājās, vai tas ir piemērots jūsu mājās. Datu kopumu sadaliet apmācības un testēšanas kopās, izmantojot , un Pārliecinieties, ka iezīmes ir sadalītas no mērķa etiķetēm.Tests tiek izmantots, lai novērtētu jūsu modeļa vispārināmību līdz neredzamiem datiem. pandas.DataFrame.sample pandas.DataFrame.drop pandas.DataFrame.iloc train_dataset = dataset.sample(frac=0.75, random_state=1) len(train_dataset) 427 test_dataset = dataset.drop(train_dataset.index) len(test_dataset) 142 # The `id` column can be dropped since each row is unique x_train, y_train = train_dataset.iloc[:, 2:], train_dataset.iloc[:, 1] x_test, y_test = test_dataset.iloc[:, 2:], test_dataset.iloc[:, 1] Datu priekšapstrāde Šis datu kopums satur vidējās, standarta kļūdas un lielākās vērtības katram no 10 audzēja mērījumiem, kas savākti, piemēram. mērķa kolonna ir kategorisks mainīgais ar indicating a malignant tumor and norāda uz labdabīgu audzēju diagnozi. Šī kolonna ir jāpārvērš skaitliski binārajā formātā modeļu apmācībai. "diagnosis" 'M' 'B' Tās Funkcija ir noderīga bināro vērtību kartēšanai uz kategorijām. pandas.Series.map Datu kopu vajadzētu arī pārveidot par tensoru ar Funkcija pēc pirmapstrādes ir pabeigta. tf.convert_to_tensor y_train, y_test = y_train.map({'B': 0, 'M': 1}), y_test.map({'B': 0, 'M': 1}) x_train, y_train = tf.convert_to_tensor(x_train, dtype=tf.float32), tf.convert_to_tensor(y_train, dtype=tf.float32) x_test, y_test = tf.convert_to_tensor(x_test, dtype=tf.float32), tf.convert_to_tensor(y_test, dtype=tf.float32) WARNING: All log messages before absl::InitializeLog() is called are written to STDERR I0000 00:00:1723689945.265757 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689945.269593 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689945.273290 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689945.276976 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689945.288712 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689945.292180 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689945.295550 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689945.299093 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689945.302584 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689945.306098 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689945.309484 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689945.312921 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689946.538105 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689946.540233 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689946.542239 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689946.544278 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689946.546323 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689946.548257 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689946.550168 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689946.552143 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689946.554591 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689946.556540 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689946.558447 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689946.560412 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689946.599852 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689946.601910 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689946.604061 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689946.606104 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689946.608094 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689946.610074 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689946.611985 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689946.613947 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689946.615903 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689946.618356 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689946.620668 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723689946.623031 132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 izmantot lai pārskatītu kopīgo sadalījumu pāris pāriem vidēji balstītas iezīmes no apmācības kopuma un novērot, kā tie attiecas uz mērķi: seaborn.pairplot sns.pairplot(train_dataset.iloc[:, 1:6], hue = 'diagnosis', diag_kind='kde'); Šis pāra gabals parāda, ka noteiktas iezīmes, piemēram, rādiuss, perimetrs un platība ir ļoti saistītas. Tas ir sagaidāms, jo audzēja rādiuss ir tieši iesaistīts gan perimetra, gan platības aprēķināšanā. Pārliecinieties, ka pārbaudāt arī vispārējo statistiku. Ņemiet vērā, kā katra funkcija aptver ļoti atšķirīgu vērtību diapazonu. train_dataset.describe().transpose()[:10] count mean std min 25% 50% 75% max id 427.0 2.756014e+07 1.162735e+08 8670.00000 865427.500000 905539.00000 8.810829e+06 9.113205e+08 radius_mean 427.0 1.414331e+01 3.528717e+00 6.98100 11.695000 13.43000 1.594000e+01 2.811000e+01 texture_mean 427.0 1.924468e+01 4.113131e+00 10.38000 16.330000 18.84000 2.168000e+01 3.381000e+01 perimeter_mean 427.0 9.206759e+01 2.431431e+01 43.79000 75.235000 86.87000 1.060000e+02 1.885000e+02 area_mean 427.0 6.563190e+02 3.489106e+02 143.50000 420.050000 553.50000 7.908500e+02 2.499000e+03 smoothness_mean 427.0 9.633618e-02 1.436820e-02 0.05263 0.085850 0.09566 1.050000e-01 1.634000e-01 compactness_mean 427.0 1.036597e-01 5.351893e-02 0.02344 0.063515 0.09182 1.296500e-01 3.454000e-01 concavity_mean 427.0 8.833008e-02 7.965884e-02 0.00000 0.029570 0.05999 1.297500e-01 4.268000e-01 concave_poinits_mean 427.0 4.872688e-02 3.853594e-02 0.00000 0.019650 0.03390 7.409500e-02 2.012000e-01 symmetry_mean 427.0 1.804597e-01 2.637837e-02 0.12030 0.161700 0.17840 1.947000e-01 2.906000e-01 ID 427.0 2.756014e+07 1.162735e+08 8670.00000 865427.500000 905539.00000 8.810829e+06 9.113205e+08 Radio nozīmē 427.0 1.414331e+01 3.528717e+00 6.98100 11.695000 13.43000 1.594000e+01 2.811000e+01 Teksts - nozīme 427.0 1.924468e+01 4.113131e+00 10.38000 16.330000 18.84000 2.168000e+01 3.381000e+01 perimeter_mean 427.0 9.206759e+01 2.431431e+01 43.79000 75.235000 86.87000 1.060000e+02 1.885000e+02 Pilsēta - nozīme 427.0 6.563190e+02 3.489106e+02 143.50000 420.050000 553.50000 7.908500e+02 2.499000e+03 Mīlestība - nozīme 427.0 9.633618e-02 1.436820e-02 0.05263 0.085850 0.09566 1.050000e-01 1.634000e-01 Mīlestība - nozīme 427.0 1.036597e-01 5.351893e-02 0.02344 0.063515 0.09182 1.296500e-01 3.454000e-01 Mīlestība – nozīme 427.0 8.833008e-02 7.965884e-02 0.00000 0.029570 0.05999 1.297500e-01 4.268000e-01 apzīmējumi_poinits_mean 427.0 4.872688e-02 3.853594e-02 0.00000 0.019650 0.03390 7.409500e-02 2.012000e-01 Simetrija - nozīme 427.0 1.804597e-01 2.637837e-02 0.12030 0.161700 0.17840 1.947000e-01 2.906000e-01 Ņemot vērā nesaskaņotos diapazonus, ir izdevīgi standartizēt datus tā, lai katrai funkcijai būtu nulle vidējā un vienības variance. . Normalizācija class Normalize(tf.Module): def __init__(self, x): # Initialize the mean and standard deviation for normalization self.mean = tf.Variable(tf.math.reduce_mean(x, axis=0)) self.std = tf.Variable(tf.math.reduce_std(x, axis=0)) def norm(self, x): # Normalize the input return (x - self.mean)/self.std def unnorm(self, x): # Unnormalize the input return (x * self.std) + self.mean norm_x = Normalize(x_train) x_train_norm, x_test_norm = norm_x.norm(x_train), norm_x.norm(x_test) Loģistikas regresija Pirms izveidot loģistikas regresijas modeli, ir svarīgi saprast metodes atšķirības salīdzinājumā ar tradicionālo lineāro regresiju. Loģistikas regresijas pamatprincipi Lineārā regresija atgriež tās ieejas lineāru kombināciju; šis iznākums ir neierobežots. Tā ir uz katram piemēram, tas atspoguļo varbūtību, ka piemērs pieder class. Loģistikas regresija (0, 1) Pozitīvi Loģistikas regresijas kartē tradicionālās lineārās regresijas nepārtrauktos rezultātus, Par iespējamām sekām, Šī transformācija ir arī simetriska, lai lineārā iznākuma zīmes pagrieziena rezultāts būtu pretējs sākotnējai varbūtībai. (-∞, ∞) (0, 1) Let Y denote the probability of being in class Vēlamo kartēšanu var panākt, interpretējot lineāro regresijas iznākumu kā Attiecība būt klasē Pretstatā klasēm : 1 Loģiskās odds 1 0 ln(Y1−Y)=wX+b Iestatot wX + b = z, tad šo vienādojumu var atrisināt Y: Y=ez1+ez=11+e−z 11+e−z izteiksme ir pazīstama kā Tādējādi loģistikas regresijas vienādojumu var rakstīt kā Y =σ (wX + b). Sigmoid funkcija Šajā apmācībā ietvertā datu kopa nodarbojas ar augstas dimensijas funkciju matricu.Tāpēc iepriekš minētais vienādojums ir jāpārraksta matricas vektoru formā šādi: Y=σ(Xw+b) Kur ir: Ym×1: mērķa vektoru Xm×n: funkciju matrica wn×1: a weight vector B: A bias σ: sigmoīda funkcija, ko piemēro katram izejas vektora elementam Sāciet, vizualizējot sigmoīdu funkciju, kas pārveido lineāro izeju, Lai nokristu starp un Sigmoid funkcija ir pieejama . (-∞, ∞) 0 1 tf.math.sigmoid x = tf.linspace(-10, 10, 500) x = tf.cast(x, tf.float32) f = lambda x : (1/20)*x + 0.6 plt.plot(x, tf.math.sigmoid(x)) plt.ylim((-0.1,1.1)) plt.title("Sigmoid function"); The log loss function Tās , vai binārā krustentropijas zudums, ir ideāla zuduma funkcija binārās klasifikācijas problēmai ar loģistikas regresiju. Katram piemēram žurnāla zudums kvantitatīvi nosaka līdzību starp prognozēto varbūtību un piemēra patieso vērtību. Logs zaudējumi L=−1m∑i=1myi⋅log(y^i)+(1−yi)⋅log(1−y^i) Kur ir: y^: prognozēto varbūtību vektors y: īstu mērķu vektors Jūs varat izmantot Šī funkcija automātiski piemēro sigmoīdu aktivizāciju regresijas izejai: tf.nn.sigmoid_cross_entropy_with_logits def log_loss(y_pred, y): # Compute the log loss function ce = tf.nn.sigmoid_cross_entropy_with_logits(labels=y, logits=y_pred) return tf.reduce_mean(ce) Gradientu lejupslīdes atjaunināšanas noteikums The TensorFlow Core APIs support automatic differentiation with Ja jūs esat ziņkārīgs par matemātiku aiz loģistikas regresijas , here is a short explanation: tf.GradientTape Gradientu atjauninājumi Iepriekš minētajā log zaudējumu vienādojumā atcerieties, ka katru y^i var pārrakstīt attiecībā uz ievadiem kā σ(Xiw + b). The goal is to find a w∗ and b∗ that minimize the log loss: L=−1m∑i=1myi⋅log(σ(Xiw+b))+(1−yi)⋅log(1−σ(Xiw+b)) Ņemot gradientu L attiecībā pret w, jūs iegūstat šādu: ∂L∂w=1m(σ(Xw+b)−y)X Ņemot gradientu L attiecībā pret b, jūs iegūstat šādu: ∂L∂b=1m∑i=1mσ(Xiw+b)−yi Tagad izveidojiet loģistikas regresijas modeli. class LogisticRegression(tf.Module): def __init__(self): self.built = False def __call__(self, x, train=True): # Initialize the model parameters on the first call if not self.built: # Randomly generate the weights and the bias term rand_w = tf.random.uniform(shape=[x.shape[-1], 1], seed=22) rand_b = tf.random.uniform(shape=[], seed=22) self.w = tf.Variable(rand_w) self.b = tf.Variable(rand_b) self.built = True # Compute the model output z = tf.add(tf.matmul(x, self.w), self.b) z = tf.squeeze(z, axis=1) if train: return z return tf.sigmoid(z) Lai apstiprinātu, pārliecinieties, ka neapmācītais modelis iegūst vērtības diapazonā par nelielu apmācību datu apjomu. (0, 1) log_reg = LogisticRegression() y_pred = log_reg(x_train_norm[:5], train=False) y_pred.numpy() array([0.9994985 , 0.9978607 , 0.29620072, 0.01979049, 0.3314926 ], dtype=float32) Tālāk uzrakstiet precizitātes funkciju, lai aprēķinātu pareizu klasifikāciju īpatsvaru apmācības laikā.Lai atgūtu klasifikācijas no prognozētajām varbūtībām, nosakiet slieksni, kurai visas varbūtības, kas pārsniedz slieksni, pieder pie klases Tas ir konfigurējams hiperparametrs, ko var iestatīt Tā kā deficīts. 1 0.5 def predict_class(y_pred, thresh=0.5): # Return a tensor with `1` if `y_pred` > `0.5`, and `0` otherwise return tf.cast(y_pred > thresh, tf.float32) def accuracy(y_pred, y): # Return the proportion of matches between `y_pred` and `y` y_pred = tf.math.sigmoid(y_pred) y_pred_class = predict_class(y_pred) check_equal = tf.cast(y_pred_class == y,tf.float32) acc_val = tf.reduce_mean(check_equal) return acc_val Vilciens ar modeli Izmantojot mini-paketes apmācībai nodrošina gan atmiņas efektivitāti, gan ātrāku konverģenci. API ir noderīgas funkcijas partiju un shuffling. API ļauj jums veidot sarežģītas ievades cauruļvadu no vienkāršiem, atkārtoti izmantojamiem gabaliem. tf.data.Dataset batch_size = 64 train_dataset = tf.data.Dataset.from_tensor_slices((x_train_norm, y_train)) train_dataset = train_dataset.shuffle(buffer_size=x_train.shape[0]).batch(batch_size) test_dataset = tf.data.Dataset.from_tensor_slices((x_test_norm, y_test)) test_dataset = test_dataset.shuffle(buffer_size=x_test.shape[0]).batch(batch_size) Tagad uzrakstiet apmācības slāni loģistikas regresijas modelim. sloksne izmanto log zaudējumu funkciju un tās gradientus attiecībā pret ievadi, lai iteratīvi atjauninātu modeļa parametrus. # Set training parameters epochs = 200 learning_rate = 0.01 train_losses, test_losses = [], [] train_accs, test_accs = [], [] # Set up the training loop and begin training for epoch in range(epochs): batch_losses_train, batch_accs_train = [], [] batch_losses_test, batch_accs_test = [], [] # Iterate over the training data for x_batch, y_batch in train_dataset: with tf.GradientTape() as tape: y_pred_batch = log_reg(x_batch) batch_loss = log_loss(y_pred_batch, y_batch) batch_acc = accuracy(y_pred_batch, y_batch) # Update the parameters with respect to the gradient calculations grads = tape.gradient(batch_loss, log_reg.variables) for g,v in zip(grads, log_reg.variables): v.assign_sub(learning_rate * g) # Keep track of batch-level training performance batch_losses_train.append(batch_loss) batch_accs_train.append(batch_acc) # Iterate over the testing data for x_batch, y_batch in test_dataset: y_pred_batch = log_reg(x_batch) batch_loss = log_loss(y_pred_batch, y_batch) batch_acc = accuracy(y_pred_batch, y_batch) # Keep track of batch-level testing performance batch_losses_test.append(batch_loss) batch_accs_test.append(batch_acc) # Keep track of epoch-level model performance train_loss, train_acc = tf.reduce_mean(batch_losses_train), tf.reduce_mean(batch_accs_train) test_loss, test_acc = tf.reduce_mean(batch_losses_test), tf.reduce_mean(batch_accs_test) train_losses.append(train_loss) train_accs.append(train_acc) test_losses.append(test_loss) test_accs.append(test_acc) if epoch % 20 == 0: print(f"Epoch: {epoch}, Training log loss: {train_loss:.3f}") Epoch: 0, Training log loss: 0.661 Epoch: 20, Training log loss: 0.418 Epoch: 40, Training log loss: 0.269 Epoch: 60, Training log loss: 0.178 Epoch: 80, Training log loss: 0.137 Epoch: 100, Training log loss: 0.116 Epoch: 120, Training log loss: 0.106 Epoch: 140, Training log loss: 0.096 Epoch: 160, Training log loss: 0.094 Epoch: 180, Training log loss: 0.089 Darbības novērtējums Novērojiet izmaiņas jūsu modeļa zudumu un precizitāti laika gaitā. plt.plot(range(epochs), train_losses, label = "Training loss") plt.plot(range(epochs), test_losses, label = "Testing loss") plt.xlabel("Epoch") plt.ylabel("Log loss") plt.legend() plt.title("Log loss vs training iterations"); plt.plot(range(epochs), train_accs, label = "Training accuracy") plt.plot(range(epochs), test_accs, label = "Testing accuracy") plt.xlabel("Epoch") plt.ylabel("Accuracy (%)") plt.legend() plt.title("Accuracy vs training iterations"); print(f"Final training log loss: {train_losses[-1]:.3f}") print(f"Final testing log Loss: {test_losses[-1]:.3f}") Final training log loss: 0.089 Final testing log Loss: 0.077 print(f"Final training accuracy: {train_accs[-1]:.3f}") print(f"Final testing accuracy: {test_accs[-1]:.3f}") Final training accuracy: 0.968 Final testing accuracy: 0.979 Modelis demonstrē augstu precizitāti un zemu zudumu, kad runa ir par audzēju klasifikāciju apmācības datu kopumā, un arī vispārina labi uz neredzamiem testa datiem. Šai problēmai FPR ir ļaundabīgo audzēju prognožu īpatsvars starp audzējiem, kas faktiski ir labdabīgi. Aprēķiniet neskaidrību matricu, izmantojot , kas novērtē klasifikācijas precizitāti un izmanto matplotlib, lai rādītu matricu: sklearn.metrics.confusion_matrix def show_confusion_matrix(y, y_classes, typ): # Compute the confusion matrix and normalize it plt.figure(figsize=(10,10)) confusion = sk_metrics.confusion_matrix(y.numpy(), y_classes.numpy()) confusion_normalized = confusion / confusion.sum(axis=1, keepdims=True) axis_labels = range(2) ax = sns.heatmap( confusion_normalized, xticklabels=axis_labels, yticklabels=axis_labels, cmap='Blues', annot=True, fmt='.4f', square=True) plt.title(f"Confusion matrix: {typ}") plt.ylabel("True label") plt.xlabel("Predicted label") y_pred_train, y_pred_test = log_reg(x_train_norm, train=False), log_reg(x_test_norm, train=False) train_classes, test_classes = predict_class(y_pred_train), predict_class(y_pred_test) show_confusion_matrix(y_train, train_classes, 'Training') show_confusion_matrix(y_test, test_classes, 'Testing') Daudzos medicīnas testēšanas pētījumos, piemēram, vēža noteikšanā, augsts viltus pozitīvais rādītājs, lai nodrošinātu zemu viltus negatīvo rādītāju, ir pilnīgi pieņemams un faktiski mudināts, jo risks, ka pazaudē ļaundabīgo audzēju diagnozi (viltus negatīvu), ir daudz sliktāks nekā labdabīga audzēja kļūdaina klasifikācija kā ļaundabīga (viltus pozitīva). Lai kontrolētu FPR un FNR, mēģiniet mainīt slieksnis hiperparametrs pirms klasificējot varbūtības prognozes. Zemāks slieksnis palielina modeļa vispārējās izredzes veikt ļaundabīgo audzēju klasifikāciju. Tas neizbēgami palielina skaitu viltus pozitīvo un FPR, bet arī palīdz samazināt skaitu viltus negatīvo un FNR. Saglabājiet modeli Sāciet, izveidojot eksporta moduli, kas ņem neapstrādātus datus un veic šādas darbības: Normalization Iespējamības prognoze Klases prognoze class ExportModule(tf.Module): def __init__(self, model, norm_x, class_pred): # Initialize pre- and post-processing functions self.model = model self.norm_x = norm_x self.class_pred = class_pred @tf.function(input_signature=[tf.TensorSpec(shape=[None, None], dtype=tf.float32)]) def __call__(self, x): # Run the `ExportModule` for new data points x = self.norm_x.norm(x) y = self.model(x, train=False) y = self.class_pred(y) return y log_reg_export = ExportModule(model=log_reg, norm_x=norm_x, class_pred=predict_class) Ja vēlaties saglabāt modeli pašreizējā stāvoklī, varat to izdarīt, izmantojot Lai ielādētu saglabāto modeli un veiktu prognozes, izmantojiet function. tf.saved_model.save tf.saved_model.load models = tempfile.mkdtemp() save_path = os.path.join(models, 'log_reg_export') tf.saved_model.save(log_reg_export, save_path) INFO:tensorflow:Assets written to: /tmpfs/tmp/tmp9k_sar52/log_reg_export/assets INFO:tensorflow:Assets written to: /tmpfs/tmp/tmp9k_sar52/log_reg_export/assets log_reg_loaded = tf.saved_model.load(save_path) test_preds = log_reg_loaded(x_test) test_preds[:10].numpy() array([1., 1., 1., 1., 0., 1., 1., 1., 1., 1.], dtype=float32) Secinājums Šajā piezīmju grāmatiņā tika ieviestas dažas metodes, lai risinātu loģistikas regresijas problēmu. TensorFlow Core API var izmantot, lai izveidotu mašīntulkošanas darba plūsmas ar augstu konfigurējamības līmeni Kļūdu rādītāju analīze ir lielisks veids, kā iegūt lielāku ieskatu par klasifikācijas modeļa veiktspēju, kas pārsniedz tā vispārējo precizitātes punktu. Overfitting ir vēl viena bieži sastopama problēma loģistikas regresijas modeļiem, lai gan šī apmācība nebija problēma. Lai iegūtu vairāk piemēru par TensorFlow Core API izmantošanu, skatiet Ja vēlaties uzzināt vairāk par datu augšupielādi un sagatavošanu, skatiet vai . ceļvedis Attēlu datu iekraušana CSV datu iekraušana Originally published on the website, this article appears here under a new headline and is licensed under CC BY 4.0. Code samples shared under the Apache 2.0 License TensorFlow Sākotnēji publicēts par Šis raksts šeit parādās ar jaunu virsrakstu un ir licencēts saskaņā ar CC BY 4.0. TensorFlow TensorFlow
