2019年3月30日 星期六
rdkit install for MacOSX
MacOSX在安裝rdkit有兩種方式，一種是利用conda安裝rdkit環境，但是要啟動rdkit環境。另一種是透過Homebrew安裝，可以直接用python編譯，缺點是2017舊版本。以下會介紹這兩種方式要如何安裝。
2019年3月27日 星期三
2019年3月23日 星期六
四塊GPU即可訓練BigGAN：「官方版」PyTorch實現出爐
作爲「史上最強 GAN 圖像生成器」，BigGAN 自去年 9 月推出以來就成爲了 AI 領域最熱詞。其生成圖像的目標和背景都高度逼真、邊界自然，簡直可以說是在「創造新物種」。然而 BigGAN 訓練時需要的超高算力（128-512 個谷歌 TPU v3 核心）卻讓很多想要參與制圖狂歡的開發者望而卻步。
今日，BigGAN 論文的第一作者、來自英國 Heriot-Watt 大學的 Andrew Brock 發佈了 BigGAN 的 PyTorch 版實現。最令人高興的是：這一次訓練模型的算力要求被降低到 4 到 8 塊 GPU 了！
今日，BigGAN 論文的第一作者、來自英國 Heriot-Watt 大學的 Andrew Brock 發佈了 BigGAN 的 PyTorch 版實現。最令人高興的是：這一次訓練模型的算力要求被降低到 4 到 8 塊 GPU 了！
Energy-Based Models
自從 GAN 出世以來，頂尖的生成模型都採用了這種框架。然而從去年的 Glow 到最近的 EBM，很多研究者都嘗試探索不同的生成框架。在這篇論文中，OpenAI 的研究者提出一種能高效訓練基於能量模型（EBM）的方法，它能獲得媲美 GAN 的效果。
2019年3月22日 星期五
2019年3月20日 星期三
python: @property
Python有一種修飾器(decorator)稱為屬性(property)，它可以執行以下操作：
1. 將類方法(class method)轉換為只讀(read-only)屬性(attribute)。
2. 將setter和getter重新實現為屬性。
以下將會敘述幾種不同的方式使用builtin類屬性。
1. 將類方法(class method)轉換為只讀(read-only)屬性(attribute)。
2. 將setter和getter重新實現為屬性。
以下將會敘述幾種不同的方式使用builtin類屬性。
Python內建函數
2019年3月18日 星期一
2019年3月17日 星期日
2019年3月16日 星期六
7種工具用來維護Pyhton code
PEP 8是Python代碼風格規範，它對行長度，縮進，多行表達式和命名約定等內容有明確的規範。你的團隊可能也有自己的代碼規則，可能與PEP 8略有不同。但是，任何代碼風格都是為了在代碼庫中強制實施一致的標準，使其更具可讀性，從而更易於維護。這裏有三個庫來幫助美化你的代碼。
2019年3月15日 星期五
2019年3月12日 星期二
2019年3月9日 星期六
2019年3月8日 星期五
2019年3月5日 星期二
2019年3月4日 星期一
Photoshop CS6 install
1. 下載主程式並且解壓縮
2. 進入"Adobe CS6"資料夾，執行"Set-up.exe"
3. 選擇安裝試用版
4. 登入
帳號：d00524xxx@ntu.edu.tw
密碼：Hxxxxx655xxx
5. 安裝完成後下載破解檔，打開"Adobe CS6 通用破解檔.rar"並且解壓縮
6. 依照電腦系統位元複製"amtlib.dll"
7. 到"開始"點"Adobe Photoshop CS6"滑鼠右鍵
8. 根據上面路徑進入資料夾並且貼上amtlib.dll即可完成
參考
http://ericayao14.pixnet.net/blog/post/176187813-photoshop-cs6%E6%9C%80%E6%96%B0-%E5%AE%98%E6%96%B9-%E6%AD%A3%E5%BC%8F-%E4%B8%AD%E6%96%87%E7%A0%B4%E8%A7%A3%E7%89%88-32%E4%BD%8D%E5%85%83-6
2. 進入"Adobe CS6"資料夾，執行"Set-up.exe"
3. 選擇安裝試用版
4. 登入
帳號：d00524xxx@ntu.edu.tw
密碼：Hxxxxx655xxx
5. 安裝完成後下載破解檔，打開"Adobe CS6 通用破解檔.rar"並且解壓縮
6. 依照電腦系統位元複製"amtlib.dll"
7. 到"開始"點"Adobe Photoshop CS6"滑鼠右鍵
8. 根據上面路徑進入資料夾並且貼上amtlib.dll即可完成
參考
http://ericayao14.pixnet.net/blog/post/176187813-photoshop-cs6%E6%9C%80%E6%96%B0-%E5%AE%98%E6%96%B9-%E6%AD%A3%E5%BC%8F-%E4%B8%AD%E6%96%87%E7%A0%B4%E8%A7%A3%E7%89%88-32%E4%BD%8D%E5%85%83-6
2019年3月3日 星期日
Array Handle
//! Specifies where to acquire the data
struct access_location
{
//! The enum
enum Enum
{
host, //!< Ask to acquire the data on the host
#ifdef ENABLE_CUDA
device //!< Ask to acquire the data on the device
#endif
};
};
//! Defines where the data is currently stored
struct data_location
{
//! The enum
enum Enum
{
host, //!< Data was last updated on the host
#ifdef ENABLE_CUDA
device, //!< Data was last updated on the device
hostdevice //!< Data is up to date on both the host and device
#endif
};
};
//! Specify how the data is to be accessed
struct access_mode
{
//! The enum
enum Enum
{
read, //!< Data will be accessed read only
readwrite, //!< Data will be accessed for read and write
overwrite //!< The data is to be completely overwritten during this acquire
};
};
//! CRTP (Curiously recurring template pattern) interface for GPUArray/GlobalArray
template<class T, class Derived>
class GPUArrayBase
{
.....
protected:
//! Acquires the data pointer for use
inline ArrayHandleDispatch<T> acquire(const access_location::Enum location, const access_mode::Enum mode
#ifdef ENABLE_CUDA
, bool async = false
#endif
) const
{
return static_cast<Derived const&>(*this).acquire(location, mode
#ifdef ENABLE_CUDA
, async
#endif
);
}
//! Release the data pointer
inline void release() const
{
return static_cast<Derived const&>(*this).release();
}
//! Returns the acquire state
inline bool isAcquired() const
{
return static_cast<Derived const&>(*this).isAcquired();
}
// need to be friend of the ArrayHandle class
friend class ArrayHandle<T>;
friend class ArrayHandleAsync<T>;
private:
// Make constructor private to prevent mistakes
GPUArrayBase() {};
friend Derived;
};
//! This base class is the glue between the ArrayHandle and a generic GPUArrayBase<Derived>
template<class T>
class ArrayHandleDispatch
{
public:
//! Constructor
ArrayHandleDispatch(T* const _data)
: data(_data) {}
//! Get the data pointer
T * const get() const
{
return data;
}
//! Destructor
virtual ~ArrayHandleDispatch() = default;
private:
//! The data pointer
T* const data;
};
//! Handle to access the data pointer handled by GPUArray
/*! The data in GPUArray is only accessible via ArrayHandle. The pointer is accessible for the lifetime of the
ArrayHandle. When the ArrayHandle is destroyed, the GPUArray is notified that the data has been released. This
tracking mechanism provides for error checking that will cause code assertions to fail if the data is acquired
more than once.
ArrayHandle is intended to be used within a scope limiting its use. For example:
\code
GPUArray<int> gpu_array(100);
{
ArrayHandle<int> h_handle(gpu_array, access_location::host, access_mode::readwrite);
... use h_handle.data ...
}
\endcode
The actual raw pointer \a data should \b NOT be assumed to be the same after the handle is released.
The pointer may in fact be re-allocated somewhere else after the handle is released and before the next handle
is acquired.
\ingroup data_structs
*/
template<class T>
class ArrayHandle
{
public:
//! Aquires the data and sets \a data
/*! \tparam Derived the type of GPUArray implementation
*/
template<class Derived>
inline ArrayHandle(const GPUArrayBase<T, Derived>& gpu_array, const access_location::Enum location = access_location::host,
const access_mode::Enum mode = access_mode::readwrite);
//! Notifies the containing GPUArray that the handle has been released
virtual inline ~ArrayHandle() = default;
private:
ArrayHandleDispatch<T> dispatch; //!< Reference to the dispatch object that manages the acquire/release
public:
T* const data; //!< Pointer to data
};
struct access_location
{
//! The enum
enum Enum
{
host, //!< Ask to acquire the data on the host
#ifdef ENABLE_CUDA
device //!< Ask to acquire the data on the device
#endif
};
};
//! Defines where the data is currently stored
struct data_location
{
//! The enum
enum Enum
{
host, //!< Data was last updated on the host
#ifdef ENABLE_CUDA
device, //!< Data was last updated on the device
hostdevice //!< Data is up to date on both the host and device
#endif
};
};
//! Specify how the data is to be accessed
struct access_mode
{
//! The enum
enum Enum
{
read, //!< Data will be accessed read only
readwrite, //!< Data will be accessed for read and write
overwrite //!< The data is to be completely overwritten during this acquire
};
};
//! CRTP (Curiously recurring template pattern) interface for GPUArray/GlobalArray
template<class T, class Derived>
class GPUArrayBase
{
.....
protected:
//! Acquires the data pointer for use
inline ArrayHandleDispatch<T> acquire(const access_location::Enum location, const access_mode::Enum mode
#ifdef ENABLE_CUDA
, bool async = false
#endif
) const
{
return static_cast<Derived const&>(*this).acquire(location, mode
#ifdef ENABLE_CUDA
, async
#endif
);
}
//! Release the data pointer
inline void release() const
{
return static_cast<Derived const&>(*this).release();
}
//! Returns the acquire state
inline bool isAcquired() const
{
return static_cast<Derived const&>(*this).isAcquired();
}
// need to be friend of the ArrayHandle class
friend class ArrayHandle<T>;
friend class ArrayHandleAsync<T>;
private:
// Make constructor private to prevent mistakes
GPUArrayBase() {};
friend Derived;
};
//! This base class is the glue between the ArrayHandle and a generic GPUArrayBase<Derived>
template<class T>
class ArrayHandleDispatch
{
public:
//! Constructor
ArrayHandleDispatch(T* const _data)
: data(_data) {}
//! Get the data pointer
T * const get() const
{
return data;
}
//! Destructor
virtual ~ArrayHandleDispatch() = default;
private:
//! The data pointer
T* const data;
};
//! Handle to access the data pointer handled by GPUArray
/*! The data in GPUArray is only accessible via ArrayHandle. The pointer is accessible for the lifetime of the
ArrayHandle. When the ArrayHandle is destroyed, the GPUArray is notified that the data has been released. This
tracking mechanism provides for error checking that will cause code assertions to fail if the data is acquired
more than once.
ArrayHandle is intended to be used within a scope limiting its use. For example:
\code
GPUArray<int> gpu_array(100);
{
ArrayHandle<int> h_handle(gpu_array, access_location::host, access_mode::readwrite);
... use h_handle.data ...
}
\endcode
The actual raw pointer \a data should \b NOT be assumed to be the same after the handle is released.
The pointer may in fact be re-allocated somewhere else after the handle is released and before the next handle
is acquired.
\ingroup data_structs
*/
template<class T>
class ArrayHandle
{
public:
//! Aquires the data and sets \a data
/*! \tparam Derived the type of GPUArray implementation
*/
template<class Derived>
inline ArrayHandle(const GPUArrayBase<T, Derived>& gpu_array, const access_location::Enum location = access_location::host,
const access_mode::Enum mode = access_mode::readwrite);
//! Notifies the containing GPUArray that the handle has been released
virtual inline ~ArrayHandle() = default;
private:
ArrayHandleDispatch<T> dispatch; //!< Reference to the dispatch object that manages the acquire/release
public:
T* const data; //!< Pointer to data
};
2019年3月2日 星期六
訂閱：
文章 (Atom)