書式保持メモ

/* Curl Test **************************************************//*  curlテスト関数                                */
s4 cl_funcs::curlTest( void )                                   //                                                //
{                                                               //                                                //
    s4 rtnCod = RET_OK;                                         //  リターンコード                                //
    TCHAR strBuf[BUFF_SIZE_MERE] = _T("");                      //  ダンプ内容説明用文字列                        //
    http_client hC( _T("http://192.168.3.6:8000/gen/") );       //  http_clientを作成                             //
                                                                //                                                //
    http_request request( methods::GET );                       //  GETリクエストを作成                           //
    auto res = hC.request( request ).get();                     //  リクエスト実行                                //
                                                                //                                                //
//    http_request request( methods::POST );                      //  POSTリクエストを作成                          //
//    request.headers().add( _T("Content-Type"), _T("application/octet-stream") ); //  ヘッダ編集                   //
//    request.headers().add( _T("Content-Length"), _T("10") ); //  ヘッダ編集                   //
//    auto data = vector< u1 >( 10, 'A' );                        
//                                                                //                                                //
//    request.set_body( data );                                   //  リクエストbodyを設定                          //
//    tstring str = uB.to_string();                               
//                                                                //                                                //
//    auto t1( hC.request( methods::GET, str ) );                 
//    auto t1( hC.request( request ).get() );
//    auto t1( response = hc.request(request).get();
//    auto res = hC.request( request ).get(); 
//    auto res = hC.request( methods::POST, _T(""), data, _T("application/octet-stream") ); 
//    auto res = hC.request( methods::POST, _T(""), data, _T("application/octet-stream") ).get(); 
//    auto res = hC.request( methods::POST, _T("") ).get(); 
//    http_response res = hC.request( methods::GET ).get(); 
                                                                //                                                //
    for ( ; ; )                                                 //  無限ループ                                    //
    {                                                           //                                                //
        TCHAR body[BUFF_SIZE_MERE];                             //  応答内容取得用                                //
        _sntprintf_s( body, _countof(body), _TRUNCATE,          //  文字列編集                                    //
                      _T("%s"), (TCHAR*)(res.extract_string().get().c_str()) ); //                                //
        MessageBox( NULL, body,                                 //  画面表示                                      //
                    APP_NAME, MB_ICONWARNING | MB_OK );         //                                                //
                                                                //                                                //
//        hC.request(methods::GET).then([](http_response res) 
//        {
//            TCHAR body[BUFF_SIZE_MERE];                             //  応答内容取得用                                //
//            _sntprintf_s( body, _countof(body), _TRUNCATE,          
//                          _T("%s"), (TCHAR*)(res.extract_string().get().c_str()) ); //  コマンド編集  //
//            MessageBox( NULL, body,                                 //  画面表示                                      //
//                        APP_NAME, MB_ICONWARNING | MB_OK );         //                                                //
////            // Print the status code.
////            std::wostringstream ss;
////            ss << L"Server returned returned status code " << response.status_code() << L'.' << std::endl;
////            std::wcout << ss.str();
////
////            // TODO: Perform actions here reading from the response stream.
////            auto bodyStream = response.body();
////
////            // In this example, we print the length of the response to the console.
////            ss.str(std::wstring());
////            ss << L"Content length is " << response.headers().content_length() << L" bytes." << std::endl;
////            std::wcout << ss.str();
//        });                                                                //                                                //
//                                                                //                                                //
//        t1.then(
//        [](http_response res)
//        {                                                       
//            TCHAR body[BUFF_SIZE_MERE];                         //  応答内容取得用                                //
////            auto body2 = res.extract_string().get(); 
////            char body3[BUFF_SIZE_MERE];
////            snprintf( body3, _countof(body3), "%s", (char*)body2.c_str() );
//                                                                //            tstring msg{ (*TCHAR)res.extract_string().get().c_str() };
////            MessageBox( NULL, (TCHAR*)msg.c_str(),                               //  画面表示                                      //
//            _sntprintf_s( body, _countof(body), _TRUNCATE, 
//                          _T("%s"), (TCHAR*)(res.extract_string().get().c_str()) ); //  コマンド編集  //
////            MessageBox( NULL, (TCHAR*)(res.extract_string().get().c_str()),                               //  画面表示                                      //
//            MessageBox( NULL, body,                               //  画面表示                                      //
//                        APP_NAME, MB_ICONWARNING | MB_OK );         //                                                //
//        }
//        ).wait();                                              
                                                                //                                                //
                                                                //                                                //
        break;                                                  //  処理終了                                      //
    }                                                           //                                                //
                                                                //                                                //
    return( rtnCod );                                           //  リターンコードを返して終了                    //
}                                                               //                                                //
//*Curl Test **************************************************//*  curlテスト関数                                */
/* Write Schedule Patterns Drums ******************************//*  学習パターン出力処理(ドラムス規定実体)        */
s4 cl_nn::writeSch_MDG( u4_ms (&vd_mSet)[SCH_TYPE_NUM], ST_SCH_CONF* vd_sch_conf, //                              //
                       HANDLE vd_OUFO, HANDLE vd_OUFO_TGT )     //                                                //
{                                                               //                                                //
    s4 rtnCod = ZERO;                                           //  リターンコード                                //
                                                                //                                                //
//    u4_ms_it bufIt;                                             //  出力対象バーリストの一時保持用イテレータ      //
//    s4 vLeft = ZERO;                                            //  無音空間左端                                  //
//    s4 vRight = ZERO;                                           //  無音空間右端                                  //
//    s4 len = ZERO;                                              //  音長                                          //
////    s4 cnt = ZERO;                                              //  ループカウンタ                                //
//                                                                //                                                //
//                                                                //                                                //
    u4_ms_it lower;                                             //  出力対象バーの下限用イテレータ                //
    u4_ms_it upper;                                             //  出力対象バーの上限用イテレータ                //
////    TCHAR strFmt[BUFF_SIZE_SHORT] = _T("");                     //  文字列出力用                                  //
    char strFmt[BUFF_SIZE_SHORT] = "";                          //  文字列出力用                                  //
//    s4 r[PARTS_NUM_MAIN] = { NEG, NEG, NEG, NEG };              //  バー右端評価用                                //
//    s4 barData = ZERO;                                          //  バー情報取得用                                //
//    s4 spacer = ZERO;                                           //  空白情報編集用                                //
//    s4 sLen = ZERO;                                             //  文字列長取得用                                //
//    s4 tCnts = ONE;                                             //  トークンカウンタ                              //
//    char eos[BUFF_SIZE_SHORT] = ".\n";                          //  文終止指示                                    //
    s4 sPos = ZERO;                                             //  開始位置                                      //
    s4 cPos = ZERO;                                             //  現在位置                                      //
    s4 ePos = ZERO;                                             //  終了位置                                      //
    s4 vLen = ZERO;                                             //  空白長                                        //
    s4 wLen = ZERO;                                             //  全長                                          //
    s4 cLen = ZERO;                                             //  積上全長                                      //
                                                                //                                                //
    vd_sch_conf;
                                                                //                                                //
    for ( ; ; )                                                 //  無限ループ                                    //
    {                                                           //                                                //
        if( true == vd_mSet[DRUMS].empty() )                    //  空のパートか                                  //
        {                                                       //  空のパートなら                                //
            rtnCod = RET_NG;                                    //  リターンにNGを設定                            //
            break;                                              //  処理中止                                      //
        }                                                       //                                                //
                                                                //                                                //
        lower = vd_mSet[DRUMS].begin();                         //  最初のバーについて                            //
        upper = vd_mSet[DRUMS].end();                           //  終端保持                                      //
//        barData = *lower;                                       //  バー情報取得                                  //
        for( ; upper != lower; lower++ )                        //  すべてのバーについて                          //
        {                                                       //                                                //
            if( ZERO != sPos )                                  //  開始位置が設定済みか                          //
            {                                                   //  開始位置が設定済みなら                        //
                cPos = getX(*lower);                            //  現在位置を取得                                //
                vLen = cPos - ePos;                             //  空白長を取得                                  //
                wLen = ePos - sPos;                             //  全長を取得                                    //
                cLen = cPos - sPos;                             //  積上全長を取得                                //
                if( ZERO == vLen )                              //  同時発音か                                    //
                {                                               //  同時発音なら                                  //
                    continue;                                   //  次のバーへ                                    //
                }                                               //                                                //
                else if( LONGEST_VOID_LEN_D < vLen )            //  空白長が上限超か                              //
                {                                               //  空白長が上限超なら                            //
                    if( SHORTEST_SENTS_LEN_D > wLen )           //  全長が下限未満か                              //
                    {                                           //  全長が下限未満なら                            //
                    }                                           //                                                //
                    else                                        //  その他の場合                                  //
                    {                                           //                                                //
//                        ePos = sPos + GRID_H;                   //  文章終了位置を設定                            //
                        if( NULL == vd_OUFO )                   //  ファイル出力先が一つしか指定されていないか    //
                        {                                       //  ファイル出力先が一つしか指定されていない場合  //
                            obj_nn.outDG( vd_mSet[DRUMS], sPos, ePos, vd_OUFO_TGT ); //  生成系ファイル出力依頼  //
                        }                                       //                                                //
                        else                                    //  その他の場合                                  //
                        {                                       //                                                //
                            obj_nn.outMD( vd_mSet, sPos, ePos, vd_OUFO, vd_OUFO_TGT ); // 対位系ファイル出力依頼 //
                        }                                       //                                                //
                    }                                           //                                                //
                    sPos = cPos;                                //  文章開始位置を設定                            //
                    rePos = ePos;                               //  文章終了位置保持                              //
                    ePos = cPos + GRID_H;                       //  文章終了位置を設定                            //
                }                                               //                                                //
                else                                            //  その他の場合                                  //
                {                                               //                                                //
                    if( SENTS_LEN_D <= cLen )                   //  ドラムス規定長に達したか                      //
                    {                                           //  ドラムス規定長に達した場合                    //
                        if( NULL == vd_OUFO )                   //  ファイル出力先が一つしか指定されていないか    //
                        {                                       //  ファイル出力先が一つしか指定されていない場合  //
                            obj_nn.outDG( vd_mSet[DRUMS], sPos, ePos, vd_OUFO_TGT ); //  生成系ファイル出力依頼  //
                        }                                       //                                                //
                        else                                    //  その他の場合                                  //
                        {                                       //                                                //
                            obj_nn.outMD( vd_mSet, sPos, ePos, vd_OUFO, vd_OUFO_TGT ); // 対位系ファイル出力依頼 //
                        }                                       //                                                //
                        sPos = cPos;                            //  文章開始位置を設定                            //
                    }                                           //                                                //
                    rePos = ePos;                               //  文章終了位置保持                              //
                    ePos = cPos + GRID_H;                       //  文章終了位置を設定                            //
                }                                               //                                                //
            }                                                   //                                                //
            else                                                //  その他の場合                                  //
            {                                                   //                                                //
                sPos = getX(*lower);                            //  開始位置を取得                                //
                rePos = sPos + GRID_H;                          //  文章終了位置を保持                            //
                ePos = sPos + GRID_H;                           //  文章終了位置を設定                            //
            }                                                   //                                                //
        }                                                       //                                                //
                                                                //                                                //
        wLen = ePos - sPos;                                     //  全長を取得                                    //
        if( SHORTEST_SENTS_LEN_D <= wLen )                      //  全長が下限以上か                              //
        {                                                       //  全長が下限以上なら                            //
            if( NULL == vd_OUFO )                               //  ファイル出力先が一つしか指定されていないか    //
            {                                                   //  ファイル出力先が一つしか指定されていない場合  //
                obj_nn.outDG( vd_mSet[DRUMS], sPos, ePos, vd_OUFO_TGT ); //  生成系ファイル出力依頼               //
            }                                                   //                                                //
            else                                                //  その他の場合                                  //
            {                                                   //                                                //
                obj_nn.outMD( vd_mSet, sPos, ePos, vd_OUFO, vd_OUFO_TGT ); //  対位系ファイル出力依頼             //
            }                                                   //                                                //
        }                                                       //                                                //
                                                                //                                                //
        break;                                                  //  処理終了                                      //
    }                                                           //                                                //
                                                                //                                                //
    return( rtnCod );                                           //  リターンコードを返して終了                    //
}                                                               //                                                //
//*Write Schedule Patterns Drums ******************************//*  学習パターン出力処理(ドラムス規定実体)        */

https://qiita.com/okoppe8/items/b56499fc04e6c2193b9d

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'production': {
            'format': '%(asctime)s [%(levelname)s] %(process)d %(thread)d '
                      '%(pathname)s:%(lineno)d %(message)s'
        },
    },
    'handlers': {
        'file': {
            'class': 'logging.handlers.TimedRotatingFileHandler',
            'filename': '/var/log/django/django.log',
            'formatter': 'production',
#            'level': 'INFO',
            'when': 'D',
            'interval': 1,
            'backupCount': 14,
        },
    },
    'loggers': {
        '': {
            'handlers': ['file'],
#            'level': 'INFO',
            'propagate': False,
        },
        'django': {
            'handlers': ['file'],
#            'level': 'INFO',
            'propagate': False,
        },
    },
import sys
import os
import glob
import random
import shutil
import errno

args = sys.argv

try:
    os.makedirs( "./test" )
    os.makedirs( "./train" )
    os.makedirs( "./valid" )
except OSError as e:
    if e.errno != errno.EEXIST:
        raise e

fileList = glob.glob( "./*.mid*" )

#print( "hello" )
#print( args[1] )
for file in fileList:
    randNum = random.randint(0,11)
    if 0 == randNum:
        shutil.copy( file, "./test" )
    elif 1 == randNum:
        shutil.copy( file, "./valid" )
    else:
        shutil.copy( file, "./train" )

sys.exit()
#include <stdio.h>
#include <time.h>
#include <stdlib.h>

int main( void )
{
    int rtnCod = 0;
    char strArr[10][9] = { "", };
    int intArr[10] = { 0, };
    int cnt = 0;
    int num = 0;

    srand( (unsigned int)time( NULL ) );

    for( cnt = 0; 10 > cnt; cnt++ )
    {
        intArr[cnt] = rand();
        printf( "%x\r\n", intArr[cnt] );
        snprintf( strArr[cnt], 9, "%x", intArr[cnt] );
        printf( "%s\r\n", strArr[cnt] );
        num = strtol( strArr[cnt], NULL, 16 );
        printf( "%x\r\n", num );
    }
    return( rtnCod );
}
#include <stdio.h>    
#include <sys/stat.h>    
//#include <time.h>    
#include <stdlib.h>    
    
int main( void )    
{    
    int rtnCod = 0;    
    int cnt = 0;    
    int num = 0;    
    int bBuf = 0;    
    int eBuf = 0;    
    int fSize = 0;    
    FILE* INFO = NULL;    
    struct stat st;                             /* for stat()                             */    
    char *inBuf;                                /* メモリ作業領域                         */    
    char fileName[8] = "./a.gem";    
    char word[9] = "";    
        
    stat( fileName, &st );    
    fSize = st.st_size;    
    inBuf = (char*)malloc( fSize );    
    INFO = fopen( fileName, "r");    
    fread( inBuf, sizeof(char), fSize, INFO );    
    fclose( INFO );    
    
//    printf( "%s\n--end--\n", inBuf );    
    
    for( cnt = 0; fSize > cnt; cnt++ )    
    {    
        if( ' ' == inBuf[cnt] )    
        {    
            eBuf = cnt + 1;    
            snprintf( word, eBuf - bBuf, "%s", &(inBuf[bBuf]) );    
            bBuf = cnt + 1;    
            num = strtol( word, NULL, 16 );    
            printf( "%x\n", num );    
        }    
    }    
    
    free( inBuf );    
    return( rtnCod );    
}
int delta = START_CUE_POS;
int dOffset = setX(GRID_H * INTERVAL);
int note = ZERO;
int len = ZERO;
int left = ZERO;
int right = ZERO;

for( 時点数 )
{
    barData取得
    for( 各パート: cnt_beg, cnt_end )
    {
        note = getNoteM( barData, cnt_beg );
        if( ONあり )
        {
            if( ZERO != offRsv[cnt_beg] )
            {
                left = getX(offRsv[cnt_beg]);    
                len = delta - left;    
                if( tgt == cnt_beg )
                {
                    len += dOffset;
                }
                offRsv[cnt_beg] += setL(len);
                vc_funcs_barList[cnt_beg].insert( offRsv[cnt_beg] );
                vc_funcs_barList[ALL_PART].insert( offRsv[cnt_beg] );
                offRsv[cnt_beg] = ZERO;
            }
            
            if( noteが範囲内 )
            {
                offRsv[cnt_beg] = setX(delta) + key2Y((u1)(note)) + setK(cnt_beg);
                if( tgtPart )
                {
                    offRsv[cnt_beg] += dOffset;
                }
            }
        }
        else
        {
            if( (ZERO == note) && (ZERO != offRsv[cnt_beg]) )
            {
                left = getX(offRsv[cnt_beg]);    
                len = delta - left;    
                if( tgt == cnt_beg )
                {
                    len += dOffset;
                }
                offRsv[cnt_beg] += setL(len);
                vc_funcs_barList[cnt_beg].insert( offRsv[cnt_beg] );
                vc_funcs_barList[ALL_PART].insert( offRsv[cnt_beg] );
                offRsv[cnt_beg] = ZERO;
            }
        }
    }

    delta += GRID_H;
}
//int delta = START_CUE_POS;
//int dOffset = setX(GRID_H * INTERVAL);
//int note = ZERO;
//int len = ZERO;
int left = ZERO;
//int right = ZERO;
int ePos = ZERO;
int cPos = START_CUE_POS;
int offset = INTERVAL * GRID_H;

ePos = 最終位置

for( ; ePos > cPos; cPos += GRID_H )
{
    for( 各パート: cnt_beg, cnt_end )
    {
        sPos = cPos;
        if( tgt == cnt_beg )
        {
            sPos += offset;
        }

        lower = lower_bound(sPos);
        if( end == lower )
        {
            continue;
        }

        note = getNote( *lower );
        left = getX( *lower );
        right = left + getL( *lower );
        if( sPos == left )
        {
            ON予約
        }
        else( lとrの間 )
        {
            N予約
        }
import torch                                                    # for pytorch                                      #
from torch.autograd import Variable                             # for Variable                                     #

X = torch.randn( 4, 4, 4 )
prevX = Variable(X[-1:, :, :].data, requires_grad=False)
#print(X)
#print("="*80)
#print(prevX)
#prevX = None

X = torch.randn( 4, 4, 4 )
Xm1 = []

#print( Xm1 )

Xm1.append(prevX if prevX is not None else X[:1, :, :] * 0)

if prevX is not None:
#    Xm2 = prevX
    Xm2 = torch.cat((prevX, X[:-1, :, :]), 0)
else:
#    Xm2 = torch.tensor(X[:1, :, :] * 0)
    Xm2 = torch.cat((X[:1, :, :] * 0, X[:-1, :, :]), 0)

#print( Xm1 )
#print( Xm2 )

if len(X) > 1:
    Xm1.append(X[:-1, :, :])
#    Xm2 = torch.cat((Xm2,X[:-1, :, :]))

#print( Xm1 )

Xm1 = torch.cat(Xm1, 0)

#print( Xm1 )
#print( Xm2 )

source = torch.cat([X, Xm1], 2)
source2 = torch.cat((X, Xm2), dim=2)

#print( source )
#print("="*80)
#print( source2 )

#l = [X, Xm1]
#t = (X, Xm1)
#print(l)
#print(t)
#print(type(l))
#print(type(t))
■頻度ログ残し
 生成したらID払出し(元種別番号+種別番号+セット番号+Index)
 フラグとともに保持しておき
 対位系のときにIDも送信
 IDをログに残す


■中断再開とColab連続稼働
 https://qiita.com/iZuno-K/items/453cbc023a477359f272


■数を絞って実現性証明
 HHC

■手動でFP16
 https://qiita.com/arutema47/items/d9e097f00b0b4934d07a

	01G	g1→gs1	11G	21G	31G	0DG	1DG	2DG	3DG	4DG	D1G	D2G	D3G	D4G
learn	sc1		sc2	sc3	sc4	scd	t1d	t2d	t3d	t4d	t1d	t2d	t3d	t4d
input	random	g1	gs1_8	gs2_s	gs3_s	random	time1	time2	time3	time4	dr	dr	dr	dr
output1	g1	gs1	gs2	gs3	gs4	dr	dr	dr	dr	dr	time1	time2	time3	time4
output2														
source1														
source2														
動作	自動	自動	自動	自動	自動	自動	手動	手動	手動	手動	手動	手動	手動	手動
切分け	1g	-	2g	3g	4g	dg								
		s + 8bit	s + 8bit*2	s + 8bit*3	s + 8bit*4

https://colab.research.google.com/drive/19icmsmrvXL3Ozv4UylAKgiHS5Lm89NVi#scrollTo=6V9nyBt2N1QI

#!/bin/bash

lNum=0
cNum=0
strBuf=`cat $1`

while read line
do
  lNum=$(expr $lNum + 1)
  CS=`echo $line | sed -e 's@[^ ]@@g'`
  cNum=${#CS}
  echo $lNum : $cNum
done << END
cat $strBuf
END

echo $lNum

トップ   編集 凍結 差分 バックアップ 添付 複製 名前変更 リロード   新規 一覧 単語検索 最終更新   ヘルプ   最終更新のRSS
Last-modified: 2020-03-23 (月) 03:53:14 (64d)