пятница, 17 января 2014 г.

Расхождение между показаниями 'du' и 'df'



$df -h /u01
Filesystem            Size  Used Avail Use% Mounted on
/dev/cciss/c1d0p8      39G  5.8G   31G  16% /u01

$du -sh /u01
5.2G    /u01



$ /usr/sbin/lsof |grep /u01 |grep deleted |awk '{print $7,$2,$4,$9}' | sort -n | tail

1614001 10421 9w /u01/oracle/admin/art/adump/ora_10421.xml
1691210 17139 9w /u01/oracle/admin/art/adump/ora_17139.xml
1967865 28646 9w /u01/oracle/admin/art/adump/ora_28646.xml
2441753 28344 9w /u01/oracle/admin/art/adump/ora_28344.xml
2629109 5405 9w /u01/oracle/admin/art/adump/ora_5405.xml
3430422 8253 9w /u01/oracle/admin/art/adump/ora_8253.xml
7629320 8288 9w /u01/oracle/admin/art/adump/ora_8288.xml
8703518 8993 9w /u01/oracle/admin/art/adump/ora_8993.xml
104262556 8051 9w /u01/oracle/admin/art/adump/ora_8051.xml
320712351 25992 9w /u01/oracle/admin/art/adump/ora_25992.xml


Далее необходимо перезапустить процесс.

Как временное решение, можно освободить место так:


$ ls -latr /proc/25992/fd/ | grep ora_25992.xml

l-wx------ 1 oracle oinstall 64 Jan 17 10:49 9 -> /u01/oracle/admin/art/adump/ora_25992.xml (deleted)


$ cat /dev/null > /proc/25992/fd/9


$df -h /u01
Filesystem            Size  Used Avail Use% Mounted on
/dev/cciss/c1d0p8      39G  5.5G   31G  16% /u01

$du -sh /u01
5.2G    /u01

понедельник, 13 января 2014 г.

Process IO Top utility with Solaris DTrace


Скрипт из блога:

http://lserinol.blogspot.ru/2009/04/process-io-top-utility-with-solaris.html


#!/usr/bin/bash
# process_io_top -  show procesess by top read/write KB I/O per file
#            Written by Levent Serinol (lserinol@gmail.com)
#            http://lserinol.blogspot.com
# Apr/14/2009
#
# USAGE: process_io_top [-s interval] [-p pid]
#    
#     -s interval     # gather and show statistics in given interval (seconds)
#     -p pid        # show read/write KB I/O just for given PID
#     -h         # show usage information
#
# eg:
#    process_io_top    -s 10   
#
#
#
####################################################################################
interval=5
show_pid=0
pid=0

function usage()
{
echo "
USAGE: io.sh [-s interval] [-p pid]
         -s             # set interval, default is 5 seconds
         -p pid         # pid
  eg,
         io -p 630                # io activity of pid 630
         io -s 10                 # refresh output in every 10 seconds";
}

while getopts h:p:s:a name
do
        case $name in
        p)         show_pid=1; pid=$OPTARG ;;
        s)         interval=$OPTARG ;;
        h|?)    usage;
                  exit 1
        esac
done

/usr/sbin/dtrace -Cws <( cat <
 inline int PID        = $pid;
 inline int SHOW_PID    = $show_pid;
 inline int INTERVAL    = $interval;


#pragma D option quiet
#pragma D option aggsortrev


dtrace:::BEGIN
{
  secs = INTERVAL;
  printf("Please wait....\n");
}

io:::start
/ (SHOW_PID == 1) && ( pid == PID) /
{
    self->rw=args[0]->b_flags & B_READ ? "R" : "W";
    @files[pid,execname,self->rw,args[2]->fi_pathname] = sum (args[0]->b_bcount);
    @total_blks[self->rw]=count();
    @total_bytes[self->rw]=sum (args[0]->b_bcount);
    self->rw=0;
}

io:::start
/ SHOW_PID == 0 /
/* SHOW_PID == 0 && args[2]->fi_pathname != "" */
{
    self->rw=args[0]->b_flags & B_READ ? "R" : "W";
    @files[pid,execname,self->rw,args[2]->fi_pathname] = sum (args[0]->b_bcount);
    @total_blks[self->rw]=count();
    @total_bytes[self->rw]=sum (args[0]->b_bcount);
    self->rw=0;
}

profile:::tick-1s
{
        secs--;
}


profile:::tick-1s
/secs == 0/
{

    trunc(@files,30);
    normalize(@files,1024);
    system("/usr/bin/clear");
    printf("%Y ",walltimestamp);
    printa("%s %@11d blocks, ",@total_blks);
    printa("%s %@11d bytes, ",@total_bytes);
    printf("\n%6s %-12s %3s %8s %3s\n", "PID", "CMD","R/W", "KB", "FILE");
    printa("%6d %-12.12s %1s %@10d %s\n",@files);
    secs = INTERVAL;

}
dtrace:::END
{
        trunc(@files);
}
EOF
)


пятница, 3 января 2014 г.

Простой перцептрон


Простой перцептрон состоит из нескольких входов inp_t[1], inp_t[2] ... inp_t[n].
Каждому входу соответствует некий вес  w[1], w[2] ... w[n].
Также имеется вход активации inp_b с весом w_b.
На вход активации постоянно подается единица,  а вес на входе активации задает порог срабатывания перцептрона.

На выходе перцептрона  может быть либо единица 1 либо -1 в зависимости от входных сигналов и весовых коэффициентов.

Условие срабатывания перцептрона ( когда на выходе появляется единица) :

w_b +   w[1] *  inp_t[1] + w[2] *  inp_t[2] + ...+ w[n] *  inp_t[n]  > 0

Но можно и не различать входы inp_t и inp_b, а просто предположить, что у перцептрона  есть еще один вход inp_t[0], на который всегда подается единица, а w_b записать как w[0].
Тогда условие срабатывания перцептрона можно записать так:

w[0] *  inp_t[0] + w[1] *  inp_t[1] + w[2] *  inp_t[2] + ...+ w[n] *  inp_t[n]  > 0

Обучение перцептрона сводится к такому подбору весов w[0]...w[n] , при которых для всех
входных наборов данных  (inp_t[1], inp_t[2] ... inp_t[n]),  (inp_t[1], inp_t[2] ... inp_t[n]) ... (inp_t[1], inp_t[2] ... inp_t[n]), на выходе появлялось бы требуемое целевое значение out_t , соответствующее каждому входному набору.

Если реальное выходное значение перцептрона  out_r  отличается от требуемого целевого значения out_t,  то необходимо подправить веса w[0]....w[n] перцептрона.

На каждом шаге обучения веса w[0]....w[n] должны изменяться в соответствии с правилом:

w[i] += t * (out_t - out_r) * inp_t[i]

где  t - это небольшая константа (обычно  0,05 - 0,2) , которая задает скорость обучения.

Например обучим перцептрон логической функции дизъюнкции (операции ИЛИ).

 inp_t[1]  inp_t[2]  out_t

0    0   -1
0    1    1
1    0    1
1    1    1

На вход алгоритму подаем скорость обучения t = 0,1
и входной вектор из четырех тестовых наборов [[0,0,-1],[0,1,1],[1,0,1],[1,1,1]]
в соответствии с таблицей истинности логической операции ИЛИ.
на выходе должны получить вектор весовых коэффициентов w[0]....w[n]



Алгоритм обучения простого перцептрона:

import random

def PerTrain(t, v):

    w = []

    # инициализируем начальные веса маленькими случайными значениями
    for i in range(len(v[0])):
        w.append((random.randrange(-5,5))/50.0)

    chw = True
    while (chw == True):

       chw = False
      
       for tst_n in v:
           
            # получаем входные значения из тесового набора
            # единицу добавляем для входа активации  ( inp_t[0] = 1)
            inp_t = [1] + tst_n[0:len(tst_n) - 1]
          
            # получаем целевое выходное значение из тестового набора
            out_t = tst_n[len(tst_n) - 1]
          
            # реальное выходное значение будет вычислено позже
            out_r = 0

            # вычисляем выходное значение перцептрона (out_r)
            for i in range(len(w)):
                out_r += w[i] * inp_t[i]

            if out_r > 0:
                out_r = 1
            else:
                out_r = -1

           
            if (out_r != out_t):
                chw = True
                # если на каком либо тестовом наборе перцептрон не сработал, то пересчитываем веса
                for i in range(len(w)):
                    w[i] += t * (out_t - out_r) * inp_t[i]
                   
                break  

    return w

rez = PerTrain(0.1,[[0,0,-1],[0,1,1],[1,0,1],[1,1,1]])

print(rez)



Например получили такие веса:

[-0.1, 0.14, 0.16]

Проверяем:

print(1*-0.1 + 0*0.14 + 0*0.16)
print(1*-0.1 + 0*0.14 + 1*0.16)
print(1*-0.1 + 1*0.14 + 0*0.16)
print(1*-0.1 + 1*0.14 + 1*0.16)

в результате получаем:

-0.1
0.06
0.04000000000000001
0.2

что действительно соответствует дизъюнкции:

-1
 1
 1
 1